Introduce AudioDecoderConfig to migrate away from GetAVStream().

media/filters/ffmpeg_audio_decoder.cc

 // Copyright (c) 2011 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/ffmpeg_audio_decoder.h"
 
 #include "base/bind.h"
 #include "media/base/data_buffer.h"
 #include "media/base/filter_host.h"
 #include "media/base/limits.h"
@@ skipping 38 matching lines @@
       codec_context_(NULL),
       bits_per_channel_(0),
       channel_layout_(CHANNEL_LAYOUT_NONE),
       sample_rate_(0),
       estimated_next_timestamp_(kNoTimestamp),
       decoded_audio_size_(AVCODEC_MAX_AUDIO_FRAME_SIZE),
       decoded_audio_(new uint8[decoded_audio_size_]),
       pending_reads_(0) {
 }
 
-FFmpegAudioDecoder::~FFmpegAudioDecoder() {}
+FFmpegAudioDecoder::~FFmpegAudioDecoder() {
+  // XXX: should we require Stop() to be called? this might end up getting
+  // called on a random thread due to refcounting.
+  if (codec_context_) {
+    av_free(codec_context_->extradata);
+    avcodec_close(codec_context_);
+    av_free(codec_context_);
+  }
+}
 
 void FFmpegAudioDecoder::Flush(FilterCallback* callback) {
   message_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &FFmpegAudioDecoder::DoFlush, callback));
 }
 
 void FFmpegAudioDecoder::Initialize(
     DemuxerStream* stream,
     FilterCallback* callback,
@@ skipping 25 matching lines @@
   return sample_rate_;
 }
 
 void FFmpegAudioDecoder::DoInitialize(
     DemuxerStream* stream,
     FilterCallback* callback,
     StatisticsCallback* stats_callback) {
   scoped_ptr<FilterCallback> c(callback);
 
   demuxer_stream_ = stream;
-  AVStream* av_stream = demuxer_stream_->GetAVStream();
-  CHECK(av_stream);
-
+  AudioDecoderConfig* config = stream->audio_decoder_config();

[Ami GONE FROM CHROMIUM, 2011/09/12 20:54:21]

Hopefully this can be a const& or at least a const*.

[scherkus (not reviewing), 2011/09/19 21:19:45]

Done.

   stats_callback_.reset(stats_callback);
 
-  // Grab the AVStream's codec context and make sure we have sensible values.
-  codec_context_ = av_stream->codec;
-  int bps = av_get_bits_per_sample_fmt(codec_context_->sample_fmt);
-  if (codec_context_->channels <= 0 ||
-      codec_context_->channels > Limits::kMaxChannels ||
-      (codec_context_->channel_layout == 0 && codec_context_->channels > 2) ||
-      bps <= 0 || bps > Limits::kMaxBitsPerSample ||
-      codec_context_->sample_rate <= 0 ||
-      codec_context_->sample_rate > Limits::kMaxSampleRate) {
+  // Sanity checking.

[Ami GONE FROM CHROMIUM, 2011/09/12 20:54:21]

Shouldn't this be happening earlier (ideally during construction/initialization
of stream->audio_decoder_config())

[scherkus (not reviewing), 2011/09/19 21:19:45]

I'm torn.. on one hand you could argue that said limits apply to this particular
use of ADC in conjunction with FFmpeg... but I think that's a little silly since
these values are crazy for any realistic application

Will move to ADC::IsValidConfig()

+  if (config->codec() == kUnknownAudioCodec ||
+      config->channel_layout() == CHANNEL_LAYOUT_UNSUPPORTED ||
+      config->bits_per_channel() <= 0 ||
+      config->bits_per_channel() > Limits::kMaxBitsPerSample ||
+      config->sample_rate() <= 0 ||
+      config->sample_rate() > Limits::kMaxSampleRate) {
     DLOG(ERROR) << "Invalid audio stream -"
-        << " channels: " << codec_context_->channels
-        << " channel layout:" << codec_context_->channel_layout
-        << " bps: " << bps
-        << " sample rate: " << codec_context_->sample_rate;
+        << " codec: " << config->codec()
+        << " channel layout: " << config->channel_layout()
+        << " bits per channel: " << config->bits_per_channel()
+        << " sample rate: " << config->sample_rate();
 
+    // XXX: format error?
     host()->SetError(PIPELINE_ERROR_DECODE);
     callback->Run();
     return;
   }
 
-  // Serialize calls to avcodec_open().
+  // Initialize AVCodecContext structure.
+  codec_context_ = avcodec_alloc_context();
+  AudioDecoderConfigToAVCodecContext(config, codec_context_);
+
   AVCodec* codec = avcodec_find_decoder(codec_context_->codec_id);
   if (!codec || avcodec_open(codec_context_, codec) < 0) {
     DLOG(ERROR) << "Could not initialize audio decoder: "
         << codec_context_->codec_id;
 
     host()->SetError(PIPELINE_ERROR_DECODE);
     callback->Run();
     return;
   }
 
   // Success!
-  bits_per_channel_= av_get_bits_per_sample_fmt(codec_context_->sample_fmt);
-  channel_layout_ =
-      ChannelLayoutToChromeChannelLayout(codec_context_->channel_layout,
-                                         codec_context_->channels);
-  sample_rate_ = codec_context_->sample_rate;
+  bits_per_channel_ = config->bits_per_channel();
+  channel_layout_ = config->channel_layout();
+  sample_rate_ = config->sample_rate();
 
   callback->Run();
 }
 
 void FFmpegAudioDecoder::DoFlush(FilterCallback* callback) {
   avcodec_flush_buffers(codec_context_);
   estimated_next_timestamp_ = kNoTimestamp;
 
   callback->Run();
   delete callback;
@@ skipping 111 matching lines @@
 
 base::TimeDelta FFmpegAudioDecoder::CalculateDuration(int size) {
   int64 denominator = ChannelLayoutToChannelCount(channel_layout_) *
       bits_per_channel_  / 8 * sample_rate_;
   double microseconds = size /
       (denominator / static_cast<double>(base::Time::kMicrosecondsPerSecond));
   return base::TimeDelta::FromMicroseconds(static_cast<int64>(microseconds));
 }
 
 }  // namespace media