Add MediaCodecAudioDecoder implementation

media/filters/android/android_audio_decoder.cc

Index: media/filters/android/android_audio_decoder.cc
diff --git a/media/filters/android/android_audio_decoder.cc b/media/filters/android/android_audio_decoder.cc
new file mode 100644
index 0000000000000000000000000000000000000000..d1e5370a6c2844bbb81034334618920dba12ba7b
--- /dev/null
+++ b/media/filters/android/android_audio_decoder.cc
@@ -0,0 +1,496 @@
+// Copyright 2016 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/android/android_audio_decoder.h"
+
+#include "base/android/build_info.h"
+#include "base/bind.h"
+#include "base/callback_helpers.h"
+#include "base/logging.h"
+#include "base/thread_task_runner_handle.h"
+

[xhwang, 2016/02/08 20:03:34]

no empty line here

[Tima Vaisburd, 2016/02/11 20:23:22]

Done.

+#include "media/base/android/sdk_media_codec_bridge.h"
+#include "media/base/audio_buffer.h"
+#include "media/base/bind_to_current_loop.h"
+
+namespace media {
+
+// Android MediaCodec can only output 16bit PCM audio.
+const int kBytesPerOutputSample = 2;
+
+// The coefficient for seconds to nanoseconds conversion.
+const int64_t kNanoMultiplier = 1000LL * 1000 * 1000;

[xhwang, 2016/02/08 20:03:34]

You can just use kNanosecondsPerSecond:

https://code.google.com/p/chromium/codesearch#chromium/src/base/time/time.h&l...

[Tima Vaisburd, 2016/02/11 20:23:22]

Used in sdk_media_codec_bridge.cc now.

+
+inline const base::TimeDelta DecodePollDelay() {
+  return base::TimeDelta::FromMilliseconds(10);
+}
+
+inline const base::TimeDelta NoWaitTimeOut() {
+  return base::TimeDelta::FromMicroseconds(0);
+}
+
+inline const base::TimeDelta IdleTimerTimeOut() {
+  return base::TimeDelta::FromSeconds(1);
+}
+
+AndroidAudioDecoder::AndroidAudioDecoder(
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
+    : task_runner_(task_runner),
+      state_(kStateUninitialized),
+      channel_count_(0),
+      bytes_per_frame_(0),
+      pending_input_buf_index_(-1),
+      weak_factory_(this) {
+  DVLOG(1) << __FUNCTION__;
+}
+
+AndroidAudioDecoder::~AndroidAudioDecoder() {
+  DVLOG(1) << __FUNCTION__;
+
+  if (!init_cb_.is_null())
+    base::ResetAndReturn(&init_cb_).Run(false);
+
+  media_codec_.reset();
+
+  // Report kAborted status for pending EOS and all frames in the input queue.
+  if (!eos_decode_cb_.is_null())
+    base::ResetAndReturn(&eos_decode_cb_).Run(kAborted);
+
+  for (const auto& entry : input_queue_) {

[qinmin, 2016/02/09 00:31:56]

nit: no {} needed

[Tima Vaisburd, 2016/02/11 20:23:23]

Done.

+    entry.second.Run(kAborted);
+  }
+}
+
+std::string AndroidAudioDecoder::GetDisplayName() const {
+  return "AndroidAudioDecoder";
+}
+
+void AndroidAudioDecoder::Initialize(const AudioDecoderConfig& config,
+                                     const SetCdmReadyCB& set_cdm_ready_cb,
+                                     const InitCB& init_cb,
+                                     const OutputCB& output_cb) {
+  DVLOG(1) << __FUNCTION__ << ": " << config.AsHumanReadableString();
+
+  InitCB bound_init_cb = BindToCurrentLoop(init_cb);
+
+  // Keep this consistent with AudioCodecBridge.

[xhwang, 2016/02/08 20:03:34]

Probably not necessary. AudioCodecBridge will go away in the future and it's not
needed to be consistent with it.

[Tima Vaisburd, 2016/02/11 20:23:23]

I changed the comment to "We can support only the codecs that AudioCodecBridge
can decode". I think as long as we use AudioCodecBridge it makes sense?
OOC: why will it go away?

[xhwang, 2016/02/12 10:15:04]

Sorry, I was wrong :) Apparently you are using it here.

+  const bool is_codec_supported = config.codec() == kCodecVorbis ||
+                                  config.codec() == kCodecAAC ||
+                                  config.codec() == kCodecOpus;
+  if (!is_codec_supported) {
+    DVLOG(1) << "Unsuported codec " << GetCodecName(config.codec());
+    bound_init_cb.Run(false);
+    return;
+  }
+

[xhwang, 2016/02/08 20:03:34]

In this CL, if config is encrypted, we should fail initialization. Then in the
next CL you can remove this check.

[Tima Vaisburd, 2016/02/11 20:23:22]

Done.

+  config_ = config;
+  // The following derived parameters are frequently used.
+  channel_count_ = ChannelLayoutToChannelCount(config_.channel_layout());
+  bytes_per_frame_ = kBytesPerOutputSample * channel_count_;
+
+  init_cb_ = bound_init_cb;

[xhwang, 2016/02/08 20:03:34]

|init_cb_| will be always be fired in this call. So it seems we don't need it as
a member variable. Then it seems we don't need bound_init_cb either. We can just
PostTask(init_cb).

[Tima Vaisburd, 2016/02/11 20:23:22]

I removed |init_cb_|, but not BindToCurrentLoop(). Both OpusAudioDecoder and
FFmpegAudioDecoder do this, I think because they care not to call the |init_cb|
from Initialize(). Is it equivalent to PostTask?

[xhwang, 2016/02/12 10:15:04]

Yes, it's just an easier way to PostTask.

+  output_cb_ = BindToCurrentLoop(output_cb);

[xhwang, 2016/02/08 20:03:34]

Will |output_cb_| be fired on other threads? If not, we probably don't need an
extra BindToCurrentLoop. Also see the comment around Decode().

[Tima Vaisburd, 2016/02/11 20:23:22]

Yes, we do not need BindToCurrentLoop for output_cb_, strictly speaking. I wrote
it that way to make the timing of the DoIOTask() independent of how long is
|output_cb_|.

+
+  const bool success = ConfigureMediaCodec();

[xhwang, 2016/02/08 20:03:34]

ddorwin@ and I talked about this before (the same code pattern in
FFmpegAudioDecoder [1]), and we felt that it would be cleaner to set the member
variables (e.g. config_, channel_count_ etc) after the initialization succeeds.

In this particular case, e.g. we could be in an kStateUninitialized state (line
97) while having config_ set. How about having ConfigureMediaCodec() be a
non-member function like:

// Returns null if configuration failed.
scoped_ptr<AudioCodecBridge> ConfigureMediaCodec(const AudioDecoderConfig&
config);

Then we can move line 87-93 after this configuration call.

In line 144, we can call ConfigureMediaCodec(config_);

[1]
https://code.google.com/p/chromium/codesearch#chromium/src/media/filters/ffmp...

+
+  SetState(success ? kStateReady : kStateUninitialized);
+  base::ResetAndReturn(&init_cb_).Run(success);
+}
+
+void AndroidAudioDecoder::Decode(const scoped_refptr<DecoderBuffer>& buffer,
+                                 const DecodeCB& decode_cb) {
+  DecodeCB bound_decode_cb = BindToCurrentLoop(decode_cb);

[xhwang, 2016/02/08 20:03:34]

We BindToCurrentLoop for two reasons:

1. Make sure the callback is fired on the correct thread.
2. Avoid reentering the caller in the same callstack by force posting the
callback.

It's very convenient to use, however it always involve an extra post, even if we
are already on the same thread.

In this case, it seems to me AAD is single threaded, so (1) isn't a concern.

The only case we can reenter the caller in the same callstack is the DoIOTask()
call on line 116. Instead of calling DoIOTask() directly, we can probably
PostTask(base::Bind(&DoIOTask)). 

The reason I *think* this is better is that when DoIOTask() is called in other
cases (e.g. OnKeyAdded, timer fired), we don't force post the decoder and output
callbacks, which seems unnecessary.

p.s. line 108 can be a PostTask.

[Tima Vaisburd, 2016/02/11 20:23:23]

Yes, (1) is not a concern. Just (2), and, as I said above, it felt safer not to
call a callback which duration I cannot control directly from DoIOTask().

Still, I do not (yet?) see a benefit of moving the extra post from DecodeCB to
Decode(). In my understanding OnKeyAdded cases can be neglected. After that the
number of Decode() calls should be the same as the DecodeCB calls. Am I missing
something?

[xhwang, 2016/02/12 10:15:04]

If you bind the callback, it will always do a post, which is not necessary if
you know it's not going to have reentrency issues.

For example, all the decoding work happens in DoIOTask(), which can be called in
3 cases:
1. In Decode().
2. In OnKeyAdded()
3. Fired by the timer.

Only in (1) we could have the reentrency issue, that's why I suggest a post
there.

I agreed that the number of Decode() calls is the same as the DecodeCB calls.
But then you don't need to post all OutputCB, which could save us a bit
cycles...

[Tima Vaisburd, 2016/02/13 01:31:24]

I unbound |output_cb_|, but kept |bound_decode_cb|, and deleted |weak_factory_|.
Let me know what you think.

+

[xhwang, 2016/02/08 20:03:34]

DCHECK that we are not in kStateUninitialized state.

[Tima Vaisburd, 2016/02/11 20:23:22]

It seems only STATE_READY is possible here. Added that.

+  if (state_ == kStateError) {

[xhwang, 2016/02/08 20:03:34]

In what case can this happen? If an error has been reported to the pipeline,
then Decode() should never be called again. It seems this could happen after
line 352, but without knowing how the state machine is supposed to work I am not
sure.

[Tima Vaisburd, 2016/02/11 20:23:22]

Yes, this is exactly right. If MediaCodec error happens in DequeueOutput() or
Reset() only the next Decode will report the error. 

+    DVLOG(2) << __FUNCTION__ << " " << buffer->AsHumanReadableString()
+             << ": Error state, dropping buffer";
+    bound_decode_cb.Run(kDecodeError);
+    return;
+  }
+
+  DVLOG(2) << __FUNCTION__ << " " << buffer->AsHumanReadableString();
+
+  input_queue_.push_back(std::make_pair(buffer, bound_decode_cb));
+
+  DoIOTask();
+}
+
+void AndroidAudioDecoder::Reset(const base::Closure& closure) {
+  DVLOG(1) << __FUNCTION__;
+
+  io_timer_.Stop();
+
+  if (!eos_decode_cb_.is_null())
+    base::ResetAndReturn(&eos_decode_cb_).Run(kAborted);
+
+  // Report kAborted status for all frames in the input queue.
+  for (const auto& entry : input_queue_) {

[qinmin, 2016/02/09 00:31:56]

ditto

[Tima Vaisburd, 2016/02/11 20:23:23]

Done.

+    entry.second.Run(kAborted);
+  }
+  input_queue_.clear();
+
+  // Flush if we can, otherwise completely recreate and reconfigure the codec.
+  // Prior to JB-MR2, flush() had several bugs (b/8125974, b/8347958).
+  bool success = false;
+  if (state_ != kStateError && state_ != kStateDrained &&
+      base::android::BuildInfo::GetInstance()->sdk_int() < 18) {
+    // media_codec_->Reset() calls MediaCodec.flush().
+    success = (media_codec_->Reset() == MEDIA_CODEC_OK);
+  }
+
+  if (!success) {
+    media_codec_.reset();
+    success = ConfigureMediaCodec();
+  }
+
+  SetState(success ? kStateReady : kStateError);
+
+  task_runner_->PostTask(FROM_HERE, closure);
+}
+
+void AndroidAudioDecoder::OnKeyAdded() {
+  DVLOG(1) << __FUNCTION__;
+
+  if (state_ == kStateWaitingForKey)
+    SetState(kStateReady);
+
+  DoIOTask();
+}
+
+void AndroidAudioDecoder::DoIOTask() {
+  if (state_ == kStateError)
+    return;
+
+  const bool did_input = QueueInput();
+  const bool did_output = DequeueOutput();
+
+  ManageTimer(did_input || did_output);
+}
+
+bool AndroidAudioDecoder::QueueInput() {
+  DVLOG(2) << __FUNCTION__;
+
+  if (input_queue_.empty())
+    return false;
+
+  if (state_ == kStateWaitingForKey)
+    return false;
+
+  if (state_ == kStateDraining)
+    return false;
+
+  scoped_refptr<DecoderBuffer> decoder_buffer = input_queue_.front().first;
+  const DecodeCB& decode_cb = input_queue_.front().second;
+
+  int input_buf_index = pending_input_buf_index_;
+
+  // Do not dequeue a new input buffer if we failed with MEDIA_CODEC_NO_KEY.
+  // That status does not return the input buffer back to the pool of
+  // available input buffers. We have to reuse it in QueueSecureInputBuffer().
+  if (input_buf_index == -1) {
+    media::MediaCodecStatus status =
+        media_codec_->DequeueInputBuffer(NoWaitTimeOut(), &input_buf_index);
+    switch (status) {
+      case media::MEDIA_CODEC_DEQUEUE_INPUT_AGAIN_LATER:
+        return false;
+      case media::MEDIA_CODEC_ERROR:
+        DVLOG(1) << __FUNCTION__ << ": MEDIA_CODEC_ERROR from DequeInputBuffer";
+        SetState(kStateError);
+
+        // Report an error to the pipeline.
+        decode_cb.Run(kDecodeError);
+        return false;
+      case media::MEDIA_CODEC_OK:
+        break;
+      default:
+        NOTREACHED() << "Unknown DequeueInputBuffer status " << status;
+        return false;
+    }
+  }
+
+  DCHECK_NE(input_buf_index, -1);
+
+  if (decoder_buffer->end_of_stream()) {
+    media_codec_->QueueEOS(input_buf_index);
+
+    // After queueing EOS we need to flush decoder, i.e. receive this EOS at
+    // the output, and then call corresponding decoder_cb.
+    eos_decode_cb_ = decode_cb;
+    input_queue_.pop_front();
+    SetState(kStateDraining);
+    return true;
+  }
+
+  // Make sure our DecoderBuffer is not EOS, otherwise we can't call any method.
+  DCHECK(!decoder_buffer->end_of_stream());
+
+  media::MediaCodecStatus status = MEDIA_CODEC_OK;
+  const DecryptConfig* decrypt_config = decoder_buffer->decrypt_config();
+  if (decrypt_config) {
+    // If pending_input_buf_index_ != -1 the input buffer is already filled up,
+    // no need to copy it again.
+    const uint8_t* memory =
+        (pending_input_buf_index_ == -1) ? decoder_buffer->data() : nullptr;
+
+    DVLOG(2) << __FUNCTION__ << ": QueueSecureInputBuffer:"
+             << " index:" << input_buf_index
+             << " pts:" << decoder_buffer->timestamp()
+             << " size:" << decoder_buffer->data_size();
+
+    status = media_codec_->QueueSecureInputBuffer(
+        input_buf_index, memory, decoder_buffer->data_size(),
+        decrypt_config->key_id(), decrypt_config->iv(),
+        decrypt_config->subsamples(), decoder_buffer->timestamp());
+
+  } else {
+    DVLOG(2) << __FUNCTION__ << ": QueueInputBuffer:"
+             << " index:" << input_buf_index
+             << " pts:" << decoder_buffer->timestamp()
+             << " size:" << decoder_buffer->data_size();
+
+    status = media_codec_->QueueInputBuffer(
+        input_buf_index, decoder_buffer->data(), decoder_buffer->data_size(),
+        decoder_buffer->timestamp());
+  }
+
+  pending_input_buf_index_ = -1;
+
+  switch (status) {
+    case MEDIA_CODEC_ERROR:
+      DVLOG(0) << __FUNCTION__ << ": MEDIA_CODEC_ERROR from QueueInputBuffer";
+      SetState(kStateError);
+
+      // Report an error to the pipeline.
+      decode_cb.Run(kDecodeError);
+      return false;
+
+    case MEDIA_CODEC_NO_KEY:
+      // Keep trying to enqueue the same input buffer.
+      // The buffer is owned by us (not the MediaCodec) and is filled with data.
+      DVLOG(1) << "QueueSecureInputBuffer failed: MEDIA_CODEC_NO_KEY";
+      pending_input_buf_index_ = input_buf_index;
+      SetState(kStateWaitingForKey);
+      return false;
+
+    case MEDIA_CODEC_OK:
+      break;
+
+    default:
+      NOTREACHED() << "Unknown Queue(Secure)InputBuffer status " << status;
+      break;
+  }
+
+  // Although audio_decoder.h says "Once the buffer is decoded the decoder calls
+  // |decode_cb|", we call |decode_cb| when the buffer is accepted by
+  // MediaCodec, not when it is completely decoded. It seems consistent to what
+  // other decoders do.
+  decode_cb.Run(kOk);
+  input_queue_.pop_front();
+  return true;
+}
+
+bool AndroidAudioDecoder::DequeueOutput() {
+  DVLOG(2) << __FUNCTION__;
+
+  DCHECK(media_codec_);
+
+  MediaCodecStatus status;
+  OutputBufferInfo out;
+  bool work_done = false;
+  do {
+    status = media_codec_->DequeueOutputBuffer(NoWaitTimeOut(), &out.buf_index,
+                                               &out.offset, &out.size, &out.pts,
+                                               &out.is_eos, &out.is_key_frame);
+
+    switch (status) {
+      case MEDIA_CODEC_OUTPUT_BUFFERS_CHANGED:
+        // Output buffers are replaced in MediaCodecBridge, nothing to do.
+        DVLOG(2) << __FUNCTION__ << " MEDIA_CODEC_OUTPUT_BUFFERS_CHANGED";
+        work_done = true;
+        break;
+
+      case MEDIA_CODEC_OUTPUT_FORMAT_CHANGED:
+        DVLOG(2) << __FUNCTION__ << " MEDIA_CODEC_OUTPUT_FORMAT_CHANGED";
+        OnOutputFormatChanged();
+        work_done = true;
+        break;
+
+      case MEDIA_CODEC_OK:
+        // We got the decoded frame.
+        if (out.is_eos) {
+          media_codec_->ReleaseOutputBuffer(out.buf_index, false);
+
+          DCHECK_EQ(state_, kStateDraining);
+          DCHECK(!eos_decode_cb_.is_null());
+
+          // Report the end of decoding for EOS DecoderBuffer.
+          base::ResetAndReturn(&eos_decode_cb_).Run(kOk);
+
+          // media_decoder_job.cc says: once output EOS has occurred, we should
+          // not be asked to decode again.
+          // Have a separate state for this case.
+          SetState(kStateDrained);
+        } else {
+          // Process the real decoded frame.
+          OnDecodedFrame(out);
+        }
+
+        work_done = true;
+        break;
+
+      case MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER:
+        // Nothing to do.
+        DVLOG(2) << __FUNCTION__ << " MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER";
+        break;
+
+      case MEDIA_CODEC_ERROR:
+        DVLOG(0) << __FUNCTION__
+                 << ": MEDIA_CODEC_ERROR from DequeueOutputBuffer";
+
+        // Next Decode() will report the error to the pipeline.
+        SetState(kStateError);
+        break;
+
+      default:
+        NOTREACHED();
+        break;
+    }
+  } while (status != MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER &&
+           status != MEDIA_CODEC_ERROR && !out.is_eos);
+
+  return work_done;
+}
+
+void AndroidAudioDecoder::ManageTimer(bool did_work) {
+  bool should_be_running = true;
+
+  base::TimeTicks now = base::TimeTicks::Now();
+  if (!did_work) {
+    // Make sure that we have done work recently enough, else stop the timer.
+    if (now - idle_time_begin_ > IdleTimerTimeOut())
+      should_be_running = false;
+  } else {
+    idle_time_begin_ = now;
+  }
+
+  if (should_be_running && !io_timer_.IsRunning()) {
+    io_timer_.Start(FROM_HERE, DecodePollDelay(), this,
+                    &AndroidAudioDecoder::DoIOTask);
+  } else if (!should_be_running && io_timer_.IsRunning()) {
+    io_timer_.Stop();
+  }
+}
+
+void AndroidAudioDecoder::SetState(State new_state) {
+  DVLOG(1) << __FUNCTION__ << ": " << AsString(state_) << "->"
+           << AsString(new_state);
+  state_ = new_state;
+}
+
+bool AndroidAudioDecoder::ConfigureMediaCodec() {
+  DVLOG(1) << __FUNCTION__;
+
+  media_codec_.reset(AudioCodecBridge::Create(config_.codec()));

[xhwang, 2016/02/08 20:03:34]

OOC and not related to this CL: why AudioCodecBridge::Create() is returning a
raw pointer instead of a scoped_ptr<>?

[Tima Vaisburd, 2016/02/11 20:23:23]

I do not know exactly. Maybe because
media_codec_.reset(AudioCodecBridge::Create())
looks better than media_codec_ = AudioCodecBridge::Create().Pass() ?

We could do the same if CreateMediaCodec(config) returned a raw pointer.

+  if (!media_codec_) {
+    DVLOG(0) << __FUNCTION__ << " failed: cannot create AudioCodecBridge";
+    return false;
+  }
+
+  AudioCodecBridge* audio_codec_bridge =
+      static_cast<AudioCodecBridge*>(media_codec_.get());
+  DCHECK(audio_codec_bridge);
+
+  jobject media_crypto = nullptr;
+
+  const bool play_audio = false;  // Do not create AudioTrack object.
+  const int64_t codec_delay_ns =
+      kNanoMultiplier * config_.codec_delay() / config_.samples_per_second();
+  const int64_t seek_preroll_ns =
+      1000LL * config_.seek_preroll().InMicroseconds();
+
+  DVLOG(2) << __FUNCTION__ << ": Calling ConfigureAndStart() with parameters:"
+           << " codec:" << config_.codec()
+           << " samples_per_second:" << config_.samples_per_second()
+           << " channel_count:" << channel_count_
+           << " codec_delay_ns:" << codec_delay_ns
+           << " seek_preroll_ns:" << seek_preroll_ns
+           << " extra data size:" << config_.extra_data().size()
+           << " play audio:" << play_audio << " media_crypto:" << media_crypto;

[xhwang, 2016/02/08 20:03:34]

Shouldn't this log be a part of AudioCodecBridge::ConfigureAndStart()?

[Tima Vaisburd, 2016/02/11 20:23:23]

Done.

+
+  if (!audio_codec_bridge->ConfigureAndStart(
+          config_.codec(), config_.samples_per_second(), channel_count_,
+          &config_.extra_data()[0], config_.extra_data().size(), codec_delay_ns,

[xhwang, 2016/02/08 20:03:34]

&config_.extra_data()[0] is not safe if extra_data is empty. Use
config_.extra_data().data() instead.

[Tima Vaisburd, 2016/02/11 20:23:22]

Done.

+          seek_preroll_ns, play_audio, media_crypto)) {
+    DVLOG(0) << __FUNCTION__ << " failed: cannot configure audio codec";
+    media_codec_.reset();
+    return false;
+  }
+
+  return true;
+}
+
+void AndroidAudioDecoder::OnDecodedFrame(const OutputBufferInfo& out) {
+  DCHECK_NE(out.size, 0U);
+  DCHECK_GE(out.buf_index, 0);  // |out->buf_index| must be valid
+  DCHECK(media_codec_);
+
+  DVLOG(2) << __FUNCTION__ << " pts:" << out.pts;
+
+  // Create AudioOutput buffer based on configuration.
+  const size_t frame_count = out.size / bytes_per_frame_;
+
+  scoped_refptr<AudioBuffer> audio_buffer = AudioBuffer::CreateBuffer(
+      kSampleFormatS16, config_.channel_layout(), channel_count_,
+      config_.samples_per_second(), frame_count);
+
+  // Set timestamp.
+  audio_buffer->set_timestamp(out.pts);
+
+  // Copy data into AudioBuffer.
+  DCHECK_LE(out.size, audio_buffer->data_size());
+
+  media_codec_->CopyFromOutputBuffer(out.buf_index, out.offset,
+                                     audio_buffer->channel_data()[0],
+                                     audio_buffer->data_size());
+
+  // Release MediaCodec output buffer.
+  media_codec_->ReleaseOutputBuffer(out.buf_index, false);
+
+  // Call the |output_cb_|.
+  output_cb_.Run(audio_buffer);
+}
+
+void AndroidAudioDecoder::OnOutputFormatChanged() {
+  DVLOG(2) << __FUNCTION__;
+
+  // Modify the stored |config_|. So far we only analyse the sampling rate.
+  int new_sampling_rate = media_codec_->GetOutputSamplingRate();
+  if (new_sampling_rate != config_.samples_per_second()) {
+    DVLOG(1) << __FUNCTION__ << ": detected sampling rate change:"
+             << config_.samples_per_second() << "->" << new_sampling_rate;
+    config_.set_samples_per_second(new_sampling_rate);
+  }
+}
+
+#undef RETURN_STRING
+#define RETURN_STRING(x) \
+  case x:                \
+    return #x;
+
+// static
+const char* AndroidAudioDecoder::AsString(State state) {
+  switch (state) {
+    RETURN_STRING(kStateUninitialized);
+    RETURN_STRING(kStateReady);
+    RETURN_STRING(kStateWaitingForKey);
+    RETURN_STRING(kStateDraining);
+    RETURN_STRING(kStateDrained);
+    RETURN_STRING(kStateError);
+  }
+  return nullptr;
+}
+
+#undef RETURN_STRING
+
+}  // namespace media