Add config change handling to SourceBufferStream & ChunkDemuxer

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 72 matching lines @@
   bool DeleteAll(BufferQueue* deleted_buffers);
 
   // Updates |out_buffer| with the next buffer in presentation order. Seek()
   // must be called before calls to GetNextBuffer(), and buffers are returned
   // in order from the last call to Seek(). Returns true if |out_buffer| is
   // filled with a valid buffer, false if there is not enough data to fulfill
   // the request.
   bool GetNextBuffer(scoped_refptr<StreamParserBuffer>* out_buffer);
   bool HasNextBuffer() const;
 
+  // Returns the config ID for the buffer that will be returned by
+  // GetNextBuffer().
+  int GetNextConfigID() const;

[xhwang, 2012/07/12 18:09:12]

s/ID/Id?

[acolwell GONE FROM CHROMIUM, 2012/07/12 23:07:58]

Done.

+
   // Returns true if the range knows the position of the next buffer it should
   // return, i.e. it has been Seek()ed. This does not necessarily mean that it
   // has the next buffer yet.
   bool HasNextBufferPosition() const;
 
   // Returns the timestamp of the next buffer that will be returned from
   // GetNextBuffer(), or kNoTimestamp() if the timestamp is unknown.
   base::TimeDelta GetNextTimestamp() const;
 
   // Returns the start timestamp of the range.
@@ skipping 113 matching lines @@
   return first->GetDecodeTimestamp() < second->GetDecodeTimestamp();
 }
 
 // An arbitrarily-chosen number to estimate the duration of a buffer if none
 // is set and there's not enough information to get a better estimate.
 static int kDefaultBufferDurationInMs = 125;
 
 namespace media {
 
 SourceBufferStream::SourceBufferStream(const AudioDecoderConfig& audio_config)
-    : seek_pending_(false),
+    : current_config_index_(0),
+      append_config_index_(0),
+      audio_configs_(1),
+      video_configs_(0),
+      seek_pending_(false),
       seek_buffer_timestamp_(kNoTimestamp()),
       selected_range_(NULL),
       end_of_stream_(false),
       media_segment_start_time_(kNoTimestamp()),
       range_for_next_append_(ranges_.end()),
       new_media_segment_(false),
       last_buffer_timestamp_(kNoTimestamp()),
       max_interbuffer_distance_(kNoTimestamp()) {
-  audio_config_.CopyFrom(audio_config);
+  audio_configs_[0] = new AudioDecoderConfig();
+  audio_configs_[0]->CopyFrom(audio_config);
 }
 
 SourceBufferStream::SourceBufferStream(const VideoDecoderConfig& video_config)
-    : seek_pending_(false),
+    : current_config_index_(0),
+      append_config_index_(0),
+      audio_configs_(0),
+      video_configs_(1),
+      seek_pending_(false),
       seek_buffer_timestamp_(kNoTimestamp()),
       selected_range_(NULL),
       end_of_stream_(false),
       media_segment_start_time_(kNoTimestamp()),
       range_for_next_append_(ranges_.end()),
       new_media_segment_(false),
       last_buffer_timestamp_(kNoTimestamp()),
       max_interbuffer_distance_(kNoTimestamp()) {
-  video_config_.CopyFrom(video_config);
+  video_configs_[0] = new VideoDecoderConfig();
+  video_configs_[0]->CopyFrom(video_config);
 }
 
 SourceBufferStream::~SourceBufferStream() {
   while (!ranges_.empty()) {
     delete ranges_.front();
     ranges_.pop_front();
   }
+
+  for (size_t i = 0; i < audio_configs_.size(); ++i)
+    delete audio_configs_[i];
+  audio_configs_.clear();
+
+  for (size_t i = 0; i < video_configs_.size(); ++i)
+    delete video_configs_[i];
+  video_configs_.clear();

[xhwang, 2012/07/12 18:09:12]

Use STLDeleteElements here and above?

[acolwell GONE FROM CHROMIUM, 2012/07/12 23:07:58]

Done.

 }
 
 void SourceBufferStream::OnNewMediaSegment(
     base::TimeDelta media_segment_start_time) {
   media_segment_start_time_ = media_segment_start_time;
 
   // Find the range that will house the buffers appended through the next
   // Append() call.
   range_for_next_append_ = FindExistingRangeFor(media_segment_start_time);
   new_media_segment_ = true;
@@ skipping 11 matching lines @@
     return false;
   }
 
   // Buffers within a media segment should be monotonically increasing.
   if (!IsMonotonicallyIncreasing(buffers)) {
     DVLOG(1) << "Buffers were not monotonically increasing.";
     return false;
   }
 
   UpdateMaxInterbufferDistance(buffers);
+  SetConfigIDs(buffers);
 
   // Save a snapshot of the |selected_range_| state before range modifications
   // are made.
   base::TimeDelta next_buffer_timestamp = GetNextBufferTimestamp();
   base::TimeDelta end_buffer_timestamp = GetEndBufferTimestamp();
 
   bool deleted_next_buffer = false;
   BufferQueue deleted_buffers;
 
   RangeList::iterator range_for_new_buffers = range_for_next_append_;
@@ skipping 91 matching lines @@
         max_interbuffer_distance_ = interbuffer_distance;
       } else {
         max_interbuffer_distance_ =
             std::max(max_interbuffer_distance_, interbuffer_distance);
       }
     }
     prev_timestamp = current_timestamp;
   }
 }
 
