Introduce the playback time into the MSE garbage collection.

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 108 matching lines @@
 
   // Gets the range of GOP to secure at least |bytes_to_free| from
   // [|start_timestamp|, |end_timestamp|).
   // Returns the size of the buffers to secure if the buffers of
   // [|start_timestamp|, |end_removal_timestamp|) is removed.
   // Will not update |end_removal_timestamp| if the returned size is 0.
   int GetRemovalGOP(
       base::TimeDelta start_timestamp, base::TimeDelta end_timestamp,
       int bytes_to_free, base::TimeDelta* end_removal_timestamp);
 
+  // Indicates whether the GOP at the beginning of the range
+  // has timestamps all lower than |media_time|.
+  bool FirstGOPEarlierThanMediaTime(base::TimeDelta media_time) const;
+
   // Indicates whether the GOP at the beginning or end of the range contains the
   // next buffer position.
   bool FirstGOPContainsNextBufferPosition() const;
   bool LastGOPContainsNextBufferPosition() const;
 
   // Updates |out_buffer| with the next buffer in presentation order. Seek()
   // must be called before calls to GetNextBuffer(), and buffers are returned
   // in order from the last call to Seek(). Returns true if |out_buffer| is
   // filled with a valid buffer, false if there is not enough data to fulfill
   // the request.
@@ skipping 205 matching lines @@
 SourceBufferStream::SourceBufferStream(const AudioDecoderConfig& audio_config,
                                        const LogCB& log_cb,
                                        bool splice_frames_enabled)
     : log_cb_(log_cb),
       current_config_index_(0),
       append_config_index_(0),
       seek_pending_(false),
       end_of_stream_(false),
       seek_buffer_timestamp_(kNoTimestamp()),
       selected_range_(NULL),
+      current_media_time_(kNoTimestamp()),
       media_segment_start_time_(kNoTimestamp()),
       range_for_next_append_(ranges_.end()),
       new_media_segment_(false),
       last_appended_buffer_timestamp_(kNoTimestamp()),
       last_appended_buffer_is_keyframe_(false),
       last_output_buffer_timestamp_(kNoTimestamp()),
       max_interbuffer_distance_(kNoTimestamp()),
       memory_limit_(kDefaultAudioMemoryLimit),
       config_change_pending_(false),
       splice_buffers_index_(0),
       pending_buffers_complete_(false),
       splice_frames_enabled_(splice_frames_enabled) {
   DCHECK(audio_config.IsValidConfig());
   audio_configs_.push_back(audio_config);
 }
 
 SourceBufferStream::SourceBufferStream(const VideoDecoderConfig& video_config,
                                        const LogCB& log_cb,
                                        bool splice_frames_enabled)
     : log_cb_(log_cb),
       current_config_index_(0),
       append_config_index_(0),
       seek_pending_(false),
       end_of_stream_(false),
       seek_buffer_timestamp_(kNoTimestamp()),
       selected_range_(NULL),
+      current_media_time_(kNoTimestamp()),
       media_segment_start_time_(kNoTimestamp()),
       range_for_next_append_(ranges_.end()),
       new_media_segment_(false),
       last_appended_buffer_timestamp_(kNoTimestamp()),
       last_appended_buffer_is_keyframe_(false),
       last_output_buffer_timestamp_(kNoTimestamp()),
       max_interbuffer_distance_(kNoTimestamp()),
       memory_limit_(kDefaultVideoMemoryLimit),
       config_change_pending_(false),
       splice_buffers_index_(0),
       pending_buffers_complete_(false),
       splice_frames_enabled_(splice_frames_enabled) {
   DCHECK(video_config.IsValidConfig());
   video_configs_.push_back(video_config);
 }
 
 SourceBufferStream::SourceBufferStream(const TextTrackConfig& text_config,
                                        const LogCB& log_cb,
                                        bool splice_frames_enabled)
     : log_cb_(log_cb),
       current_config_index_(0),
       append_config_index_(0),
       text_track_config_(text_config),
       seek_pending_(false),
       end_of_stream_(false),
       seek_buffer_timestamp_(kNoTimestamp()),
       selected_range_(NULL),
