Add config change handling to SourceBufferStream & ChunkDemuxer

media/filters/chunk_demuxer.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/chunk_demuxer.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
@@ skipping 174 matching lines @@
   virtual const VideoDecoderConfig& video_decoder_config() OVERRIDE;
   virtual Ranges<TimeDelta> GetBufferedRanges() OVERRIDE;
 
  protected:
   virtual ~ChunkDemuxerStream();
 
  private:
   enum State {
     RETURNING_DATA_FOR_READS,
     WAITING_FOR_SEEK,
+    CONFIG_CHANGE,
     SHUTDOWN,
   };
 
   // Assigns |state_| to |state|
   void ChangeState_Locked(State state);
 
   // Adds the callback to |read_cbs_| so it can be called later when we
   // have data.
   void DeferRead_Locked(const ReadCB& read_cb);
 
   // Creates closures that bind ReadCBs in |read_cbs_| to data in
   // |buffers_| and pops the callbacks & buffers from the respecive queues.
   void CreateReadDoneClosures_Locked(ClosureQueue* closures);
 
+  // Called when audio_decoder_config() or video_decoder_config() is called.
+  // This method handles transitioning from
+  // CONFIG_CHANGE to RETURNING_DATA_FOR_READS if necessary.
+  void OnConfigRequest();
+
   // Specifies the type of the stream (must be AUDIO or VIDEO for now).
   Type type_;
 
   scoped_ptr<SourceBufferStream> stream_;
 
   mutable base::Lock lock_;
   State state_;
   ReadCBQueue read_cbs_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(ChunkDemuxerStream);
