Experiment with more aggressive MSE GC on memory pressure

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 <sstream>
 #include <string>
@@ skipping 675 matching lines @@
 }
 
 void SourceBufferStream::SetConfigIds(const BufferQueue& buffers) {
   for (BufferQueue::const_iterator itr = buffers.begin();
        itr != buffers.end(); ++itr) {
     (*itr)->SetConfigId(append_config_index_);
   }
 }
 
 bool SourceBufferStream::GarbageCollectIfNeeded(DecodeTimestamp media_time,
-                                                size_t newDataSize) {
+                                                size_t eviction_size,
+                                                size_t* bytes_released) {
   DCHECK(media_time != kNoDecodeTimestamp());
-  // Garbage collection should only happen before/during appending new data,
-  // which should not happen in end-of-stream state.
-  DCHECK(!end_of_stream_);
+
+  if (bytes_released)
+    *bytes_released = 0;
+
   // Compute size of |ranges_|.
   size_t ranges_size = GetBufferedSize();
 
   // Sanity and overflow checks
-  if ((newDataSize > memory_limit_) ||
-      (ranges_size + newDataSize < ranges_size)) {
+  if ((eviction_size > memory_limit_) ||
+      (ranges_size + eviction_size < ranges_size)) {
     LIMITED_MEDIA_LOG(DEBUG, media_log_, num_garbage_collect_algorithm_logs_,
                       kMaxGarbageCollectAlgorithmWarningLogs)
-        << GetStreamTypeName() << " stream: "
-        << "new append of newDataSize=" << newDataSize
+        << GetStreamTypeName() << " stream: " << __func__
+        << " eviction_size=" << eviction_size
         << " bytes exceeds memory_limit_=" << memory_limit_
         << ", currently buffered ranges_size=" << ranges_size;
     return false;
   }
 
   // Return if we're under or at the memory limit.
-  if (ranges_size + newDataSize <= memory_limit_)
+  if (ranges_size + eviction_size <= memory_limit_)
     return true;
 
-  size_t bytes_to_free = ranges_size + newDataSize - memory_limit_;
+  size_t bytes_to_free = ranges_size + eviction_size - memory_limit_;
 
   DVLOG(2) << __func__ << " " << GetStreamTypeName()
            << ": Before GC media_time=" << media_time.InSecondsF()
            << " ranges_=" << RangesToString(ranges_)
            << " seek_pending_=" << seek_pending_
-           << " ranges_size=" << ranges_size << " newDataSize=" << newDataSize
+           << " ranges_size=" << ranges_size
+           << " eviction_size=" << eviction_size
            << " memory_limit_=" << memory_limit_
            << " last_appended_buffer_timestamp_="
            << last_appended_buffer_timestamp_.InSecondsF();
 
   if (selected_range_ && !seek_pending_ &&
       media_time > selected_range_->GetBufferedEndTimestamp()) {
     // Strictly speaking |media_time| (taken from HTMLMediaElement::currentTime)
     // should always be in the buffered ranges, but media::Pipeline uses audio
     // stream as the main time source, when audio is present.
     // In cases when audio and video streams have different buffered ranges, the
@@ skipping 78 matching lines @@
 
   // Try removing data from the front of the SourceBuffer up to |media_time|
   // position.
   if (bytes_freed < bytes_to_free) {
     size_t front = FreeBuffers(bytes_to_free - bytes_freed, media_time, false);
     DVLOG(3) << __func__ << " Removed " << front
              << " bytes from the front. ranges_=" << RangesToString(ranges_);
     bytes_freed += front;
   }
 
   // Try removing data from the back of the SourceBuffer, until we reach the

[chcunningham, 2017/01/12 22:31:25]

We may want to avoid removing data from the back in response to memory pressure.
Its possible we may have a 2GB chromebook that is capable from GPU/CPU pov of
playing 4K (or at least > 1080p). Such a machine will hit our current hard coded
limit with under a minute of buffer and could easily face memory pressure.
Cutting the limit in half (or restricting to current GOP) may cause these higher
resolutions to be unwatchable (constant underflows due to tiny buffer ahead of
current time). 

   // most recent append position.
   if (bytes_freed < bytes_to_free) {
     size_t back = FreeBuffers(bytes_to_free - bytes_freed, media_time, true);
     DVLOG(3) << __func__ << " Removed " << back
              << " bytes from the back. ranges_=" << RangesToString(ranges_);
     bytes_freed += back;
   }
 
   DVLOG(2) << __func__ << " " << GetStreamTypeName()
            << ": After GC bytes_to_free=" << bytes_to_free
            << " bytes_freed=" << bytes_freed
            << " ranges_=" << RangesToString(ranges_);
 
+  if (bytes_released)
+    *bytes_released = bytes_freed;
+
   return bytes_freed >= bytes_to_free;
 }
 
 size_t SourceBufferStream::FreeBuffersAfterLastAppended(
     size_t total_bytes_to_free, DecodeTimestamp media_time) {
   DVLOG(4) << __func__ << " last_appended_buffer_timestamp_="
            << last_appended_buffer_timestamp_.InSecondsF()
            << " media_time=" << media_time.InSecondsF();
 
   DecodeTimestamp remove_range_start = last_appended_buffer_timestamp_;
@@ skipping 908 matching lines @@
 
   if (!have_preroll_buffer)
     return false;
 
   pending_buffer_.swap(*out_buffer);
   pending_buffers_complete_ = false;
   return true;
 }
 
 }  // namespace media