Add kSeekToStartFudgeRoom to SourceBufferStream

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 213 matching lines @@
 static bool BufferComparator(
     const scoped_refptr<media::StreamParserBuffer>& first,
     const scoped_refptr<media::StreamParserBuffer>& second) {
   return first->GetDecodeTimestamp() < second->GetDecodeTimestamp();
 }
 
 // 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;
 
+// The amount of time the beginning of the buffered data can differ from the
+// start time in order to still be considered the start of stream.
+static base::TimeDelta kSeekToStartFudgeRoom() {
+  return base::TimeDelta::FromMilliseconds(1000);
+}
+
 namespace media {
 
 SourceBufferStream::SourceBufferStream(const AudioDecoderConfig& audio_config)
     : current_config_index_(0),
       append_config_index_(0),
       audio_configs_(1),
       video_configs_(0),
       stream_start_time_(kNoTimestamp()),
       seek_pending_(false),
       seek_buffer_timestamp_(kNoTimestamp()),
@@ skipping 137 matching lines @@
       // than |end_buffer_timestamp|).
       selected_range_->SeekAheadPast(end_buffer_timestamp);
     }
   }
 
   DCHECK(IsRangeListSorted(ranges_));
   DCHECK(OnlySelectedRangeIsSeeked());
   return true;
 }
 
-bool SourceBufferStream::IsBeforeFirstRange(base::TimeDelta timestamp) const {
+bool SourceBufferStream::ShouldSeekToStartOfBuffered(
+    base::TimeDelta seek_timestamp) const {
   if (ranges_.empty())
     return false;
-  return timestamp < ranges_.front()->GetStartTimestamp();
+  base::TimeDelta beginning_of_buffered =
+      ranges_.front()->GetStartTimestamp();
+  base::TimeDelta start_time_delta = beginning_of_buffered - stream_start_time_;
+  return seek_timestamp <= beginning_of_buffered &&
+      start_time_delta < kSeekToStartFudgeRoom();
 }
 
 bool SourceBufferStream::IsMonotonicallyIncreasing(
     const BufferQueue& buffers) const {
   DCHECK(!buffers.empty());
   base::TimeDelta prev_timestamp = last_buffer_timestamp_;
   for (BufferQueue::const_iterator itr = buffers.begin();
        itr != buffers.end(); ++itr) {
     base::TimeDelta current_timestamp = (*itr)->GetDecodeTimestamp();
     DCHECK(current_timestamp != kNoTimestamp());
@@ skipping 239 matching lines @@
     ranges_.erase(next_range_itr);
   }
 }
 
 void SourceBufferStream::Seek(base::TimeDelta timestamp) {
   DCHECK(stream_start_time_ != kNoTimestamp());
   DCHECK(timestamp >= stream_start_time_);
   SetSelectedRange(NULL);
   track_buffer_.clear();
 
-  if (IsBeforeFirstRange(timestamp)) {
+  if (ShouldSeekToStartOfBuffered(timestamp)) {
     SetSelectedRange(ranges_.front());
     ranges_.front()->SeekToStart();
     seek_pending_ = false;
     return;
   }
 
   seek_buffer_timestamp_ = timestamp;
   seek_pending_ = true;
 
   RangeList::iterator itr = ranges_.end();
@@ skipping 509 matching lines @@
   return 2 * GetApproximateDuration();
 }
 
 base::TimeDelta SourceBufferRange::GetApproximateDuration() const {
   base::TimeDelta max_interbuffer_distance = interbuffer_distance_cb_.Run();
   DCHECK(max_interbuffer_distance != kNoTimestamp());
   return max_interbuffer_distance;
 }
 
 }  // namespace media