Add plumbing and support for crossfading StreamParserBuffers.

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 10 matching lines @@
 // Returns true if |prev_is_keyframe| and |current_is_keyframe| indicate a
 // same timestamp situation that is allowed. False is returned otherwise.
 static bool AllowSameTimestamp(
     bool prev_is_keyframe, bool current_is_keyframe, bool is_video) {
   if (is_video)
     return !prev_is_keyframe && !current_is_keyframe;
 
   return prev_is_keyframe || !current_is_keyframe;
 }
 
+// Returns the config ID of |buffer| if |buffer| has no fade out preroll or
+// |index| is out of range.  Otherwise returns the config ID for the fade out
+// preroll buffer at position |index|.
+static int GetConfigId(StreamParserBuffer* buffer, size_t index) {
+  return index < buffer->GetFadeOutPreroll().size()
+             ? buffer->GetFadeOutPreroll()[index]->GetConfigId()
+             : buffer->GetConfigId();
+}
+
 // Helper class representing a range of buffered data. All buffers in a
 // SourceBufferRange are ordered sequentially in presentation order with no
 // gaps.
 class SourceBufferRange {
  public:
   typedef std::deque<scoped_refptr<StreamParserBuffer> > BufferQueue;
 
   // Returns the maximum distance in time between any buffer seen in this
   // stream. Used to estimate the duration of a buffer if its duration is not
   // known.
@@ skipping 293 matching lines @@
       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) {
+      config_change_pending_(false),
+      fade_out_preroll_index_(0) {
   DCHECK(audio_config.IsValidConfig());
   audio_configs_.push_back(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),
       end_of_stream_(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) {
+      config_change_pending_(false),
+      fade_out_preroll_index_(0) {
   DCHECK(video_config.IsValidConfig());
   video_configs_.push_back(video_config);
 }
 
 SourceBufferStream::SourceBufferStream(const TextTrackConfig& text_config,
                                        const LogCB& log_cb)
     : log_cb_(log_cb),
       current_config_index_(0),
       append_config_index_(0),
       text_track_config_(text_config),
       seek_pending_(false),
       end_of_stream_(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) {
+      config_change_pending_(false),
+      fade_out_preroll_index_(0) {
 }
 
 SourceBufferStream::~SourceBufferStream() {
   while (!ranges_.empty()) {
     delete ranges_.front();
     ranges_.pop_front();
   }
 }
 
 void SourceBufferStream::OnNewMediaSegment(
@@ skipping 263 matching lines @@
   DCHECK(IsRangeListSorted(ranges_));
   DCHECK(OnlySelectedRangeIsSeeked());
   DVLOG(1) << __FUNCTION__ << " : done";
 }
 
 void SourceBufferStream::ResetSeekState() {
   SetSelectedRange(NULL);
   track_buffer_.clear();
   config_change_pending_ = false;
   last_output_buffer_timestamp_ = kNoTimestamp();
+  fade_out_preroll_index_ = 0;
+  fade_in_buffer_ = NULL;
 }
 
 bool SourceBufferStream::ShouldSeekToStartOfBuffered(
     base::TimeDelta seek_timestamp) const {
   if (ranges_.empty())
     return false;
   base::TimeDelta beginning_of_buffered =
       ranges_.front()->GetStartTimestamp();
   return (seek_timestamp <= beginning_of_buffered &&
           beginning_of_buffered < kSeekToStartFudgeRoom());
@@ skipping 402 matching lines @@
     // If we're about to delete the selected range, also reset the seek state.
     DCHECK((*itr)->GetStartTimestamp() >= duration);
     if (*itr == selected_range_)
       ResetSeekState();
     DeleteAndRemoveRange(&itr);
   }
 }
 
 SourceBufferStream::Status SourceBufferStream::GetNextBuffer(
     scoped_refptr<StreamParserBuffer>* out_buffer) {
+  if (!fade_in_buffer_) {
+    const SourceBufferStream::Status status = GetNextBufferInternal(out_buffer);
+
+    // Just return if GetNextBufferInternal() failed or there's no fade out
+    // preroll, there's nothing else to do.
+    if (status != SourceBufferStream::kSuccess ||
+        (*out_buffer)->GetFadeOutPreroll().empty()) {
+      return status;
+    }
+
+    // Setup fade in buffer and fall through into splice frame buffer handling.
+    fade_out_preroll_index_ = 0;
+    fade_in_buffer_ = *out_buffer;
+  }

[acolwell GONE FROM CHROMIUM, 2014/01/15 19:28:50]

nit: I think you should set *out_buffer = NULL here so that you can't
accidentally hand out the wrong pointer and so that the value is NULL when
kConfigChange is returned.

[DaleCurtis, 2014/01/15 22:40:56]

Done.

+
+  DCHECK(fade_in_buffer_);
+  const std::vector<scoped_refptr<StreamParserBuffer> >& fade_out_preroll =
+      fade_in_buffer_->GetFadeOutPreroll();
+
+  // Are there any fade out buffers left to hand out?
+  if (fade_out_preroll_index_ < fade_out_preroll.size()) {
+    // Account for config changes which occur between fade out buffers.
+    if (current_config_index_ !=
+        fade_out_preroll[fade_out_preroll_index_]->GetConfigId()) {
+      config_change_pending_ = true;
+      DVLOG(1) << "Config change (fade out preroll config ID does not match).";
+      return SourceBufferStream::kConfigChange;
+    }
+
+    *out_buffer = fade_out_preroll[fade_out_preroll_index_++];
+    return SourceBufferStream::kSuccess;
+  }
+
+  // Did we hand out the last fade out buffer on the last call?
+  if (fade_out_preroll_index_ == fade_out_preroll.size()) {
+    fade_out_preroll_index_++;
+    config_change_pending_ = true;
+    DVLOG(1) << "Config change (forced for fade in of splice frame).";
+    return SourceBufferStream::kConfigChange;
+  }
+
+  // All fade out buffers have been handed out and a config change completed, so
+  // hand out the final buffer for fade in.  Because a config change is always
+  // issued prior to handing out this buffer, any changes in config id have been
+  // inherently handled.
+  DCHECK_GT(fade_out_preroll_index_, fade_out_preroll.size());
+  *out_buffer = fade_in_buffer_;
+  fade_in_buffer_ = NULL;
+  fade_out_preroll_index_ = 0;
+  return SourceBufferStream::kSuccess;
+}
+
+SourceBufferStream::Status SourceBufferStream::GetNextBufferInternal(
+    scoped_refptr<StreamParserBuffer>* out_buffer) {
   CHECK(!config_change_pending_);
 
   if (!track_buffer_.empty()) {
     DCHECK(!selected_range_);
-    if (track_buffer_.front()->GetConfigId() != current_config_index_) {
+    scoped_refptr<StreamParserBuffer>& next_buffer = track_buffer_.front();
+
+    // If the next buffer is an audio splice frame, the next effective config id
+    // comes from the first fade out preroll buffer.
+    if (GetConfigId(next_buffer, 0) != current_config_index_) {
       config_change_pending_ = true;
       DVLOG(1) << "Config change (track buffer config ID does not match).";
       return kConfigChange;
     }
 
-    *out_buffer = track_buffer_.front();
+    *out_buffer = next_buffer;
     track_buffer_.pop_front();
     last_output_buffer_timestamp_ = (*out_buffer)->GetDecodeTimestamp();
 
     // If the track buffer becomes empty, then try to set the selected range
     // based on the timestamp of this buffer being returned.
     if (track_buffer_.empty())
       SetSelectedRangeIfNeeded(last_output_buffer_timestamp_);
 
     return kSuccess;
   }
@@ skipping 215 matching lines @@
   append_config_index_ = video_configs_.size();
   DVLOG(2) << "New video config - index: " << append_config_index_;
   video_configs_.resize(video_configs_.size() + 1);
   video_configs_[append_config_index_] = config;
   return true;
 }
 
 void SourceBufferStream::CompleteConfigChange() {
   config_change_pending_ = false;
 
+  if (fade_in_buffer_) {
+    current_config_index_ =
+        GetConfigId(fade_in_buffer_, fade_out_preroll_index_);
+    return;
+  }
+
   if (!track_buffer_.empty()) {
     current_config_index_ = track_buffer_.front()->GetConfigId();

[acolwell GONE FROM CHROMIUM, 2014/01/15 19:28:50]

I think you need to use the helper function here too just in case a splice frame
makes its way into track_buffer_.

[DaleCurtis, 2014/01/15 22:40:56]

Done.

     return;
   }
 
   if (selected_range_ && selected_range_->HasNextBuffer())
     current_config_index_ = selected_range_->GetNextConfigId();
 }
 
 void SourceBufferStream::SetSelectedRangeIfNeeded(
     const base::TimeDelta timestamp) {
   DVLOG(1) << __FUNCTION__ << "(" << timestamp.InSecondsF() << ")";
@@ skipping 486 matching lines @@
 
   // Remove everything from |starting_point| onward.
   FreeBufferRange(starting_point, buffers_.end());
 }
 
 bool SourceBufferRange::GetNextBuffer(
     scoped_refptr<StreamParserBuffer>* out_buffer) {
   if (!HasNextBuffer())
     return false;
 
-  *out_buffer = buffers_.at(next_buffer_index_);
+  *out_buffer = buffers_[next_buffer_index_];
   next_buffer_index_++;
   return true;
 }
 
 bool SourceBufferRange::HasNextBuffer() const {
   return next_buffer_index_ >= 0 &&
       next_buffer_index_ < static_cast<int>(buffers_.size());
 }
 
 int SourceBufferRange::GetNextConfigId() const {
   DCHECK(HasNextBuffer());
-  return buffers_.at(next_buffer_index_)->GetConfigId();
+  const scoped_refptr<StreamParserBuffer>& next_buffer =
+      buffers_[next_buffer_index_];
+  // If the next buffer is an audio splice frame, the next effective config id
+  // comes from the first fade out preroll buffer.
+  return next_buffer->GetFadeOutPreroll().empty() ?

[acolwell GONE FROM CHROMIUM, 2014/01/15 19:28:50]

nit: Use the helper function here too.

[DaleCurtis, 2014/01/15 22:40:56]

Done.

+      next_buffer->GetConfigId() :
+      next_buffer->GetFadeOutPreroll()[0]->GetConfigId();
 }
 
 base::TimeDelta SourceBufferRange::GetNextTimestamp() const {
   DCHECK(!buffers_.empty());
   DCHECK(HasNextBufferPosition());
 
   if (next_buffer_index_ >= static_cast<int>(buffers_.size())) {
     return kNoTimestamp();
   }
 
-  return buffers_.at(next_buffer_index_)->GetDecodeTimestamp();
+  return buffers_[next_buffer_index_]->GetDecodeTimestamp();
 }
 
 bool SourceBufferRange::HasNextBufferPosition() const {
   return next_buffer_index_ >= 0;
 }
 
 void SourceBufferRange::ResetNextBufferPosition() {
   next_buffer_index_ = -1;
 }
 
@@ skipping 101 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