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 252 matching lines @@
 // 12MB: approximately 5 minutes of 320Kbps content.
 // 150MB: approximately 5 minutes of 4Mbps content.
 static int kDefaultAudioMemoryLimit = 12 * 1024 * 1024;
 static int kDefaultVideoMemoryLimit = 150 * 1024 * 1024;
 
 namespace media {
 
 SourceBufferStream::SourceBufferStream(const AudioDecoderConfig& audio_config)
     : 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()),
-      memory_limit_(kDefaultAudioMemoryLimit) {
-  audio_configs_[0] = new AudioDecoderConfig();
-  audio_configs_[0]->CopyFrom(audio_config);
+      memory_limit_(kDefaultAudioMemoryLimit),
+      config_change_pending_(false) {
+  DCHECK(audio_config.IsValidConfig());
+  audio_configs_.push_back(new AudioDecoderConfig());
+  audio_configs_.back()->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) {
-  video_configs_[0] = new VideoDecoderConfig();
-  video_configs_[0]->CopyFrom(video_config);
+      memory_limit_(kDefaultVideoMemoryLimit),
+      config_change_pending_(false) {
+  DCHECK(video_config.IsValidConfig());
+  video_configs_.push_back(new VideoDecoderConfig());
+  video_configs_.back()->CopyFrom(video_config);
 }
 
 SourceBufferStream::~SourceBufferStream() {
   while (!ranges_.empty()) {
     delete ranges_.front();
     ranges_.pop_front();
   }
 
   STLDeleteElements(&audio_configs_);
   STLDeleteElements(&video_configs_);
@@ skipping 413 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 11 matching lines @@
   selected_range_->Seek(timestamp);
   seek_pending_ = false;
 }
 
 bool SourceBufferStream::IsSeekPending() const {
   return seek_pending_;
 }
 
 SourceBufferStream::Status SourceBufferStream::GetNextBuffer(
     scoped_refptr<StreamParserBuffer>* out_buffer) {
+  CHECK(!config_change_pending_);
+
   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 55 matching lines @@
 
   // 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() {
+  config_change_pending_ = false;
+
   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();
+  if (selected_range_ && selected_range_->HasNextBuffer())
+    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),
@@ 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