Add gapless playback support for AAC playback.

media/base/stream_parser_buffer.cc

Index: media/base/stream_parser_buffer.cc
diff --git a/media/base/stream_parser_buffer.cc b/media/base/stream_parser_buffer.cc
index 1d3440235488a9a241d75ac5530dc11e9cfcf11b..598cf55a402f86bcbcb26cb771d564131c145e50 100644
--- a/media/base/stream_parser_buffer.cc
+++ b/media/base/stream_parser_buffer.cc
@@ -67,8 +67,10 @@ base::TimeDelta StreamParserBuffer::GetDecodeTimestamp() const {
   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,
@@ -97,6 +99,8 @@ int StreamParserBuffer::GetConfigId() const {
 
 void StreamParserBuffer::SetConfigId(int config_id) {
   config_id_ = config_id;
+  if (preroll_buffer_)
+    preroll_buffer_->SetConfigId(config_id);
 }
 
 void StreamParserBuffer::ConvertToSpliceBuffer(
@@ -118,6 +122,12 @@ void StreamParserBuffer::ConvertToSpliceBuffer(
   // 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());
@@ -141,6 +151,7 @@ void StreamParserBuffer::ConvertToSpliceBuffer(
        ++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());
@@ -149,4 +160,33 @@ void StreamParserBuffer::ConvertToSpliceBuffer(
   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