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"
 #include "base/logging.h"
+#include "base/stl_util.h"
 
 namespace media {
 
 // 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;
 
@@ skipping 64 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;
+
   // 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;
 
   // Resets this range to an "unseeked" state.
   void ResetNextBufferPosition();
 
   // Returns the timestamp of the next buffer that will be returned from
   // GetNextBuffer(), or kNoTimestamp() if the timestamp is unknown.
@@ skipping 116 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)
-    : stream_start_time_(kNoTimestamp()),
+    : current_config_index_(0),
+      append_config_index_(0),
+      audio_configs_(1),
+      video_configs_(0),
+      stream_start_time_(kNoTimestamp()),
       seek_pending_(false),
       seek_buffer_timestamp_(kNoTimestamp()),
       selected_range_(NULL),
       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)
-    : stream_start_time_(kNoTimestamp()),
+    : current_config_index_(0),
+      append_config_index_(0),
+      audio_configs_(0),
+      video_configs_(1),
+      stream_start_time_(kNoTimestamp()),
       seek_pending_(false),
       seek_buffer_timestamp_(kNoTimestamp()),
       selected_range_(NULL),
       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();
   }
+
+  STLDeleteElements(&audio_configs_);
+  STLDeleteElements(&video_configs_);
 }
 
 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 26 matching lines @@
     return false;
   }
 
   if (stream_start_time_ != kNoTimestamp() &&
       media_segment_start_time_ < stream_start_time_) {
     DVLOG(1) << "Cannot append a media segment before the start of stream.";
     return false;
   }
 
   UpdateMaxInterbufferDistance(buffers);
+  SetConfigIds(buffers);
 
   // Save a snapshot of stream 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_;
   // If there's a range for |buffers|, insert |buffers| accordingly. Otherwise,
@@ skipping 98 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_);
+  }
+}
+
 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 210 matching lines @@
 
   SetSelectedRange(*itr);
   selected_range_->Seek(timestamp);
   seek_pending_ = 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;
   }
 
-  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;
+
+  CHECK(selected_range_->GetNextBuffer(out_buffer));
+  return kSuccess;
 }
 
 base::TimeDelta SourceBufferStream::GetNextBufferTimestamp() {
   if (!selected_range_)
     return kNoTimestamp();
 
   DCHECK(selected_range_->HasNextBufferPosition());
   return selected_range_->GetNextTimestamp();
 }
 
@@ skipping 47 matching lines @@
        itr != ranges_.end(); ++itr) {
     ranges.Add((*itr)->GetStartTimestamp(), (*itr)->GetBufferedEndTimestamp());
   }
   return ranges;
 }
 
 bool SourceBufferStream::IsEndSelected() const {
   return ranges_.empty() || selected_range_ == ranges_.back();
 }
 
+const AudioDecoderConfig& SourceBufferStream::GetCurrentAudioDecoderConfig() {
+  CompleteConfigChange();
+  return *audio_configs_[current_config_index_];
+}
+
+const VideoDecoderConfig& SourceBufferStream::GetCurrentVideoDecoderConfig() {
+  CompleteConfigChange();
+  return *video_configs_[current_config_index_];
+}
+
 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());
+  DCHECK(video_configs_.empty());
+
+  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) {
+    if (config.Matches(*audio_configs_[i])) {
+      append_config_index_ = i;
+      return true;
+    }
+  }
+
+  // No matches found so let's add this one to the list.
+  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());
+  DCHECK(audio_configs_.empty());
+
+  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) {
+    if (config.Matches(*video_configs_[i])) {
+      append_config_index_ = i;
+      return true;
+    }
+  }
+
+  // No matches found so let's add this one to the list.
+  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::CompleteConfigChange() {
+  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 170 matching lines @@
       keyframe_map_.lower_bound((*starting_point)->GetDecodeTimestamp());
   keyframe_map_.erase(starting_point_keyframe, keyframe_map_.end());
 
   // Remove everything from |starting_point| onward.
   buffers_.erase(starting_point, buffers_.end());
   return removed_next_buffer;
 }
 
 bool SourceBufferRange::GetNextBuffer(
     scoped_refptr<StreamParserBuffer>* out_buffer) {
-  if (waiting_for_keyframe_ ||
-      next_buffer_index_ >= static_cast<int>(buffers_.size())) {
+  if (!HasNextBuffer())
     return false;
-  }
 
-  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());
+      next_buffer_index_ < static_cast<int>(buffers_.size()) &&
+      !waiting_for_keyframe_;
 }
 
+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 93 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