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

media/filters/source_buffer_range.h

 // 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.
 
 #ifndef MEDIA_FILTERS_SOURCE_BUFFER_RANGE_H_
 #define MEDIA_FILTERS_SOURCE_BUFFER_RANGE_H_
 
 #include <stddef.h>
 
 #include <map>
@@ skipping 19 matching lines @@
 
   // Policy for handling large gaps between buffers. Continuous media like
   // audio & video should use NO_GAPS_ALLOWED. Discontinuous media like
   // timed text should use ALLOW_GAPS because large differences in timestamps
   // are common and acceptable.
   enum GapPolicy {
     NO_GAPS_ALLOWED,
     ALLOW_GAPS
   };
 
-  // Buffers with the same timestamp are only allowed under certain conditions.
-  // More precisely, it is allowed in all situations except when the previous
-  // frame is not a key frame and the current is a key frame.
-  // Examples of situations where DTS of two consecutive frames can be equal:
+  // Sequential buffers with the same decode timestamp make sense under certain
+  // conditions, typically when the first buffer is a keyframe. Due to some
+  // atypical media append behaviors where a new keyframe might have the same
+  // timestamp as a previous non-keyframe, the playback of the sequence might
+  // involve some throwaway decode work. This method supports detecting this
+  // situation so that callers can log warnings (it returns true in this case
+  // only).
+  // For all other cases, including more typical same-DTS sequences, this method
+  // returns false. Examples of typical situations where DTS of two consecutive
+  // frames can be equal:
   // - Video: VP8 Alt-Ref frames.
   // - Video: IPBPBP...: DTS for I frame and for P frame can be equal.
   // - Text track cues that start at same time.
   // Returns true if |prev_is_keyframe| and |current_is_keyframe| indicate a
-  // same timestamp situation that is allowed. False is returned otherwise.
-  static bool AllowSameTimestamp(bool prev_is_keyframe,
-                                 bool current_is_keyframe);
+  // same timestamp situation that is atypical. False is returned otherwise.
+  static bool IsUncommonSameTimestampSequence(bool prev_is_keyframe,

[wolenetz, 2016/02/05 23:27:24]

Note that I've inverted the logic and the name here. This is handled at the
callers correctly.

+                                              bool current_is_keyframe);
 
   // Creates a source buffer range with |new_buffers|. |new_buffers| cannot be
   // empty and the front of |new_buffers| must be a keyframe.
   // |media_segment_start_time| refers to the starting timestamp for the media
   // segment to which these buffers belong.
   SourceBufferRange(GapPolicy gap_policy,
                     const BufferQueue& new_buffers,
                     DecodeTimestamp media_segment_start_time,
                     const InterbufferDistanceCB& interbuffer_distance_cb);
 
@@ skipping 130 matching lines @@
 
   // Returns true if this range's buffered timespan completely overlaps the
   // buffered timespan of |range|.
   bool CompletelyOverlaps(const SourceBufferRange& range) const;
 
   // Returns true if the end of this range contains buffers that overlaps with
   // the beginning of |range|.
   bool EndOverlaps(const SourceBufferRange& range) const;
 
   // Returns true if |timestamp| is the timestamp of the next buffer in
-  // sequence after |buffers_.back()|, false otherwise.
-  bool IsNextInSequence(DecodeTimestamp timestamp, bool is_key_frame) const;
+  // sequence after |buffers_.back()|, false othewise.

[wolenetz, 2016/02/05 23:27:24]

nit-to-self: fix this typo.

[wolenetz, 2016/02/12 01:23:47]

Done.

+  bool IsNextInSequence(DecodeTimestamp timestamp) const;
 
   // Adds all buffers which overlap [start, end) to the end of |buffers|.  If
   // no buffers exist in the range returns false, true otherwise.
   bool GetBuffersInRange(DecodeTimestamp start, DecodeTimestamp end,
                          BufferQueue* buffers);
 
   size_t size_in_bytes() const { return size_in_bytes_; }
 
  private:
   typedef std::map<DecodeTimestamp, int> KeyframeMap;
@@ skipping 77 matching lines @@
 
   // Stores the amount of memory taken up by the data in |buffers_|.
   size_t size_in_bytes_;
 
   DISALLOW_COPY_AND_ASSIGN(SourceBufferRange);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_FILTERS_SOURCE_BUFFER_RANGE_H_