Add gapless playback support for AAC playback.

media/base/stream_parser_buffer.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/base/stream_parser_buffer.h"
 
 #include "base/logging.h"
 #include "media/base/buffers.h"
 
 namespace media {
@@ skipping 49 matching lines @@
       new StreamParserBuffer(data, data_size, side_data, side_data_size,
                              is_keyframe, type, track_id));
 }
 
 base::TimeDelta StreamParserBuffer::GetDecodeTimestamp() const {
   if (decode_timestamp_ == kNoTimestamp())
     return timestamp();
   return decode_timestamp_;
 }
 
-void StreamParserBuffer::SetDecodeTimestamp(const base::TimeDelta& timestamp) {
+void StreamParserBuffer::SetDecodeTimestamp(base::TimeDelta timestamp) {
   decode_timestamp_ = timestamp;
+  if (preroll_buffer_)
+    preroll_buffer_->SetDecodeTimestamp(timestamp);
 }
 
 StreamParserBuffer::StreamParserBuffer(const uint8* data, int data_size,
                                        const uint8* side_data,
                                        int side_data_size, bool is_keyframe,
                                        Type type, TrackId track_id)
     : DecoderBuffer(data, data_size, side_data, side_data_size),
       is_keyframe_(is_keyframe),
       decode_timestamp_(kNoTimestamp()),
       config_id_(kInvalidConfigId),
       type_(type),
       track_id_(track_id) {
   // TODO(scherkus): Should DataBuffer constructor accept a timestamp and
   // duration to force clients to set them? Today they end up being zero which
   // is both a common and valid value and could lead to bugs.
   if (data) {
     set_duration(kNoTimestamp());
   }
 }
 
 StreamParserBuffer::~StreamParserBuffer() {}
 
 int StreamParserBuffer::GetConfigId() const {
   return config_id_;
 }
 
 void StreamParserBuffer::SetConfigId(int config_id) {
   config_id_ = config_id;
+  if (preroll_buffer_)
+    preroll_buffer_->SetConfigId(config_id);
 }
 
 void StreamParserBuffer::ConvertToSpliceBuffer(
     const BufferQueue& pre_splice_buffers) {
   DCHECK(splice_buffers_.empty());
   DCHECK(!end_of_stream());
 
   // Make a copy of this first, before making any changes.
   scoped_refptr<StreamParserBuffer> overlapping_buffer = CopyBuffer(*this);
   overlapping_buffer->set_splice_timestamp(kNoTimestamp());
 
   const scoped_refptr<StreamParserBuffer>& first_splice_buffer =
       pre_splice_buffers.front();
 
   // Ensure the given buffers are actually before the splice point.
   DCHECK(first_splice_buffer->timestamp() <= overlapping_buffer->timestamp());
 
   // TODO(dalecurtis): We should also clear |data| and |side_data|, but since
   // that implies EOS care must be taken to ensure there are no clients relying
   // on that behavior.
 
+  // Move over any preroll from this buffer.
+  if (preroll_buffer_) {
+    DCHECK(!overlapping_buffer->preroll_buffer_);
+    overlapping_buffer->preroll_buffer_.swap(preroll_buffer_);
+  }
+
   // Rewrite |this| buffer as a splice buffer.
   SetDecodeTimestamp(first_splice_buffer->GetDecodeTimestamp());
   SetConfigId(first_splice_buffer->GetConfigId());
   set_timestamp(first_splice_buffer->timestamp());
   is_keyframe_ = first_splice_buffer->IsKeyframe();
   type_ = first_splice_buffer->type();
   track_id_ = first_splice_buffer->track_id();
   set_splice_timestamp(overlapping_buffer->timestamp());
 
   // The splice duration is the duration of all buffers before the splice plus
   // the highest ending timestamp after the splice point.
   set_duration(
       std::max(overlapping_buffer->timestamp() + overlapping_buffer->duration(),
                pre_splice_buffers.back()->timestamp() +
                    pre_splice_buffers.back()->duration()) -
       first_splice_buffer->timestamp());
 
   // Copy all pre splice buffers into our wrapper buffer.
   for (BufferQueue::const_iterator it = pre_splice_buffers.begin();
        it != pre_splice_buffers.end();
        ++it) {
     const scoped_refptr<StreamParserBuffer>& buffer = *it;
     DCHECK(!buffer->end_of_stream());
+    DCHECK(!buffer->preroll_buffer());
     DCHECK(buffer->splice_buffers().empty());
     splice_buffers_.push_back(CopyBuffer(*buffer));
     splice_buffers_.back()->set_splice_timestamp(splice_timestamp());
   }
 
   splice_buffers_.push_back(overlapping_buffer);
 }
 
+void StreamParserBuffer::SetPrerollBuffer(
+    const scoped_refptr<StreamParserBuffer>& preroll_buffer) {
+  DCHECK(!preroll_buffer_);
+  DCHECK(!end_of_stream());
+  DCHECK(!preroll_buffer->end_of_stream());
+  DCHECK(!preroll_buffer->preroll_buffer_);
+  DCHECK(preroll_buffer->splice_timestamp() == kNoTimestamp());
+  DCHECK(preroll_buffer->splice_buffers().empty());
+  DCHECK(preroll_buffer->timestamp() <= timestamp());

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

Please add DCHECK(preroll_buffer->GetDecodeTimestamp() <= GetDecodeTimestamp());
I'm concerned that so much of SourceBufferStream assumes non-decreasing PTS in
many cases, which is fine for webm, but not fine for out-of-order stream types.
The assumption should at least include non-decreasing DTS, and in some cases
allow PTS to decrease.
I'm uncertain the timestamp() check is good: are there any out-of-order decodes
allowed for any stream types that use SetPrerollBuffer?

[DaleCurtis, 2014/05/23 21:46:26]

Currently I ignore the decode timestamp on the preroll buffer, so that check
wouldn't do anything.  The preroll buffer gets whatever decode timestamp the
containing buffer has.

+  DCHECK(preroll_buffer->discard_padding() == DecoderBuffer::DiscardPadding());
+  DCHECK_EQ(preroll_buffer->type(), type());
+
+  preroll_buffer_ = preroll_buffer;
+  preroll_buffer_->track_id_ = track_id_;

[acolwell GONE FROM CHROMIUM, 2014/05/23 17:27:30]

Why do you have to do this? I would expect these buffers to have the same
track_id. If they don't is seems like there would be a problem upstream since it
doesn't make sense to have a buffer from one track be the preroll for a
different one.

[DaleCurtis, 2014/05/23 21:46:26]

I was just wholesale copying here, looking at it more closely, you're correct
and that we shouldn't have to do this.  Changed to a DCHECK().

+  preroll_buffer_->set_timestamp(timestamp());
+  preroll_buffer_->SetDecodeTimestamp(GetDecodeTimestamp());
+  preroll_buffer_->SetConfigId(GetConfigId());

[acolwell GONE FROM CHROMIUM, 2014/05/23 17:27:30]

Why do you need this? It seems like there would be a problem upstream if these
got out of sync. I don't think this object really has enough information to be
sure that this is a safe thing to do. ISTM that you should be asserting that the
configID's match instead.

[DaleCurtis, 2014/05/23 21:46:26]

Because a config ID hasn't yet been assigned to this buffer.  That's not done
until SourceBufferStream::Append() by SBS::SetConfigIDs().

[acolwell GONE FROM CHROMIUM, 2014/05/24 00:58:20]

ok, but isn't this method always called before then? Both should be unset at
this point because neither buffer has reached SBS yet right? What is the
situation where the config IDs are different when this method is called? I
really don't think this should be calling SetConfigId() here.

[DaleCurtis, 2014/05/27 23:59:32]

Oh I see what you're saying. Yes this is useless, removed.

+
+  // Mark the entire buffer for discard.
+  preroll_buffer_->set_discard_padding(
+      std::make_pair(kInfiniteDuration(), base::TimeDelta()));
+}
+
+void StreamParserBuffer::set_timestamp(base::TimeDelta timestamp) {
+  DecoderBuffer::set_timestamp(timestamp);
+  if (preroll_buffer_)
+    preroll_buffer_->set_timestamp(timestamp);
+}
+
 }  // namespace media