+      current_media_time_(kNoTimestamp()),
       media_segment_start_time_(kNoTimestamp()),
       range_for_next_append_(ranges_.end()),
       new_media_segment_(false),
       last_appended_buffer_timestamp_(kNoTimestamp()),
       last_appended_buffer_is_keyframe_(false),
       last_output_buffer_timestamp_(kNoTimestamp()),
       max_interbuffer_distance_(kNoTimestamp()),
       memory_limit_(kDefaultAudioMemoryLimit),
       config_change_pending_(false),
       splice_buffers_index_(0),
@@ skipping 21 matching lines @@
   if (range_for_next_append_ == ranges_.end() ||
       !AreAdjacentInSequence(last_appended_buffer_timestamp_,
                              media_segment_start_time)) {
     last_appended_buffer_timestamp_ = kNoTimestamp();
     last_appended_buffer_is_keyframe_ = false;
   } else if (last_range != ranges_.end()) {
     DCHECK(last_range == range_for_next_append_);
   }
 }
 
-bool SourceBufferStream::Append(const BufferQueue& buffers) {
+bool SourceBufferStream::Append(const BufferQueue& buffers,
+                                base::TimeDelta media_time) {
   TRACE_EVENT2("media", "SourceBufferStream::Append",
                "stream type", GetStreamTypeName(),
                "buffers to append", buffers.size());
 
   DCHECK(!buffers.empty());
   DCHECK(media_segment_start_time_ != kNoTimestamp());
   DCHECK(media_segment_start_time_ <= buffers.front()->GetDecodeTimestamp());
   DCHECK(!end_of_stream_);
 
   // New media segments must begin with a keyframe.
@@ skipping 111 matching lines @@
   // are appended to the range covered by |track_buffer_|.
   if (!track_buffer_.empty()) {
     base::TimeDelta keyframe_timestamp =
         FindKeyframeAfterTimestamp(track_buffer_.front()->GetDecodeTimestamp());
     if (keyframe_timestamp != kNoTimestamp())
       PruneTrackBuffer(keyframe_timestamp);
   }
 
   SetSelectedRangeIfNeeded(next_buffer_timestamp);
 
-  GarbageCollectIfNeeded();
+  GarbageCollectIfNeeded(media_time);
 
   DCHECK(IsRangeListSorted(ranges_));
   DCHECK(OnlySelectedRangeIsSeeked());
   return true;
 }
 
 void SourceBufferStream::Remove(base::TimeDelta start, base::TimeDelta end,
                                 base::TimeDelta duration) {
   DVLOG(1) << __FUNCTION__ << "(" << start.InSecondsF()
            << ", " << end.InSecondsF()
@@ skipping 193 matching lines @@
   }
 }
 
 void SourceBufferStream::SetConfigIds(const BufferQueue& buffers) {
   for (BufferQueue::const_iterator itr = buffers.begin();
        itr != buffers.end(); ++itr) {
     (*itr)->SetConfigId(append_config_index_);
   }
 }
 
