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

media/filters/audio_decoder_unittest.cc

 // Copyright 2014 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 <stddef.h>
 #include <stdint.h>
 
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 11 matching lines @@
 #include "media/base/audio_hash.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/media_util.h"
 #include "media/base/test_data_util.h"
 #include "media/base/test_helpers.h"
 #include "media/base/timestamp_constants.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 #include "media/filters/audio_file_reader.h"
 #include "media/filters/ffmpeg_audio_decoder.h"
 #include "media/filters/in_memory_url_protocol.h"
-#include "media/filters/opus_audio_decoder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/build_info.h"
 #include "media/base/android/media_codec_util.h"
 #include "media/filters/android/media_codec_audio_decoder.h"
 
 #if defined(USE_PROPRIETARY_CODECS)
 #include "media/formats/mpeg/adts_stream_parser.h"
 #endif
@@ skipping 16 matching lines @@
 #else
 #define SKIP_TEST_IF_NO_MEDIA_CODEC() \
   do {                                \
   } while (0)
 #endif  // !defined(OS_ANDROID)
 
 namespace media {
 
 // The number of packets to read and then decode from each file.
 static const size_t kDecodeRuns = 3;
-static const uint8_t kOpusExtraData[] = {
-    0x4f, 0x70, 0x75, 0x73, 0x48, 0x65, 0x61, 0x64, 0x01, 0x02,
-    // The next two bytes represent the codec delay.
-    0x00, 0x00, 0x80, 0xbb, 0x00, 0x00, 0x00, 0x00, 0x00};
 
 enum AudioDecoderType {
   FFMPEG,
-  OPUS,
 #if defined(OS_ANDROID)
   MEDIA_CODEC,
 #endif
 };
 
 struct DecodedBufferExpectations {
   const int64_t timestamp;
   const int64_t duration;
   const char* hash;
 };
@@ skipping 48 matching lines @@
  public:
   AudioDecoderTest()
       : pending_decode_(false),
         pending_reset_(false),
         last_decode_status_(DecodeStatus::DECODE_ERROR) {
     switch (GetParam().decoder_type) {
       case FFMPEG:
         decoder_.reset(new FFmpegAudioDecoder(message_loop_.task_runner(),
                                               new MediaLog()));
         break;
-      case OPUS:
-        decoder_.reset(
-            new OpusAudioDecoder(message_loop_.task_runner()));
-        break;
 #if defined(OS_ANDROID)
       case MEDIA_CODEC:
         decoder_.reset(new MediaCodecAudioDecoder(message_loop_.task_runner()));
         break;
 #endif
     }
   }
 
   virtual ~AudioDecoderTest() {
     EXPECT_FALSE(pending_decode_);
     EXPECT_FALSE(pending_reset_);
   }
 
  protected:
   void DecodeBuffer(const scoped_refptr<DecoderBuffer>& buffer) {
     ASSERT_FALSE(pending_decode_);
     pending_decode_ = true;
     last_decode_status_ = DecodeStatus::DECODE_ERROR;
 
     base::RunLoop run_loop;
     decoder_->Decode(
         buffer, base::Bind(&AudioDecoderTest::DecodeFinished,
                            base::Unretained(this), run_loop.QuitClosure()));
     run_loop.Run();
     ASSERT_FALSE(pending_decode_);
   }
 
-  void SendEndOfStream() {
-    DecodeBuffer(DecoderBuffer::CreateEOSBuffer());
-  }
+  void SendEndOfStream() { DecodeBuffer(DecoderBuffer::CreateEOSBuffer()); }
 
   void Initialize() {
     // Load the test data file.
     data_ = ReadTestDataFile(GetParam().filename);
     protocol_.reset(
         new InMemoryUrlProtocol(data_->data(), data_->data_size(), false));
     reader_.reset(new AudioFileReader(protocol_.get()));
     ASSERT_TRUE(reader_->OpenDemuxerForTesting());
 
     // Load the first packet and check its timestamp.
@@ skipping 61 matching lines @@
         DecoderBuffer::CopyFrom(packet.data, packet.size);
     buffer->set_timestamp(ConvertFromTimeBase(
         reader_->GetAVStreamForTesting()->time_base, packet.pts));
     buffer->set_duration(ConvertFromTimeBase(
         reader_->GetAVStreamForTesting()->time_base, packet.duration));
     if (packet.flags & AV_PKT_FLAG_KEY)
       buffer->set_is_key_frame(true);
 
     // Don't set discard padding for Opus, it already has discard behavior set
     // based on the codec delay in the AudioDecoderConfig.
-    if (GetParam().decoder_type == FFMPEG)
+    if (GetParam().decoder_type == FFMPEG && GetParam().codec != kCodecOpus)
       SetDiscardPadding(&packet, buffer, GetParam().samples_per_second);
 
     // DecodeBuffer() shouldn't need the original packet since it uses the copy.
     av_packet_unref(&packet);
     DecodeBuffer(buffer);
   }
 
   void Reset() {
     ASSERT_FALSE(pending_reset_);
     pending_reset_ = true;
@@ skipping 114 matching lines @@
   bool pending_decode_;
   bool pending_reset_;
   DecodeStatus last_decode_status_;
 
   std::deque<scoped_refptr<AudioBuffer> > decoded_audio_;
   base::TimeDelta start_timestamp_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioDecoderTest);
 };
 
