basesink: Rename last_segment_running_time to last_anchor_running_time for consistence with the design docinstant-rate-change

1 files changed, 25 insertions, 25 deletions

diff --git a/libs/gst/base/gstbasesink.c b/libs/gst/base/gstbasesink.c
index b61977f51..60f0632fe 100644
--- a/libs/gst/base/gstbasesink.c
+++ b/libs/gst/base/gstbasesink.c
@@ -254,7 +254,7 @@ struct _GstBaseSinkPrivate
   GstSegment upstream_segment;
   /* Running time at the start of the last segment event
    * or instant-rate switch in *our* segment, not upstream */
-  GstClockTime last_segment_running_time;
+  GstClockTime last_anchor_running_time;
   /* Difference between upstream running time and our own running time
    * at the last segment event or instant-rate switch:
    * upstream + offset = ours */
@@ -2719,18 +2719,18 @@ gst_base_sink_send_qos (GstBaseSink * basesink, GstQOSType type,
     GST_DEBUG_OBJECT (basesink,
         "Current internal running time %" GST_TIME_FORMAT
         ", last internal running time %" GST_TIME_FORMAT, GST_TIME_ARGS (time),
-        GST_TIME_ARGS (basesink->priv->last_segment_running_time));
+        GST_TIME_ARGS (basesink->priv->last_anchor_running_time));
 
     /* Calculate how much running time was spent since the last switch/segment
      * in the "corrected upstream segment", our segment */
     /* Due to rounding errors and other inaccuracies, it can happen
      * that our calculated internal running time is before the upstream
      * running time. We need to compensate for that */
-    if (time < basesink->priv->last_segment_running_time) {
-      actual_duration = basesink->priv->last_segment_running_time - time;
+    if (time < basesink->priv->last_anchor_running_time) {
+      actual_duration = basesink->priv->last_anchor_running_time - time;
       negative_duration = TRUE;
     } else {
-      actual_duration = time - basesink->priv->last_segment_running_time;
+      actual_duration = time - basesink->priv->last_anchor_running_time;
       negative_duration = FALSE;
     }
 
@@ -3119,7 +3119,7 @@ gst_base_sink_flush_stop (GstBaseSink * basesink, GstPad * pad,
       basesink->priv->instant_rate = 0;
       basesink->priv->segment_seqnum = GST_SEQNUM_INVALID;
       basesink->priv->instant_rate_offset = 0;
-      basesink->priv->last_segment_running_time = 0;
+      basesink->priv->last_anchor_running_time = 0;
     }
   }
   GST_OBJECT_UNLOCK (basesink);
@@ -3311,23 +3311,23 @@ gst_base_sink_default_event (GstBaseSink * basesink, GstEvent * event)
               "Current upstream running time %" GST_TIME_FORMAT
               ", last upstream running time %" GST_TIME_FORMAT,
               GST_TIME_ARGS (new_segment_running_time),
-              GST_TIME_ARGS (basesink->priv->last_segment_running_time -
+              GST_TIME_ARGS (basesink->priv->last_anchor_running_time -
                   basesink->priv->instant_rate_offset));
 
           /* Due to rounding errors and other inaccuracies, it can happen
            * that our calculated internal running time is before the upstream
            * running time. We need to compensate for that */
           if (new_segment_running_time <
-              basesink->priv->last_segment_running_time -
+              basesink->priv->last_anchor_running_time -
               basesink->priv->instant_rate_offset) {
             upstream_duration =
-                basesink->priv->last_segment_running_time -
+                basesink->priv->last_anchor_running_time -
                 basesink->priv->instant_rate_offset - new_segment_running_time;
             negative_duration = TRUE;
           } else {
             upstream_duration =
                 new_segment_running_time -
-                basesink->priv->last_segment_running_time +
+                basesink->priv->last_anchor_running_time +
                 basesink->priv->instant_rate_offset;
             negative_duration = FALSE;
           }
@@ -3347,7 +3347,7 @@ gst_base_sink_default_event (GstBaseSink * basesink, GstEvent * event)
               ", last internal running time %" GST_TIME_FORMAT,
               GST_TIME_ARGS (new_segment_running_time +
                   basesink->priv->instant_rate_offset + difference),
-              GST_TIME_ARGS (basesink->priv->last_segment_running_time));
+              GST_TIME_ARGS (basesink->priv->last_anchor_running_time));
 
           /* Add the difference to the previously accumulated correction. */
           basesink->priv->instant_rate_offset += difference;
@@ -3370,10 +3370,10 @@ gst_base_sink_default_event (GstBaseSink * basesink, GstEvent * event)
                 GST_TIME_ARGS (new_segment_running_time),
                 GST_STIME_ARGS (basesink->priv->instant_rate_offset));
 
