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 470 matching lines @@
   while (!ranges_.empty() && bytes_to_free > 0) {
     SourceBufferRange* current_range = NULL;
     BufferQueue buffers;
     int bytes_deleted = 0;
 
     if (reverse_direction) {
       current_range = ranges_.back();
       if (current_range->LastGOPContainsNextBufferPosition()) {
         DCHECK_EQ(current_range, selected_range_);
         break;
       }

[acolwell GONE FROM CHROMIUM, 2014/06/19 16:00:25]

I think you need a LastGOP equivalent so that the GOP doesn't get removed from
the backwards direction either. FirstGOPContainsNextBufferPosition() and
LastGOPContainsNextBufferPosition() should probably be renamed with
s/NextBufferPosition/CurrentPlaybackPosition/ and handle the time & position
based checks since both represent the "current position". Another way to think
if this is to essentially protect the time range between the current media time
and the timestamp on the "next buffer position". If a GOP intersects with that
range, then it shouldn't be removed.

       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(current_media_time_)) {

[acolwell GONE FROM CHROMIUM, 2014/06/19 16:00:25]

Don't you really want FirstGOPContainsMediaTime(current_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