Implement evictFrames() to support MSE's coded frame eviction algorithm.

media/filters/chunk_demuxer.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/chunk_demuxer.h"
 
 #include <algorithm>
 #include <limits>
 #include <list>
 
@@ skipping 115 matching lines @@
 
   // Aborts the current append sequence and resets the parser.
   void Abort(TimeDelta append_window_start,
              TimeDelta append_window_end,
              TimeDelta* timestamp_offset);
 
   // Calls Remove(|start|, |end|, |duration|) on all
   // ChunkDemuxerStreams managed by this object.
   void Remove(TimeDelta start, TimeDelta end, TimeDelta duration);
 
+  bool EvictFrames(DecodeTimestamp media_time);
+
   // Returns true if currently parsing a media segment, or false otherwise.
   bool parsing_media_segment() const { return parsing_media_segment_; }
 
   // Sets |frame_processor_|'s sequence mode to |sequence_mode|.
   void SetSequenceMode(bool sequence_mode);
 
   // Signals the coded frame processor to update its group start timestamp to be
   // |timestamp_offset| if it is in sequence append mode.
   void SetGroupStartTimestampIfInSequenceMode(base::TimeDelta timestamp_offset);
 
@@ skipping 222 matching lines @@
 
   if (video_)
     video_->Remove(start, end, duration);
 
   for (TextStreamMap::iterator itr = text_stream_map_.begin();
        itr != text_stream_map_.end(); ++itr) {
     itr->second->Remove(start, end, duration);
   }
 }
 
+bool SourceState::EvictFrames(DecodeTimestamp media_time) {
+  bool success = true;
+
+  if(audio_)
+    success = audio_->EvictFrames(media_time) && success;
+
+  if (video_)
+    success = video_->EvictFrames(media_time) && success;
+
+  for (TextStreamMap::iterator itr = text_stream_map_.begin();
+       itr != text_stream_map_.end(); ++itr) {
+    success = itr->second->EvictFrames(media_time) && success;
+  }
+
+  return success;
+}
+
 Ranges<TimeDelta> SourceState::GetBufferedRanges(TimeDelta duration,
                                                  bool ended) const {
   // TODO(acolwell): When we start allowing disabled tracks we'll need to update
   // this code to only add ranges from active tracks.
   RangesList ranges_list;
   if (audio_)
     ranges_list.push_back(audio_->GetBufferedRanges(duration));
 
   if (video_)
     ranges_list.push_back(video_->GetBufferedRanges(duration));
@@ skipping 488 matching lines @@
 
   return true;
 }
 
 void ChunkDemuxerStream::Remove(TimeDelta start, TimeDelta end,
                                 TimeDelta duration) {
   base::AutoLock auto_lock(lock_);
   stream_->Remove(start, end, duration);
 }
 
+bool ChunkDemuxerStream::EvictFrames(DecodeTimestamp media_time) {
+  base::AutoLock auto_lock(lock_);
+  return stream_->GarbageCollectIfNeeded(media_time);
+}
+
 void ChunkDemuxerStream::OnSetDuration(TimeDelta duration) {
   base::AutoLock auto_lock(lock_);
   stream_->OnSetDuration(duration);
 }
 
 Ranges<TimeDelta> ChunkDemuxerStream::GetBufferedRanges(
     TimeDelta duration) const {
   base::AutoLock auto_lock(lock_);
 
   if (type_ == TEXT) {
@@ skipping 221 matching lines @@
       log_cb_(log_cb),
       media_log_(media_log),
       duration_(kNoTimestamp()),
       user_specified_duration_(-1),
       liveness_(DemuxerStream::LIVENESS_UNKNOWN),
       splice_frames_enabled_(splice_frames_enabled) {
   DCHECK(!open_cb_.is_null());
   DCHECK(!encrypted_media_init_data_cb_.is_null());
 }
 
+void ChunkDemuxer::SetMediaTimeProvider(
+    const base::Callback<base::TimeDelta(void)>& get_media_time_cb) {
+  get_media_time_cb_ = get_media_time_cb;
+}
+
 void ChunkDemuxer::Initialize(
     DemuxerHost* host,
     const PipelineStatusCB& cb,
     bool enable_text_tracks) {
   DVLOG(1) << "Init()";
 
   base::AutoLock auto_lock(lock_);
 
   init_cb_ = BindToCurrentLoop(cb);
   if (state_ == SHUTDOWN) {
@@ skipping 172 matching lines @@
 Ranges<TimeDelta> ChunkDemuxer::GetBufferedRanges(const std::string& id) const {
   base::AutoLock auto_lock(lock_);
   DCHECK(!id.empty());
 
   SourceStateMap::const_iterator itr = source_state_map_.find(id);
 
   DCHECK(itr != source_state_map_.end());
   return itr->second->GetBufferedRanges(duration_, state_ == ENDED);
 }
 
+bool ChunkDemuxer::EvictFrames() {
+  DecodeTimestamp current_media_time;
+  if (!get_media_time_cb_.is_null()) {
+    current_media_time =
+        DecodeTimestamp::FromPresentationTime(get_media_time_cb_.Run());
+  } else {
+    current_media_time = kNoDecodeTimestamp();
+  }
+
+  bool success = true;
+  for (SourceStateMap::iterator itr = source_state_map_.begin();
+       itr != source_state_map_.end(); ++itr) {
+    success = itr->second->EvictFrames(current_media_time) && success;
+  }
+  return success;
+}
+
 void ChunkDemuxer::AppendData(
     const std::string& id,
     const uint8* data,
     size_t length,
     TimeDelta append_window_start,
     TimeDelta append_window_end,
     TimeDelta* timestamp_offset,
     const InitSegmentReceivedCB& init_segment_received_cb) {
   DVLOG(1) << "AppendData(" << id << ", " << length << ")";
 
@@ skipping 523 matching lines @@
 }
 
 void ChunkDemuxer::ShutdownAllStreams() {
   for (SourceStateMap::iterator itr = source_state_map_.begin();
        itr != source_state_map_.end(); ++itr) {
     itr->second->Shutdown();
   }
 }
 
 }  // namespace media