Revert of Opus implementation of the AudioDecoderFactoryTemplate API (patchset #1 id:1 of https://codereview.webrtc.org/2942733003/ )

Reason for revert:
breaking downstream projects

Original issue's description:
> Opus implementation of the AudioDecoderFactoryTemplate API
>
> BUG=webrtc:7837
>
> Review-Url: https://codereview.webrtc.org/2942733003
> Cr-Commit-Position: refs/heads/master@{#18646}
> Committed: d053fe4ab3

TBR=ossu@webrtc.org,solenberg@webrtc.org,kwiberg@webrtc.org
# Skipping CQ checks because original CL landed less than 1 days ago.
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=webrtc:7837

Review-Url: https://codereview.webrtc.org/2944763002
Cr-Commit-Position: refs/heads/master@{#18648}

webrtc/api/audio_codecs/opus/BUILD.gn

@@ -41,16 +41,3 @@ rtc_static_library("audio_encoder_opus") {
     "../../../modules/audio_coding:webrtc_opus",
   ]
 }
-
-rtc_static_library("audio_decoder_opus") {
-  sources = [
-    "audio_decoder_opus.cc",
-    "audio_decoder_opus.h",
-  ]
-  deps = [
-    "..:audio_codecs_api",
-    "../../..:webrtc_common",
-    "../../../base:rtc_base_approved",
-    "../../../modules/audio_coding:webrtc_opus",
-  ]
-}

webrtc/api/audio_codecs/opus/audio_decoder_opus.cc

@@ -1,62 +0,0 @@
-/*
- *  Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS.  All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#include "webrtc/api/audio_codecs/opus/audio_decoder_opus.h"
-
-#include <memory>
-#include <utility>
-#include <vector>
-
-#include "webrtc/base/ptr_util.h"
-#include "webrtc/common_types.h"
-#include "webrtc/modules/audio_coding/codecs/opus/audio_decoder_opus.h"
-
-namespace webrtc {
-
-rtc::Optional<AudioDecoderOpus::Config> AudioDecoderOpus::SdpToConfig(
-    const SdpAudioFormat& format) {
-  const rtc::Optional<int> num_channels = [&] {
-    auto stereo = format.parameters.find("stereo");
-    if (stereo != format.parameters.end()) {
-      if (stereo->second == "0") {
-        return rtc::Optional<int>(1);
-      } else if (stereo->second == "1") {
-        return rtc::Optional<int>(2);
-      } else {
-        return rtc::Optional<int>();  // Bad stereo parameter.
-      }
-    }
-    return rtc::Optional<int>(1);  // Default to mono.
-  }();
-  if (STR_CASE_CMP(format.name.c_str(), "opus") == 0 &&
-      format.clockrate_hz == 48000 && format.num_channels == 2 &&
-      num_channels) {
-    return rtc::Optional<Config>(Config{*num_channels});
-  } else {
-    return rtc::Optional<Config>();
-  }
-}
-
-void AudioDecoderOpus::AppendSupportedDecoders(
-    std::vector<AudioCodecSpec>* specs) {
-  AudioCodecInfo opus_info{48000, 1, 64000, 6000, 510000};
-  opus_info.allow_comfort_noise = false;
-  opus_info.supports_network_adaption = true;
-  SdpAudioFormat opus_format(
-      {"opus", 48000, 2, {{"minptime", "10"}, {"useinbandfec", "1"}}});
-  specs->push_back({std::move(opus_format), std::move(opus_info)});
-}
-
-std::unique_ptr<AudioDecoder> AudioDecoderOpus::MakeAudioDecoder(
-    Config config) {
-  return rtc::MakeUnique<AudioDecoderOpusImpl>(config.num_channels);
-}
-
-}  // namespace webrtc

webrtc/api/audio_codecs/opus/audio_decoder_opus.h

@@ -1,38 +0,0 @@
-/*
- *  Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS.  All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#ifndef WEBRTC_API_AUDIO_CODECS_OPUS_AUDIO_DECODER_OPUS_H_
-#define WEBRTC_API_AUDIO_CODECS_OPUS_AUDIO_DECODER_OPUS_H_
-
-#include <memory>
-#include <vector>
-
-#include "webrtc/api/audio_codecs/audio_decoder.h"
-#include "webrtc/api/audio_codecs/audio_format.h"
-#include "webrtc/base/optional.h"
-
-namespace webrtc {
-
-// Opus decoder API for use as a template parameter to
-// CreateAudioDecoderFactory<...>().
-//
-// NOTE: This struct is still under development and may change without notice.
-struct AudioDecoderOpus {
-  struct Config {
-    int num_channels;
-  };
-  static rtc::Optional<Config> SdpToConfig(const SdpAudioFormat& audio_format);
-  static void AppendSupportedDecoders(std::vector<AudioCodecSpec>* specs);
-  static std::unique_ptr<AudioDecoder> MakeAudioDecoder(Config config);
-};
-
-}  // namespace webrtc
-
-#endif  // WEBRTC_API_AUDIO_CODECS_OPUS_AUDIO_DECODER_OPUS_H_

webrtc/api/audio_codecs/test/BUILD.gn

@@ -26,7 +26,6 @@ if (rtc_include_tests) {
       "../../../test:test_support",
       "../g722:audio_decoder_g722",
       "../g722:audio_encoder_g722",
-      "../opus:audio_decoder_opus",
       "../opus:audio_encoder_opus",
       "//testing/gmock",
     ]

webrtc/api/audio_codecs/test/audio_decoder_factory_template_unittest.cc

@@ -10,7 +10,6 @@
 
 #include "webrtc/api/audio_codecs/audio_decoder_factory_template.h"
 #include "webrtc/api/audio_codecs/g722/audio_decoder_g722.h"
-#include "webrtc/api/audio_codecs/opus/audio_decoder_opus.h"
 #include "webrtc/base/ptr_util.h"
 #include "webrtc/test/gmock.h"
 #include "webrtc/test/gtest.h"
@@ -125,21 +124,4 @@ TEST(AudioDecoderFactoryTemplateTest, G722) {
   EXPECT_EQ(16000, dec->SampleRateHz());
 }
 
-TEST(AudioDecoderFactoryTemplateTest, Opus) {
-  auto factory = CreateAudioDecoderFactory<AudioDecoderOpus>();
-  AudioCodecInfo opus_info{48000, 1, 64000, 6000, 510000};
-  opus_info.allow_comfort_noise = false;
-  opus_info.supports_network_adaption = true;
-  const SdpAudioFormat opus_format(
-      {"opus", 48000, 2, {{"minptime", "10"}, {"useinbandfec", "1"}}});
-  EXPECT_THAT(factory->GetSupportedDecoders(),
-              testing::ElementsAre(AudioCodecSpec{opus_format, opus_info}));
-  EXPECT_FALSE(factory->IsSupportedDecoder({"opus", 48000, 1}));
-  EXPECT_TRUE(factory->IsSupportedDecoder({"opus", 48000, 2}));
-  EXPECT_EQ(nullptr, factory->MakeAudioDecoder({"bar", 16000, 1}));
-  auto dec = factory->MakeAudioDecoder({"opus", 48000, 2});
-  ASSERT_NE(nullptr, dec);
-  EXPECT_EQ(48000, dec->SampleRateHz());
-}
-
 }  // namespace webrtc

webrtc/modules/audio_coding/codecs/builtin_audio_decoder_factory_internal.cc

@@ -162,7 +162,7 @@ NamedDecoderConstructor decoder_constructors[] = {
        if (format.clockrate_hz == 48000 && format.num_channels == 2 &&
            num_channels) {
          if (out) {
-           out->reset(new AudioDecoderOpusImpl(*num_channels));
+           out->reset(new AudioDecoderOpus(*num_channels));
          }
          return true;
        } else {

webrtc/modules/audio_coding/codecs/opus/audio_decoder_opus.cc

@@ -19,7 +19,7 @@ namespace webrtc {
 namespace {
 class OpusFrame : public AudioDecoder::EncodedAudioFrame {
  public:
-  OpusFrame(AudioDecoderOpusImpl* decoder,
+  OpusFrame(AudioDecoderOpus* decoder,
             rtc::Buffer&& payload,
             bool is_primary_payload)
       : decoder_(decoder),
@@ -57,25 +57,25 @@ class OpusFrame : public AudioDecoder::EncodedAudioFrame {
   }
 
  private:
-  AudioDecoderOpusImpl* const decoder_;
+  AudioDecoderOpus* const decoder_;
   const rtc::Buffer payload_;
   const bool is_primary_payload_;
 };
 
 }  // namespace
 
-AudioDecoderOpusImpl::AudioDecoderOpusImpl(size_t num_channels)
+AudioDecoderOpus::AudioDecoderOpus(size_t num_channels)
     : channels_(num_channels) {
   RTC_DCHECK(num_channels == 1 || num_channels == 2);
   WebRtcOpus_DecoderCreate(&dec_state_, channels_);
   WebRtcOpus_DecoderInit(dec_state_);
 }
 
-AudioDecoderOpusImpl::~AudioDecoderOpusImpl() {
+AudioDecoderOpus::~AudioDecoderOpus() {
   WebRtcOpus_DecoderFree(dec_state_);
 }
 
-std::vector<AudioDecoder::ParseResult> AudioDecoderOpusImpl::ParsePayload(
+std::vector<AudioDecoder::ParseResult> AudioDecoderOpus::ParsePayload(
     rtc::Buffer&& payload,
     uint32_t timestamp) {
   std::vector<ParseResult> results;
@@ -95,7 +95,7 @@ std::vector<AudioDecoder::ParseResult> AudioDecoderOpusImpl::ParsePayload(
   return results;
 }
 
-int AudioDecoderOpusImpl::DecodeInternal(const uint8_t* encoded,
+int AudioDecoderOpus::DecodeInternal(const uint8_t* encoded,
                                      size_t encoded_len,
                                      int sample_rate_hz,
                                      int16_t* decoded,
@@ -110,7 +110,7 @@ int AudioDecoderOpusImpl::DecodeInternal(const uint8_t* encoded,
   return ret;
 }
 
-int AudioDecoderOpusImpl::DecodeRedundantInternal(const uint8_t* encoded,
+int AudioDecoderOpus::DecodeRedundantInternal(const uint8_t* encoded,
                                               size_t encoded_len,
                                               int sample_rate_hz,
                                               int16_t* decoded,
@@ -131,16 +131,16 @@ int AudioDecoderOpusImpl::DecodeRedundantInternal(const uint8_t* encoded,
   return ret;
 }
 
-void AudioDecoderOpusImpl::Reset() {
+void AudioDecoderOpus::Reset() {
   WebRtcOpus_DecoderInit(dec_state_);
 }
 
-int AudioDecoderOpusImpl::PacketDuration(const uint8_t* encoded,
+int AudioDecoderOpus::PacketDuration(const uint8_t* encoded,
                                      size_t encoded_len) const {
   return WebRtcOpus_DurationEst(dec_state_, encoded, encoded_len);
 }
 
-int AudioDecoderOpusImpl::PacketDurationRedundant(const uint8_t* encoded,
+int AudioDecoderOpus::PacketDurationRedundant(const uint8_t* encoded,
                                               size_t encoded_len) const {
   if (!PacketHasFec(encoded, encoded_len)) {
     // This packet is a RED packet.
@@ -150,18 +150,18 @@ int AudioDecoderOpusImpl::PacketDurationRedundant(const uint8_t* encoded,
   return WebRtcOpus_FecDurationEst(encoded, encoded_len);
 }
 
-bool AudioDecoderOpusImpl::PacketHasFec(const uint8_t* encoded,
+bool AudioDecoderOpus::PacketHasFec(const uint8_t* encoded,
                                     size_t encoded_len) const {
   int fec;
   fec = WebRtcOpus_PacketHasFec(encoded, encoded_len);
   return (fec == 1);
 }
 
-int AudioDecoderOpusImpl::SampleRateHz() const {
+int AudioDecoderOpus::SampleRateHz() const {
   return 48000;
 }
 
-size_t AudioDecoderOpusImpl::Channels() const {
+size_t AudioDecoderOpus::Channels() const {
   return channels_;
 }
 

webrtc/modules/audio_coding/codecs/opus/audio_decoder_opus.h

@@ -17,10 +17,10 @@
 
 namespace webrtc {
 
-class AudioDecoderOpusImpl final : public AudioDecoder {
+class AudioDecoderOpus final : public AudioDecoder {
  public:
-  explicit AudioDecoderOpusImpl(size_t num_channels);
+  explicit AudioDecoderOpus(size_t num_channels);
-  ~AudioDecoderOpusImpl() override;
+  ~AudioDecoderOpus() override;
 
   std::vector<ParseResult> ParsePayload(rtc::Buffer&& payload,
                                         uint32_t timestamp) override;
@@ -47,7 +47,7 @@ class AudioDecoderOpusImpl final : public AudioDecoder {
  private:
   OpusDecInst* dec_state_;
   const size_t channels_;
-  RTC_DISALLOW_COPY_AND_ASSIGN(AudioDecoderOpusImpl);
+  RTC_DISALLOW_COPY_AND_ASSIGN(AudioDecoderOpus);
 };
 
 }  // namespace webrtc

webrtc/modules/audio_coding/neteq/audio_decoder_unittest.cc

@@ -433,7 +433,7 @@ class AudioDecoderOpusTest : public AudioDecoderTest {
     codec_input_rate_hz_ = 48000;
     frame_size_ = 480;
     data_length_ = 10 * frame_size_;
-    decoder_ = new AudioDecoderOpusImpl(1);
+    decoder_ = new AudioDecoderOpus(1);
     AudioEncoderOpusConfig config;
     config.frame_size_ms = static_cast<int>(frame_size_) / 48;
     config.application = AudioEncoderOpusConfig::ApplicationMode::kVoip;
@@ -446,7 +446,7 @@ class AudioDecoderOpusStereoTest : public AudioDecoderOpusTest {
   AudioDecoderOpusStereoTest() : AudioDecoderOpusTest() {
     channels_ = 2;
     delete decoder_;
-    decoder_ = new AudioDecoderOpusImpl(2);
+    decoder_ = new AudioDecoderOpus(2);
     AudioEncoderOpusConfig config;
     config.frame_size_ms = static_cast<int>(frame_size_) / 48;
     config.num_channels = 2;

webrtc/test/fuzzers/audio_decoder_opus_fuzzer.cc

@@ -14,7 +14,7 @@
 namespace webrtc {
 void FuzzOneInput(const uint8_t* data, size_t size) {
   const size_t channels = (size % 2) + 1;  // 1 or 2 channels.
-  AudioDecoderOpusImpl dec(channels);
+  AudioDecoderOpus dec(channels);
   const int kSampleRateHz = 48000;
   const size_t kAllocatedOuputSizeSamples = kSampleRateHz / 10;  // 100 ms.
   int16_t output[kAllocatedOuputSizeSamples];

webrtc/test/fuzzers/audio_decoder_opus_redundant_fuzzer.cc

@@ -14,7 +14,7 @@
 namespace webrtc {
 void FuzzOneInput(const uint8_t* data, size_t size) {
   const size_t channels = (size % 2) + 1;  // 1 or 2 channels.
-  AudioDecoderOpusImpl dec(channels);
+  AudioDecoderOpus dec(channels);
   const int kSampleRateHz = 48000;
   const size_t kAllocatedOuputSizeSamples = kSampleRateHz / 10;  // 100 ms.
   int16_t output[kAllocatedOuputSizeSamples];