+void SourceBufferStream::SetConfigIDs(const BufferQueue& buffers) {
+  for (BufferQueue::const_iterator itr = buffers.begin();
+       itr != buffers.end(); ++itr) {
+    (*itr)->SetConfigID(append_config_index_);

[xhwang, 2012/07/12 18:09:12]

The comment in .h file uses set_config_id, which sounds right. Change
StreamParserBuffer::SetConfigID to set_config_id since it's a setter?

[acolwell GONE FROM CHROMIUM, 2012/07/12 23:07:58]

I just fixed the comment to reflect the SetConfigId() form. I originally had the
lower case form, but I used MixedCase to match the getter/setters in
StreamParserBuffer & DecoderBuffer.

+  }
+}
+
 void SourceBufferStream::InsertIntoExistingRange(
     const RangeList::iterator& range_for_new_buffers_itr,
     const BufferQueue& new_buffers,
     bool* deleted_next_buffer, BufferQueue* deleted_buffers) {
   DCHECK(deleted_next_buffer);
   DCHECK(deleted_buffers);
 
   SourceBufferRange* range_for_new_buffers = *range_for_new_buffers_itr;
 
   // If this is a simple case where we can just append to the end of the range,
@@ skipping 191 matching lines @@
   selected_range_ = *itr;
   selected_range_->Seek(timestamp);
   seek_pending_ = false;
   end_of_stream_ = false;
 }
 
 bool SourceBufferStream::IsSeekPending() const {
   return seek_pending_;
 }
 
