Reland: MSE: Relax the 'media segment must begin with keyframe' requirement

media/filters/source_buffer_stream.h

 // Copyright (c) 2012 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.
 
 // SourceBufferStream is a data structure that stores media Buffers in ranges.
 // Buffers can be appended out of presentation order. Buffers are retrieved by
 // seeking to the desired start point and calling GetNextBuffer(). Buffers are
 // returned in sequential presentation order.
 
 #ifndef MEDIA_FILTERS_SOURCE_BUFFER_STREAM_H_
@@ skipping 50 matching lines @@
                      bool splice_frames_enabled);
   SourceBufferStream(const VideoDecoderConfig& video_config,
                      const scoped_refptr<MediaLog>& media_log,
                      bool splice_frames_enabled);
   SourceBufferStream(const TextTrackConfig& text_config,
                      const scoped_refptr<MediaLog>& media_log,
                      bool splice_frames_enabled);
 
   ~SourceBufferStream();
 
-  // Signals that the next buffers appended are part of a new media segment
-  // starting at |media_segment_start_time|.
+  // Signals that the next buffers appended are part of a new coded frame group
+  // starting at |coded_frame_group_start_time|.
   // TODO(acolwell/wolenetz): This should be changed to a presentation
   // timestamp. See http://crbug.com/402502
-  void OnNewMediaSegment(DecodeTimestamp media_segment_start_time);
+  void OnStartOfCodedFrameGroup(DecodeTimestamp coded_frame_group_start_time);
 
   // Add the |buffers| to the SourceBufferStream. Buffers within the queue are
   // expected to be in order, but multiple calls to Append() may add buffers out
   // of order or overlapping. Assumes all buffers within |buffers| are in
   // presentation order and are non-overlapping.
   // Returns true if Append() was successful, false if |buffers| are not added.
   // TODO(vrk): Implement garbage collection. (crbug.com/125070)
   bool Append(const BufferQueue& buffers);
 
   // Removes buffers between |start| and |end| according to the steps
@@ skipping 118 matching lines @@
   // Returns true if |second_timestamp| is the timestamp of the next buffer in
   // sequence after |first_timestamp|, false otherwise.
   bool AreAdjacentInSequence(
       DecodeTimestamp first_timestamp, DecodeTimestamp second_timestamp) const;
 
   // Helper method that returns the timestamp for the next buffer that
   // |selected_range_| will return from GetNextBuffer() call, or kNoTimestamp()
   // if in between seeking (i.e. |selected_range_| is null).
   DecodeTimestamp GetNextBufferTimestamp();
 
-  // Finds the range that should contain a media segment that begins with
+  // Finds the range that should contain a coded frame group that begins with
   // |start_timestamp| and returns the iterator pointing to it. Returns
   // |ranges_.end()| if there's no such existing range.
   RangeList::iterator FindExistingRangeFor(DecodeTimestamp start_timestamp);
 
   // Inserts |new_range| into |ranges_| preserving sorted order. Returns an
   // iterator in |ranges_| that points to |new_range|.
   RangeList::iterator AddToRanges(SourceBufferRange* new_range);
 
   // Returns an iterator that points to the place in |ranges_| where
   // |selected_range_| lives.
   RangeList::iterator GetSelectedRangeItr();
 
   // Sets the |selected_range_| to |range| and resets the next buffer position
   // for the previous |selected_range_|.
   void SetSelectedRange(SourceBufferRange* range);
 
   // Seeks |range| to |seek_timestamp| and then calls SetSelectedRange() with
   // |range|.
   void SeekAndSetSelectedRange(SourceBufferRange* range,
                                DecodeTimestamp seek_timestamp);
 
   // Resets this stream back to an unseeked state.
   void ResetSeekState();
 
   // Returns true if |seek_timestamp| refers to the beginning of the first range
   // in |ranges_|, false otherwise or if |ranges_| is empty.
   bool ShouldSeekToStartOfBuffered(base::TimeDelta seek_timestamp) const;
 
   // Returns true if the timestamps of |buffers| are monotonically increasing
-  // since the previous append to the media segment, false otherwise.
-  bool IsMonotonicallyIncreasing(const BufferQueue& buffers) const;
-
-  // Returns true if |next_timestamp| and |next_is_keyframe| are valid for
-  // the first buffer after the previous append.
-  bool IsNextTimestampValid(DecodeTimestamp next_timestamp,
-                            bool next_is_keyframe) const;
+  // since the previous append to the coded frame group, false otherwise.
+  bool IsMonotonicallyIncreasing(const BufferQueue& buffers);
 
   // Returns true if |selected_range_| is the only range in |ranges_| that
   // HasNextBufferPosition().
   bool OnlySelectedRangeIsSeeked() const;
 
   // Measures the distances between buffer timestamps and tracks the max.
   void UpdateMaxInterbufferDistance(const BufferQueue& buffers);
 
   // Sets the config ID for each buffer to |append_config_index_|.
   void SetConfigIds(const BufferQueue& buffers);
