Set |config_| only after decoder has been successfully configured

media/filters/ffmpeg_audio_decoder.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/ffmpeg_audio_decoder.h"
 
 #include <stdint.h>
 
 #include "base/callback_helpers.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 76 matching lines @@
   DCHECK(config.IsValidConfig());
 
   InitCB bound_init_cb = BindToCurrentLoop(init_cb);
 
   if (config.is_encrypted()) {
     bound_init_cb.Run(false);
     return;
   }
 
   FFmpegGlue::InitializeFFmpeg();
-  config_ = config;
 
-  // TODO(xhwang): Only set |config_| after we successfully configure the
-  // decoder. Make sure we clean up all member variables upon failure.
-  if (!ConfigureDecoder()) {
+  if (!ConfigureDecoder(config)) {
+    av_sample_format_ = 0;
     bound_init_cb.Run(false);
     return;
   }
 
   // Success!
+  config_ = config;
   output_cb_ = BindToCurrentLoop(output_cb);
   state_ = kNormal;
   bound_init_cb.Run(true);
 }
 
 void FFmpegAudioDecoder::Decode(const scoped_refptr<DecoderBuffer>& buffer,
                                 const DecodeCB& decode_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(!decode_cb.is_null());
   CHECK_NE(state_, kUninitialized);
@@ skipping 11 matching lines @@
   }
 
   DecodeBuffer(buffer, decode_cb_bound);
 }
 
 void FFmpegAudioDecoder::Reset(const base::Closure& closure) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   avcodec_flush_buffers(codec_context_.get());
   state_ = kNormal;
-  ResetTimestampState();
+  ResetTimestampState(config_);
   task_runner_->PostTask(FROM_HERE, closure);
 }
 
 void FFmpegAudioDecoder::DecodeBuffer(
     const scoped_refptr<DecoderBuffer>& buffer,
     const DecodeCB& decode_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_NE(state_, kUninitialized);
   DCHECK_NE(state_, kDecodeFinished);
   DCHECK_NE(state_, kError);
@@ skipping 102 matching lines @@
               << ", ChannelLayout: " << channel_layout << " vs "
               << config_.channel_layout() << ", Channels: " << channels
               << " vs "
               << ChannelLayoutToChannelCount(config_.channel_layout());
           config_.Initialize(config_.codec(), config_.sample_format(),
                              channel_layout, av_frame_->sample_rate,
                              config_.extra_data(), config_.encryption_scheme(),
                              config_.seek_preroll(), config_.codec_delay());
           config_changed = true;
           if (is_sample_rate_change)
-            ResetTimestampState();
+            ResetTimestampState(config_);
         } else {
           MEDIA_LOG(ERROR, media_log_)
               << "Unsupported midstream configuration change!"
               << " Sample Rate: " << av_frame_->sample_rate << " vs "
               << config_.samples_per_second() << ", Channels: " << channels
               << " vs " << ChannelLayoutToChannelCount(config_.channel_layout())
               << ", Sample Format: " << av_frame_->format << " vs "
               << av_sample_format_;
           // This is an unrecoverable error, so bail out.
           av_frame_unref(av_frame_.get());
@@ skipping 34 matching lines @@
   } while (packet.size > 0);
 
   return true;
 }
 
 void FFmpegAudioDecoder::ReleaseFFmpegResources() {
   codec_context_.reset();
   av_frame_.reset();
 }
 
-bool FFmpegAudioDecoder::ConfigureDecoder() {
-  DCHECK(config_.IsValidConfig());
-  DCHECK(!config_.is_encrypted());
+bool FFmpegAudioDecoder::ConfigureDecoder(const AudioDecoderConfig& config) {
+  DCHECK(config.IsValidConfig());
+  DCHECK(!config.is_encrypted());
 
   // Release existing decoder resources if necessary.
   ReleaseFFmpegResources();
 
   // Initialize AVCodecContext structure.
   codec_context_.reset(avcodec_alloc_context3(NULL));
-  AudioDecoderConfigToAVCodecContext(config_, codec_context_.get());
+  AudioDecoderConfigToAVCodecContext(config, codec_context_.get());
 
   codec_context_->opaque = this;
   codec_context_->get_buffer2 = GetAudioBufferImpl;
   codec_context_->refcounted_frames = 1;
 
-  if (config_.codec() == kCodecOpus)
+  if (config.codec() == kCodecOpus)
     codec_context_->request_sample_fmt = AV_SAMPLE_FMT_FLT;
 
   AVCodec* codec = avcodec_find_decoder(codec_context_->codec_id);
   if (!codec || avcodec_open2(codec_context_.get(), codec, NULL) < 0) {
     DLOG(ERROR) << "Could not initialize audio decoder: "
                 << codec_context_->codec_id;
     ReleaseFFmpegResources();
     state_ = kUninitialized;
     return false;
   }
 
   // Success!
   av_frame_.reset(av_frame_alloc());
   av_sample_format_ = codec_context_->sample_fmt;
 
   if (codec_context_->channels !=
-      ChannelLayoutToChannelCount(config_.channel_layout())) {
+      ChannelLayoutToChannelCount(config.channel_layout())) {
     MEDIA_LOG(ERROR, media_log_)
         << "Audio configuration specified "
-        << ChannelLayoutToChannelCount(config_.channel_layout())
+        << ChannelLayoutToChannelCount(config.channel_layout())
         << " channels, but FFmpeg thinks the file contains "
         << codec_context_->channels << " channels";
     ReleaseFFmpegResources();
     state_ = kUninitialized;
     return false;
   }
 
-  ResetTimestampState();
+  ResetTimestampState(config);
   return true;
 }
 
-void FFmpegAudioDecoder::ResetTimestampState() {
+void FFmpegAudioDecoder::ResetTimestampState(const AudioDecoderConfig& config) {
   // Opus codec delay is handled by ffmpeg.
   const int codec_delay =
-      config_.codec() == kCodecOpus ? 0 : config_.codec_delay();
-  discard_helper_.reset(
-      new AudioDiscardHelper(config_.samples_per_second(), codec_delay,
-                             config_.codec() == kCodecVorbis));
+      config.codec() == kCodecOpus ? 0 : config.codec_delay();
+  discard_helper_.reset(new AudioDiscardHelper(config.samples_per_second(),
+                                               codec_delay,
+                                               config.codec() == kCodecVorbis));
   discard_helper_->Reset(codec_delay);
 }
 
 int FFmpegAudioDecoder::GetAudioBuffer(struct AVCodecContext* s,
                                        AVFrame* frame,
                                        int flags) {
   DCHECK(s->codec->capabilities & CODEC_CAP_DR1);
   DCHECK_EQ(s->codec_type, AVMEDIA_TYPE_AUDIO);
 
   // Since this routine is called by FFmpeg when a buffer is required for audio
@@ skipping 71 matching lines @@
   // Now create an AVBufferRef for the data just allocated. It will own the
   // reference to the AudioBuffer object.
   AudioBuffer* opaque = buffer.get();
   opaque->AddRef();
   frame->buf[0] = av_buffer_create(frame->data[0], buffer_size_in_bytes,
                                    ReleaseAudioBufferImpl, opaque, 0);
   return 0;
 }
 
 }  // namespace media