MSE: Reduce spurious buffered range discontinuities

media/filters/source_buffer_stream.cc

 // 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.
 
 #include "media/filters/source_buffer_stream.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/bind.h"
@@ skipping 15 matching lines @@
     if (prev != kNoDecodeTimestamp() && prev >= (*itr)->GetStartTimestamp())
       return false;
     prev = (*itr)->GetEndTimestamp();
   }
   return true;
 }
 
 // Returns an estimate of how far from the beginning or end of a range a buffer
 // can be to still be considered in the range, given the |approximate_duration|
 // of a buffer in the stream.
+// TODO(wolenetz): Once all stream parsers emit accurate frame durations, use
+// logic like FrameProcessor (2*last_frame_duration + last_decode_timestamp)
+// instead of an overall maximum interbuffer delta for range discontinuity
+// detection, and adjust similarly for splice frame discontinuity detection.
+// See http://crbug.com/351489 and http://crbug.com/351166.
 static base::TimeDelta ComputeFudgeRoom(base::TimeDelta approximate_duration) {
   // 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 * approximate_duration;
 }
 
 // An arbitrarily-chosen number to estimate the duration of a buffer if none
 // is set and there's not enough information to get a better estimate.
 static int kDefaultBufferDurationInMs = 125;
@@ skipping 96 matching lines @@
 
 SourceBufferStream::~SourceBufferStream() {
   while (!ranges_.empty()) {
     delete ranges_.front();
     ranges_.pop_front();
   }
 }
 
 void SourceBufferStream::OnNewMediaSegment(
     DecodeTimestamp media_segment_start_time) {
+  DVLOG(1) << __FUNCTION__ << "(" << media_segment_start_time.InSecondsF()
+           << ")";
   DCHECK(!end_of_stream_);
   media_segment_start_time_ = media_segment_start_time;
   new_media_segment_ = true;
 
   RangeList::iterator last_range = range_for_next_append_;
   range_for_next_append_ = FindExistingRangeFor(media_segment_start_time);
 
   // Only reset |last_appended_buffer_timestamp_| if this new media segment is
   // not adjacent to the previous media segment appended to the stream.
   if (range_for_next_append_ == ranges_.end() ||
       !AreAdjacentInSequence(last_appended_buffer_timestamp_,
                              media_segment_start_time)) {
     last_appended_buffer_timestamp_ = kNoDecodeTimestamp();
     last_appended_buffer_is_keyframe_ = false;
+    DVLOG(3) << __FUNCTION__ << " next appended buffers will be in a new range";
   } else if (last_range != ranges_.end()) {
     DCHECK(last_range == range_for_next_append_);
+    DVLOG(3) << __FUNCTION__ << " next appended buffers will continue range "
+             << "unless intervening remove makes discontinuity";
   }
 }
 
 bool SourceBufferStream::Append(const BufferQueue& buffers) {
   TRACE_EVENT2("media", "SourceBufferStream::Append",
                "stream type", GetStreamTypeName(),
                "buffers to append", buffers.size());
 
   DCHECK(!buffers.empty());
   DCHECK(media_segment_start_time_ != kNoDecodeTimestamp());
@@ skipping 318 matching lines @@
 
 void SourceBufferStream::UpdateMaxInterbufferDistance(
     const BufferQueue& buffers) {
   DCHECK(!buffers.empty());
   DecodeTimestamp prev_timestamp = last_appended_buffer_timestamp_;
   for (BufferQueue::const_iterator itr = buffers.begin();
        itr != buffers.end(); ++itr) {
     DecodeTimestamp current_timestamp = (*itr)->GetDecodeTimestamp();
     DCHECK(current_timestamp != kNoDecodeTimestamp());
 
+    base::TimeDelta interbuffer_distance = (*itr)->duration();
+    DCHECK(interbuffer_distance >= base::TimeDelta());
+
     if (prev_timestamp != kNoDecodeTimestamp()) {
-      base::TimeDelta interbuffer_distance = current_timestamp - prev_timestamp;
+      interbuffer_distance =
+          std::max(current_timestamp - prev_timestamp, interbuffer_distance);
+    }
+
+    if (interbuffer_distance > base::TimeDelta()) {
       if (max_interbuffer_distance_ == kNoTimestamp()) {
         max_interbuffer_distance_ = interbuffer_distance;
       } else {
         max_interbuffer_distance_ =
             std::max(max_interbuffer_distance_, interbuffer_distance);
       }
     }
     prev_timestamp = current_timestamp;
   }
 }
@@ skipping 936 matching lines @@
     return false;
 
   DCHECK_NE(have_splice_buffers, have_preroll_buffer);
   splice_buffers_index_ = 0;
   pending_buffer_.swap(*out_buffer);
   pending_buffers_complete_ = false;
   return true;
 }
 
 }  // namespace media