Fix SourceBufferStream alt-ref frame handling.

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 "base/bind.h"
@@ skipping 282 matching lines @@
     : log_cb_(log_cb),
       current_config_index_(0),
       append_config_index_(0),
       seek_pending_(false),
       seek_buffer_timestamp_(kNoTimestamp()),
       selected_range_(NULL),
       media_segment_start_time_(kNoTimestamp()),
       range_for_next_append_(ranges_.end()),
       new_media_segment_(false),
       last_appended_buffer_timestamp_(kNoTimestamp()),
+      last_appended_buffer_is_keyframe_(false),
       last_output_buffer_timestamp_(kNoTimestamp()),
       max_interbuffer_distance_(kNoTimestamp()),
       memory_limit_(kDefaultAudioMemoryLimit),
       config_change_pending_(false) {
   DCHECK(audio_config.IsValidConfig());
   audio_configs_.push_back(new AudioDecoderConfig());
   audio_configs_.back()->CopyFrom(audio_config);
 }
 
 SourceBufferStream::SourceBufferStream(const VideoDecoderConfig& video_config,
                                        const LogCB& log_cb)
     : log_cb_(log_cb),
       current_config_index_(0),
       append_config_index_(0),
       seek_pending_(false),
       seek_buffer_timestamp_(kNoTimestamp()),
       selected_range_(NULL),
       media_segment_start_time_(kNoTimestamp()),
       range_for_next_append_(ranges_.end()),
       new_media_segment_(false),
       last_appended_buffer_timestamp_(kNoTimestamp()),
+      last_appended_buffer_is_keyframe_(false),
       last_output_buffer_timestamp_(kNoTimestamp()),
       max_interbuffer_distance_(kNoTimestamp()),
       memory_limit_(kDefaultVideoMemoryLimit),
       config_change_pending_(false) {
   DCHECK(video_config.IsValidConfig());
   video_configs_.push_back(new VideoDecoderConfig());
   video_configs_.back()->CopyFrom(video_config);
 }
 
 SourceBufferStream::~SourceBufferStream() {
@@ skipping 13 matching lines @@
 
   RangeList::iterator last_range = range_for_next_append_;
   range_for_next_append_ = FindExistingRangeFor(media_segment_start_time);
 
   // Only reset |last_appended_buffer_timestamp_| if this new media segment is
   // not adjacent to the previous media segment appended to the stream.
   if (range_for_next_append_ == ranges_.end() ||
       !AreAdjacentInSequence(last_appended_buffer_timestamp_,
                              media_segment_start_time)) {
     last_appended_buffer_timestamp_ = kNoTimestamp();
+    last_appended_buffer_is_keyframe_ = false;
   } else {
     DCHECK(last_range == range_for_next_append_);
   }
 }
 
 bool SourceBufferStream::Append(
     const SourceBufferStream::BufferQueue& buffers) {
   TRACE_EVENT2("mse", "SourceBufferStream::Append",
                "stream type", GetStreamTypeName(),
                "buffers to append", buffers.size());
 
   DCHECK(!buffers.empty());
   DCHECK(media_segment_start_time_ != kNoTimestamp());
 
   // New media segments must begin with a keyframe.
   if (new_media_segment_ && !buffers.front()->IsKeyframe()) {
     MEDIA_LOG(log_cb_) << "Media segment did not begin with keyframe.";
     return false;
   }
 
   // Buffers within a media segment should be monotonically increasing.
-  if (!IsMonotonicallyIncreasing(buffers)) {
-    MEDIA_LOG(log_cb_) << "Buffers were not monotonically increasing.";
+  if (!IsMonotonicallyIncreasing(buffers))
     return false;
-  }
 
   if (media_segment_start_time_ < base::TimeDelta() ||
       buffers.front()->GetDecodeTimestamp() < base::TimeDelta()) {
     MEDIA_LOG(log_cb_)
         << "Cannot append a media segment with negative timestamps.";
     return false;
   }
 
   UpdateMaxInterbufferDistance(buffers);
   SetConfigIds(buffers);
 
   // Save a snapshot of stream state before range modifications are made.
   base::TimeDelta next_buffer_timestamp = GetNextBufferTimestamp();
   BufferQueue deleted_buffers;
 
   RangeList::iterator range_for_new_buffers = range_for_next_append_;
   // If there's a range for |buffers|, insert |buffers| accordingly. Otherwise,
   // create a new range with |buffers|.
   if (range_for_new_buffers != ranges_.end()) {
-    InsertIntoExistingRange(range_for_new_buffers, buffers, &deleted_buffers);
+    if (!InsertIntoExistingRange(range_for_new_buffers, buffers,
+                                 &deleted_buffers)) {
+      return false;
+    }
   } else {
     DCHECK(new_media_segment_);
     range_for_new_buffers =
         AddToRanges(new SourceBufferRange(
             buffers, media_segment_start_time_,
             base::Bind(&SourceBufferStream::GetMaxInterbufferDistance,
                        base::Unretained(this))));
   }
 
   range_for_next_append_ = range_for_new_buffers;
   new_media_segment_ = false;
   last_appended_buffer_timestamp_ = buffers.back()->GetDecodeTimestamp();
+  last_appended_buffer_is_keyframe_ = buffers.back()->IsKeyframe();
 
   // Resolve overlaps.
   ResolveCompleteOverlaps(range_for_new_buffers, &deleted_buffers);
   ResolveEndOverlap(range_for_new_buffers, &deleted_buffers);
   MergeWithAdjacentRangeIfNecessary(range_for_new_buffers);
 
   // Seek to try to fulfill a previous call to Seek().
   if (seek_pending_) {
     DCHECK(!selected_range_);
     DCHECK(deleted_buffers.empty());
@@ skipping 46 matching lines @@
   base::TimeDelta beginning_of_buffered =
       ranges_.front()->GetStartTimestamp();
   return (seek_timestamp <= beginning_of_buffered &&
           beginning_of_buffered < kSeekToStartFudgeRoom());
 }
 
 bool SourceBufferStream::IsMonotonicallyIncreasing(
     const BufferQueue& buffers) const {
   DCHECK(!buffers.empty());
   base::TimeDelta prev_timestamp = last_appended_buffer_timestamp_;
+  bool prev_is_keyframe = last_appended_buffer_is_keyframe_;
   for (BufferQueue::const_iterator itr = buffers.begin();
        itr != buffers.end(); ++itr) {
     base::TimeDelta current_timestamp = (*itr)->GetDecodeTimestamp();
+    bool current_is_keyframe = (*itr)->IsKeyframe();
     DCHECK(current_timestamp != kNoTimestamp());
 
-    if (prev_timestamp != kNoTimestamp() && current_timestamp < prev_timestamp)
-      return false;
+    if (prev_timestamp != kNoTimestamp()) {
+      if (current_timestamp < prev_timestamp) {
+        MEDIA_LOG(log_cb_) << "Buffers were not monotonically increasing.";
+        return false;
+      }
+
+      if (current_timestamp == prev_timestamp &&
+          (current_is_keyframe || prev_is_keyframe)) {
+        MEDIA_LOG(log_cb_) << "Invalid alt-ref frame construct detected at "
+                           << current_timestamp.InSecondsF();
+        return false;
+      }
+    }
 
     prev_timestamp = current_timestamp;
+    prev_is_keyframe = current_is_keyframe;
   }
   return true;
 }
 
 bool SourceBufferStream::OnlySelectedRangeIsSeeked() const {
   for (RangeList::const_iterator itr = ranges_.begin();
        itr != ranges_.end(); ++itr) {
     if ((*itr)->HasNextBufferPosition() && (*itr) != selected_range_)
       return false;
   }
@@ skipping 122 matching lines @@
     if (range_for_next_append_ != ranges_.begin()) {
       RangeList::iterator range_before_next = range_for_next_append_;
       --range_before_next;
       MergeWithAdjacentRangeIfNecessary(range_before_next);
     }
     MergeWithAdjacentRangeIfNecessary(range_for_next_append_);
   }
   return bytes_freed;
 }
 
