Reland r145965 - Make sure previous seek points in SourceBufferStream are ignored during overlaps

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 77 matching lines @@
   // filled with a valid buffer, false if there is not enough data to fulfill
   // the request.
   bool GetNextBuffer(scoped_refptr<StreamParserBuffer>* out_buffer);
   bool HasNextBuffer() const;
 
   // Returns true if the range knows the position of the next buffer it should
   // return, i.e. it has been Seek()ed. This does not necessarily mean that it
   // has the next buffer yet.
   bool HasNextBufferPosition() const;
 
+  // Resets this range to an "unseeked" state.
+  void ResetNextBufferPosition();
+
   // Returns the timestamp of the next buffer that will be returned from
   // GetNextBuffer(), or kNoTimestamp() if the timestamp is unknown.
   base::TimeDelta GetNextTimestamp() const;
 
   // Returns the start timestamp of the range.
   base::TimeDelta GetStartTimestamp() const;
 
   // Returns the timestamp of the last buffer in the range.
   base::TimeDelta GetEndTimestamp() const;
 
@@ skipping 208 matching lines @@
   ResolveCompleteOverlaps(
       range_for_new_buffers, &deleted_next_buffer, &deleted_buffers);
   ResolveEndOverlap(
       range_for_new_buffers, &deleted_next_buffer, &deleted_buffers);
   MergeWithAdjacentRangeIfNecessary(range_for_new_buffers);
 
   // If these were the first buffers appended to the stream, seek to the
   // beginning of the range.
   // TODO(vrk): This should be done by ChunkDemuxer. (crbug.com/132815)
   if (!seek_pending_ && !selected_range_) {
-    selected_range_ = *range_for_new_buffers;
+    SetSelectedRange(*range_for_new_buffers);
     selected_range_->Seek(buffers.front()->GetDecodeTimestamp());
   }
 
   // Seek to try to fulfill a previous call to Seek().
   if (seek_pending_) {
     DCHECK(!selected_range_);
     DCHECK(!deleted_next_buffer);
     Seek(seek_buffer_timestamp_);
   }
 
   // Seek because the Append() has deleted the buffer that would have been
   // returned in the next call to GetNextBuffer().
   if (deleted_next_buffer) {
     DCHECK(!seek_pending_);
-    selected_range_ = *range_for_new_buffers;
+    SetSelectedRange(*range_for_new_buffers);
     if (!deleted_buffers.empty()) {
       // Seek the range to the keyframe at or after |next_buffer_timestamp|.
       selected_range_->SeekAheadTo(next_buffer_timestamp);
       UpdateTrackBuffer(deleted_buffers);
     } else {
       // If we've deleted the next buffer but |deleted_buffers| is empty,
       // that means we need to seek past the timestamp of the last buffer in
       // the range (i.e. the keyframe timestamp needs to be strictly greater
       // than |end_buffer_timestamp|).
       selected_range_->SeekAheadPast(end_buffer_timestamp);
     }
   }
 
   DCHECK(IsRangeListSorted(ranges_));
+  DCHECK(OnlySelectedRangeIsSeeked());
   return true;
 }
 
 bool SourceBufferStream::IsMonotonicallyIncreasing(
     const BufferQueue& buffers) {
   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());
 
     if (prev_timestamp != kNoTimestamp() && current_timestamp < prev_timestamp)
       return false;
 
     prev_timestamp = current_timestamp;
   }
   return true;
 }
 
