zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
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}
This commit is contained in:
charujain
2017-06-18 02:37:17 -07:00
committed by Commit Bot
parent af6293517f
commit eb2d2d31d1
11 changed files with 33 additions and 165 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
webrtc/api/audio_codecs/opus/BUILD.gn
View File

@ -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",
]
}

62
webrtc/api/audio_codecs/opus/audio_decoder_opus.cc
View File

@ -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

38
webrtc/api/audio_codecs/opus/audio_decoder_opus.h
View File

@ -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_

1
webrtc/api/audio_codecs/test/BUILD.gn
View File

@ -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",
]

18
webrtc/api/audio_codecs/test/audio_decoder_factory_template_unittest.cc
View File

@ -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

2
webrtc/modules/audio_coding/codecs/builtin_audio_decoder_factory_internal.cc
View File

@ -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 {

26
webrtc/modules/audio_coding/codecs/opus/audio_decoder_opus.cc
View File

@ -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_;
}

8
webrtc/modules/audio_coding/codecs/opus/audio_decoder_opus.h
View File

@ -17,10 +17,10 @@
namespace webrtc {
class AudioDecoderOpusImpl final : public AudioDecoder {
class AudioDecoderOpus final : public AudioDecoder {
public:
explicit AudioDecoderOpusImpl(size_t num_channels);
~AudioDecoderOpusImpl() override;
explicit AudioDecoderOpus(size_t num_channels);
~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

4
webrtc/modules/audio_coding/neteq/audio_decoder_unittest.cc
View File

@ -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;

2
webrtc/test/fuzzers/audio_decoder_opus_fuzzer.cc
View File

@ -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];

2
webrtc/test/fuzzers/audio_decoder_opus_redundant_fuzzer.cc
View File

@ -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];