-bool SourceBufferStream::GetNextBuffer(
+SourceBufferStream::Status SourceBufferStream::GetNextBuffer(
     scoped_refptr<StreamParserBuffer>* out_buffer) {
   if (!track_buffer_.empty()) {
+    if (track_buffer_.front()->GetConfigID() != current_config_index_)
+      return kConfigChange;
+
     *out_buffer = track_buffer_.front();
     track_buffer_.pop_front();
-    return true;
+    return kSuccess;
   }
 
   if (end_of_stream_ && (!selected_range_ ||
                          !selected_range_->HasNextBuffer())) {
     *out_buffer = StreamParserBuffer::CreateEOSBuffer();
-    return true;
+    return kSuccess;
   }
 
-  return selected_range_ && selected_range_->GetNextBuffer(out_buffer);
+  if (!selected_range_ || !selected_range_->HasNextBuffer())
+    return kNeedBuffer;
+
+  if (selected_range_->GetNextConfigID() != current_config_index_)
+    return kConfigChange;
+
+  return selected_range_->GetNextBuffer(out_buffer) ? kSuccess : kNeedBuffer;

[vrk (LEFT CHROMIUM), 2012/07/12 19:37:55]

At this point, shouldn't selected_range_->GetNextBuffer(out_buffer) always
return true?

[acolwell GONE FROM CHROMIUM, 2012/07/12 23:07:58]

I wasn't sure. The guard in SourceBufferRange::GetNextBuffer() has an added
check for waiting_for_keyframe_, but SourceBufferRange::HasNextBuffer() doesn't
check for this. I wasn't sure if there was a situation were HasNextBuffer()
could return true and waiting_for_keyframe_ was true.

 }
 
 base::TimeDelta SourceBufferStream::GetNextBufferTimestamp() {
   if (!selected_range_)
     return kNoTimestamp();
 
   DCHECK(selected_range_->HasNextBufferPosition());
   return selected_range_->GetNextTimestamp();
 }
 
@@ skipping 52 matching lines @@
 bool SourceBufferStream::CanEndOfStream() const {
   return ranges_.empty() || selected_range_ == ranges_.back();
 }
 
 base::TimeDelta SourceBufferStream::GetMaxInterbufferDistance() const {
   if (max_interbuffer_distance_ == kNoTimestamp())
     return base::TimeDelta::FromMilliseconds(kDefaultBufferDurationInMs);
   return max_interbuffer_distance_;
 }
 
+bool SourceBufferStream::UpdateAudioConfig(const AudioDecoderConfig& config) {
+  DCHECK(!audio_configs_.empty());

[vrk (LEFT CHROMIUM), 2012/07/12 19:37:55]

DCHECK(video_configs_.empty())?

[acolwell GONE FROM CHROMIUM, 2012/07/12 23:07:58]

Done.

+
+  if (audio_configs_[0]->codec() != config.codec()) {
+    DVLOG(1) << "UpdateAudioConfig() : Codec changes not allowed.";
+    return false;
+  }
+
+  if (audio_configs_[0]->samples_per_second() != config.samples_per_second()) {
+    DVLOG(1) << "UpdateAudioConfig() : Sample rate changes not allowed.";
+    return false;
+  }
+
+  if (audio_configs_[0]->channel_layout() != config.channel_layout()) {
+    DVLOG(1) << "UpdateAudioConfig() : Channel layout changes not allowed.";
+    return false;
+  }
+
+  if (audio_configs_[0]->bits_per_channel() != config.bits_per_channel()) {
+    DVLOG(1) << "UpdateAudioConfig() : Bits per channel changes not allowed.";
+    return false;
+  }
+
+  // Check to see if the new config matches an existing one.
+  for (size_t i = 0; i < audio_configs_.size(); ++i) {
+    const AudioDecoderConfig& existing_config = *audio_configs_[i];
+    if ((existing_config.codec() == config.codec()) &&
+        (existing_config.bits_per_channel() == config.bits_per_channel()) &&
+        (existing_config.channel_layout() == config.channel_layout()) &&
+        (existing_config.samples_per_second() == config.samples_per_second()) &&
+        (existing_config.extra_data_size() == config.extra_data_size()) &&
+        (!existing_config.extra_data() ||
+         !memcmp(existing_config.extra_data(), config.extra_data(),
+                 existing_config.extra_data_size()))) {

[xhwang, 2012/07/12 18:09:12]

How about having helper functions for this and below (793)? e.g.
VideoDecoderConfig::Matches(const VideoDecoderConfig&)

[acolwell GONE FROM CHROMIUM, 2012/07/12 23:07:58]

Done.

+      append_config_index_ = i;
+      return true;
+    }
+  }
+
+  // No matches found so lets add this one to the list.

[vrk (LEFT CHROMIUM), 2012/07/12 19:37:55]

nit: "let's"

[acolwell GONE FROM CHROMIUM, 2012/07/12 23:07:58]

Done.

+  append_config_index_ = audio_configs_.size();
+  audio_configs_.resize(audio_configs_.size() + 1);
+  audio_configs_[append_config_index_] = new AudioDecoderConfig();
+  audio_configs_[append_config_index_]->CopyFrom(config);
+  return true;
+}
+
+bool SourceBufferStream::UpdateVideoConfig(const VideoDecoderConfig& config) {
+  DCHECK(!video_configs_.empty());

[vrk (LEFT CHROMIUM), 2012/07/12 19:37:55]

DCHECK(audio_configs_.empty())?

[acolwell GONE FROM CHROMIUM, 2012/07/12 23:07:58]

Done.

+
+  if (video_configs_[0]->codec() != config.codec()) {
+    DVLOG(1) << "UpdateVideoConfig() : Codec changes not allowed.";
+    return false;
+  }
+
+  // Check to see if the new config matches an existing one.
+  for (size_t i = 0; i < video_configs_.size(); ++i) {
+    const VideoDecoderConfig& existing_config = *video_configs_[i];
+    if ((existing_config.codec() == config.codec()) &&
+        (existing_config.format() == config.format()) &&
+        (existing_config.profile() == config.profile()) &&
+        (existing_config.coded_size() == config.coded_size()) &&
+        (existing_config.visible_rect() == config.visible_rect()) &&
+        (existing_config.natural_size() == config.natural_size()) &&
+        (existing_config.extra_data_size() == config.extra_data_size()) &&
+        (!existing_config.extra_data() ||
+         !memcmp(existing_config.extra_data(), config.extra_data(),
+                 existing_config.extra_data_size()))) {
+      append_config_index_ = i;
+      return true;
+    }
+  }
+
+  // No matches found so lets add this one to the list.

[vrk (LEFT CHROMIUM), 2012/07/12 19:37:55]

nit: "let's"

[acolwell GONE FROM CHROMIUM, 2012/07/12 23:07:58]

Done.

+  append_config_index_ = video_configs_.size();
+  video_configs_.resize(video_configs_.size() + 1);
+  video_configs_[append_config_index_] = new VideoDecoderConfig();
+  video_configs_[append_config_index_]->CopyFrom(config);
+  return true;
+}
+
+void SourceBufferStream::UpdateCurrentConfigIndex() {
+  if (!track_buffer_.empty()) {
+    current_config_index_ = track_buffer_.front()->GetConfigID();
+    return;
+  }
+
+  if (!selected_range_ || !selected_range_->HasNextBuffer())
+    return;
+
+  current_config_index_ = selected_range_->GetNextConfigID();
+}
+
 SourceBufferRange::SourceBufferRange(
     const BufferQueue& new_buffers, base::TimeDelta media_segment_start_time,
     const InterbufferDistanceCB& interbuffer_distance_cb)
     : next_buffer_index_(-1),
       waiting_for_keyframe_(false),
       next_keyframe_timestamp_(kNoTimestamp()),
       media_segment_start_time_(media_segment_start_time),
       interbuffer_distance_cb_(interbuffer_distance_cb) {
   DCHECK(!new_buffers.empty());
   DCHECK(new_buffers.front()->IsKeyframe());
@@ skipping 172 matching lines @@
   }
 
   DCHECK_GE(next_buffer_index_, 0);
   *out_buffer = buffers_.at(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());

[vrk (LEFT CHROMIUM), 2012/07/12 19:37:55]

nit: indentation + add "&& !waiting_for_keyframe_" just to be safe.

[acolwell GONE FROM CHROMIUM, 2012/07/12 23:07:58]

Done. Changed GetNextBuffer() to use this now that the conditions match.

 }
 
+int SourceBufferRange::GetNextConfigID() const {
+  DCHECK(HasNextBuffer());
+  return buffers_.at(next_buffer_index_)->GetConfigID();
+}
+
+
 base::TimeDelta SourceBufferRange::GetNextTimestamp() const {
   DCHECK(!buffers_.empty());
   DCHECK(HasNextBufferPosition());
 
   if (waiting_for_keyframe_)
     return next_keyframe_timestamp_;
 
   if (next_buffer_index_ >= static_cast<int>(buffers_.size()))
     return kNoTimestamp();
 
@@ skipping 85 matching lines @@
   return 2 * 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