+bool SourceBufferStream::OnlySelectedRangeIsSeeked() const {
+  for (RangeList::const_iterator itr = ranges_.begin();
+       itr != ranges_.end(); ++itr) {
+    if ((*itr)->HasNextBufferPosition() && (*itr) != selected_range_)
+      return false;
+  }
+  return !selected_range_ || selected_range_->HasNextBufferPosition();
+}
+
 void SourceBufferStream::UpdateMaxInterbufferDistance(
     const BufferQueue& buffers) {
   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());
 
     if (prev_timestamp != kNoTimestamp()) {
@@ skipping 31 matching lines @@
   // of |new_buffers|, and add them into a new range.
   SourceBufferRange* new_next_range =
       range_for_new_buffers->SplitRange(
           new_buffers.back()->GetDecodeTimestamp());
 
   if (new_next_range)
     AddToRanges(new_next_range);
 
   // Delete the buffers that are overlapped by |new_buffers|, then append
   // |new_buffers| to the end of the range.
+  BufferQueue saved_buffers;
+  bool deleted_next_buffer_from_range =
+      range_for_new_buffers->TruncateAt(new_buffers.front(), &saved_buffers);
+  range_for_new_buffers->AppendToEnd(new_buffers);
+
+  if (selected_range_ != range_for_new_buffers)
+    return;
+
   DCHECK(!*deleted_next_buffer);
-  *deleted_next_buffer =
-      range_for_new_buffers->TruncateAt(new_buffers.front(), deleted_buffers);
-  range_for_new_buffers->AppendToEnd(new_buffers);
+  *deleted_buffers = saved_buffers;
+  *deleted_next_buffer = deleted_next_buffer_from_range;
 
   // If this was a middle overlap resulting in a new range, and the next buffer
   // position has been transferred to the newly created range, update the
   // |selected_range_| accordingly.
   if (new_next_range && new_next_range->HasNextBufferPosition()) {
     DCHECK(!range_for_new_buffers->HasNextBufferPosition());
     DCHECK(!*deleted_next_buffer);
-    selected_range_ = new_next_range;
+    SetSelectedRange(new_next_range);
   }
 }
 
 void SourceBufferStream::ResolveCompleteOverlaps(
     const RangeList::iterator& range_with_new_buffers_itr,
     bool* deleted_next_buffer, BufferQueue* deleted_buffers) {
   DCHECK(deleted_next_buffer);
   DCHECK(deleted_buffers);
 
   SourceBufferRange* range_with_new_buffers = *range_with_new_buffers_itr;
   RangeList::iterator next_range_itr = range_with_new_buffers_itr;
   next_range_itr++;
 
   while (next_range_itr != ranges_.end() &&
          range_with_new_buffers->CompletelyOverlaps(**next_range_itr)) {
     if (*next_range_itr == selected_range_) {
-      selected_range_ = NULL;
       DCHECK(!*deleted_next_buffer);
-      *deleted_next_buffer = (*next_range_itr)->DeleteAll(deleted_buffers);
+      *deleted_next_buffer = selected_range_->DeleteAll(deleted_buffers);
       DCHECK(*deleted_next_buffer);
+      SetSelectedRange(NULL);
     }
     delete *next_range_itr;
     next_range_itr = ranges_.erase(next_range_itr);
   }
 }
 
 void SourceBufferStream::ResolveEndOverlap(
     const RangeList::iterator& range_with_new_buffers_itr,
     bool* deleted_next_buffer, BufferQueue* deleted_buffers) {
   DCHECK(deleted_next_buffer);
@@ skipping 23 matching lines @@
     AddToRanges(new_next_range);
 
   // If we didn't overlap a selected range, return.
   if (selected_range_ != overlapped_range.get())
     return;
 
   // If the |overlapped_range| transfers its next buffer position to
   // |new_next_range|, make |new_next_range| the |selected_range_|.
   if (new_next_range && new_next_range->HasNextBufferPosition()) {
     DCHECK(!overlapped_range->HasNextBufferPosition());
-    selected_range_ = new_next_range;
+    SetSelectedRange(new_next_range);
     return;
   }
 
   // Save the buffers in |overlapped_range|.
   DCHECK(!*deleted_next_buffer);
+  DCHECK_EQ(overlapped_range.get(), selected_range_);
   *deleted_next_buffer = overlapped_range->DeleteAll(deleted_buffers);
   DCHECK(*deleted_next_buffer);
+
+  // |overlapped_range| will be deleted, so set |selected_range_| to NULL.
+  SetSelectedRange(NULL);
 }
 
 void SourceBufferStream::UpdateTrackBuffer(const BufferQueue& deleted_buffers) {
   DCHECK(!deleted_buffers.empty());
   if (!track_buffer_.empty())
     return;
 
   DCHECK(selected_range_);
   DCHECK(selected_range_->HasNextBufferPosition());
 
@@ skipping 27 matching lines @@
 
   // See if the next range contains the keyframe after the end of the
   // |track_buffer_|, and if so, change |selected_range_|.
   RangeList::iterator next_range_itr = ++(GetSelectedRangeItr());
   if (next_range_itr != ranges_.end()) {
     (*next_range_itr)->SeekAheadPast(
         track_buffer_.back()->GetDecodeTimestamp());
     if ((*next_range_itr)->HasNextBuffer() &&
         selected_range_->IsNextInSequence(
             track_buffer_.back(), (*next_range_itr)->GetNextTimestamp())) {
-      selected_range_ = *next_range_itr;
+      SetSelectedRange(*next_range_itr);
     }
   }
 }
 
 void SourceBufferStream::MergeWithAdjacentRangeIfNecessary(
     const RangeList::iterator& range_with_new_buffers_itr) {
   SourceBufferRange* range_with_new_buffers = *range_with_new_buffers_itr;
   RangeList::iterator next_range_itr = range_with_new_buffers_itr;
   next_range_itr++;
 
   if (next_range_itr != ranges_.end() &&
       range_with_new_buffers->CanAppendToEnd(**next_range_itr)) {
     bool transfer_current_position = selected_range_ == *next_range_itr;
     range_with_new_buffers->AppendToEnd(**next_range_itr,
                                         transfer_current_position);
     // Update |selected_range_| pointer if |range| has become selected after
     // merges.
     if (transfer_current_position)
-      selected_range_ = range_with_new_buffers;
+      SetSelectedRange(range_with_new_buffers);
 
     delete *next_range_itr;
     ranges_.erase(next_range_itr);
   }
 }
 
 void SourceBufferStream::Seek(base::TimeDelta timestamp) {
-  selected_range_ = NULL;
+  SetSelectedRange(NULL);
   track_buffer_.clear();
 
   seek_buffer_timestamp_ = timestamp;
   seek_pending_ = true;
 
   RangeList::iterator itr = ranges_.end();
   for (itr = ranges_.begin(); itr != ranges_.end(); itr++) {
     if ((*itr)->CanSeekTo(timestamp))
       break;
   }
 
   if (itr == ranges_.end())
     return;
 
-  selected_range_ = *itr;
+  SetSelectedRange(*itr);
   selected_range_->Seek(timestamp);
   seek_pending_ = false;
   end_of_stream_ = false;
 }
 
 bool SourceBufferStream::IsSeekPending() const {
   return seek_pending_;
 }
 
 bool SourceBufferStream::GetNextBuffer(
@@ skipping 52 matching lines @@
   DCHECK(selected_range_);
   RangeList::iterator itr = ranges_.end();
   for (itr = ranges_.begin(); itr != ranges_.end(); itr++) {
     if (*itr == selected_range_)
       break;
   }
   DCHECK(itr != ranges_.end());
   return itr;
 }
 