-void SourceBufferStream::InsertIntoExistingRange(
+bool SourceBufferStream::InsertIntoExistingRange(
     const RangeList::iterator& range_for_new_buffers_itr,
     const BufferQueue& new_buffers, BufferQueue* deleted_buffers) {
   DCHECK(deleted_buffers);
 
   SourceBufferRange* range_for_new_buffers = *range_for_new_buffers_itr;
 
   bool temporarily_select_range = false;
   if (!track_buffer_.empty()) {
     base::TimeDelta tb_timestamp = track_buffer_.back()->GetDecodeTimestamp();
     base::TimeDelta seek_timestamp = FindKeyframeAfterTimestamp(tb_timestamp);
     if (seek_timestamp != kNoTimestamp() &&
         seek_timestamp < new_buffers.front()->GetDecodeTimestamp() &&
         range_for_new_buffers->BelongsToRange(seek_timestamp)) {
       DCHECK(tb_timestamp < seek_timestamp);
       DCHECK(!selected_range_);
       DCHECK(!range_for_new_buffers->HasNextBufferPosition());
 
       // If there are GOPs between the end of the track buffer and the
       // beginning of the new buffers, then temporarily seek the range
       // so that the buffers between these two times will be deposited in
       // |deleted_buffers| as if they were part of the current playback
       // position.
       // TODO(acolwell): Figure out a more elegant way to do this.
       SeekAndSetSelectedRange(range_for_new_buffers, seek_timestamp);
       temporarily_select_range = true;
     }
   }
 
-  if (last_appended_buffer_timestamp_ != kNoTimestamp()) {
+  base::TimeDelta prev_timestamp = last_appended_buffer_timestamp_;
+  bool prev_is_keyframe = last_appended_buffer_is_keyframe_;
+  base::TimeDelta next_timestamp = new_buffers.front()->GetDecodeTimestamp();
+  bool next_is_keyframe = new_buffers.front()->IsKeyframe();
+
+  if (prev_timestamp != kNoTimestamp() && prev_timestamp != next_timestamp) {
     // Clean up the old buffers between the last appended buffer and the
     // beginning of |new_buffers|.
     DeleteBetween(
-        range_for_new_buffers_itr, last_appended_buffer_timestamp_,
-        new_buffers.front()->GetDecodeTimestamp(), true,
+        range_for_new_buffers_itr, prev_timestamp, next_timestamp, true,
         deleted_buffers);
   }
 
+  // Check for invalid alt-ref frame constructs.

[scherkus (not reviewing), 2013/03/11 23:21:50]

want to format this to use a bullet list / indent for the two cases we're
checking for?

Check for invalid alt-ref frame constructs:
  * a keyframe followed by a non-keyframe or
  * a non-keyframe blah blah ...

also might be nice to link / describe what an alt-ref frame is -- the expected
results for AltRefFrame_Overlap_3 looks a bit funny at first glance due to the
duplicated "90" timestamps (I'm guessing one of those is considered the alt-ref
frame?)

[acolwell GONE FROM CHROMIUM, 2013/03/12 03:22:50]

Done.

+  // A keyframe followed by a non-keyframe or
+  // a non-keyframe followed by a keyframe that is not
+  // the first frame of a media segment are errors.
+  if (prev_timestamp == next_timestamp &&
+      ((prev_is_keyframe && !next_is_keyframe) ||
+       (!new_media_segment_ && next_is_keyframe))) {
+    MEDIA_LOG(log_cb_) << "Invalid alt-ref frame construct detected at time "
+                       << prev_timestamp.InSecondsF();
+    return false;
+  }
+
   // If we cannot append the |new_buffers| to the end of the existing range,
   // this is either a start overlap or an middle overlap. Delete the buffers

[scherkus (not reviewing), 2013/03/11 23:21:50]

s/or an middle/or a middle/

[acolwell GONE FROM CHROMIUM, 2013/03/12 03:22:50]

Done.

   // that |new_buffers| overlaps.
   if (!range_for_new_buffers->CanAppendBuffersToEnd(new_buffers)) {
+    // Make the delete range exclusive if we are dealing with an alt-ref
+    // situation so that the buffer with the same timestamp that is already
+    // stored in |*range_for_new_buffers_itr| doesn't get deleted.
+    bool is_exclusive = prev_timestamp == next_timestamp &&
+        !prev_is_keyframe && !next_is_keyframe;
+
     DeleteBetween(
         range_for_new_buffers_itr, new_buffers.front()->GetDecodeTimestamp(),
-        new_buffers.back()->GetDecodeTimestamp(), false,
+        new_buffers.back()->GetDecodeTimestamp(), is_exclusive,
         deleted_buffers);
   }
 
   // Restore the range seek state if necessary.
   if (temporarily_select_range)
     SetSelectedRange(NULL);
 
   range_for_new_buffers->AppendBuffersToEnd(new_buffers);
+  return true;
 }
 
 void SourceBufferStream::DeleteBetween(
     const RangeList::iterator& range_itr, base::TimeDelta start_timestamp,
     base::TimeDelta end_timestamp, bool is_range_exclusive,
     BufferQueue* deleted_buffers) {
   SourceBufferRange* new_next_range =
       (*range_itr)->SplitRange(end_timestamp, is_range_exclusive);
 
   // Insert the |new_next_range| into |ranges_| after |range|.
@@ skipping 556 matching lines @@
       media_segment_start_time_(media_segment_start_time),
       interbuffer_distance_cb_(interbuffer_distance_cb),
       size_in_bytes_(0) {
   DCHECK(!new_buffers.empty());
   DCHECK(new_buffers.front()->IsKeyframe());
   DCHECK(!interbuffer_distance_cb.is_null());
   AppendBuffersToEnd(new_buffers);
 }
 
 void SourceBufferRange::AppendBuffersToEnd(const BufferQueue& new_buffers) {
+  DCHECK(buffers_.empty() ||
+         buffers_.back()->GetDecodeTimestamp() <=
+         new_buffers.front()->GetDecodeTimestamp());
+
   for (BufferQueue::const_iterator itr = new_buffers.begin();
        itr != new_buffers.end(); ++itr) {
     DCHECK((*itr)->GetDecodeTimestamp() != kNoTimestamp());
     buffers_.push_back(*itr);
     size_in_bytes_ += (*itr)->GetDataSize();
 
     if ((*itr)->IsKeyframe()) {
       keyframe_map_.insert(
           std::make_pair((*itr)->GetDecodeTimestamp(),
                          buffers_.size() - 1 + keyframe_map_index_base_));
@@ skipping 415 matching lines @@
   return ComputeFudgeRoom(GetApproximateDuration());
 }
 
 base::TimeDelta SourceBufferRange::GetApproximateDuration() const {
   base::TimeDelta max_interbuffer_distance = interbuffer_distance_cb_.Run();
   DCHECK(max_interbuffer_distance != kNoTimestamp());
   return max_interbuffer_distance;
 }
 
 }  // namespace media