Add support for config changes during playback to FFmpegVideoDecoder.

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 264 matching lines @@
       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()),
       memory_limit_(kDefaultAudioMemoryLimit) {
+  DCHECK(audio_config.IsValidConfig());
   audio_configs_[0] = new AudioDecoderConfig();

[Ami GONE FROM CHROMIUM, 2012/08/17 15:16:59]

FWIW, you could
audio_configs_.push_back(new AudioDecoderConfig());
audio_configs_.back()->CopyFrom(audio_config);
and drop the size ctor at l.273.
(and ditto for the VDC ctor below)

[acolwell GONE FROM CHROMIUM, 2012/08/20 23:10:12]

Done.

   audio_configs_[0]->CopyFrom(audio_config);
 }
 
 SourceBufferStream::SourceBufferStream(const VideoDecoderConfig& video_config)
     : 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()),
       memory_limit_(kDefaultVideoMemoryLimit) {
+  DCHECK(video_config.IsValidConfig());
   video_configs_[0] = new VideoDecoderConfig();
   video_configs_[0]->CopyFrom(video_config);
 }
 
 SourceBufferStream::~SourceBufferStream() {
   while (!ranges_.empty()) {
     delete ranges_.front();
     ranges_.pop_front();
   }
 
@@ skipping 415 matching lines @@
     delete *next_range_itr;
     ranges_.erase(next_range_itr);
   }
 }
 
 void SourceBufferStream::Seek(base::TimeDelta timestamp) {
   DCHECK(stream_start_time_ != kNoTimestamp());
   DCHECK(timestamp >= stream_start_time_);
   SetSelectedRange(NULL);
   track_buffer_.clear();
+  config_change_pending_ = false;
 
   if (ShouldSeekToStartOfBuffered(timestamp)) {
     SetSelectedRange(ranges_.front());
     ranges_.front()->SeekToStart();
     seek_pending_ = false;
     return;
   }
 
   seek_buffer_timestamp_ = timestamp;
   seek_pending_ = true;
@@ skipping 12 matching lines @@
   seek_pending_ = false;
 }
 
 bool SourceBufferStream::IsSeekPending() const {
   return seek_pending_;
 }
 
 SourceBufferStream::Status SourceBufferStream::GetNextBuffer(
     scoped_refptr<StreamParserBuffer>* out_buffer) {
   if (!track_buffer_.empty()) {
-    if (track_buffer_.front()->GetConfigId() != current_config_index_)
+    if (track_buffer_.front()->GetConfigId() != current_config_index_) {
+      config_change_pending_ = true;
       return kConfigChange;
+    }
 
     *out_buffer = track_buffer_.front();
     track_buffer_.pop_front();
     return kSuccess;
   }
 
   if (!selected_range_ || !selected_range_->HasNextBuffer())
     return kNeedBuffer;
 
-  if (selected_range_->GetNextConfigId() != current_config_index_)
+  if (selected_range_->GetNextConfigId() != current_config_index_) {
+    config_change_pending_ = true;
     return kConfigChange;
+  }
 
   CHECK(selected_range_->GetNextBuffer(out_buffer));
   return kSuccess;
 }
 
 base::TimeDelta SourceBufferStream::GetNextBufferTimestamp() {
   if (!selected_range_)
     return kNoTimestamp();
 
   DCHECK(selected_range_->HasNextBufferPosition());
@@ skipping 51 matching lines @@
     ranges.Add((*itr)->GetStartTimestamp(), (*itr)->GetBufferedEndTimestamp());
   }
   return ranges;
 }
 
 bool SourceBufferStream::IsEndSelected() const {
   return ranges_.empty() || selected_range_ == ranges_.back();
 }
 
 const AudioDecoderConfig& SourceBufferStream::GetCurrentAudioDecoderConfig() {
-  CompleteConfigChange();
+  if (config_change_pending_)
+    CompleteConfigChange();
   return *audio_configs_[current_config_index_];
 }
 
 const VideoDecoderConfig& SourceBufferStream::GetCurrentVideoDecoderConfig() {
-  CompleteConfigChange();
+  if (config_change_pending_)
+    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) {
@@ skipping 57 matching lines @@
   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();
+    config_change_pending_ = false;
     return;
   }
 
   if (!selected_range_ || !selected_range_->HasNextBuffer())

[Ami GONE FROM CHROMIUM, 2012/08/17 15:16:59]

Can this really happen?
If not, then you can unconditionally set
config_change_pending_ = false;
at the top of the function and simplify a bit.

[acolwell GONE FROM CHROMIUM, 2012/08/20 23:10:12]

I believe it can happen with an unfortunate end overlap, but I believe the
proper thing to do would be to clear config_change_pending_ unconditionally
anyways so that GNB can be called again to reassess the situation.

     return;
 
   current_config_index_ = selected_range_->GetNextConfigId();
+  config_change_pending_ = false;
 }
 
 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),
@@ skipping 423 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