+void SourceBufferStream::SetSelectedRange(SourceBufferRange* range) {
+  if (selected_range_)
+    selected_range_->ResetNextBufferPosition();
+  selected_range_ = range;
+}
+
 Ranges<base::TimeDelta> SourceBufferStream::GetBufferedTime() const {
   Ranges<base::TimeDelta> ranges;
   for (RangeList::const_iterator itr = ranges_.begin();
        itr != ranges_.end(); itr++) {
     ranges.Add((*itr)->GetStartTimestamp(), (*itr)->GetBufferedEndTimestamp());
   }
   return ranges;
 }
 
 void SourceBufferStream::EndOfStream() {
@@ skipping 216 matching lines @@
   if (next_buffer_index_ >= static_cast<int>(buffers_.size()))
     return kNoTimestamp();
 
   return buffers_.at(next_buffer_index_)->GetDecodeTimestamp();
 }
 
 bool SourceBufferRange::HasNextBufferPosition() const {
   return next_buffer_index_ >= 0 || waiting_for_keyframe_;
 }
 
+void SourceBufferRange::ResetNextBufferPosition() {
+  next_buffer_index_ = -1;
+  waiting_for_keyframe_ = false;
+  next_keyframe_timestamp_ = kNoTimestamp();
+}
+
 void SourceBufferRange::AppendToEnd(const SourceBufferRange& range,
                                     bool transfer_current_position) {
   DCHECK(CanAppendToEnd(range));
   DCHECK(!buffers_.empty());
 
   if (transfer_current_position)
     next_buffer_index_ = range.next_buffer_index_ + buffers_.size();
 
   AppendToEnd(range.buffers_);
 }
@@ skipping 68 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