Add Opus decode wrapper to media.

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 "base/bind.h"
+#include "base/callback_helpers.h"
+#include "base/location.h"
+#include "base/message_loop_proxy.h"
+#include "base/sys_byteorder.h"
+#include "media/base/audio_decoder_config.h"
+#include "media/base/audio_timestamp_helper.h"
+#include "media/base/data_buffer.h"
+#include "media/base/decoder_buffer.h"
+#include "media/base/demuxer.h"
+#include "media/base/pipeline.h"
+#include "third_party/opus/src/include/opus.h"
+#include "third_party/opus/src/include/opus_multistream.h"
+
+namespace media {
+
+static uint16 ReadLE16(const uint8* data, size_t data_size, int read_offset) {
+  DCHECK(data);
+  DCHECK_LE(read_offset + sizeof(uint16), data_size);
+  return base::ByteSwapToLE16(static_cast<uint16>(*(data + read_offset)));

[xhwang, 2012/12/12 22:16:10]

Is this correct? *(data + read_offset) is still a uint8 value. We cast it to
uint16 then do a byteswap? Shouldn't we read two bytes out?

[Tom Finegan, 2012/12/13 06:18:14]

Yeah, fixed. Deref'ing a uint8* and casting the value to uint16 doesn't
magically read 2 bytes. Oops. :)

+}
+
+// Helper structure for managing multiple decoded audio frames per packet.
+struct QueuedAudioBuffer {
+  AudioDecoder::Status status;
+  scoped_refptr<Buffer> buffer;
+};
+
+// Returns true if the decode result was end of stream.
+static inline bool IsEndOfStream(int decoded_size, Buffer* input) {
+  // Two conditions to meet to declare end of stream for this decoder:
+  // 1. Opus didn't output anything.
+  // 2. An end of stream buffer is received.
+  return decoded_size == 0 && input->IsEndOfStream();
+}
+
+// Opus uses Vorbis channel mapping, and Vorbis channel mapping specifies
+// mappings for up to 8 channels. See section 4.3.9 of the vorbis
+// specification:
+// http://www.xiph.org/vorbis/doc/Vorbis_I_spec.html
+static const int kMaxVorbisChannels = 8;
+
+// Maximum packet size used in Xiph's opusdec and FFmpeg's libopusdec.
+static const int kMaxOpusOutputPacketSizeSamples = 960 * 6;
+static const int kMaxOpusOutputPacketSizeBytes =
+    kMaxOpusOutputPacketSizeSamples * 2;
+
+// OpusAudioDecoder currently supports only 16 bit samples.
+static const int kRequiredSampleSize = 16;
+
+static bool RemapOpusChannelLayout(const uint8* opus_mapping,
+                                   int num_channels,
+                                   uint8* channel_layout) {
+  DCHECK(opus_mapping);
+  DCHECK(channel_layout);
+  DCHECK_LE(num_channels, kMaxVorbisChannels);
+  if (!channel_layout || num_channels > kMaxVorbisChannels)
+    return false;
+
+  // Opus uses Vorbis channel layout.
+  const int32 kNumVorbisChannelLayouts = 8;
+  const int32 kMaxVorbisChannels = 8;
+  const int32 num_layouts = kNumVorbisChannelLayouts;
+  const int32 num_layout_values = kMaxVorbisChannels;
+  const uint8 kVorbisChannelLayouts[num_layouts][num_layout_values] = {
+    { 0 },
+    { 0, 1 },
+    { 0, 2, 1 },
+    { 0, 1, 2, 3 },
+    { 0, 2, 1, 3, 4 },
+    { 0, 2, 1, 5, 3, 4 },
+    { 0, 2, 1, 6, 5, 3, 4 },
+    { 0, 2, 1, 7, 5, 6, 3, 4 },
+  };
+
+  const uint8* vorbis_layout_offset = kVorbisChannelLayouts[num_channels - 1];
+  for (int channel = 0; channel < num_channels; ++channel)
+    channel_layout[channel] = opus_mapping[vorbis_layout_offset[channel]];
+
+  return true;
+}
+
+// Opus Header contents:
+// - "OpusHead" (64 bits)
+// - version number (8 bits)
+// - Channels C (8 bits)
+// - Pre-skip (16 bits)
+// - Sampling rate (32 bits)
+// - Gain in dB (16 bits, S7.8)
+// - Mapping (8 bits, 0=single stream (mono/stereo) 1=Vorbis mapping,
+//            2..254: reserved, 255: multistream with no mapping)
+//
+// - if (mapping != 0)
+//    - N = totel number of streams (8 bits)
+//    - M = number of paired streams (8 bits)
+//    - C times channel origin
+//         - if (C<2*M)
+//            - stream = byte/2
+//            - if (byte&0x1 == 0)
+//                - left
+//              else
+//                - right
+//         - else
+//            - stream = byte-M
+
+static const uint8 kDefaultOpusStreamMap[kMaxVorbisChannels] = {
+    0, 1, 0, 0, 0, 0, 0, 0 };

