To M56: Use ffmpeg for opus decoding, no need to maintain our decoder.

media/filters/opus_audio_decoder.cc

Index: media/filters/opus_audio_decoder.cc
diff --git a/media/filters/opus_audio_decoder.cc b/media/filters/opus_audio_decoder.cc
deleted file mode 100644
index 5532cfa62806bec124dda547d66222366ffc70e9..0000000000000000000000000000000000000000
--- a/media/filters/opus_audio_decoder.cc
+++ /dev/null
@@ -1,368 +0,0 @@
-// Copyright 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 <stddef.h>
-#include <stdint.h>
-
-#include <cmath>
-
-#include "base/single_thread_task_runner.h"
-#include "base/sys_byteorder.h"
-#include "media/base/audio_buffer.h"
-#include "media/base/audio_decoder_config.h"
-#include "media/base/audio_discard_helper.h"
-#include "media/base/bind_to_current_loop.h"
-#include "media/base/decoder_buffer.h"
-#include "media/base/timestamp_constants.h"
-#include "media/filters/opus_constants.h"
-#include "third_party/opus/src/include/opus.h"
-#include "third_party/opus/src/include/opus_multistream.h"
-
-namespace media {
-
-static uint16_t ReadLE16(const uint8_t* data,
-                         size_t data_size,
-                         int read_offset) {
-  uint16_t value = 0;
-  DCHECK_LE(read_offset + sizeof(value), data_size);
-  memcpy(&value, data + read_offset, sizeof(value));
-  return base::ByteSwapToLE16(value);
-}
-
-// The Opus specification is part of IETF RFC 6716:
-// http://tools.ietf.org/html/rfc6716
-
-// Maximum packet size used in Xiph's opusdec and FFmpeg's libopusdec.
-static const int kMaxOpusOutputPacketSizeSamples = 960 * 6;
-
-static void RemapOpusChannelLayout(const uint8_t* opus_mapping,
-                                   int num_channels,
-                                   uint8_t* channel_layout) {
-  DCHECK_LE(num_channels, OPUS_MAX_VORBIS_CHANNELS);
-
-  // Reorder the channels to produce the same ordering as FFmpeg, which is
-  // what the pipeline expects.
-  const uint8_t* vorbis_layout_offset =
-      kFFmpegChannelDecodingLayouts[num_channels - 1];
-  for (int channel = 0; channel < num_channels; ++channel)
-    channel_layout[channel] = opus_mapping[vorbis_layout_offset[channel]];
-}
-
-struct OpusExtraData {
-  OpusExtraData()
-      : channels(0),
-        skip_samples(0),
-        channel_mapping(0),
-        num_streams(0),
-        num_coupled(0),
-        gain_db(0),
-        stream_map() {
-    memcpy(stream_map, kDefaultOpusChannelLayout,
-           OPUS_MAX_CHANNELS_WITH_DEFAULT_LAYOUT);
-  }
-  int channels;
-  uint16_t skip_samples;
-  int channel_mapping;
-  int num_streams;
-  int num_coupled;
-  int16_t gain_db;
-  uint8_t stream_map[OPUS_MAX_VORBIS_CHANNELS];
-};
-
-// Returns true when able to successfully parse and store Opus extra data in
-// |extra_data|. Based on opus header parsing code in libopusdec from FFmpeg,
-// and opus_header from Xiph's opus-tools project.
-static bool ParseOpusExtraData(const uint8_t* data,
-                               int data_size,
-                               const AudioDecoderConfig& config,
-                               OpusExtraData* extra_data) {
-  if (data_size < OPUS_EXTRADATA_SIZE) {
-    DLOG(ERROR) << "Extra data size is too small:" << data_size;
-    return false;
-  }
-
-  extra_data->channels = *(data + OPUS_EXTRADATA_CHANNELS_OFFSET);
-
-  if (extra_data->channels <= 0 ||
-      extra_data->channels > OPUS_MAX_VORBIS_CHANNELS) {
-    DLOG(ERROR) << "invalid channel count in extra data: "
-                << extra_data->channels;
-    return false;
-  }
-
-  extra_data->skip_samples =
-      ReadLE16(data, data_size, OPUS_EXTRADATA_SKIP_SAMPLES_OFFSET);
-  extra_data->gain_db = static_cast<int16_t>(
-      ReadLE16(data, data_size, OPUS_EXTRADATA_GAIN_OFFSET));
-
-  extra_data->channel_mapping = *(data + OPUS_EXTRADATA_CHANNEL_MAPPING_OFFSET);
-
-  if (!extra_data->channel_mapping) {
-    if (extra_data->channels > OPUS_MAX_CHANNELS_WITH_DEFAULT_LAYOUT) {
-      DLOG(ERROR) << "Invalid extra data, missing stream map.";
-      return false;
-    }
-
-    extra_data->num_streams = 1;
-    extra_data->num_coupled =
-        (ChannelLayoutToChannelCount(config.channel_layout()) > 1) ? 1 : 0;
-    return true;
-  }
-
-  if (data_size < OPUS_EXTRADATA_STREAM_MAP_OFFSET + extra_data->channels) {
-    DLOG(ERROR) << "Invalid stream map; insufficient data for current channel "
-                << "count: " << extra_data->channels;
-    return false;
-  }
-
-  extra_data->num_streams = *(data + OPUS_EXTRADATA_NUM_STREAMS_OFFSET);
-  extra_data->num_coupled = *(data + OPUS_EXTRADATA_NUM_COUPLED_OFFSET);
-
-  if (extra_data->num_streams + extra_data->num_coupled != extra_data->channels)
-    DVLOG(1) << "Inconsistent channel mapping.";
-
-  for (int i = 0; i < extra_data->channels; ++i)
-    extra_data->stream_map[i] = *(data + OPUS_EXTRADATA_STREAM_MAP_OFFSET + i);
-  return true;
-}
-
-OpusAudioDecoder::OpusAudioDecoder(
-    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
-    : task_runner_(task_runner), opus_decoder_(nullptr) {}
-
-std::string OpusAudioDecoder::GetDisplayName() const {
-  return "OpusAudioDecoder";
-}
-
-void OpusAudioDecoder::Initialize(const AudioDecoderConfig& config,
-                                  CdmContext* /* cdm_context */,
-                                  const InitCB& init_cb,
-                                  const OutputCB& output_cb) {
-  DCHECK(task_runner_->BelongsToCurrentThread());
-  InitCB bound_init_cb = BindToCurrentLoop(init_cb);
-
-  if (config.is_encrypted()) {
-    bound_init_cb.Run(false);
-    return;
-  }
-
-  config_ = config;
-  output_cb_ = BindToCurrentLoop(output_cb);
-
-  if (!ConfigureDecoder()) {
-    bound_init_cb.Run(false);
-    return;
-  }
-
-  bound_init_cb.Run(true);
-}
-
-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));
-}
-
-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);
-}
-
-OpusAudioDecoder::~OpusAudioDecoder() {
-  DCHECK(task_runner_->BelongsToCurrentThread());
-
-  if (!opus_decoder_)
-    return;
-
-  opus_multistream_decoder_ctl(opus_decoder_, OPUS_RESET_STATE);
-  CloseDecoder();
-}
-
-void OpusAudioDecoder::DecodeBuffer(
-    const scoped_refptr<DecoderBuffer>& input,
-    const DecodeCB& decode_cb) {
-  DCHECK(task_runner_->BelongsToCurrentThread());
-  DCHECK(!decode_cb.is_null());
-  DCHECK(input.get());
-
-  // Libopus does not buffer output. Decoding is complete when an end of stream
-  // input buffer is received.
-  if (input->end_of_stream()) {
-    decode_cb.Run(DecodeStatus::OK);
-    return;
-  }
-
-  // Make sure we are notified if http://crbug.com/49709 returns.  Issue also
-  // occurs with some damaged files.
-  if (input->timestamp() == kNoTimestamp) {
-    DLOG(ERROR) << "Received a buffer without timestamps!";
-    decode_cb.Run(DecodeStatus::DECODE_ERROR);
-    return;
-  }
-
-  scoped_refptr<AudioBuffer> output_buffer;
-
-  if (!Decode(input, &output_buffer)) {
-    decode_cb.Run(DecodeStatus::DECODE_ERROR);
-    return;
-  }
-
-  if (output_buffer.get()) {
-    output_cb_.Run(output_buffer);
-  }
-
-  decode_cb.Run(DecodeStatus::OK);
-}
-
-bool OpusAudioDecoder::ConfigureDecoder() {
-  if (config_.codec() != kCodecOpus) {
-    DVLOG(1) << "Codec must be kCodecOpus.";
-    return false;
-  }
-
-  const int channel_count =
-      ChannelLayoutToChannelCount(config_.channel_layout());
-  if (!config_.IsValidConfig() || channel_count > OPUS_MAX_VORBIS_CHANNELS) {
-    DLOG(ERROR) << "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_.is_encrypted()) {
-    DLOG(ERROR) << "Encrypted audio stream not supported.";
-    return false;
-  }
-
-  // Clean up existing decoder if necessary.
-  CloseDecoder();
-
-  // Parse the Opus Extra Data.
-  OpusExtraData opus_extra_data;
-  if (!ParseOpusExtraData(config_.extra_data().empty() ? nullptr :
-                              &config_.extra_data()[0],
-                          config_.extra_data().size(),
-                          config_,
-                          &opus_extra_data))
-    return false;
-
-  if (config_.codec_delay() < 0) {
-    DLOG(ERROR) << "Invalid file. Incorrect value for codec delay: "
-                << config_.codec_delay();
-    return false;
-  }
-
-  if (config_.codec_delay() != opus_extra_data.skip_samples) {
-    DLOG(WARNING) << "Invalid file. Codec Delay in container does not match "
-                  << "the value in Opus Extra Data. " << config_.codec_delay()
-                  << " vs " << opus_extra_data.skip_samples;
-    config_.Initialize(config_.codec(), config_.sample_format(),
-                       config_.channel_layout(), config_.samples_per_second(),
-                       config_.extra_data(), config_.encryption_scheme(),
-                       config_.seek_preroll(), opus_extra_data.skip_samples);
-  }
-
-  uint8_t channel_mapping[OPUS_MAX_VORBIS_CHANNELS] = {0};
-  memcpy(&channel_mapping, kDefaultOpusChannelLayout,
-         OPUS_MAX_CHANNELS_WITH_DEFAULT_LAYOUT);
-
-  if (channel_count > OPUS_MAX_CHANNELS_WITH_DEFAULT_LAYOUT) {
-    RemapOpusChannelLayout(opus_extra_data.stream_map,
-                           channel_count,
-                           channel_mapping);
-  }
-
-  // Init Opus.
-  int status = OPUS_INVALID_STATE;
-  opus_decoder_ = opus_multistream_decoder_create(config_.samples_per_second(),
-                                                  channel_count,
-                                                  opus_extra_data.num_streams,
-                                                  opus_extra_data.num_coupled,
-                                                  channel_mapping,
-                                                  &status);
-  if (!opus_decoder_ || status != OPUS_OK) {
-    DLOG(ERROR) << "opus_multistream_decoder_create failed status="
-                << opus_strerror(status);
-    return false;
-  }
-
-  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;
-  }
-
-  ResetTimestampState();
-  return true;
-}
-
-void OpusAudioDecoder::CloseDecoder() {
-  if (opus_decoder_) {
-    opus_multistream_decoder_destroy(opus_decoder_);
-    opus_decoder_ = nullptr;
-  }
-}
-
-void OpusAudioDecoder::ResetTimestampState() {
-  discard_helper_.reset(
-      new AudioDiscardHelper(config_.samples_per_second(), 0));
-  discard_helper_->Reset(config_.codec_delay());
-}
-
-bool OpusAudioDecoder::Decode(const scoped_refptr<DecoderBuffer>& input,
-                              scoped_refptr<AudioBuffer>* output_buffer) {
-  // Allocate a buffer for the output samples.
-  *output_buffer = AudioBuffer::CreateBuffer(
-      kSampleFormatF32, config_.channel_layout(),
-      ChannelLayoutToChannelCount(config_.channel_layout()),
-      config_.samples_per_second(), kMaxOpusOutputPacketSizeSamples);
-  const int buffer_size = output_buffer->get()->channel_count() *
-                          output_buffer->get()->frame_count() *
-                          SampleFormatToBytesPerChannel(kSampleFormatF32);
-
-  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);
-
-  if (frames_decoded < 0) {
-    DLOG(ERROR) << "opus_multistream_decode failed for"
-                << " timestamp: " << input->timestamp().InMicroseconds()
-                << " us, duration: " << input->duration().InMicroseconds()
-                << " us, packet size: " << input->data_size() << " bytes with"
-                << " status: " << opus_strerror(frames_decoded);
-    return false;
-  }
-
-  // Trim off any extraneous allocation.
-  DCHECK_LE(frames_decoded, output_buffer->get()->frame_count());
-  const int trim_frames = output_buffer->get()->frame_count() - frames_decoded;
-  if (trim_frames > 0)
-    output_buffer->get()->TrimEnd(trim_frames);
-
-  // Handles discards and timestamping.  Discard the buffer if more data needed.
-  if (!discard_helper_->ProcessBuffers(input, *output_buffer))
-    *output_buffer = nullptr;
-
-  return true;
-}
-
-}  // namespace media