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/demuxer.h"
 #include "media/base/filter_host.h"
-#include "media/base/limits.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 
 namespace media {
 
 // Returns true if the decode result was an error.
 static bool IsErrorResult(int result, int decoded_size) {
   return result < 0 ||
       decoded_size < 0 ||
       decoded_size > AVCODEC_MAX_AUDIO_FRAME_SIZE;
 }
@@ skipping 29 matching lines @@
       bits_per_channel_(0),
       channel_layout_(CHANNEL_LAYOUT_NONE),
       sample_rate_(0),
       decoded_audio_size_(AVCODEC_MAX_AUDIO_FRAME_SIZE),
       decoded_audio_(static_cast<uint8*>(av_malloc(decoded_audio_size_))),
       pending_reads_(0) {
 }
 
 FFmpegAudioDecoder::~FFmpegAudioDecoder() {
   av_free(decoded_audio_);
+
+  // 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,
@@ skipping 27 matching lines @@
   return sample_rate_;
 }
 
 void FFmpegAudioDecoder::DoInitialize(
     const scoped_refptr<DemuxerStream>& stream,
     FilterCallback* callback,
     StatisticsCallback* stats_callback) {
   scoped_ptr<FilterCallback> c(callback);
 
   demuxer_stream_ = stream;
-  AVStream* av_stream = demuxer_stream_->GetAVStream();
-  CHECK(av_stream);
-
+  const AudioDecoderConfig& config = stream->audio_decoder_config();
   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) {
+  if (!config.IsValidConfig()) {

[Ami GONE FROM CHROMIUM, 2011/09/20 20:34:50]

This is better, but my point was that it would be nicer if not every caller of
audio_decoder_config() needed to check the return value for validity.  Is there
no opportunity for erroring-out earlier, presumably during stream construction?

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

You're right in that the correct place for this check is before this object is
even created, however I'm hesitant to toss more code into PipelineImpl at this
time as it needs a lot of loving itself

TODOing it up for now

     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();
 
-    host()->SetError(PIPELINE_ERROR_DECODE);
+    host()->SetError(DECODER_ERROR_NOT_SUPPORTED);
     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);
+    host()->SetError(DECODER_ERROR_NOT_SUPPORTED);
     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 126 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