-void SourceBufferStream::GarbageCollectIfNeeded() {
+void SourceBufferStream::GarbageCollectIfNeeded(base::TimeDelta media_time) {
   // Compute size of |ranges_|.
   int ranges_size = 0;
   for (RangeList::iterator itr = ranges_.begin(); itr != ranges_.end(); ++itr)
     ranges_size += (*itr)->size_in_bytes();
 
   // Return if we're under or at the memory limit.
   if (ranges_size <= memory_limit_)
     return;
 
   int bytes_to_free = ranges_size - memory_limit_;
 
   // Begin deleting after the last appended buffer.
   int bytes_freed = FreeBuffersAfterLastAppended(bytes_to_free);
 
   // Begin deleting from the front.
   if (bytes_to_free - bytes_freed > 0)
-    bytes_freed += FreeBuffers(bytes_to_free - bytes_freed, false);
+    bytes_freed += FreeBuffers(bytes_to_free - bytes_freed, false, media_time);
 
   // Begin deleting from the back.
   if (bytes_to_free - bytes_freed > 0)
-    FreeBuffers(bytes_to_free - bytes_freed, true);
+    FreeBuffers(bytes_to_free - bytes_freed, true, media_time);
 }
 
 int SourceBufferStream::FreeBuffersAfterLastAppended(int total_bytes_to_free) {
   base::TimeDelta next_buffer_timestamp = GetNextBufferTimestamp();
   if (last_appended_buffer_timestamp_ == kNoTimestamp() ||
       next_buffer_timestamp == kNoTimestamp() ||
       last_appended_buffer_timestamp_ >= next_buffer_timestamp) {
     return 0;
   }
 
@@ skipping 38 matching lines @@
 
     int bytes_removed = range->GetRemovalGOP(
         start_timestamp, end_timestamp, bytes_to_free, removal_end_timestamp);
     bytes_to_free -= bytes_removed;
     bytes_freed += bytes_removed;
   }
   return bytes_freed;
 }
 
 int SourceBufferStream::FreeBuffers(int total_bytes_to_free,
-                                    bool reverse_direction) {
+                                    bool reverse_direction,
+                                    base::TimeDelta media_time) {
   TRACE_EVENT2("media", "SourceBufferStream::FreeBuffers",
                "total bytes to free", total_bytes_to_free,
                "reverse direction", reverse_direction);
 
   DCHECK_GT(total_bytes_to_free, 0);
   int bytes_to_free = total_bytes_to_free;
   int bytes_freed = 0;
 
   // This range will save the last GOP appended to |range_for_next_append_|
   // if the buffers surrounding it get deleted during garbage collection.
@@ skipping 10 matching lines @@
         DCHECK_EQ(current_range, selected_range_);
         break;
       }
       bytes_deleted = current_range->DeleteGOPFromBack(&buffers);
     } else {
       current_range = ranges_.front();
       if (current_range->FirstGOPContainsNextBufferPosition()) {
         DCHECK_EQ(current_range, selected_range_);
         break;
       }
+      if (current_media_time_ != kNoTimestamp() &&
+          !current_range->FirstGOPEarlierThanMediaTime(media_time)) {
+        break;
+      }
       bytes_deleted = current_range->DeleteGOPFromFront(&buffers);
     }
 
     // Check to see if we've just deleted the GOP that was last appended.
     base::TimeDelta end_timestamp = buffers.back()->GetDecodeTimestamp();
     if (end_timestamp == last_appended_buffer_timestamp_) {
       DCHECK(last_appended_buffer_timestamp_ != kNoTimestamp());
       DCHECK(!new_range_for_append);
       // Create a new range containing these buffers.
       new_range_for_append = new SourceBufferRange(
@@ skipping 152 matching lines @@
   // merges.
   if (transfer_current_position)
     SetSelectedRange(range_with_new_buffers);
 
   if (next_range_itr == range_for_next_append_)
     range_for_next_append_ = range_with_new_buffers_itr;
 
   DeleteAndRemoveRange(&next_range_itr);
 }
 
+void SourceBufferStream::NotifyMediaTimeUpdate(base::TimeDelta media_time) {
+  if (current_media_time_ != kNoTimestamp() &&
+      media_time < current_media_time_) {
+    LOG(WARNING) << "Time should be monotonically increasing: "
+                 << media_time.InMilliseconds()
+                 << " " << current_media_time_.InMilliseconds();
+    return;
+  }
+  current_media_time_ = media_time;
+}
+
 void SourceBufferStream::Seek(base::TimeDelta timestamp) {
   DCHECK(timestamp >= base::TimeDelta());
   ResetSeekState();
 
+  current_media_time_ = kNoTimestamp();
+
   if (ShouldSeekToStartOfBuffered(timestamp)) {
     ranges_.front()->SeekToStart();
     SetSelectedRange(ranges_.front());
     seek_pending_ = false;
     return;
   }
 
   seek_buffer_timestamp_ = timestamp;
   seek_pending_ = true;
 
@@ skipping 890 matching lines @@
     bytes_removed += gop_size;
     bytes_to_free -= gop_size;
   }
   if (bytes_removed > 0) {
     *removal_end_timestamp = gop_itr == keyframe_map_.end() ?
         GetBufferedEndTimestamp() : gop_itr->first;
   }
   return bytes_removed;
 }
 
+bool SourceBufferRange::FirstGOPEarlierThanMediaTime(
+    base::TimeDelta media_time) const {
+  if (keyframe_map_.size() == 1u)
+    return (GetEndTimestamp() < media_time);
+
+  KeyframeMap::const_iterator second_gop = keyframe_map_.begin();
+  ++second_gop;
+  return second_gop->first <= media_time;
+}
+
 bool SourceBufferRange::FirstGOPContainsNextBufferPosition() const {
   if (!HasNextBufferPosition())
     return false;
 
   // If there is only one GOP, it must contain the next buffer position.
   if (keyframe_map_.size() == 1u)
     return true;
 
   KeyframeMap::const_iterator second_gop = keyframe_map_.begin();
   ++second_gop;
@@ skipping 265 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