Improving WebM video duration estimation.

media/filters/source_buffer_range.cc

 // Copyright 2014 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_range.h"
 
 #include <algorithm>
 
 namespace media {
 
@@ skipping 30 matching lines @@
   AppendBuffersToEnd(new_buffers);
 }
 
 SourceBufferRange::~SourceBufferRange() {}
 
 void SourceBufferRange::AppendBuffersToEnd(const BufferQueue& new_buffers) {
   DCHECK(buffers_.empty() || CanAppendBuffersToEnd(new_buffers));
   DCHECK(media_segment_start_time_ == kNoDecodeTimestamp() ||
          media_segment_start_time_ <=
              new_buffers.front()->GetDecodeTimestamp());
+
+  AdjustEstimatedDurationForNewAppend(new_buffers);
+
   for (BufferQueue::const_iterator itr = new_buffers.begin();
        itr != new_buffers.end();
        ++itr) {
     DCHECK((*itr)->GetDecodeTimestamp() != kNoDecodeTimestamp());
     buffers_.push_back(*itr);
     size_in_bytes_ += (*itr)->data_size();
 
     if ((*itr)->is_key_frame()) {
       keyframe_map_.insert(
           std::make_pair((*itr)->GetDecodeTimestamp(),
                          buffers_.size() - 1 + keyframe_map_index_base_));
     }
   }
 }
 
+void SourceBufferRange::AdjustEstimatedDurationForNewAppend(
+    const BufferQueue& new_buffers) {
+  if (buffers_.empty() || new_buffers.empty()) {

[DaleCurtis, 2015/04/15 22:51:46]

Typically no {} for one line if statements, but up to you.

[chcunningham, 2015/04/16 18:04:16]

I'm a believer! I think no brackets is asking for trouble (and its bitten me
before).

+    return;
+  }
+
+  // If the last of the previously appended buffers contains estimated duration,
+  // we now refine that estimate by taking the PTS delta from the first new
+  // buffer being appended.
+  const auto& last_appended_buffer = buffers_.back();
+  if (last_appended_buffer->is_duration_estimated()) {
+    base::TimeDelta timestamp_delta =
+        new_buffers.front()->timestamp() - last_appended_buffer->timestamp();

[DaleCurtis, 2015/04/15 22:51:46]

Always positive? What happens in an overlap case?

[chcunningham, 2015/04/16 18:04:16]

This should be always positive, but I think this is a great place for a DCHECK
(just added).

For this to be negative, the buffers we are now appending would have to have a
front PTS that is lower than our current back buffer PTS. AppendBuffersToEnd
DCHECKS this when it calls CanAppendToEnd, and SourceBufferStream also checks
using that same CanAppendToEnd before doing the append. 

In cases where the PTS of new buffers would overlap the PTS of existing buffers,
this is handled in SourceBufferStream in the ::PrepareRangesForNextAppend, where
the existing buffers which are about to be overlapped are entirely removed.

+    if (last_appended_buffer->duration() != timestamp_delta) {
+      DVLOG(1) << "Replacing estimated duration ("
+               << last_appended_buffer->duration()
+               << ") from previous range end with derived duration ("
+               << timestamp_delta << ").";
+      last_appended_buffer->set_duration(timestamp_delta);
+    }
+  }
+}
+
 void SourceBufferRange::Seek(DecodeTimestamp timestamp) {
   DCHECK(CanSeekTo(timestamp));
   DCHECK(!keyframe_map_.empty());
 
-  KeyframeMap::iterator result = GetFirstKeyframeBefore(timestamp);
+  KeyframeMap::iterator result = GetFirstKeyframeAtOrBefore(timestamp);
   next_buffer_index_ = result->second - keyframe_map_index_base_;
   DCHECK_LT(next_buffer_index_, static_cast<int>(buffers_.size()));
 }
 
 void SourceBufferRange::SeekAheadTo(DecodeTimestamp timestamp) {
   SeekAhead(timestamp, false);
 }
 
 void SourceBufferRange::SeekAheadPast(DecodeTimestamp timestamp) {
   SeekAhead(timestamp, true);
@@ skipping 85 matching lines @@
 
 SourceBufferRange::KeyframeMap::iterator
 SourceBufferRange::GetFirstKeyframeAt(DecodeTimestamp timestamp,
                                       bool skip_given_timestamp) {
   return skip_given_timestamp ?
       keyframe_map_.upper_bound(timestamp) :
       keyframe_map_.lower_bound(timestamp);
 }
 
 SourceBufferRange::KeyframeMap::iterator
-SourceBufferRange::GetFirstKeyframeBefore(DecodeTimestamp timestamp) {
+SourceBufferRange::GetFirstKeyframeAtOrBefore(DecodeTimestamp timestamp) {
   KeyframeMap::iterator result = keyframe_map_.lower_bound(timestamp);
   // lower_bound() returns the first element >= |timestamp|, so we want the
   // previous element if it did not return the element exactly equal to
   // |timestamp|.
   if (result != keyframe_map_.begin() &&
       (result == keyframe_map_.end() || result->first != timestamp)) {
     --result;
   }
   return result;
 }
@@ skipping 92 matching lines @@
   int bytes_to_free = total_bytes_to_free;
   int bytes_removed = 0;
 
   KeyframeMap::iterator gop_itr = GetFirstKeyframeAt(start_timestamp, false);
   if (gop_itr == keyframe_map_.end())
     return 0;
   int keyframe_index = gop_itr->second - keyframe_map_index_base_;
   BufferQueue::iterator buffer_itr = buffers_.begin() + keyframe_index;
   KeyframeMap::iterator gop_end = keyframe_map_.end();
   if (end_timestamp < GetBufferedEndTimestamp())
-    gop_end = GetFirstKeyframeBefore(end_timestamp);
+    gop_end = GetFirstKeyframeAtOrBefore(end_timestamp);
 
   // Check if the removal range is within a GOP and skip the loop if so.
   // [keyframe]...[start_timestamp]...[end_timestamp]...[keyframe]
   KeyframeMap::iterator gop_itr_prev = gop_itr;
   if (gop_itr_prev != keyframe_map_.begin() && --gop_itr_prev == gop_end)
     gop_end = gop_itr;
 
   while (gop_itr != gop_end && bytes_to_free > 0) {
     ++gop_itr;
 
@@ skipping 219 matching lines @@
   return itr->first;
 }
 
 DecodeTimestamp SourceBufferRange::KeyframeBeforeTimestamp(
     DecodeTimestamp timestamp) {
   DCHECK(!keyframe_map_.empty());
 
   if (timestamp < GetStartTimestamp() || timestamp >= GetBufferedEndTimestamp())
     return kNoDecodeTimestamp();
 
-  return GetFirstKeyframeBefore(timestamp)->first;
+  return GetFirstKeyframeAtOrBefore(timestamp)->first;
 }
 
 bool SourceBufferRange::IsNextInSequence(
     DecodeTimestamp timestamp, bool is_key_frame) const {
   DecodeTimestamp end = buffers_.back()->GetDecodeTimestamp();
   if (end < timestamp &&
       (gap_policy_ == ALLOW_GAPS ||
        timestamp <= end + GetFudgeRoom())) {
     return true;
   }
@@ skipping 40 matching lines @@
     }
 
     if (buffer->timestamp() + buffer->duration() <= start.ToPresentationTime())
       continue;
     buffers->push_back(buffer);
   }
   return previous_size < buffers->size();
 }
 
 }  // namespace media