@@ skipping 68 matching lines @@
 }
 
 Ranges<TimeDelta> ChunkDemuxerStream::GetBufferedRanges() {
   base::AutoLock auto_lock(lock_);
   return stream_->GetBufferedTime();
 }
 
 bool ChunkDemuxerStream::UpdateAudioConfig(const AudioDecoderConfig& config) {
   DCHECK(config.IsValidConfig());
   DCHECK_EQ(type_, AUDIO);
-
-  const AudioDecoderConfig& current_config =
-      stream_->GetCurrentAudioDecoderConfig();
-
-  bool success = (current_config.codec() == config.codec()) &&
-      (current_config.bits_per_channel() == config.bits_per_channel()) &&
-      (current_config.channel_layout() == config.channel_layout()) &&
-      (current_config.samples_per_second() == config.samples_per_second()) &&
-      (current_config.extra_data_size() == config.extra_data_size()) &&
-      (!current_config.extra_data() ||
-       !memcmp(current_config.extra_data(), config.extra_data(),
-               current_config.extra_data_size()));
-
-  if (!success)
-    DVLOG(1) << "UpdateAudioConfig() : Failed to update audio config.";
-
-  return success;
+  return stream_->UpdateAudioConfig(config);
 }
 
 bool ChunkDemuxerStream::UpdateVideoConfig(const VideoDecoderConfig& config) {
   DCHECK(config.IsValidConfig());
   DCHECK_EQ(type_, VIDEO);
-  const VideoDecoderConfig& current_config =
-      stream_->GetCurrentVideoDecoderConfig();
-
-  bool success = (current_config.codec() == config.codec()) &&
-      (current_config.format() == config.format()) &&
-      (current_config.profile() == config.profile()) &&
-      (current_config.coded_size() == config.coded_size()) &&
-      (current_config.visible_rect() == config.visible_rect()) &&
-      (current_config.natural_size() == config.natural_size()) &&
-      (current_config.extra_data_size() == config.extra_data_size()) &&
-      (!current_config.extra_data() ||
-       !memcmp(current_config.extra_data(), config.extra_data(),
-               current_config.extra_data_size()));
-
-  if (!success)
-    DVLOG(1) << "UpdateVideoConfig() : Failed to update video config.";
-
-  return success;
+  return stream_->UpdateVideoConfig(config);
 }
 
 void ChunkDemuxerStream::EndOfStream() {
   ClosureQueue closures;
   {
     base::AutoLock auto_lock(lock_);
     stream_->EndOfStream();
     CreateReadDoneClosures_Locked(&closures);
   }
 
@@ skipping 38 matching lines @@
 void ChunkDemuxerStream::Read(const ReadCB& read_cb) {
   DemuxerStream::Status status = kOk;
   scoped_refptr<StreamParserBuffer> buffer;
   {
     base::AutoLock auto_lock(lock_);
 
     switch (state_) {
       case RETURNING_DATA_FOR_READS:
         // If we already have pending reads or we don't have any buffers ready,
         // then defer this read.
-        if (!read_cbs_.empty() || !stream_->GetNextBuffer(&buffer)) {
+        if (!read_cbs_.empty()) {
           DeferRead_Locked(read_cb);
           return;
         }
+
+        switch (stream_->GetNextBuffer(&buffer)) {
+          case SourceBufferStream::kSuccess:
+            // Do nothing and continue

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

nit: period at end

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

Done.

+            break;
+          case SourceBufferStream::kNeedBuffer:
+            DeferRead_Locked(read_cb);
+            return;
+          case SourceBufferStream::kConfigChange:
+            ChangeState_Locked(CONFIG_CHANGE);
+            status = kConfigChanged;
+            break;
+        }
         break;
       case WAITING_FOR_SEEK:
         // Null buffers should be returned in this state since we are waiting
         // for a seek. Any buffers in the SourceBuffer should NOT be returned
         // because they are associated with the seek.
         DCHECK(read_cbs_.empty());
         status = kAborted;
         break;
+      case CONFIG_CHANGE:
+        DCHECK(read_cbs_.empty());
+        status = kConfigChanged;
+        break;
       case SHUTDOWN:
         DCHECK(read_cbs_.empty());
         buffer = StreamParserBuffer::CreateEOSBuffer();
     }
   }
 
   read_cb.Run(status, buffer);
 }
 
 DemuxerStream::Type ChunkDemuxerStream::type() { return type_; }
 
 void ChunkDemuxerStream::EnableBitstreamConverter() {}
 
 const AudioDecoderConfig& ChunkDemuxerStream::audio_decoder_config() {

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

nit: {audio,video}_decoder_config() does more than being a simple accessor now,
so should be renamed.

   CHECK_EQ(type_, AUDIO);
   base::AutoLock auto_lock(lock_);
+  OnConfigRequest();
   return stream_->GetCurrentAudioDecoderConfig();
 }
 
 const VideoDecoderConfig& ChunkDemuxerStream::video_decoder_config() {
   CHECK_EQ(type_, VIDEO);
   base::AutoLock auto_lock(lock_);
+  OnConfigRequest();
   return stream_->GetCurrentVideoDecoderConfig();
 }
 
+void ChunkDemuxerStream::OnConfigRequest() {
+  lock_.AssertAcquired();
+  if (state_ == CONFIG_CHANGE) {
+    stream_->UpdateCurrentConfigIndex();

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

Change method name to something like "CompleteConfigChange"

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

Done.

+    ChangeState_Locked(RETURNING_DATA_FOR_READS);
+  }
+}
+
 void ChunkDemuxerStream::ChangeState_Locked(State state) {
   lock_.AssertAcquired();
+  DVLOG(1) << "ChunkDemuxerStream::ChangeState_Locked() : "
+           << "type " << type_
+           << " - " << state_ << " -> " << state;
   state_ = state;
 }
 
 ChunkDemuxerStream::~ChunkDemuxerStream() {}
 
 void ChunkDemuxerStream::DeferRead_Locked(const ReadCB& read_cb) {
   lock_.AssertAcquired();
   // Wrap & store |read_cb| so that it will
   // get called on the current MessageLoop.
   read_cbs_.push_back(base::Bind(&RunOnMessageLoop, read_cb,
                                  MessageLoop::current()));
 }
 
 void ChunkDemuxerStream::CreateReadDoneClosures_Locked(ClosureQueue* closures) {
   lock_.AssertAcquired();
 
   if (state_ != RETURNING_DATA_FOR_READS)
     return;
 
-  scoped_refptr<StreamParserBuffer> buffer;
+  bool configChange = false;
   while (!read_cbs_.empty()) {
-    if (!stream_->GetNextBuffer(&buffer))
-      return;
-    closures->push_back(base::Bind(read_cbs_.front(),
-                                   DemuxerStream::kOk, buffer));
-    read_cbs_.pop_front();
+    scoped_refptr<StreamParserBuffer> buffer;
+    switch (stream_->GetNextBuffer(&buffer)) {
+      case SourceBufferStream::kSuccess:
+        closures->push_back(base::Bind(read_cbs_.front(),
+                                       DemuxerStream::kOk, buffer));
+        read_cbs_.pop_front();
+        break;
+      case SourceBufferStream::kNeedBuffer:
+        return;
+      case SourceBufferStream::kConfigChange:
+        configChange = true;
+        closures->push_back(base::Bind(read_cbs_.front(),
+                                       DemuxerStream::kConfigChanged,
+                                       scoped_refptr<DecoderBuffer>()));
+        read_cbs_.pop_front();
+    }
   }
+  if (configChange)
+    ChangeState_Locked(CONFIG_CHANGE);
 }
 
 ChunkDemuxer::ChunkDemuxer(ChunkDemuxerClient* client)
     : state_(WAITING_FOR_INIT),
       host_(NULL),
       client_(client) {
   DCHECK(client);
 }
 
 void ChunkDemuxer::Initialize(DemuxerHost* host,
@@ skipping 511 matching lines @@
   // TODO(vrk): There should be a special case for the first appends where all
   // streams (for both demuxed and muxed case) begin at the earliest stream
   // timestamp. (crbug.com/132815)
   if (audio_ && source_id == source_id_audio_)
     audio_->OnNewMediaSegment(start_timestamp);
   if (video_ && source_id == source_id_video_)
     video_->OnNewMediaSegment(start_timestamp);
 }
 
 }  // namespace media