MSE: Signal new coded frame group more aggressively

media/filters/frame_processor.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/filters/frame_processor.h"
 
 #include <stdint.h>
 
 #include <cstdlib>
 
@@ skipping 167 matching lines @@
 void FrameProcessor::SetSequenceMode(bool sequence_mode) {
   DVLOG(2) << __FUNCTION__ << "(" << sequence_mode << ")";
   // Per June 9, 2016 MSE spec editor's draft:
   // https://rawgit.com/w3c/media-source/d8f901f22/
   //     index.html#widl-SourceBuffer-mode
   // Step 7: If the new mode equals "sequence", then set the group start
   // timestamp to the group end timestamp.
   if (sequence_mode) {
     DCHECK(kNoTimestamp() != group_end_timestamp_);
     group_start_timestamp_ = group_end_timestamp_;
+  } else if (sequence_mode_) {
+    // We're switching from 'sequence' to 'segments' mode. Be safe and signal a
+    // new coded frame group on the next frame emitted.
+    coded_frame_group_last_dts_ = kNoDecodeTimestamp();
   }
 
   // Step 8: Update the attribute to new mode.
   sequence_mode_ = sequence_mode;
 }
 
 bool FrameProcessor::ProcessFrames(
     const StreamParser::BufferQueue& audio_buffers,
     const StreamParser::BufferQueue& video_buffers,
     const StreamParser::TextBufferQueueMap& text_map,
@@ skipping 87 matching lines @@
   }
 }
 
 void FrameProcessor::Reset() {
   DVLOG(2) << __FUNCTION__ << "()";
   for (TrackBufferMap::iterator itr = track_buffers_.begin();
        itr != track_buffers_.end(); ++itr) {
     itr->second->Reset();
   }
 
-  // Maintain current |in_coded_frame_group_| state for Reset() during
-  // sequence mode. Reset it here only if in segments mode.
+  // Maintain current |coded_frame_group_last_dts_| state for Reset() during
+  // sequence mode. Reset it here only if in segments mode. In sequence mode,
+  // the current coded frame group may be continued across Reset() operations to
+  // allow the stream to coaelesce what might otherwise be gaps in the buffered
+  // ranges. See also the declaration for |coded_frame_group_last_dts_|.
   if (!sequence_mode_) {
-    in_coded_frame_group_ = false;
+    coded_frame_group_last_dts_ = kNoDecodeTimestamp();
     return;
   }
 
   // Sequence mode
   DCHECK(kNoTimestamp() != group_end_timestamp_);
   group_start_timestamp_ = group_end_timestamp_;
 }
 
 void FrameProcessor::OnPossibleAudioConfigUpdate(
     const AudioDecoderConfig& config) {
@@ skipping 285 matching lines @@
     //    If last decode timestamp for track buffer is set and the difference
     //    between decode timestamp and last decode timestamp is greater than 2
     //    times last frame duration:
     DecodeTimestamp track_last_decode_timestamp =
         track_buffer->last_decode_timestamp();
     if (track_last_decode_timestamp != kNoDecodeTimestamp()) {
       base::TimeDelta track_dts_delta =
           decode_timestamp - track_last_decode_timestamp;
       if (track_dts_delta < base::TimeDelta() ||
           track_dts_delta > 2 * track_buffer->last_frame_duration()) {
-        DCHECK(in_coded_frame_group_);
+        DCHECK(coded_frame_group_last_dts_ != kNoDecodeTimestamp());
         // 6.1. If mode equals "segments": Set group end timestamp to
         //      presentation timestamp.
         //      If mode equals "sequence": Set group start timestamp equal to
         //      the group end timestamp.
         if (!sequence_mode_) {
           group_end_timestamp_ = presentation_timestamp;
           // This triggers a discontinuity so we need to treat the next frames
           // appended within the append window as if they were the beginning of
-          // a new coded frame group.
-          in_coded_frame_group_ = false;
+          // a new coded frame group. |coded_frame_group_last_dts_| is reset in
+          // Reset(), below, for "segments" mode.
         } else {
           DVLOG(3) << __FUNCTION__ << " : Sequence mode discontinuity, GETS: "
                    << group_end_timestamp_.InSecondsF();
-          DCHECK(kNoTimestamp() != group_end_timestamp_);
-          group_start_timestamp_ = group_end_timestamp_;
+          // Reset(), below, performs the "Set group start timestamp equal to
+          // the group end timestamp" operation for "sequence" mode.
         }
 
         // 6.2. - 6.5.:
         Reset();
 
         // 6.6. Jump to the Loop Top step above to restart processing of the
         //      current coded frame.
         DVLOG(3) << __FUNCTION__ << ": Discontinuity: reprocessing frame";
         continue;
       }
@@ skipping 67 matching lines @@
       }
 
       // 10.2. Set the need random access point flag on track buffer to false.
       track_buffer->set_needs_random_access_point(false);
     }
 
     // We now have a processed buffer to append to the track buffer's stream.
     // If it is the first in a new coded frame group (such as following a
     // discontinuity), notify all the track buffers' streams that a coded frame
     // group is starting.
-    if (!in_coded_frame_group_) {
+    // If in 'sequence' appendMode, also check to make sure we don't need to
+    // signal the start of a new coded frame group in the case where
+    // timestampOffset adjustments by the app may cause this coded frame to be
+    // in the timeline prior to the last frame processed.
+    if (coded_frame_group_last_dts_ == kNoDecodeTimestamp() ||
+        (sequence_mode_ && coded_frame_group_last_dts_ > decode_timestamp)) {
       // First, complete the append to track buffer streams of the previous
       // coded frame group's frames, if any.
       if (!FlushProcessedFrames())
         return false;
 
-      // TODO(acolwell/wolenetz): This should be changed to a presentation
-      // timestamp. See http://crbug.com/402502
+      // TODO(wolenetz): This should be changed to a presentation timestamp. See
+      // http://crbug.com/402502
       NotifyStartOfCodedFrameGroup(decode_timestamp);
-      in_coded_frame_group_ = true;
     }
 
+    coded_frame_group_last_dts_ = decode_timestamp;
+
     DVLOG(3) << __FUNCTION__ << ": Sending processed frame to stream, "
              << "PTS=" << presentation_timestamp.InSecondsF()
              << ", DTS=" << decode_timestamp.InSecondsF();
 
     // Steps 11-16: Note, we optimize by appending groups of contiguous
     // processed frames for each track buffer at end of ProcessFrames() or prior
     // to NotifyStartOfCodedFrameGroup().
     track_buffer->EnqueueProcessedFrame(frame);
 
     // 17. Set last decode timestamp for track buffer to decode timestamp.
@@ skipping 18 matching lines @@
     // Step 21 is currently handled differently. See MediaSourceState's
     // |auto_update_timestamp_offset_|.
     return true;
   }
 
   NOTREACHED();
   return false;
 }
 
 }  // namespace media