Fix MSE GC, make it less aggressive, more spec-compliant

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 113 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);
 
+  // If the buffer is full, attempts to try to free up space, as specified in
+  // the "Coded Frame Eviction Algorithm" in the Media Source Extensions Spec.
+  // Returns false iff buffer is still full after running eviction.
+  // https://w3c.github.io/media-source/#sourcebuffer-coded-frame-eviction
+  bool EvictCodedFrames(DecodeTimestamp media_time, size_t newDataSize);
+
   // 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 218 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::EvictCodedFrames(DecodeTimestamp media_time,

[wolenetz, 2015/08/20 23:23:37]

Please extract the heuristic for determining newAudioSize and newVideoSize into
a method, and add unit tests for that method.

[servolk, 2015/08/21 01:32:08]

I've extracted the heuristic into a new method in SourceState class. But that's
an internal helper class for the ChunkDemuxer and currently there are no direct
tests for it. So for now I've added a new ChunkDemuxer test for
EvictCodedFrames, that uses muxed data and implicitly tests this function as
well.

+                                   size_t newDataSize) {
+  bool success = true;
+
+  size_t newAudioSize = 0;
+  size_t newVideoSize = 0;
+  size_t videoBufferedSize = video_ ? video_->GetBufferedSize() : 0;
+  if (audio_ && video_ && videoBufferedSize > 0) {

[wolenetz, 2015/08/20 23:23:37]

nit: please add a comment describing this heuristic, perhaps mentioning that
other heuristics that incrementally build audio/video/text removal ranges that
are aligned in time could be a better solution, since muxed contents are muxed
in interleaved DTS sequence across the streams.

[servolk, 2015/08/21 01:32:08]

Done.

+    newVideoSize = newDataSize * audio_->GetBufferedSize() / videoBufferedSize;

[wolenetz, 2015/08/20 23:23:37]

This seems incorrect.
[estimated headroom for new video] should be = [total new media size] *
[proportion of video of all buffered size]

example:
100MB total currently buffered, 80MB video + 20MB audio
total new media size = 10MB
estimated new video size = 10MB * (80MB / 100MB) = 8MB
estimated new audio size = 10MB * (20MB / 100MB) = 2MB

However, current patch set would instead calculate:
estimated new video size = 10MB * (20MB / 80MB) = 2.5MB
estimated new audio size = 10MB - 2.5MB = 7.5MB

[servolk, 2015/08/21 01:32:08]

Oh, yes, you are right, not sure what I was thinking, I've changed the formula
to newDataSize * V / (A+V) now.

+    newAudioSize = newDataSize - newVideoSize;
+  } else if (video_) {
+    newVideoSize = newDataSize;
+  } else if (audio_) {
+    newAudioSize = newDataSize;
+  }
+

[wolenetz, 2015/08/20 23:23:37]

Please add some DVLOGs describing newDataSize, newAudioSize, newVideoSize, and
before and after video_,audio_ ->GetBufferedSize()

[servolk, 2015/08/21 01:32:08]

Done.

+  if (audio_)
+    success = audio_->EvictCodedFrames(media_time, newAudioSize) && success;
+
+  if (video_)
+    success = video_->EvictCodedFrames(media_time, newVideoSize) && success;
+
+  for (TextStreamMap::iterator itr = text_stream_map_.begin();
+       itr != text_stream_map_.end(); ++itr) {
+    success = itr->second->EvictCodedFrames(media_time, 0) && 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 490 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::EvictCodedFrames(DecodeTimestamp media_time,
+                                          size_t newDataSize) {
+  base::AutoLock auto_lock(lock_);
+  return stream_->GarbageCollectIfNeeded(media_time, newDataSize);
+}
+
 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 16 matching lines @@
   // range.
   Ranges<TimeDelta> valid_time_range;
   valid_time_range.Add(range.start(0), duration);
   return range.IntersectionWith(valid_time_range);
 }
 
 TimeDelta ChunkDemuxerStream::GetBufferedDuration() const {
   return stream_->GetBufferedDuration();
 }
 
+size_t ChunkDemuxerStream::GetBufferedSize() const {
+  return stream_->GetBufferedSize();
+}
+
 void ChunkDemuxerStream::OnNewMediaSegment(DecodeTimestamp start_timestamp) {
   DVLOG(2) << "ChunkDemuxerStream::OnNewMediaSegment("
            << start_timestamp.InSecondsF() << ")";
   base::AutoLock auto_lock(lock_);
   stream_->OnNewMediaSegment(start_timestamp);
 }
 
 bool ChunkDemuxerStream::UpdateAudioConfig(
     const AudioDecoderConfig& config,
     const scoped_refptr<MediaLog>& media_log) {
@@ skipping 386 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::EvictCodedFrames(const std::string& id,
+                                    base::TimeDelta currentMediaTime,
+                                    size_t newDataSize) {
+  DVLOG(1) << __FUNCTION__ << "(" << id << ")"
+           << " media_time=" << currentMediaTime.InSecondsF()
+           << " newDataSize=" << newDataSize;
+  base::AutoLock auto_lock(lock_);
+
+  // Note: The direct conversion from PTS to DTS is safe here, since we don't
+  // need to know currentTime precisely for GC. GC only needs to know which GOP
+  // currentTime points to.
+  DecodeTimestamp media_time_dts =
+      DecodeTimestamp::FromPresentationTime(currentMediaTime);
+
+  DCHECK(!id.empty());
+  SourceStateMap::const_iterator itr = source_state_map_.find(id);
+  if (itr == source_state_map_.end()) {
+    LOG(WARNING) << __FUNCTION__ << " stream " << id << " not found";
+    return false;
+  }
+  return itr->second->EvictCodedFrames(media_time_dts, newDataSize);
+}
+
 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 500 matching lines @@
 }
 
 void ChunkDemuxer::ShutdownAllStreams() {
   for (SourceStateMap::iterator itr = source_state_map_.begin();
        itr != source_state_map_.end(); ++itr) {
     itr->second->Shutdown();
   }
 }
 
 }  // namespace media