Add support for midstream audio configuration changes.

media/filters/opus_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/opus_audio_decoder.h"
 
 #include <cmath>
 
 #include "base/single_thread_task_runner.h"
 #include "base/sys_byteorder.h"
@@ skipping 233 matching lines @@
 
   for (int i = 0; i < extra_data->channels; ++i)
     extra_data->stream_map[i] = *(data + kOpusExtraDataStreamMapOffset + i);
   return true;
 }
 
 OpusAudioDecoder::OpusAudioDecoder(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
     : task_runner_(task_runner),
       opus_decoder_(NULL),
-      channel_layout_(CHANNEL_LAYOUT_NONE),
-      samples_per_second_(0),
-      sample_format_(kSampleFormatF32),
-      bits_per_channel_(SampleFormatToBytesPerChannel(sample_format_) * 8),
       last_input_timestamp_(kNoTimestamp()),
       frames_to_discard_(0),
       frame_delay_at_start_(0),
       start_input_timestamp_(kNoTimestamp()) {}
 
 void OpusAudioDecoder::Initialize(const AudioDecoderConfig& config,
                                   const PipelineStatusCB& status_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   PipelineStatusCB initialize_cb = BindToCurrentLoop(status_cb);
 
   config_ = config;
 
   if (!ConfigureDecoder()) {
     initialize_cb.Run(DECODER_ERROR_NOT_SUPPORTED);
     return;
   }
 
   initialize_cb.Run(PIPELINE_OK);
 }
 
 void OpusAudioDecoder::Decode(const scoped_refptr<DecoderBuffer>& buffer,
             const DecodeCB& decode_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(!decode_cb.is_null());
 
   DecodeBuffer(buffer, BindToCurrentLoop(decode_cb));
 }
 
-int OpusAudioDecoder::bits_per_channel() {
-  DCHECK(task_runner_->BelongsToCurrentThread());
-  return bits_per_channel_;
-}
-
-ChannelLayout OpusAudioDecoder::channel_layout() {
-  DCHECK(task_runner_->BelongsToCurrentThread());
-  return channel_layout_;
-}
-
-int OpusAudioDecoder::samples_per_second() {
-  DCHECK(task_runner_->BelongsToCurrentThread());
-  return samples_per_second_;
-}
-
 void OpusAudioDecoder::Reset(const base::Closure& closure) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   opus_multistream_decoder_ctl(opus_decoder_, OPUS_RESET_STATE);
   ResetTimestampState();
   task_runner_->PostTask(FROM_HERE, closure);
 }
 
 void OpusAudioDecoder::Stop(const base::Closure& closure) {
   DCHECK(task_runner_->BelongsToCurrentThread());
@@ skipping 83 matching lines @@
                 << " bits per channel: " << config_.bits_per_channel()
                 << " samples per second: " << config_.samples_per_second();
     return false;
   }
 
   if (config_.is_encrypted()) {
     DLOG(ERROR) << "Encrypted audio stream not supported.";
     return false;
   }
 
-  // TODO(rileya) Remove this check once we properly support midstream audio
-  // config changes.
-  if (opus_decoder_ &&
-      (channel_layout_ != config_.channel_layout() ||
-       samples_per_second_ != config_.samples_per_second())) {
-    DLOG(ERROR) << "Unsupported config change -"
-                << ", channel_layout: " << channel_layout_
-                << " -> " << config_.channel_layout()
-                << ", sample_rate: " << samples_per_second_
-                << " -> " << config_.samples_per_second();
-    return false;
-  }
-
   // Clean up existing decoder if necessary.
   CloseDecoder();
 
   // Parse the Opus Extra Data.
   OpusExtraData opus_extra_data;
   if (!ParseOpusExtraData(config_.extra_data(), config_.extra_data_size(),
                           config_,
                           &opus_extra_data))
     return false;
 