-class OpusAudioDecoderBehavioralTest : public AudioDecoderTest {};
 class FFmpegAudioDecoderBehavioralTest : public AudioDecoderTest {};
 
 TEST_P(AudioDecoderTest, Initialize) {
   SKIP_TEST_IF_NO_MEDIA_CODEC();
   ASSERT_NO_FATAL_FAILURE(Initialize());
 }
 
 // Verifies decode audio as well as the Decode() -> Reset() sequence.
 TEST_P(AudioDecoderTest, ProduceAudioSamples) {
   SKIP_TEST_IF_NO_MEDIA_CODEC();
@@ skipping 51 matching lines @@
 
 TEST_P(AudioDecoderTest, NoTimestamp) {
   SKIP_TEST_IF_NO_MEDIA_CODEC();
   ASSERT_NO_FATAL_FAILURE(Initialize());
   scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(0));
   buffer->set_timestamp(kNoTimestamp);
   DecodeBuffer(buffer);
   EXPECT_EQ(DecodeStatus::DECODE_ERROR, last_decode_status());
 }
 
-TEST_P(OpusAudioDecoderBehavioralTest, InitializeWithNoCodecDelay) {
-  ASSERT_EQ(GetParam().decoder_type, OPUS);
-  std::vector<uint8_t> extra_data(
-      kOpusExtraData,
-      kOpusExtraData + arraysize(kOpusExtraData));
-  AudioDecoderConfig decoder_config;
-  decoder_config.Initialize(kCodecOpus, kSampleFormatF32, CHANNEL_LAYOUT_STEREO,
-                            48000, extra_data, Unencrypted(),
-                            base::TimeDelta::FromMilliseconds(80), 0);
-  InitializeDecoder(decoder_config);
-}
-
-TEST_P(OpusAudioDecoderBehavioralTest, InitializeWithBadCodecDelay) {
-  ASSERT_EQ(GetParam().decoder_type, OPUS);
-  std::vector<uint8_t> extra_data(
-      kOpusExtraData,
-      kOpusExtraData + arraysize(kOpusExtraData));
-  AudioDecoderConfig decoder_config;
-  decoder_config.Initialize(
-      kCodecOpus, kSampleFormatF32, CHANNEL_LAYOUT_STEREO, 48000, extra_data,
-      Unencrypted(), base::TimeDelta::FromMilliseconds(80),
-      // Use a different codec delay than in the extradata.
-      100);
-  InitializeDecoderWithResult(decoder_config, true);
-}
-
-#if defined(OPUS_FIXED_POINT)
-const DecodedBufferExpectations kSfxOpusExpectations[] = {
-    {0, 13500, "-2.70,-1.41,-0.78,-1.27,-2.56,-3.73,"},
-    {13500, 20000, "5.48,5.93,6.05,5.83,5.54,5.46,"},
-    {33500, 20000, "-3.44,-3.34,-3.57,-4.11,-4.74,-5.13,"},
-};
-#else
-const DecodedBufferExpectations kSfxOpusExpectations[] = {
-    {0, 13500, "-2.70,-1.41,-0.78,-1.27,-2.56,-3.73,"},
-    {13500, 20000, "5.48,5.93,6.04,5.83,5.54,5.45,"},
-    {33500, 20000, "-3.45,-3.35,-3.57,-4.12,-4.74,-5.14,"},
-};
-#endif
-
 const DecodedBufferExpectations kBearOpusExpectations[] = {
     {500, 3500, "-0.26,0.87,1.36,0.84,-0.30,-1.22,"},
     {4000, 10000, "0.09,0.23,0.21,0.03,-0.17,-0.24,"},
     {14000, 10000, "0.10,0.24,0.23,0.04,-0.14,-0.23,"},
 };
 