@@ skipping 32 matching lines @@
   // 2. We don't have any ranges, or the last or no range is selected,
   //    or there is a pending seek beyond any existing ranges.
   bool IsEndOfStreamReached() const;
 
   // Deletes the range pointed to by |*itr| and removes it from |ranges_|.
   // If |*itr| points to |selected_range_|, then |selected_range_| is set to
   // NULL. After the range is removed, |*itr| is to the range after the one that
   // was removed or to |ranges_.end()| if the last range was removed.
   void DeleteAndRemoveRange(RangeList::iterator* itr);
 
+  // Helper function used when updating |range_for_next_append_|.
+  // Returns a guess of what the next append timestamp will be based on
+  // |last_appended_buffer_timestamp_|, |new_coded_frame_group_| and
+  // |coded_frame_group_start_time_|. Returns kNoDecodeTimestamp() if unable to
+  // guess, which can occur prior to first OnStartOfCodedFrameGroup(), or
+  // when the most recent GOP appended to since the last
+  // OnStartOfCodedFrameGroup() is removed.
+  DecodeTimestamp PotentialNextAppendTimestamp() const;
+
   // Helper function used by Remove() and PrepareRangesForNextAppend() to
   // remove buffers and ranges between |start| and |end|.
   // |exclude_start| - If set to true, buffers with timestamps that
   // match |start| are not removed. If set to false, buffers with
   // timestamps that match |start| will be removed.
   // |*deleted_buffers| - Filled with buffers for the current playback position
   // if the removal range included the current playback position. These buffers
   // can be used as candidates for placing in the |track_buffer_|.
   void RemoveInternal(DecodeTimestamp start,
                       DecodeTimestamp end,
@@ skipping 77 matching lines @@
   SourceBufferRange* selected_range_ = nullptr;
 
   // Queue of the next buffers to be returned from calls to GetNextBuffer(). If
   // |track_buffer_| is empty, return buffers from |selected_range_|.
   BufferQueue track_buffer_;
 
   // If there has been no intervening Seek, this will be true if the last
   // emitted buffer emptied |track_buffer_|.
   bool just_exhausted_track_buffer_ = false;
 
-  // The start time of the current media segment being appended.
-  DecodeTimestamp media_segment_start_time_;
+  // The start time of the current coded frame group being appended.
+  DecodeTimestamp coded_frame_group_start_time_;
 
-  // Points to the range containing the current media segment being appended.
+  // Points to the range containing the current coded frame group being
+  // appended.
   RangeList::iterator range_for_next_append_;
 
-  // True when the next call to Append() begins a new media segment.
-  bool new_media_segment_ = false;
+  // True when the next call to Append() begins a new coded frame group.
+  // TODO(wolenetz): Simplify by passing this flag into Append().
+  bool new_coded_frame_group_ = false;
 
-  // The timestamp of the last buffer appended to the media segment, set to
-  // kNoDecodeTimestamp() if the beginning of the segment.
+  // The timestamp of the last buffer appended to the coded frame group, set to
+  // kNoDecodeTimestamp() if the beginning of the group.
   DecodeTimestamp last_appended_buffer_timestamp_ = kNoDecodeTimestamp();
   base::TimeDelta last_appended_buffer_duration_ = kNoTimestamp();
   bool last_appended_buffer_is_keyframe_ = false;
 
   // The decode timestamp on the last buffer returned by the most recent
   // GetNextBuffer() call. Set to kNoDecodeTimestamp() if GetNextBuffer() hasn't
   // been called yet or a seek has happened since the last GetNextBuffer() call.
   DecodeTimestamp last_output_buffer_timestamp_;
 
   // Stores the largest distance between two adjacent buffers in this stream.
@@ skipping 21 matching lines @@
   bool pending_buffers_complete_ = false;
 
   // Indicates that splice frame generation is enabled.
   const bool splice_frames_enabled_;
 
   // To prevent log spam, count the number of warnings and successes logged.
   int num_splice_generation_warning_logs_ = 0;
   int num_splice_generation_success_logs_ = 0;
   int num_track_buffer_gap_warning_logs_ = 0;
   int num_garbage_collect_algorithm_logs_ = 0;
+  int num_strange_same_timestamps_logs_ = 0;
 
   DISALLOW_COPY_AND_ASSIGN(SourceBufferStream);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_FILTERS_SOURCE_BUFFER_STREAM_H_