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

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>
 
@@ skipping 330 matching lines @@
   // are appended to the range covered by |track_buffer_|.
   if (!track_buffer_.empty()) {
     DecodeTimestamp keyframe_timestamp =
         FindKeyframeAfterTimestamp(track_buffer_.front()->GetDecodeTimestamp());
     if (keyframe_timestamp != kNoDecodeTimestamp())
       PruneTrackBuffer(keyframe_timestamp);
   }
 
   SetSelectedRangeIfNeeded(next_buffer_timestamp);
 
-  GarbageCollectIfNeeded();
-
   DVLOG(1) << __FUNCTION__ << " " << GetStreamTypeName()
            << ": done. ranges_=" << RangesToString(ranges_);
   DCHECK(IsRangeListSorted(ranges_));
   DCHECK(OnlySelectedRangeIsSeeked());
   return true;
 }
 
 void SourceBufferStream::Remove(base::TimeDelta start, base::TimeDelta end,
                                 base::TimeDelta duration) {
   DVLOG(1) << __FUNCTION__ << " " << GetStreamTypeName()
@@ skipping 213 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() {
+bool SourceBufferStream::GarbageCollectIfNeeded(DecodeTimestamp 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;
+    return true;
 
   int bytes_to_free = ranges_size - memory_limit_;
 
   DVLOG(2) << __FUNCTION__ << " " << GetStreamTypeName() << ": Before GC"
            << " ranges_size=" << ranges_size
            << " ranges_=" << RangesToString(ranges_)
            << " memory_limit_=" << 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);
-
-  // Begin deleting from the back.
-  if (bytes_to_free - bytes_freed > 0)
-    bytes_freed += FreeBuffers(bytes_to_free - bytes_freed, true);

[servolk, 2014/12/12 01:01:53]

So now we are never gonna to try freeing buffers from the back? Is it safe? What
if we are playing at the end of a very long video and then seek back to
beginning. I think in the past GC would remove the buffers at the back of the
SBS - how is it gonna be handled now?

[kjoswiak, 2014/12/12 01:22:05]

The call to FreeBuffersAfterLastAppended on line 604 should take care of extra
buffers at end of our ranges.

This call removes buffers between current playhead and last append, which is
going to create a gap in the buffer. This is the source of gaps that have been
causing the playback stall bugs, since most clients are not going to expect
they're going to have to reappend data in this range.

I can put this call back in if I'm misunderstanding the situation, but I think
this is the source of GC over aggression, and would prefer we fail rather than
try this call.

+    bytes_freed += FreeBuffers(bytes_to_free - bytes_freed, media_time, false);
 
   DVLOG(2) << __FUNCTION__ << " " << GetStreamTypeName() << ": After GC"
            << " bytes_freed=" << bytes_freed
            << " ranges_=" << RangesToString(ranges_);
+
+  return (bytes_to_free - bytes_freed <= 0);

[servolk, 2014/12/12 01:01:53]

Why not just "return bytes_freed >= bytes_to_free" ? I think that would be more
readable.

[kjoswiak, 2014/12/12 01:22:05]

Done.

 }
 
 int SourceBufferStream::FreeBuffersAfterLastAppended(int total_bytes_to_free) {
   DecodeTimestamp next_buffer_timestamp = GetNextBufferTimestamp();
   if (last_appended_buffer_timestamp_ == kNoDecodeTimestamp() ||
       next_buffer_timestamp == kNoDecodeTimestamp() ||
       last_appended_buffer_timestamp_ >= next_buffer_timestamp) {
     return 0;
   }
 
@@ skipping 42 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,
+                                    DecodeTimestamp media_time,
                                     bool reverse_direction) {
   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_|
@@ skipping 11 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 (media_time != kNoDecodeTimestamp() &&
+          !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.
     DecodeTimestamp end_timestamp = buffers.back()->GetDecodeTimestamp();
     if (end_timestamp == last_appended_buffer_timestamp_) {
       DCHECK(last_appended_buffer_timestamp_ != kNoDecodeTimestamp());
       DCHECK(!new_range_for_append);
       // Create a new range containing these buffers.
       new_range_for_append = new SourceBufferRange(
@@ skipping 842 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