Add gapless playback support for AAC playback.

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 341 matching lines @@
       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),
       splice_buffers_index_(0),
-      pre_splice_complete_(false),
+      pending_buffers_complete_(false),
       splice_frames_enabled_(splice_frames_enabled) {
   DCHECK(audio_config.IsValidConfig());
   audio_configs_.push_back(audio_config);
 }
 
 SourceBufferStream::SourceBufferStream(const VideoDecoderConfig& video_config,
                                        const LogCB& log_cb,
                                        bool splice_frames_enabled)
     : 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),
       splice_buffers_index_(0),
-      pre_splice_complete_(false),
+      pending_buffers_complete_(false),
       splice_frames_enabled_(splice_frames_enabled) {
   DCHECK(video_config.IsValidConfig());
   video_configs_.push_back(video_config);
 }
 
 SourceBufferStream::SourceBufferStream(const TextTrackConfig& text_config,
                                        const LogCB& log_cb,
                                        bool splice_frames_enabled)
     : 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),
       splice_buffers_index_(0),
-      pre_splice_complete_(false),
+      pending_buffers_complete_(false),
       splice_frames_enabled_(splice_frames_enabled) {}
 
 SourceBufferStream::~SourceBufferStream() {
   while (!ranges_.empty()) {
     delete ranges_.front();
     ranges_.pop_front();
   }
 }
 
 void SourceBufferStream::OnNewMediaSegment(
@@ skipping 260 matching lines @@
   DCHECK(OnlySelectedRangeIsSeeked());
   DVLOG(1) << __FUNCTION__ << " : done";
 }
 
 void SourceBufferStream::ResetSeekState() {
   SetSelectedRange(NULL);
   track_buffer_.clear();
   config_change_pending_ = false;
   last_output_buffer_timestamp_ = kNoTimestamp();
   splice_buffers_index_ = 0;
-  splice_buffer_ = NULL;
-  pre_splice_complete_ = false;
+  pending_buffer_ = NULL;
+  pending_buffers_complete_ = false;
 }
 
 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 420 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 (!splice_buffer_) {
+  if (!pending_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)->get_splice_buffers().empty()) {
-      return status;
+    if (status == SourceBufferStream::kSuccess) {
+      if (!(*out_buffer)->get_splice_buffers().empty())
+        return HandleNextBufferWithSplice(out_buffer);
+      if ((*out_buffer)->GetPrerollBuffer())
+        return HandleNextBufferWithPreroll(out_buffer);
     }
-
-    // Fall through into splice buffer processing.
-    splice_buffers_index_ = 0;
-    splice_buffer_.swap(*out_buffer);
+    return status;
   }
 