-const DecoderTestData kOpusTests[] = {
-    {OPUS, kCodecOpus, "sfx-opus.ogg", kSfxOpusExpectations, -312, 48000,
-     CHANNEL_LAYOUT_MONO},
-    {OPUS, kCodecOpus, "bear-opus.ogg", kBearOpusExpectations, 24, 48000,
-     CHANNEL_LAYOUT_STEREO},
-};
-
-// Dummy data for behavioral tests.
-const DecoderTestData kOpusBehavioralTest[] = {
-    {OPUS, kUnknownAudioCodec, "", NULL, 0, 0, CHANNEL_LAYOUT_NONE},
-};
-
-INSTANTIATE_TEST_CASE_P(OpusAudioDecoderTest,
-                        AudioDecoderTest,
-                        testing::ValuesIn(kOpusTests));
-INSTANTIATE_TEST_CASE_P(OpusAudioDecoderBehavioralTest,
-                        OpusAudioDecoderBehavioralTest,
-                        testing::ValuesIn(kOpusBehavioralTest));
-
 #if defined(OS_ANDROID)
 #if defined(USE_PROPRIETARY_CODECS)
 const DecodedBufferExpectations kSfxAdtsMcExpectations[] = {
     {0, 23219, "-1.80,-1.49,-0.23,1.11,1.54,-0.11,"},
     {23219, 23219, "-1.90,-1.53,-0.15,1.28,1.23,-0.33,"},
     {46439, 23219, "0.54,0.88,2.19,3.54,3.24,1.63,"},
 };
 
 const DecodedBufferExpectations kHeAacMcExpectations[] = {
     {0, 42666, "-1.76,-0.12,1.72,1.45,0.10,-1.32,"},
@@ skipping 57 matching lines @@
     {13061, 23219, "-2.79,-2.42,-1.06,0.33,0.93,-0.64,"},
     {36281, 23219, "-1.19,-0.80,0.57,1.97,2.08,0.51,"},
 };
 
 const DecodedBufferExpectations kBearOgvExpectations[] = {
     {0, 13061, "-1.25,0.10,2.11,2.29,1.50,-0.68,"},
     {13061, 23219, "-1.80,-1.41,-0.13,1.30,1.65,0.01,"},
     {36281, 23219, "-1.43,-1.25,0.11,1.29,1.86,0.14,"},
 };
 
+#if defined(OPUS_FIXED_POINT)
+const DecodedBufferExpectations kSfxOpusExpectations[] = {
+    {0, 13500, "-2.70,-1.41,-0.78,-1.27,-2.56,-3.73,"},
+    {13500, 20000, "5.48,5.93,6.05,5.83,5.54,5.46,"},
+    {33500, 20000, "-3.44,-3.34,-3.57,-4.11,-4.74,-5.13,"},
+};
+#else
+const DecodedBufferExpectations kSfxOpusExpectations[] = {
+    {0, 13500, "-2.70,-1.41,-0.78,-1.27,-2.56,-3.73,"},
+    {13500, 20000, "5.48,5.93,6.04,5.83,5.54,5.45,"},
+    {33500, 20000, "-3.45,-3.35,-3.57,-4.12,-4.74,-5.14,"},
+};
+#endif
+
 const DecoderTestData kFFmpegTests[] = {
 #if defined(USE_PROPRIETARY_CODECS)
     {FFMPEG, kCodecMP3, "sfx.mp3", kSfxMp3Expectations, 0, 44100,
      CHANNEL_LAYOUT_MONO},
     {FFMPEG, kCodecAAC, "sfx.adts", kSfxAdtsExpectations, 0, 44100,
      CHANNEL_LAYOUT_MONO},
 #endif
 #if defined(OS_CHROMEOS)
     {FFMPEG, kCodecFLAC, "sfx.flac", kSfxFlacExpectations, 0, 44100,
      CHANNEL_LAYOUT_MONO},
 #endif
     {FFMPEG, kCodecPCM, "sfx_f32le.wav", kSfxWaveExpectations, 0, 44100,
      CHANNEL_LAYOUT_MONO},
     {FFMPEG, kCodecPCM, "4ch.wav", kFourChannelWaveExpectations, 0, 44100,
      CHANNEL_LAYOUT_QUAD},
     {FFMPEG, kCodecVorbis, "sfx.ogg", kSfxOggExpectations, 0, 44100,
      CHANNEL_LAYOUT_MONO},
     // Note: bear.ogv is incorrectly muxed such that valid samples are given
     // negative timestamps, this marks them for discard per the ogg vorbis spec.
     {FFMPEG, kCodecVorbis, "bear.ogv", kBearOgvExpectations, -704, 44100,
      CHANNEL_LAYOUT_STEREO},
+    {FFMPEG, kCodecOpus, "sfx-opus.ogg", kSfxOpusExpectations, -312, 48000,
+     CHANNEL_LAYOUT_MONO},
+    {FFMPEG, kCodecOpus, "bear-opus.ogg", kBearOpusExpectations, 24, 48000,
+     CHANNEL_LAYOUT_STEREO},
 };
 
 // Dummy data for behavioral tests.
 const DecoderTestData kFFmpegBehavioralTest[] = {
     {FFMPEG, kUnknownAudioCodec, "", NULL, 0, 0, CHANNEL_LAYOUT_NONE},
 };
 
 INSTANTIATE_TEST_CASE_P(FFmpegAudioDecoderTest,
                         AudioDecoderTest,
                         testing::ValuesIn(kFFmpegTests));
 INSTANTIATE_TEST_CASE_P(FFmpegAudioDecoderBehavioralTest,
                         FFmpegAudioDecoderBehavioralTest,
                         testing::ValuesIn(kFFmpegBehavioralTest));
 
 }  // namespace media