@@ skipping 39 matching lines @@
   }
 
   status = opus_multistream_decoder_ctl(
       opus_decoder_, OPUS_SET_GAIN(opus_extra_data.gain_db));
   if (status != OPUS_OK) {
     DLOG(ERROR) << "Failed to set OPUS header gain; status="
                 << opus_strerror(status);
     return false;
   }
 
-  channel_layout_ = config_.channel_layout();
-  samples_per_second_ = config_.samples_per_second();
   output_timestamp_helper_.reset(
       new AudioTimestampHelper(config_.samples_per_second()));
   start_input_timestamp_ = kNoTimestamp();
   return true;
 }
 
 void OpusAudioDecoder::CloseDecoder() {
   if (opus_decoder_) {
     opus_multistream_decoder_destroy(opus_decoder_);
     opus_decoder_ = NULL;
   }
 }
 
 void OpusAudioDecoder::ResetTimestampState() {
   output_timestamp_helper_->SetBaseTimestamp(kNoTimestamp());
   last_input_timestamp_ = kNoTimestamp();
-  frames_to_discard_ =
-      TimeDeltaToAudioFrames(config_.seek_preroll(), samples_per_second_);
+  frames_to_discard_ = TimeDeltaToAudioFrames(config_.seek_preroll(),
+                                              config_.samples_per_second());
 }
 
 bool OpusAudioDecoder::Decode(const scoped_refptr<DecoderBuffer>& input,
                               scoped_refptr<AudioBuffer>* output_buffer) {
   // Allocate a buffer for the output samples.
-  *output_buffer = AudioBuffer::CreateBuffer(
-      sample_format_,
-      channel_layout_,
-      samples_per_second_,
-      kMaxOpusOutputPacketSizeSamples);
+  *output_buffer = AudioBuffer::CreateBuffer(config_.sample_format(),
+                                             config_.channel_layout(),
+                                             config_.samples_per_second(),
+                                             kMaxOpusOutputPacketSizeSamples);
   const int buffer_size =
       output_buffer->get()->channel_count() *
       output_buffer->get()->frame_count() *
-      SampleFormatToBytesPerChannel(sample_format_);
+      SampleFormatToBytesPerChannel(config_.sample_format());
 
   float* float_output_buffer = reinterpret_cast<float*>(
       output_buffer->get()->channel_data()[0]);
   const int frames_decoded =
       opus_multistream_decode_float(opus_decoder_,
                                     input->data(),
                                     input->data_size(),
                                     float_output_buffer,
                                     buffer_size,
                                     0);
@@ skipping 21 matching lines @@
 
   // Handle frame discard and trimming.
   int frames_to_output = frames_decoded;
   if (frames_decoded > frames_to_discard_) {
     if (frames_to_discard_ > 0) {
       output_buffer->get()->TrimStart(frames_to_discard_);
       frames_to_output -= frames_to_discard_;
       frames_to_discard_ = 0;
     }
     if (input->discard_padding().InMicroseconds() > 0) {
-      int discard_padding = TimeDeltaToAudioFrames(input->discard_padding(),
-                                                   samples_per_second_);
+      int discard_padding = TimeDeltaToAudioFrames(
+          input->discard_padding(), config_.samples_per_second());
       if (discard_padding < 0 || discard_padding > frames_to_output) {
         DVLOG(1) << "Invalid file. Incorrect discard padding value.";
         return false;
       }
       output_buffer->get()->TrimEnd(discard_padding);
       frames_to_output -= discard_padding;
     }
   } else {
     frames_to_discard_ -= frames_to_output;
     frames_to_output = 0;
   }
 
   // Assign timestamp and duration to the buffer.
   output_buffer->get()->set_timestamp(
       output_timestamp_helper_->GetTimestamp() - timestamp_offset_);
   output_buffer->get()->set_duration(
       output_timestamp_helper_->GetFrameDuration(frames_to_output));
   output_timestamp_helper_->AddFrames(frames_decoded);
 
   // Discard the buffer to indicate we need more data.
   if (!frames_to_output)
     *output_buffer = NULL;
 
   return true;
 }
 
 }  // namespace media