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

media/filters/source_buffer_range.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/source_buffer_range.h"
 
 #include <algorithm>
 
 #include "media/base/timestamp_constants.h"
 
 namespace media {
 
 // Comparison operators for std::upper_bound() and std::lower_bound().
 static bool CompareTimeDeltaToStreamParserBuffer(
     const DecodeTimestamp& decode_timestamp,
     const scoped_refptr<StreamParserBuffer>& buffer) {
   return decode_timestamp < buffer->GetDecodeTimestamp();
 }
 static bool CompareStreamParserBufferToTimeDelta(
     const scoped_refptr<StreamParserBuffer>& buffer,
     const DecodeTimestamp& decode_timestamp) {
   return buffer->GetDecodeTimestamp() < decode_timestamp;
 }
 
-bool SourceBufferRange::AllowSameTimestamp(
-    bool prev_is_keyframe, bool current_is_keyframe) {
-  return prev_is_keyframe || !current_is_keyframe;
+bool SourceBufferRange::IsUncommonSameTimestampSequence(
+    bool prev_is_keyframe,
+    bool current_is_keyframe) {
+  return current_is_keyframe && !prev_is_keyframe;

[chcunningham, 2016/02/09 00:21:08]

Just to note: I wasn't sure how (un)common this is in the case of VP9 alt-ref
frames. Word from fgalligan@ is that an alt-ref frame is *almost always*
followed by a non-key frame. In other words, "uncommon" (rather than
"impossible" or "error") is a good choice of naming here...  

[wolenetz, 2016/02/09 00:47:19]

Acknowledged.

 }
 
 SourceBufferRange::SourceBufferRange(
     GapPolicy gap_policy, const BufferQueue& new_buffers,
     DecodeTimestamp media_segment_start_time,
     const InterbufferDistanceCB& interbuffer_distance_cb)
     : gap_policy_(gap_policy),
       keyframe_map_index_base_(0),
       next_buffer_index_(-1),
       media_segment_start_time_(media_segment_start_time),
@@ skipping 442 matching lines @@
 }
 
 bool SourceBufferRange::CanAppendRangeToEnd(
     const SourceBufferRange& range) const {
   return CanAppendBuffersToEnd(range.buffers_);
 }
 
 bool SourceBufferRange::CanAppendBuffersToEnd(
     const BufferQueue& buffers) const {
   DCHECK(!buffers_.empty());
-  return IsNextInSequence(buffers.front()->GetDecodeTimestamp(),
-                          buffers.front()->is_key_frame());
+  return IsNextInSequence(buffers.front()->GetDecodeTimestamp());
 }
 
 bool SourceBufferRange::BelongsToRange(DecodeTimestamp timestamp) const {
   DCHECK(!buffers_.empty());
 
-  return (IsNextInSequence(timestamp, false) ||
+  return (IsNextInSequence(timestamp) ||
           (GetStartTimestamp() <= timestamp && timestamp <= GetEndTimestamp()));
 }
 
 bool SourceBufferRange::CanSeekTo(DecodeTimestamp timestamp) const {
   DecodeTimestamp start_timestamp =
       std::max(DecodeTimestamp(), GetStartTimestamp() - GetFudgeRoom());
   return !keyframe_map_.empty() && start_timestamp <= timestamp &&
       timestamp < GetBufferedEndTimestamp();
 }
 
@@ skipping 55 matching lines @@
 DecodeTimestamp SourceBufferRange::KeyframeBeforeTimestamp(
     DecodeTimestamp timestamp) {
   DCHECK(!keyframe_map_.empty());
 
   if (timestamp < GetStartTimestamp() || timestamp >= GetBufferedEndTimestamp())
     return kNoDecodeTimestamp();
 
   return GetFirstKeyframeAtOrBefore(timestamp)->first;
 }
 
-bool SourceBufferRange::IsNextInSequence(
-    DecodeTimestamp timestamp, bool is_key_frame) const {
+bool SourceBufferRange::IsNextInSequence(DecodeTimestamp timestamp) const {
   DecodeTimestamp end = buffers_.back()->GetDecodeTimestamp();
-  if (end < timestamp &&
-      (gap_policy_ == ALLOW_GAPS ||
-       timestamp <= end + GetFudgeRoom())) {
-    return true;
-  }
-
-  return timestamp == end && AllowSameTimestamp(
-      buffers_.back()->is_key_frame(), is_key_frame);
+  return (end == timestamp ||
+          (end < timestamp &&
+           (gap_policy_ == ALLOW_GAPS || timestamp <= end + GetFudgeRoom())));
 }
 
 base::TimeDelta SourceBufferRange::GetFudgeRoom() const {
   // Because we do not know exactly when is the next timestamp, any buffer
   // that starts within 2x the approximate duration of a buffer is considered
   // within this range.
   return 2 * GetApproximateDuration();
 }
 
 base::TimeDelta SourceBufferRange::GetApproximateDuration() const {
@@ skipping 27 matching lines @@
     }
 
     if (buffer->timestamp() + buffer->duration() <= start.ToPresentationTime())
       continue;
     buffers->push_back(buffer);
   }
   return previous_size < buffers->size();
 }
 
 }  // namespace media