refactoring decoder interface

media/filters/audio_renderer_base.cc

 // Copyright (c) 2010 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/audio_renderer_base.h"
 
 #include <algorithm>
 
 #include "base/callback.h"
 #include "media/base/filter_host.h"
@@ skipping 61 matching lines @@
 }
 
 void AudioRendererBase::Initialize(AudioDecoder* decoder,
                                    FilterCallback* callback) {
   DCHECK(decoder);
   DCHECK(callback);
   DCHECK_EQ(kUninitialized, state_);
   scoped_ptr<FilterCallback> c(callback);
   decoder_ = decoder;
 
+  decoder_->set_fill_buffer_done_callback(
+      NewCallback(this, &AudioRendererBase::OnFillBufferDone));
   // Get the media properties to initialize our algorithms.
   int channels = 0;
   int sample_rate = 0;
   int sample_bits = 0;
   if (!ParseMediaFormat(decoder_->media_format(), &channels, &sample_rate,
                         &sample_bits)) {
     host()->SetError(PIPELINE_ERROR_INITIALIZATION_FAILED);
     callback->Run();
     return;
   }
@@ skipping 27 matching lines @@
 
 bool AudioRendererBase::HasEnded() {
   AutoLock auto_lock(lock_);
   if (rendered_end_of_stream_) {
     DCHECK(algorithm_->IsQueueEmpty())
         << "Audio queue should be empty if we have rendered end of stream";
   }
   return recieved_end_of_stream_ && rendered_end_of_stream_;
 }
 
-void AudioRendererBase::OnReadComplete(Buffer* buffer_in) {
+void AudioRendererBase::OnFillBufferDone(scoped_refptr<Buffer> buffer_in) {
   AutoLock auto_lock(lock_);
   DCHECK(state_ == kPaused || state_ == kSeeking || state_ == kPlaying);
   DCHECK_GT(pending_reads_, 0u);
   --pending_reads_;
 
   // TODO(scherkus): this happens due to a race, primarily because Stop() is a
   // synchronous call when it should be asynchronous and accept a callback.
   // Refer to http://crbug.com/16059
   if (state_ == kStopped) {
     return;
@@ skipping 82 matching lines @@
       last_fill_buffer_time -= playback_delay;
     host()->SetTime(last_fill_buffer_time);
   }
 
   return dest_written;
 }
 
 void AudioRendererBase::ScheduleRead_Locked() {
   lock_.AssertAcquired();
   ++pending_reads_;
-  decoder_->Read(NewCallback(this, &AudioRendererBase::OnReadComplete));
+  // TODO(jiesun): We use dummy buffer to feed decoder to let decoder to
+  // provide buffer pools. In the future, we may want to implement real
+  // buffer pool to recycle buffers.
+  scoped_refptr<Buffer> buffer;
+  decoder_->FillThisBuffer(buffer);
 }
 
 // static
 bool AudioRendererBase::ParseMediaFormat(const MediaFormat& media_format,
                                          int* channels_out,
                                          int* sample_rate_out,
                                          int* sample_bits_out) {
   // TODO(scherkus): might be handy to support NULL parameters.
   std::string mime_type;
   return media_format.GetAsString(MediaFormat::kMimeType, &mime_type) &&
       media_format.GetAsInteger(MediaFormat::kChannels, channels_out) &&
       media_format.GetAsInteger(MediaFormat::kSampleRate, sample_rate_out) &&
       media_format.GetAsInteger(MediaFormat::kSampleBits, sample_bits_out) &&
       mime_type.compare(mime_type::kUncompressedAudio) == 0;
 }
 
 void AudioRendererBase::SetPlaybackRate(float playback_rate) {
   algorithm_->set_playback_rate(playback_rate);
 }
 
 float AudioRendererBase::GetPlaybackRate() {
   return algorithm_->playback_rate();
 }
 
 }  // namespace media