-            basesink->priv->last_segment_running_time = 0;
+            basesink->priv->last_anchor_running_time = 0;
             basesink->priv->instant_rate_offset = 0;
           } else {
-            basesink->priv->last_segment_running_time =
+            basesink->priv->last_anchor_running_time =
                 new_segment_running_time + basesink->priv->instant_rate_offset;
           }
         }
@@ -3397,7 +3397,7 @@ gst_base_sink_default_event (GstBaseSink * basesink, GstEvent * event)
         /* otherwise both segments are simply the same, no correction needed */
         basesink->priv->upstream_segment = new_segment;
         basesink->segment = new_segment;
-        basesink->priv->last_segment_running_time =
+        basesink->priv->last_anchor_running_time =
             gst_segment_to_running_time (&new_segment, new_segment.format,
             new_segment.position);
       }
@@ -4329,18 +4329,18 @@ gst_base_sink_perform_instant_rate_change (GstBaseSink * sink, GstPad * pad,
     GST_DEBUG_OBJECT (sink, "Current internal running time %" GST_TIME_FORMAT
         ", last internal running time %" GST_TIME_FORMAT,
         GST_TIME_ARGS (running_time),
-        GST_TIME_ARGS (sink->priv->last_segment_running_time));
+        GST_TIME_ARGS (sink->priv->last_anchor_running_time));
 
     /* Calculate how much running time was spent since the last switch/segment
      * in the "corrected upstream segment", our segment */
     /* Due to rounding errors and other inaccuracies, it can happen
      * that our calculated internal running time is before the upstream
      * running time. We need to compensate for that */
-    if (running_time < sink->priv->last_segment_running_time) {
-      actual_duration = sink->priv->last_segment_running_time - running_time;
+    if (running_time < sink->priv->last_anchor_running_time) {
+      actual_duration = sink->priv->last_anchor_running_time - running_time;
       negative_duration = TRUE;
     } else {
-      actual_duration = running_time - sink->priv->last_segment_running_time;
+      actual_duration = running_time - sink->priv->last_anchor_running_time;
       negative_duration = FALSE;
     }
 
@@ -4372,10 +4372,10 @@ gst_base_sink_perform_instant_rate_change (GstBaseSink * sink, GstPad * pad,
           GST_TIME_ARGS (running_time),
           GST_STIME_ARGS (sink->priv->instant_rate_offset));
 
-      sink->priv->last_segment_running_time = 0;
+      sink->priv->last_anchor_running_time = 0;
       sink->priv->instant_rate_offset = 0;
     } else {
-      sink->priv->last_segment_running_time = running_time;
+      sink->priv->last_anchor_running_time = running_time;
     }
 
     /* Calculate the current position in the segment and do a seek with the
@@ -4932,7 +4932,7 @@ gst_base_sink_send_event (GstElement * element, GstEvent * event)
       GST_DEBUG_OBJECT (basesink,
           "Current internal running time %" GST_TIME_FORMAT
           ", last internal running time %" GST_TIME_FORMAT, GST_TIME_ARGS (now),
-          GST_TIME_ARGS (basesink->priv->last_segment_running_time));
+          GST_TIME_ARGS (basesink->priv->last_anchor_running_time));
 
       if (now != GST_CLOCK_TIME_NONE) {
         /* Calculate how much running time was spent since the last switch/segment
@@ -4940,11 +4940,11 @@ gst_base_sink_send_event (GstElement * element, GstEvent * event)
         /* Due to rounding errors and other inaccuracies, it can happen
          * that our calculated internal running time is before the upstream
          * running time. We need to compensate for that */
-        if (now < basesink->priv->last_segment_running_time) {
-          actual_duration = basesink->priv->last_segment_running_time - now;
+        if (now < basesink->priv->last_anchor_running_time) {
+          actual_duration = basesink->priv->last_anchor_running_time - now;
           negative_duration = TRUE;
         } else {
-          actual_duration = now - basesink->priv->last_segment_running_time;
+          actual_duration = now - basesink->priv->last_anchor_running_time;
           negative_duration = FALSE;
         }
 
@@ -5556,7 +5556,7 @@ gst_base_sink_change_state (GstElement * element, GstStateChange transition)
       priv->instant_rate = 0;
       priv->segment_seqnum = GST_SEQNUM_INVALID;
       priv->instant_rate_offset = 0;
-      priv->last_segment_running_time = 0;
+      priv->last_anchor_running_time = 0;
       if (priv->async_enabled) {
         GST_DEBUG_OBJECT (basesink, "doing async state change");
         /* when async enabled, post async-start message and return ASYNC from