-  DCHECK(splice_buffer_);
-  const BufferQueue& splice_buffers = splice_buffer_->get_splice_buffers();
+  if (!pending_buffer_->get_splice_buffers().empty())
+    return HandleNextBufferWithSplice(out_buffer);
+
+  DCHECK(pending_buffer_->GetPrerollBuffer());
+  return HandleNextBufferWithPreroll(out_buffer);
+}
+
+SourceBufferStream::Status SourceBufferStream::HandleNextBufferWithSplice(
+    scoped_refptr<StreamParserBuffer>* out_buffer) {
+  if (!pending_buffer_) {

[acolwell GONE FROM CHROMIUM, 2014/05/16 17:01:11]

It seems weird to have this here. Why not put this code in GetNextBuffer() where
you detect a new splice buffer? That would at least make it more obvious that
pending_buffer_ gets set.

[DaleCurtis, 2014/05/16 17:48:59]

This is done for consistency with the HandleNextBufferWithPreroll() method
below.  It's done there since HandleNextBufferWithSplice() can flow into
HandleNextBufferWithPreroll() afterward.  I can extract a "set pending buffer"
method, but it might lose some of it's DCHECKs if I move it outside of each
Handle method.

[acolwell GONE FROM CHROMIUM, 2014/05/16 20:26:05]

I think the setting logic should be extracted into a helper and the helper
called at the relevant call sites instead of in this and
HandleNextBufferWithSplice(). I realize that might make the code at the bottom
of this func a little longer, but I think it will be a little clearer that
pending_buffers_ gets reset in the buffers with preroll case.

[DaleCurtis, 2014/05/22 23:58:57]

Done.

+    DCHECK(*out_buffer);
+    DCHECK(!(*out_buffer)->get_splice_buffers().empty());
+    splice_buffers_index_ = 0;
+    pending_buffer_.swap(*out_buffer);
+    pending_buffers_complete_ = false;
+  }
+
+  const BufferQueue& splice_buffers = pending_buffer_->get_splice_buffers();
   const size_t last_splice_buffer_index = splice_buffers.size() - 1;
 
   // Are there any splice buffers left to hand out?  The last buffer should be
   // handed out separately since it represents the first post-splice buffer.
   if (splice_buffers_index_ < last_splice_buffer_index) {
     // Account for config changes which occur between fade out buffers.
     if (current_config_index_ !=
         splice_buffers[splice_buffers_index_]->GetConfigId()) {
       config_change_pending_ = true;
       DVLOG(1) << "Config change (splice buffer config ID does not match).";
       return SourceBufferStream::kConfigChange;
     }
 
     // Every pre splice buffer must have the same splice_timestamp().
-    DCHECK(splice_buffer_->splice_timestamp() ==
+    DCHECK(pending_buffer_->splice_timestamp() ==
            splice_buffers[splice_buffers_index_]->splice_timestamp());
 
+    // No pre splice buffers should have preroll.
+    DCHECK(!splice_buffers[splice_buffers_index_]->GetPrerollBuffer());
+
     *out_buffer = splice_buffers[splice_buffers_index_++];
     return SourceBufferStream::kSuccess;
   }
 
   // Did we hand out the last pre-splice buffer on the previous call?
-  if (!pre_splice_complete_) {
+  if (!pending_buffers_complete_) {
     DCHECK_EQ(splice_buffers_index_, last_splice_buffer_index);
-    pre_splice_complete_ = true;
+    pending_buffers_complete_ = true;
     config_change_pending_ = true;
     DVLOG(1) << "Config change (forced for fade in of splice frame).";
     return SourceBufferStream::kConfigChange;
   }
 
   // All pre-splice 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(pre_splice_complete_);
+  DCHECK(pending_buffers_complete_);
   DCHECK_EQ(splice_buffers_index_, splice_buffers.size() - 1);
   DCHECK(splice_buffers.back()->splice_timestamp() == kNoTimestamp());
   *out_buffer = splice_buffers.back();
-  splice_buffer_ = NULL;
+  pending_buffer_ = NULL;
   splice_buffers_index_ = 0;
-  pre_splice_complete_ = false;
+
+  // If the last splice buffer has preroll hand off to the preroll handler.
+  return (*out_buffer)->GetPrerollBuffer()
+             ? HandleNextBufferWithPreroll(out_buffer)
+             : SourceBufferStream::kSuccess;
+}
+
+SourceBufferStream::Status SourceBufferStream::HandleNextBufferWithPreroll(
+    scoped_refptr<StreamParserBuffer>* out_buffer) {
+  if (!pending_buffer_) {
+    DCHECK(*out_buffer);
+    DCHECK((*out_buffer)->GetPrerollBuffer());
+    pending_buffer_.swap(*out_buffer);

[acolwell GONE FROM CHROMIUM, 2014/05/16 17:01:11]

This seems odd as well. I think the setting operation should be split out so
that this is more explicit at the call sites.

[DaleCurtis, 2014/05/16 17:48:59]

As detailed above.

[DaleCurtis, 2014/05/22 23:58:57]

Done.

+    pending_buffers_complete_ = false;
+  }
+
+  // The preroll buffer should not be a splice buffer.
+  DCHECK(pending_buffer_->get_splice_buffers().empty());

[wolenetz, 2014/05/17 00:41:17]

nit: is it worth adding DCHECK_EQ(0, splice_buffers_index_); here too?

[DaleCurtis, 2014/05/22 23:58:57]

Moved into SetPendingBuffer().

[wolenetz, 2014/05/23 19:59:45]

The set is moved into SetPendingBuffer(), though the DCHECK_EQ I suggested would
still be good here to protect borders.

+
+  // Any config change should have already been handled.
+  DCHECK_EQ(current_config_index_, pending_buffer_->GetConfigId());
+
+  // Check if the preroll buffer has already been handed out.
+  if (!pending_buffers_complete_) {
+    pending_buffers_complete_ = true;
+    *out_buffer = pending_buffer_->GetPrerollBuffer();
+    return SourceBufferStream::kSuccess;
+  }
+
+  // Preroll complete, hand out the final buffer.
+  *out_buffer = pending_buffer_;
+  pending_buffer_ = NULL;
   return SourceBufferStream::kSuccess;
 }
 
 SourceBufferStream::Status SourceBufferStream::GetNextBufferInternal(
     scoped_refptr<StreamParserBuffer>* out_buffer) {
   CHECK(!config_change_pending_);
 
   if (!track_buffer_.empty()) {
     DCHECK(!selected_range_);
     scoped_refptr<StreamParserBuffer>& next_buffer = track_buffer_.front();
@@ 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 (splice_buffer_) {
+  if (pending_buffer_) {
     current_config_index_ =
-        GetConfigId(splice_buffer_, splice_buffers_index_);
+        GetConfigId(pending_buffer_, splice_buffers_index_);
     return;
   }
 
   if (!track_buffer_.empty()) {
     current_config_index_ = GetConfigId(track_buffer_.front(), 0);
     return;
   }
 
   if (selected_range_ && selected_range_->HasNextBuffer())
     current_config_index_ = selected_range_->GetNextConfigId();
@@ skipping 186 matching lines @@
 
   // If there are gaps in the timeline, it's possible that we only find buffers
   // after the splice point but within the splice range.  For simplicity, we do
   // not generate splice frames in this case.
   //
   // We also do not want to generate splices if the first new buffer replaces an
   // existing buffer exactly.
   if (pre_splice_buffers.front()->timestamp() >= splice_timestamp)
     return;
 
-  // If any |pre_splice_buffers| are already splices, do not generate a splice.
+  // If any |pre_splice_buffers| are already splices or preroll, do not generate
+  // a splice.
   for (size_t i = 0; i < pre_splice_buffers.size(); ++i) {
     const BufferQueue& original_splice_buffers =
         pre_splice_buffers[i]->get_splice_buffers();
     if (!original_splice_buffers.empty()) {
       DVLOG(1) << "Can't generate splice: overlapped buffers contain a "
                   "pre-existing splice.";
       return;
     }
+
+    if (pre_splice_buffers[i]->GetPrerollBuffer()) {
+      DVLOG(1) << "Can't generate splice: overlapped buffers contain preroll.";
+      return;
+    }
   }
 
   // Don't generate splice frames which represent less than two frames, since we
   // need at least that much to generate a crossfade.  Per the spec, make this
   // check using the sample rate of the overlapping buffers.
   const base::TimeDelta splice_duration =
       pre_splice_buffers.back()->timestamp() +
       pre_splice_buffers.back()->duration() - splice_timestamp;
   const base::TimeDelta minimum_splice_duration = base::TimeDelta::FromSecondsD(
       2.0 / audio_configs_[append_config_index_].samples_per_second());
@@ skipping 532 matching lines @@
     if (buffer->end_of_stream() || buffer->timestamp() >= end)
       break;
     if (buffer->timestamp() + buffer->duration() <= start)
       continue;
     buffers->push_back(buffer);
   }
   return previous_size < buffers->size();
 }
 
 }  // namespace media