[xhwang, 2012/12/12 22:16:10]

Could you please add a comment explain what this is?

[Tom Finegan, 2012/12/13 06:18:14]

Done.

+
+struct OpusHeader {
+  OpusHeader()
+      : channels(0),
+        skip_samples(0),
+        channel_mapping(0),
+        num_streams(0),
+        num_coupled(0) { *stream_map = *kDefaultOpusStreamMap; }

[xhwang, 2012/12/12 22:16:10]

Do you mean memcpy(stream_map, .... ?

[Tom Finegan, 2012/12/13 06:18:14]

Done.

+  int channels;
+  int skip_samples;
+  int channel_mapping;
+  int num_streams;
+  int num_coupled;
+  uint8 stream_map[kMaxVorbisChannels];
+};
+
+// Returns true when able to successfully parse and store Opus header data in
+// data parsed in |header|. Based on opus header parsing code in libopusdec
+// from FFmpeg, and opus_header from Xiph's opus-tools project.
+static bool ParseOpusHeader(const uint8* data, int data_size,
+                            const AudioDecoderConfig& config,
+                            OpusHeader* header) {
+  DCHECK(data);
+  DCHECK(header);
+
+  const int kOpusHeaderSize = 19;
+  DCHECK_GE(data_size, kOpusHeaderSize);
+
+  if (!data || data_size < kOpusHeaderSize || !header)
+    return false;
+
+  const int kChannelsOffset = 9;

[xhwang, 2012/12/12 22:16:10]

hmm, can we have these constants in one place, preferably close to line 90?

[Tom Finegan, 2012/12/13 06:18:14]

Done.

+  header->channels = *(data + kChannelsOffset);
+
+  DCHECK(header->channels > 0 && header->channels <= kMaxVorbisChannels);
+  if (header->channels <= 0 || header->channels > kMaxVorbisChannels) {
+    LOG(ERROR) << "ParseOpusHeader(): invalid channel count in header "
+               << ChannelLayoutToChannelCount(config.channel_layout());
+    return false;
+  }
+
+  if (data_size >= kOpusHeaderSize) {

[xhwang, 2012/12/12 22:16:10]

shouldn't this been covered by line 142 already?

[Tom Finegan, 2012/12/13 06:18:14]

Done.

+    const int kSkipOffset = 10;
+    header->skip_samples = ReadLE16(data, data_size, kSkipOffset);
+
+    const int kChannelMappingOffset = 18;
+    header->channel_mapping = *(data + kChannelMappingOffset);
+  }
+
+  const int kMappingRequiredSize = kOpusHeaderSize + 2 + header->channels;

[xhwang, 2012/12/12 22:16:10]

what's this magic number 2? Since this contains header->channels, it doesn't
look like a real constant...

[Tom Finegan, 2012/12/13 06:18:14]

It's not a real constant... it changes based on channel count. Changed the name,
and added a constant for bytes per channel (the magic 2).

+  if (data_size >= kMappingRequiredSize) {
+    // Header contains a stream map. The mapping values are in extra data
+    // beyond the always present |kOpusHeaderSize| bytes of data. The mapping
+    // data contains stream count, coupling information, and per channel
+    // mapping values:
+    //   - Byte 0: Number of streams.
+    //   - Byte 1: Number coupled.
+    //   - Byte 2: Starting at byte 2 are |header->channels| uint8 mapping
+    //     values.
+    header->num_streams = *(data + kOpusHeaderSize);
+    header->num_coupled = *(data + kOpusHeaderSize + 1);
+
+    if (header->num_streams + header->num_coupled != header->channels)
+      LOG(WARNING) << "ParseOpusHeader(): Inconsistent channel mapping.";
+
+    for (int i = 0; i < kMaxVorbisChannels; ++i)
+      header->stream_map[i] = *(data + kOpusHeaderSize + 2 + i);
+  } else {
+    if (header->channels > 2 || header->channel_mapping) {
+      // The opus stream is invalid: It's missing its stream map.
+      LOG(ERROR) << "ParseOpusHeader(): Invalid header, missing stream map.";
+      return false;
+    }
+
+    header->num_streams = 1;
+    header->num_coupled =
+        (ChannelLayoutToChannelCount(config.channel_layout()) > 1) ? 1 : 0;
+  }

[xhwang, 2012/12/12 22:16:10]

What do you think of reordering the logic of line 164-191 like this?
if (header->channel_mapping) {
  if (data_size < mapping_required_size) {
    LOG(ERROR)...
    return false;
  }

  normal case here
}

[Tom Finegan, 2012/12/13 06:18:14]

Moved things around, but not exactly as requested above. PTAL/WDYT?

+
+  return true;
+}
+
+OpusAudioDecoder::OpusAudioDecoder(
+    const scoped_refptr<base::MessageLoopProxy>& message_loop)
+    : message_loop_(message_loop),
+      opus_decoder_(NULL),
+      bits_per_channel_(0),
+      channel_layout_(CHANNEL_LAYOUT_NONE),
+      samples_per_second_(0),
+      last_input_timestamp_(kNoTimestamp()),
+      output_bytes_to_drop_(0) {
+}
+
+void OpusAudioDecoder::Initialize(
+    const scoped_refptr<DemuxerStream>& stream,
+    const PipelineStatusCB& status_cb,
+    const StatisticsCB& statistics_cb) {
+  if (!message_loop_->BelongsToCurrentThread()) {
+    message_loop_->PostTask(FROM_HERE, base::Bind(
+        &OpusAudioDecoder::DoInitialize, this,
+        stream, status_cb, statistics_cb));
+    return;
+  }
+  DoInitialize(stream, status_cb, statistics_cb);
+}
+
+void OpusAudioDecoder::Read(const ReadCB& read_cb) {
+  // Complete operation asynchronously on different stack of execution as per
+  // the API contract of AudioDecoder::Read()
+  message_loop_->PostTask(FROM_HERE, base::Bind(
+      &OpusAudioDecoder::DoRead, this, read_cb));
+}
+
+int OpusAudioDecoder::bits_per_channel() {
+  return bits_per_channel_;
+}
+
+ChannelLayout OpusAudioDecoder::channel_layout() {
+  return channel_layout_;
+}
+
+int OpusAudioDecoder::samples_per_second() {
+  return samples_per_second_;
+}
+
+void OpusAudioDecoder::Reset(const base::Closure& closure) {
+  message_loop_->PostTask(FROM_HERE, base::Bind(
+      &OpusAudioDecoder::DoReset, this, closure));
+}
+
+OpusAudioDecoder::~OpusAudioDecoder() {
+  // TODO(scherkus): should we require Stop() to be called? this might end up
+  // getting called on a random thread due to refcounting.
+  CloseDecoder();
+}
+
+void OpusAudioDecoder::DoInitialize(
+    const scoped_refptr<DemuxerStream>& stream,
+    const PipelineStatusCB& status_cb,
+    const StatisticsCB& statistics_cb) {
+  if (demuxer_stream_) {
+    // TODO(scherkus): initialization currently happens more than once in
+    // PipelineIntegrationTest.BasicPlayback.
+    LOG(ERROR) << "Initialize has already been called.";
+    CHECK(false);
+  }
+
+  demuxer_stream_ = stream;
+
+  if (!ConfigureDecoder()) {
+    status_cb.Run(DECODER_ERROR_NOT_SUPPORTED);
+    return;
+  }
+
+  statistics_cb_ = statistics_cb;
+  status_cb.Run(PIPELINE_OK);
+}
+
+void OpusAudioDecoder::DoReset(const base::Closure& closure) {
+  opus_multistream_decoder_ctl(opus_decoder_, OPUS_RESET_STATE);
+  ResetTimestampState();
+  queued_audio_.clear();
+  closure.Run();
+}
+
+void OpusAudioDecoder::DoRead(const ReadCB& read_cb) {
+  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(!read_cb.is_null());
+  CHECK(read_cb_.is_null()) << "Overlapping decodes are not supported.";
+
+  read_cb_ = read_cb;
+
+  // If we don't have any queued audio from the last packet we decoded, ask for
+  // more data from the demuxer to satisfy this read.
+  if (queued_audio_.empty()) {
+    ReadFromDemuxerStream();
+    return;
+  }
+
+  base::ResetAndReturn(&read_cb_).Run(
+      queued_audio_.front().status, queued_audio_.front().buffer);
+  queued_audio_.pop_front();
+}
+
+void OpusAudioDecoder::DoDecodeBuffer(
+    DemuxerStream::Status status,
+    const scoped_refptr<DecoderBuffer>& input) {
+  if (!message_loop_->BelongsToCurrentThread()) {
+    message_loop_->PostTask(FROM_HERE, base::Bind(
+        &OpusAudioDecoder::DoDecodeBuffer, this, status, input));
+    return;
+  }
+
+  DCHECK(!read_cb_.is_null());
+  DCHECK(queued_audio_.empty());
+  DCHECK_EQ(status != DemuxerStream::kOk, !input) << status;
+
+  if (status == DemuxerStream::kAborted) {
+    DCHECK(!input);
+    base::ResetAndReturn(&read_cb_).Run(kAborted, NULL);
+    return;
+  }
+
+  if (status == DemuxerStream::kConfigChanged) {
+    DCHECK(!input);
+
+    // Send a "end of stream" buffer to the decode loop
+    // to output any remaining data still in the decoder.
+    if (!Decode(DecoderBuffer::CreateEOSBuffer(), true)) {
+      base::ResetAndReturn(&read_cb_).Run(kDecodeError, NULL);
+      return;
+    }
+
+    DVLOG(1) << "Config changed.";
+
+    if (!ConfigureDecoder()) {
+      base::ResetAndReturn(&read_cb_).Run(kDecodeError, NULL);
+      return;
+    }
+
+    ResetTimestampState();
+
+    if (queued_audio_.empty()) {
+      ReadFromDemuxerStream();
+      return;
+    }
+
+    base::ResetAndReturn(&read_cb_).Run(
+        queued_audio_.front().status, queued_audio_.front().buffer);
+    queued_audio_.pop_front();
+    return;
+  }
+
+  DCHECK_EQ(status, DemuxerStream::kOk);
+  DCHECK(input);
+
+  // Make sure we are notified if http://crbug.com/49709 returns.  Issue also
+  // occurs with some damaged files.
+  if (!input->IsEndOfStream() && input->GetTimestamp() == kNoTimestamp() &&
+      output_timestamp_helper_->base_timestamp() == kNoTimestamp()) {
+    DVLOG(1) << "Received a buffer without timestamps!";
+    base::ResetAndReturn(&read_cb_).Run(kDecodeError, NULL);
+    return;
+  }
+
+  if (!input->IsEndOfStream()) {
+    if (last_input_timestamp_ == kNoTimestamp())
+      last_input_timestamp_ = input->GetTimestamp();
+    else if (input->GetTimestamp() != kNoTimestamp()) {
+      if (input->GetTimestamp() < last_input_timestamp_) {
+        base::TimeDelta diff = input->GetTimestamp() - last_input_timestamp_;
+        DVLOG(1) << "Input timestamps are not monotonically increasing! "
+                 << " ts " << input->GetTimestamp().InMicroseconds() << " us"
+                 << " diff " << diff.InMicroseconds() << " us";
+        base::ResetAndReturn(&read_cb_).Run(kDecodeError, NULL);
+        return;
+      }
+
+      last_input_timestamp_ = input->GetTimestamp();
+    }
+  }
+
+  if (!Decode(input, false)) {
+    base::ResetAndReturn(&read_cb_).Run(kDecodeError, NULL);
+    return;
+  }
+
+  // We exhausted the provided packet, but it wasn't enough for a frame.  Ask
+  // for more data in order to fulfill this read.
+  if (queued_audio_.empty()) {
+    ReadFromDemuxerStream();
+    return;
+  }
+
+  // Execute callback to return the first frame we decoded.
+  base::ResetAndReturn(&read_cb_).Run(
+      queued_audio_.front().status, queued_audio_.front().buffer);
+  queued_audio_.pop_front();
+}
+
+void OpusAudioDecoder::ReadFromDemuxerStream() {
+  DCHECK(!read_cb_.is_null());
+
+  demuxer_stream_->Read(base::Bind(&OpusAudioDecoder::DoDecodeBuffer, this));
+}
+
+bool OpusAudioDecoder::ConfigureDecoder() {
+  const AudioDecoderConfig& config = demuxer_stream_->audio_decoder_config();
+
+  if (config.codec() != kCodecOpus) {
+    DLOG(ERROR) << "ConfigureDecoder(): codec must be kCodecOpus.";
+    return false;
+  }
+
+  const int channel_count =
+      ChannelLayoutToChannelCount(config.channel_layout());
+  if (!config.IsValidConfig() || channel_count > kMaxVorbisChannels) {
+    DLOG(ERROR) << "ConfigureDecoder(): Invalid or unsupported audio stream -"
+                << " codec: " << config.codec()
+                << " channel count: " << channel_count
+                << " channel layout: " << config.channel_layout()
+                << " bits per channel: " << config.bits_per_channel()
+                << " samples per second: " << config.samples_per_second();
+    return false;
+  }
+
+  if (config.bits_per_channel() != kRequiredSampleSize) {
+    DLOG(ERROR) << "ConfigureDecoder(): 16 bit samples required.";
+    return false;
+  }
+
+  if (config.is_encrypted()) {
+    DLOG(ERROR) << "ConfigureDecoder(): Encrypted audio stream not supported.";
+    return false;
+  }
+
+  if (opus_decoder_ &&
+      (bits_per_channel_ != config.bits_per_channel() ||
+       channel_layout_ != config.channel_layout() ||
+       samples_per_second_ != config.samples_per_second())) {
+    DVLOG(1) << "Unsupported config change :";
+    DVLOG(1) << "\tbits_per_channel : " << bits_per_channel_
+             << " -> " << config.bits_per_channel();
+    DVLOG(1) << "\tchannel_layout : " << channel_layout_
+             << " -> " << config.channel_layout();
+    DVLOG(1) << "\tsample_rate : " << samples_per_second_
+             << " -> " << config.samples_per_second();
+    return false;
+  }
+
+  // Clean up existing decoder if necessary.
+  CloseDecoder();
+
+  // Allocate the output buffer if necessary.
+  if (!output_buffer_)
+    output_buffer_.reset(new uint8[kMaxOpusOutputPacketSizeBytes]);
+
+  // Parse the Opus header.
+  OpusHeader opus_header;
+  if (!ParseOpusHeader(config.extra_data(), config.extra_data_size(),
+                       config,
+                       &opus_header)) {
+    LOG(ERROR) << "ConfigureDecoder(): cannot parse opus header.";
+    return false;
+  }
+
+  skip_samples_ = opus_header.skip_samples;
+
+  if (skip_samples_ > 0)
+    output_bytes_to_drop_ = skip_samples_ * config.bytes_per_frame();
+
+  std::vector<uint8> channel_mapping(
+      &kDefaultOpusStreamMap[0],
+      &kDefaultOpusStreamMap[kMaxVorbisChannels - 1]);
+
+  if (channel_count > 2) {
+    // Remap channels from Vorbis order to FFmpeg order (which I what I think
+    // we want).
+    if (!RemapOpusChannelLayout(&opus_header.stream_map[0],
+                                channel_count,
+                                &channel_mapping[0])) {
+      LOG(ERROR) << "ConfigureDecoder(): unable to remap opus channels.";
+      return false;
+    }
+  }
+
+  // Init Opus.
+  int status = 0;
+  opus_decoder_ = opus_multistream_decoder_create(config.samples_per_second(),
+                                                  channel_count,
+                                                  opus_header.num_streams,
+                                                  opus_header.num_coupled,
+                                                  &channel_mapping[0],
+                                                  &status);
+  if (!opus_decoder_) {
+    LOG(ERROR) << "ConfigureDecoder(): opus_multistream_decoder_create failed"
+               << " status=" << opus_strerror(status);
+    return false;
+  }
+
+  // TODO(tomfinegan): The OPUS_GET_LOOKAHEAD ctl fails with a not implemented
+  // error code (-5). Not sure how to calculate delay....
+  // // Get audio delay from Opus.
+  // status = opus_multistream_decoder_ctl(opus_decoder_,
+  //                                       OPUS_GET_LOOKAHEAD(&delay_));
+  // if (status != OPUS_OK) {
+  //   LOG(ERROR) << "ConfigureDecoder(): cannot read audio delay from Opus.";
+  //   return false;
+  // }
+
+  bits_per_channel_ = config.bits_per_channel();
+  channel_layout_ = config.channel_layout();
+  samples_per_second_ = config.samples_per_second();
+  output_timestamp_helper_.reset(new AudioTimestampHelper(
+      config.bytes_per_frame(), config.samples_per_second()));
+  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();
+  output_bytes_to_drop_ = 0;
+}
+
+bool OpusAudioDecoder::Decode(const scoped_refptr<DecoderBuffer>& input,
+                              bool skip_eos_append) {
+  int16* output_buffer = reinterpret_cast<int16*>(&output_buffer_[0]);
+  int samples_decoded =
+      opus_multistream_decode(opus_decoder_,
+                              input->GetData(), input->GetDataSize(),
+                              output_buffer, kMaxOpusOutputPacketSizeSamples,
+                              0);
+  if (samples_decoded < 0) {
+    DCHECK(!input->IsEndOfStream())
+        << "Decode(): End of stream buffer produced an error!";
+
+    LOG(ERROR) << "ConfigureDecoder(): opus_multistream_decode failed for"
+               << " timestamp: " << input->GetTimestamp().InMicroseconds()
+               << " us, duration: " << input->GetDuration().InMicroseconds()
+               << " us, packet size: " << input->GetDataSize() << " bytes with"
+               << " status: " << opus_strerror(samples_decoded);
+    return false;
+  }
+
+  uint8* decoded_audio_data = &output_buffer_[0];
+  int decoded_audio_size = samples_decoded *
+      demuxer_stream_->audio_decoder_config().bytes_per_frame();
+  DCHECK_LE(decoded_audio_size, kMaxOpusOutputPacketSizeBytes);
+
+  if (output_timestamp_helper_->base_timestamp() == kNoTimestamp() &&
+      !input->IsEndOfStream()) {
+    DCHECK(input->GetTimestamp() != kNoTimestamp());
+    output_timestamp_helper_->SetBaseTimestamp(input->GetTimestamp());
+  }
+
+  scoped_refptr<DataBuffer> output;
+
+  if (decoded_audio_size > 0 && output_bytes_to_drop_ > 0) {
+    int dropped_size = std::min(decoded_audio_size, output_bytes_to_drop_);
+    decoded_audio_data += dropped_size;
+    decoded_audio_size -= dropped_size;
+    output_bytes_to_drop_ -= dropped_size;
+  }
+
+  if (decoded_audio_size > 0) {
+    // Copy the audio samples into an output buffer.
+    output = new DataBuffer(decoded_audio_data, decoded_audio_size);
+    output->SetTimestamp(output_timestamp_helper_->GetTimestamp());
+    output->SetDuration(
+        output_timestamp_helper_->GetDuration(decoded_audio_size));
+    output_timestamp_helper_->AddBytes(decoded_audio_size);
+  } else if (IsEndOfStream(decoded_audio_size, input) && !skip_eos_append) {
+    DCHECK_EQ(input->GetDataSize(), 0);
+    // Create an end of stream output buffer.
+    output = new DataBuffer(0);
+  }
+
+  if (output) {
+    QueuedAudioBuffer queue_entry = { kOk, output };
+    queued_audio_.push_back(queue_entry);
+  }
+
+  // Decoding finished successfully, update statistics.
+  PipelineStatistics statistics;
+  statistics.audio_bytes_decoded = decoded_audio_size;
+  statistics_cb_.Run(statistics);
+
+  return true;
+}
+
+}  // namespace media