Support setting an explicit duration on MediaSource objects

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 65 matching lines @@
   // deleted, and deletes the |keyframe_map_| entries for the buffers that
   // were removed.
   // |deleted_buffers| contains the buffers that were deleted from this range,
   // starting at the buffer that had been at |next_buffer_index_|.
   // Returns true if the |next_buffer_index_| is reset. Note that this method
   // may return true even if it does not add any buffers to |deleted_buffers|.
   // This indicates that the range had not buffered |next_buffer_index_|, but
   // a buffer at that position would have been deleted.
   bool TruncateAt(scoped_refptr<StreamParserBuffer> buffer,
                   BufferQueue* deleted_buffers);
+  bool TruncateAt(base::TimeDelta timestamp);
   // Deletes all buffers in range.
   bool DeleteAll(BufferQueue* deleted_buffers);
 
   // Attempts to free |bytes| data from the range, preferring to delete at the
   // beginning of the range. Deletes data in GOPS at a time so that the range
   // always begins with a keyframe. Returns the number of bytes freed.
   int FreeFromStart(int bytes);
 
   // Attempts to free |bytes| data from the range, preferring to delete at the
   // end of the range. Returns the number of bytes freed.
@@ skipping 312 matching lines @@
     }
   }
 
   GarbageCollectIfNeeded();
 
   DCHECK(IsRangeListSorted(ranges_));
   DCHECK(OnlySelectedRangeIsSeeked());
   return true;
 }
 
+void SourceBufferStream::ResetSeekState() {
+  SetSelectedRange(NULL);
+  track_buffer_.clear();
+  config_change_pending_ = false;
+}
+
 bool SourceBufferStream::ShouldSeekToStartOfBuffered(
     base::TimeDelta seek_timestamp) const {
   if (ranges_.empty())
     return false;
   base::TimeDelta beginning_of_buffered =
       ranges_.front()->GetStartTimestamp();
   return (seek_timestamp <= beginning_of_buffered &&
           beginning_of_buffered < kSeekToStartFudgeRoom());
 }
 
@@ skipping 286 matching lines @@
     if (transfer_current_position)
       SetSelectedRange(range_with_new_buffers);
 
     delete *next_range_itr;
     ranges_.erase(next_range_itr);
   }
 }
 
 void SourceBufferStream::Seek(base::TimeDelta timestamp) {
   DCHECK(timestamp >= base::TimeDelta());
-  SetSelectedRange(NULL);
-  track_buffer_.clear();
-  config_change_pending_ = false;
+  ResetSeekState();
 
   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();
   for (itr = ranges_.begin(); itr != ranges_.end(); ++itr) {
     if ((*itr)->CanSeekTo(timestamp))
       break;
   }
 
   if (itr == ranges_.end())
     return;
 
   SetSelectedRange(*itr);
   selected_range_->Seek(timestamp);
   seek_pending_ = false;
 }
 
 bool SourceBufferStream::IsSeekPending() const {
   return seek_pending_;
 }
 
+void SourceBufferStream::OnSetDuration(base::TimeDelta duration) {
+  RangeList::iterator itr = ranges_.end();
+  for (itr = ranges_.begin(); itr != ranges_.end(); ++itr) {
+    if ((*itr)->GetEndTimestamp() > duration)
+      break;
+  }
+  if (itr == ranges_.end())
+    return;
+
+  // Need to partially truncate this range.
+  if ((*itr)->GetStartTimestamp() < duration) {
+    bool deleted_seek_point = (*itr)->TruncateAt(duration);
+    if (deleted_seek_point)
+      ResetSeekState();
+    ++itr;
+  }
+
+  // Delete all ranges that begin after |duration|.
+  while (itr != ranges_.end()) {
+    // If we're about to delete the selected range, also reset the seek state.
+    DCHECK((*itr)->GetStartTimestamp() >= duration);
+    if (*itr== selected_range_)
+      ResetSeekState();
+    delete *itr;
+    itr = ranges_.erase(itr);
+  }
+}
+
 SourceBufferStream::Status SourceBufferStream::GetNextBuffer(
     scoped_refptr<StreamParserBuffer>* out_buffer) {
   CHECK(!config_change_pending_);
 
   if (!track_buffer_.empty()) {
     if (track_buffer_.front()->GetConfigId() != current_config_index_) {
       config_change_pending_ = true;
       return kConfigChange;
     }
 
@@ skipping 316 matching lines @@
       (result == keyframe_map_.end() || result->first != timestamp)) {
     --result;
   }
   return result;
 }
 
 bool SourceBufferRange::DeleteAll(BufferQueue* removed_buffers) {
   return TruncateAt(buffers_.begin(), removed_buffers);
 }
 
+bool SourceBufferRange::TruncateAt(base::TimeDelta timestamp) {
+  // Need to make a dummy buffer with timestamp |timestamp| in order to search
+  // the |buffers_| container.
+  scoped_refptr<StreamParserBuffer> dummy_buffer =
+      StreamParserBuffer::CopyFrom(NULL, 0, false);
+  dummy_buffer->SetDecodeTimestamp(timestamp);
+  return TruncateAt(dummy_buffer, NULL);
+}
+
 bool SourceBufferRange::TruncateAt(
     scoped_refptr<StreamParserBuffer> buffer, BufferQueue* removed_buffers) {
   // Find the place in |buffers_| where we will begin deleting data.
   BufferQueue::iterator starting_point =
       std::lower_bound(buffers_.begin(), buffers_.end(),
                        buffer,
                        BufferComparator);
   return TruncateAt(starting_point, removed_buffers);
 }
 
@@ skipping 101 matching lines @@
   for (BufferQueue::iterator itr = starting_point;
        itr != ending_point; ++itr) {
     size_in_bytes_ -= (*itr)->GetDataSize();
     DCHECK_GE(size_in_bytes_, 0);
   }
   buffers_.erase(starting_point, ending_point);
 }
 
 bool SourceBufferRange::TruncateAt(
     const BufferQueue::iterator& starting_point, BufferQueue* removed_buffers) {
-  DCHECK(removed_buffers);
-  DCHECK(removed_buffers->empty());
+  DCHECK(!removed_buffers || removed_buffers->empty());
 
   // Return if we're not deleting anything.
   if (starting_point == buffers_.end())
     return false;
 
   // Reset the next buffer index if we will be deleting the buffer that's next
   // in sequence.
   bool removed_next_buffer = false;
   if (HasNextBufferPosition()) {
     base::TimeDelta next_buffer_timestamp = GetNextTimestamp();
     if (next_buffer_timestamp == kNoTimestamp() ||
         next_buffer_timestamp >= (*starting_point)->GetDecodeTimestamp()) {
-      if (HasNextBuffer()) {
+      if (HasNextBuffer() && removed_buffers) {
         int starting_offset = starting_point - buffers_.begin();
         int next_buffer_offset = next_buffer_index_ - starting_offset;
         DCHECK_GE(next_buffer_offset, 0);
         BufferQueue saved(starting_point + next_buffer_offset, buffers_.end());
         removed_buffers->swap(saved);
       }
       ResetNextBufferPosition();
       removed_next_buffer = true;
     }
   }
@@ skipping 136 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