admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove dead code

Browse Source 
This code became dead when the builtin audio codec factories were
rewritten in https://codereview.webrtc.org/2997713002/.

BUG=webrtc:7821, webrtc:7822

Review-Url: https://codereview.webrtc.org/3003603002
Cr-Commit-Position: refs/heads/master@{#19535}
This commit is contained in:
kwiberg 2017-08-25 22:22:42 -07:00 committed by Commit Bot
parent 68214cbd3f
commit d1d79f6866
14 changed files with 42 additions and 260 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -26,6 +26,7 @@ rtc_static_library("audio_encoder_g722") {
deps = [
":audio_encoder_g722_config",
"..:audio_codecs_api",
"../../..:webrtc_common",
"../../../modules/audio_coding:g722",
"../../../rtc_base:rtc_base_approved",
]

21
webrtc/api/audio_codecs/g722/audio_encoder_g722.cc
View File

@ -13,15 +13,34 @@
#include <memory>
#include <vector>
#include "webrtc/common_types.h"
#include "webrtc/modules/audio_coding/codecs/g722/audio_encoder_g722.h"
#include "webrtc/rtc_base/ptr_util.h"
#include "webrtc/rtc_base/safe_conversions.h"
#include "webrtc/rtc_base/safe_minmax.h"
#include "webrtc/rtc_base/string_to_number.h"
namespace webrtc {
rtc::Optional<AudioEncoderG722Config> AudioEncoderG722::SdpToConfig(
const SdpAudioFormat& format) {
return AudioEncoderG722Impl::SdpToConfig(format);
if (STR_CASE_CMP(format.name.c_str(), "g722") != 0 ||
format.clockrate_hz != 8000) {
return rtc::Optional<AudioEncoderG722Config>();
}
AudioEncoderG722Config config;
config.num_channels = rtc::checked_cast<int>(format.num_channels);
auto ptime_iter = format.parameters.find("ptime");
if (ptime_iter != format.parameters.end()) {
auto ptime = rtc::StringToNumber<int>(ptime_iter->second);
if (ptime && *ptime > 0) {
const int whole_packets = *ptime / 10;
config.frame_size_ms = rtc::SafeClamp<int>(whole_packets * 10, 10, 60);
}
}
return config.IsOk() ? rtc::Optional<AudioEncoderG722Config>(config)
: rtc::Optional<AudioEncoderG722Config>();
}
void AudioEncoderG722::AppendSupportedEncoders(

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

@ -26,6 +26,7 @@ rtc_static_library("audio_encoder_ilbc") {
deps = [
":audio_encoder_ilbc_config",
"..:audio_codecs_api",
"../../..:webrtc_common",
"../../../modules/audio_coding:ilbc",
"../../../rtc_base:rtc_base_approved",
]

20
webrtc/api/audio_codecs/ilbc/audio_encoder_ilbc.cc
View File

@ -13,9 +13,12 @@
#include <memory>
#include <vector>
#include "webrtc/common_types.h"
#include "webrtc/modules/audio_coding/codecs/ilbc/audio_encoder_ilbc.h"
#include "webrtc/rtc_base/ptr_util.h"
#include "webrtc/rtc_base/safe_conversions.h"
#include "webrtc/rtc_base/safe_minmax.h"
#include "webrtc/rtc_base/string_to_number.h"
namespace webrtc {
namespace {
@ -37,7 +40,22 @@ int GetIlbcBitrate(int ptime) {
rtc::Optional<AudioEncoderIlbcConfig> AudioEncoderIlbc::SdpToConfig(
const SdpAudioFormat& format) {
return AudioEncoderIlbcImpl::SdpToConfig(format);
if (STR_CASE_CMP(format.name.c_str(), "ILBC") != 0 ||
format.clockrate_hz != 8000 || format.num_channels != 1) {
return rtc::Optional<AudioEncoderIlbcConfig>();
}
AudioEncoderIlbcConfig config;
auto ptime_iter = format.parameters.find("ptime");
if (ptime_iter != format.parameters.end()) {
auto ptime = rtc::StringToNumber<int>(ptime_iter->second);
if (ptime && *ptime > 0) {
const int whole_packets = *ptime / 10;
config.frame_size_ms = rtc::SafeClamp<int>(whole_packets * 10, 20, 60);
}
}
return config.IsOk() ? rtc::Optional<AudioEncoderIlbcConfig>(config)
: rtc::Optional<AudioEncoderIlbcConfig>();
}
void AudioEncoderIlbc::AppendSupportedEncoders(

48
webrtc/modules/audio_coding/codecs/g711/audio_encoder_pcm.cc
View File

@ -16,7 +16,6 @@
#include "webrtc/common_types.h"
#include "webrtc/modules/audio_coding/codecs/g711/g711_interface.h"
#include "webrtc/rtc_base/checks.h"
#include "webrtc/rtc_base/string_to_number.h"
namespace webrtc {
@ -31,35 +30,6 @@ typename T::Config CreateConfig(const CodecInst& codec_inst) {
return config;
}
template <typename T>
typename T::Config CreateConfig(int payload_type,
const SdpAudioFormat& format) {
typename T::Config config;
config.frame_size_ms = 20;
auto ptime_iter = format.parameters.find("ptime");
if (ptime_iter != format.parameters.end()) {
auto ptime = rtc::StringToNumber<int>(ptime_iter->second);
if (ptime && *ptime > 0) {
const int whole_packets = *ptime / 10;
config.frame_size_ms = std::max(10, std::min(whole_packets * 10, 60));
}
}
config.num_channels = format.num_channels;
config.payload_type = payload_type;
return config;
}
template <typename T>
rtc::Optional<AudioCodecInfo> QueryAudioEncoderImpl(
const SdpAudioFormat& format) {
if (STR_CASE_CMP(format.name.c_str(), T::GetPayloadName()) == 0 &&
format.clockrate_hz == 8000 && format.num_channels >= 1 &&
CreateConfig<T>(0, format).IsOk()) {
return rtc::Optional<AudioCodecInfo>({8000, format.num_channels, 64000});
}
return rtc::Optional<AudioCodecInfo>();
}
} // namespace
bool AudioEncoderPcm::Config::IsOk() const {
@ -138,15 +108,6 @@ void AudioEncoderPcm::Reset() {
AudioEncoderPcmA::AudioEncoderPcmA(const CodecInst& codec_inst)
: AudioEncoderPcmA(CreateConfig<AudioEncoderPcmA>(codec_inst)) {}
AudioEncoderPcmA::AudioEncoderPcmA(int payload_type,
const SdpAudioFormat& format)
: AudioEncoderPcmA(CreateConfig<AudioEncoderPcmA>(payload_type, format)) {}
rtc::Optional<AudioCodecInfo> AudioEncoderPcmA::QueryAudioEncoder(
const SdpAudioFormat& format) {
return QueryAudioEncoderImpl<AudioEncoderPcmA>(format);
}
size_t AudioEncoderPcmA::EncodeCall(const int16_t* audio,
size_t input_len,
uint8_t* encoded) {
@ -164,15 +125,6 @@ AudioEncoder::CodecType AudioEncoderPcmA::GetCodecType() const {
AudioEncoderPcmU::AudioEncoderPcmU(const CodecInst& codec_inst)
: AudioEncoderPcmU(CreateConfig<AudioEncoderPcmU>(codec_inst)) {}
AudioEncoderPcmU::AudioEncoderPcmU(int payload_type,
const SdpAudioFormat& format)
: AudioEncoderPcmU(CreateConfig<AudioEncoderPcmU>(payload_type, format)) {}
rtc::Optional<AudioCodecInfo> AudioEncoderPcmU::QueryAudioEncoder(
const SdpAudioFormat& format) {
return QueryAudioEncoderImpl<AudioEncoderPcmU>(format);
}
size_t AudioEncoderPcmU::EncodeCall(const int16_t* audio,
size_t input_len,
uint8_t* encoded) {

11
webrtc/modules/audio_coding/codecs/g711/audio_encoder_pcm.h
View File

@ -14,7 +14,6 @@
#include <vector>
#include "webrtc/api/audio_codecs/audio_encoder.h"
#include "webrtc/api/audio_codecs/audio_format.h"
#include "webrtc/rtc_base/constructormagic.h"
namespace webrtc {
@ -81,11 +80,6 @@ class AudioEncoderPcmA final : public AudioEncoderPcm {
explicit AudioEncoderPcmA(const Config& config)
: AudioEncoderPcm(config, kSampleRateHz) {}
explicit AudioEncoderPcmA(const CodecInst& codec_inst);
AudioEncoderPcmA(int payload_type, const SdpAudioFormat& format);
static constexpr const char* GetPayloadName() { return "PCMA"; }
static rtc::Optional<AudioCodecInfo> QueryAudioEncoder(
const SdpAudioFormat& format);
protected:
size_t EncodeCall(const int16_t* audio,
@ -110,11 +104,6 @@ class AudioEncoderPcmU final : public AudioEncoderPcm {
explicit AudioEncoderPcmU(const Config& config)
: AudioEncoderPcm(config, kSampleRateHz) {}
explicit AudioEncoderPcmU(const CodecInst& codec_inst);
AudioEncoderPcmU(int payload_type, const SdpAudioFormat& format);
static constexpr const char* GetPayloadName() { return "PCMU"; }
static rtc::Optional<AudioCodecInfo> QueryAudioEncoder(
const SdpAudioFormat& format);
protected:
size_t EncodeCall(const int16_t* audio,

40
webrtc/modules/audio_coding/codecs/g722/audio_encoder_g722.cc
View File

@ -17,7 +17,6 @@
#include "webrtc/modules/audio_coding/codecs/g722/g722_interface.h"
#include "webrtc/rtc_base/checks.h"
#include "webrtc/rtc_base/safe_conversions.h"
#include "webrtc/rtc_base/string_to_number.h"
namespace webrtc {
@ -34,27 +33,6 @@ AudioEncoderG722Config CreateConfig(const CodecInst& codec_inst) {
} // namespace
rtc::Optional<AudioEncoderG722Config> AudioEncoderG722Impl::SdpToConfig(
const SdpAudioFormat& format) {
if (STR_CASE_CMP(format.name.c_str(), "g722") != 0 ||
format.clockrate_hz != 8000) {
return rtc::Optional<AudioEncoderG722Config>();
}
AudioEncoderG722Config config;
config.num_channels = rtc::dchecked_cast<int>(format.num_channels);
auto ptime_iter = format.parameters.find("ptime");
if (ptime_iter != format.parameters.end()) {
auto ptime = rtc::StringToNumber<int>(ptime_iter->second);
if (ptime && *ptime > 0) {
const int whole_packets = *ptime / 10;
config.frame_size_ms = std::max(10, std::min(whole_packets * 10, 60));
}
}
return config.IsOk() ? rtc::Optional<AudioEncoderG722Config>(config)
: rtc::Optional<AudioEncoderG722Config>();
}
AudioEncoderG722Impl::AudioEncoderG722Impl(const AudioEncoderG722Config& config,
int payload_type)
: num_channels_(config.num_channels),
@ -78,26 +56,8 @@ AudioEncoderG722Impl::AudioEncoderG722Impl(const AudioEncoderG722Config& config,
AudioEncoderG722Impl::AudioEncoderG722Impl(const CodecInst& codec_inst)
: AudioEncoderG722Impl(CreateConfig(codec_inst), codec_inst.pltype) {}
AudioEncoderG722Impl::AudioEncoderG722Impl(int payload_type,
const SdpAudioFormat& format)
: AudioEncoderG722Impl(*SdpToConfig(format), payload_type) {}
AudioEncoderG722Impl::~AudioEncoderG722Impl() = default;
rtc::Optional<AudioCodecInfo> AudioEncoderG722Impl::QueryAudioEncoder(
const SdpAudioFormat& format) {
if (STR_CASE_CMP(format.name.c_str(), GetPayloadName()) == 0) {
const auto config_opt = SdpToConfig(format);
if (format.clockrate_hz == 8000 && config_opt) {
RTC_DCHECK(config_opt->IsOk());
return rtc::Optional<AudioCodecInfo>(
{rtc::dchecked_cast<int>(kSampleRateHz),
rtc::dchecked_cast<size_t>(config_opt->num_channels), 64000});
}
}
return rtc::Optional<AudioCodecInfo>();
}
int AudioEncoderG722Impl::SampleRateHz() const {
return kSampleRateHz;
}

9
webrtc/modules/audio_coding/codecs/g722/audio_encoder_g722.h
View File

@ -14,7 +14,6 @@
#include <memory>
#include "webrtc/api/audio_codecs/audio_encoder.h"
#include "webrtc/api/audio_codecs/audio_format.h"
#include "webrtc/api/audio_codecs/g722/audio_encoder_g722_config.h"
#include "webrtc/modules/audio_coding/codecs/g722/g722_interface.h"
#include "webrtc/rtc_base/buffer.h"
@ -26,18 +25,10 @@ struct CodecInst;
class AudioEncoderG722Impl final : public AudioEncoder {
public:
static rtc::Optional<AudioEncoderG722Config> SdpToConfig(
const SdpAudioFormat& format);
AudioEncoderG722Impl(const AudioEncoderG722Config& config, int payload_type);
explicit AudioEncoderG722Impl(const CodecInst& codec_inst);
AudioEncoderG722Impl(int payload_type, const SdpAudioFormat& format);
~AudioEncoderG722Impl() override;
static constexpr const char* GetPayloadName() { return "G722"; }
static rtc::Optional<AudioCodecInfo> QueryAudioEncoder(
const SdpAudioFormat& format);
int SampleRateHz() const override;
size_t NumChannels() const override;
int RtpTimestampRateHz() const override;

40
webrtc/modules/audio_coding/codecs/ilbc/audio_encoder_ilbc.cc
View File

@ -16,7 +16,6 @@
#include "webrtc/modules/audio_coding/codecs/ilbc/ilbc.h"
#include "webrtc/rtc_base/checks.h"
#include "webrtc/rtc_base/safe_conversions.h"
#include "webrtc/rtc_base/string_to_number.h"
namespace webrtc {
@ -47,26 +46,6 @@ int GetIlbcBitrate(int ptime) {
} // namespace
rtc::Optional<AudioEncoderIlbcConfig> AudioEncoderIlbcImpl::SdpToConfig(
const SdpAudioFormat& format) {
if (STR_CASE_CMP(format.name.c_str(), "ilbc") != 0 ||
format.clockrate_hz != 8000 || format.num_channels != 1) {
return rtc::Optional<AudioEncoderIlbcConfig>();
}
AudioEncoderIlbcConfig config;
auto ptime_iter = format.parameters.find("ptime");
if (ptime_iter != format.parameters.end()) {
auto ptime = rtc::StringToNumber<int>(ptime_iter->second);
if (ptime && *ptime > 0) {
const int whole_packets = *ptime / 10;
config.frame_size_ms = std::max(20, std::min(whole_packets * 10, 60));
}
}
return config.IsOk() ? rtc::Optional<AudioEncoderIlbcConfig>(config)
: rtc::Optional<AudioEncoderIlbcConfig>();
}
AudioEncoderIlbcImpl::AudioEncoderIlbcImpl(const AudioEncoderIlbcConfig& config,
int payload_type)
: frame_size_ms_(config.frame_size_ms),
@ -81,29 +60,10 @@ AudioEncoderIlbcImpl::AudioEncoderIlbcImpl(const AudioEncoderIlbcConfig& config,
AudioEncoderIlbcImpl::AudioEncoderIlbcImpl(const CodecInst& codec_inst)
: AudioEncoderIlbcImpl(CreateConfig(codec_inst), codec_inst.pltype) {}
AudioEncoderIlbcImpl::AudioEncoderIlbcImpl(int payload_type,
const SdpAudioFormat& format)
: AudioEncoderIlbcImpl(*SdpToConfig(format), payload_type) {}
AudioEncoderIlbcImpl::~AudioEncoderIlbcImpl() {
RTC_CHECK_EQ(0, WebRtcIlbcfix_EncoderFree(encoder_));
}
rtc::Optional<AudioCodecInfo> AudioEncoderIlbcImpl::QueryAudioEncoder(
const SdpAudioFormat& format) {
if (STR_CASE_CMP(format.name.c_str(), GetPayloadName()) == 0) {
const auto config_opt = SdpToConfig(format);
if (format.clockrate_hz == 8000 && format.num_channels == 1 &&
config_opt) {
RTC_DCHECK(config_opt->IsOk());
return rtc::Optional<AudioCodecInfo>(
{rtc::dchecked_cast<int>(kSampleRateHz), 1,
GetIlbcBitrate(config_opt->frame_size_ms)});
}
}
return rtc::Optional<AudioCodecInfo>();
}
int AudioEncoderIlbcImpl::SampleRateHz() const {
return kSampleRateHz;
}

9
webrtc/modules/audio_coding/codecs/ilbc/audio_encoder_ilbc.h
View File

@ -12,7 +12,6 @@
#define WEBRTC_MODULES_AUDIO_CODING_CODECS_ILBC_AUDIO_ENCODER_ILBC_H_
#include "webrtc/api/audio_codecs/audio_encoder.h"
#include "webrtc/api/audio_codecs/audio_format.h"
#include "webrtc/api/audio_codecs/ilbc/audio_encoder_ilbc_config.h"
#include "webrtc/modules/audio_coding/codecs/ilbc/ilbc.h"
#include "webrtc/rtc_base/constructormagic.h"
@ -23,18 +22,10 @@ struct CodecInst;
class AudioEncoderIlbcImpl final : public AudioEncoder {
public:
static rtc::Optional<AudioEncoderIlbcConfig> SdpToConfig(
const SdpAudioFormat& format);
AudioEncoderIlbcImpl(const AudioEncoderIlbcConfig& config, int payload_type);
explicit AudioEncoderIlbcImpl(const CodecInst& codec_inst);
AudioEncoderIlbcImpl(int payload_type, const SdpAudioFormat& format);
~AudioEncoderIlbcImpl() override;
static constexpr const char* GetPayloadName() { return "ILBC"; }
static rtc::Optional<AudioCodecInfo> QueryAudioEncoder(
const SdpAudioFormat& format);
int SampleRateHz() const override;
size_t NumChannels() const override;
size_t Num10MsFramesInNextPacket() const override;

6
webrtc/modules/audio_coding/codecs/isac/audio_encoder_isac_t.h
View File

@ -14,7 +14,6 @@
#include <vector>
#include "webrtc/api/audio_codecs/audio_encoder.h"
#include "webrtc/api/audio_codecs/audio_format.h"
#include "webrtc/modules/audio_coding/codecs/isac/locked_bandwidth_info.h"
#include "webrtc/rtc_base/constructormagic.h"
#include "webrtc/rtc_base/scoped_ref_ptr.h"
@ -56,13 +55,8 @@ class AudioEncoderIsacT final : public AudioEncoder {
explicit AudioEncoderIsacT(
const CodecInst& codec_inst,
const rtc::scoped_refptr<LockedIsacBandwidthInfo>& bwinfo);
AudioEncoderIsacT(int payload_type, const SdpAudioFormat& format);
~AudioEncoderIsacT() override;
static constexpr const char* GetPayloadName() { return "ISAC"; }
static rtc::Optional<AudioCodecInfo> QueryAudioEncoder(
const SdpAudioFormat& format);
int SampleRateHz() const override;
size_t NumChannels() const override;
size_t Num10MsFramesInNextPacket() const override;

52
webrtc/modules/audio_coding/codecs/isac/audio_encoder_isac_t_impl.h
View File

@ -13,14 +13,8 @@
#include "webrtc/common_types.h"
#include "webrtc/rtc_base/checks.h"
#include "webrtc/rtc_base/string_to_number.h"
namespace webrtc {
namespace { // NOLINT (not a "regular" header file)
int GetIsacMaxBitrate(int clockrate_hz) {
return (clockrate_hz == 32000) ? 56000 : 32000;
}
} // namespace
template <typename T>
typename AudioEncoderIsacT<T>::Config CreateIsacConfig(
@ -38,33 +32,6 @@ typename AudioEncoderIsacT<T>::Config CreateIsacConfig(
return config;
}
template <typename T>
typename AudioEncoderIsacT<T>::Config CreateIsacConfig(
int payload_type,
const SdpAudioFormat& format) {
typename AudioEncoderIsacT<T>::Config config;
config.payload_type = payload_type;
config.sample_rate_hz = format.clockrate_hz;
// We only support different frame sizes at 16000 Hz.
if (config.sample_rate_hz == 16000) {
auto ptime_iter = format.parameters.find("ptime");
if (ptime_iter != format.parameters.end()) {
auto ptime = rtc::StringToNumber<int>(ptime_iter->second);
if (ptime && *ptime >= 60) {
config.frame_size_ms = 60;
} else {
config.frame_size_ms = 30;
}
}
}
// Set the default bitrate for ISAC to the maximum bitrate allowed at this
// clockrate. At this point, adaptive mode is not used by WebRTC.
config.bit_rate = GetIsacMaxBitrate(format.clockrate_hz);
return config;
}
template <typename T>
bool AudioEncoderIsacT<T>::Config::IsOk() const {
if (max_bit_rate < 32000 && max_bit_rate != -1)
@ -105,25 +72,6 @@ AudioEncoderIsacT<T>::AudioEncoderIsacT(
const rtc::scoped_refptr<LockedIsacBandwidthInfo>& bwinfo)
: AudioEncoderIsacT(CreateIsacConfig<T>(codec_inst, bwinfo)) {}
template <typename T>
AudioEncoderIsacT<T>::AudioEncoderIsacT(int payload_type,
const SdpAudioFormat& format)
: AudioEncoderIsacT(CreateIsacConfig<T>(payload_type, format)) {}
template <typename T>
rtc::Optional<AudioCodecInfo> AudioEncoderIsacT<T>::QueryAudioEncoder(
const SdpAudioFormat& format) {
if (STR_CASE_CMP(format.name.c_str(), GetPayloadName()) == 0) {
Config config = CreateIsacConfig<T>(0, format);
if (config.IsOk()) {
return rtc::Optional<AudioCodecInfo>(
{config.sample_rate_hz, 1, config.bit_rate, 10000,
GetIsacMaxBitrate(format.clockrate_hz)});
}
}
return rtc::Optional<AudioCodecInfo>();
}
template <typename T>
AudioEncoderIsacT<T>::~AudioEncoderIsacT() {
RTC_CHECK_EQ(0, T::Free(isac_state_));

39
webrtc/modules/audio_coding/codecs/pcm16b/audio_encoder_pcm16b.cc
View File

@ -16,7 +16,6 @@
#include "webrtc/modules/audio_coding/codecs/pcm16b/pcm16b.h"
#include "webrtc/rtc_base/checks.h"
#include "webrtc/rtc_base/safe_conversions.h"
#include "webrtc/rtc_base/string_to_number.h"
namespace webrtc {
@ -35,6 +34,7 @@ AudioEncoder::CodecType AudioEncoderPcm16B::GetCodecType() const {
}
namespace {
AudioEncoderPcm16B::Config CreateConfig(const CodecInst& codec_inst) {
AudioEncoderPcm16B::Config config;
config.num_channels = codec_inst.channels;
@ -45,23 +45,6 @@ AudioEncoderPcm16B::Config CreateConfig(const CodecInst& codec_inst) {
return config;
}
AudioEncoderPcm16B::Config CreateConfig(int payload_type,
const SdpAudioFormat& format) {
AudioEncoderPcm16B::Config config;
config.num_channels = format.num_channels;
config.sample_rate_hz = format.clockrate_hz;
config.frame_size_ms = 10;
auto ptime_iter = format.parameters.find("ptime");
if (ptime_iter != format.parameters.end()) {
auto ptime = rtc::StringToNumber<int>(ptime_iter->second);
if (ptime && *ptime > 0) {
const int whole_packets = *ptime / 10;
config.frame_size_ms = std::max(10, std::min(whole_packets * 10, 60));
}
}
config.payload_type = payload_type;
return config;
}
} // namespace
bool AudioEncoderPcm16B::Config::IsOk() const {
@ -74,24 +57,4 @@ bool AudioEncoderPcm16B::Config::IsOk() const {
AudioEncoderPcm16B::AudioEncoderPcm16B(const CodecInst& codec_inst)
: AudioEncoderPcm16B(CreateConfig(codec_inst)) {}
AudioEncoderPcm16B::AudioEncoderPcm16B(int payload_type,
const SdpAudioFormat& format)
: AudioEncoderPcm16B(CreateConfig(payload_type, format)) {}
rtc::Optional<AudioCodecInfo> AudioEncoderPcm16B::QueryAudioEncoder(
const SdpAudioFormat& format) {
if (STR_CASE_CMP(format.name.c_str(), GetPayloadName()) == 0 &&
format.num_channels >= 1) {
Config config = CreateConfig(0, format);
if (config.IsOk()) {
constexpr int bits_per_sample = 16;
return rtc::Optional<AudioCodecInfo>(
{config.sample_rate_hz, config.num_channels,
config.sample_rate_hz * bits_per_sample *
rtc::dchecked_cast<int>(config.num_channels)});
}
}
return rtc::Optional<AudioCodecInfo>();
}
} // namespace webrtc

5
webrtc/modules/audio_coding/codecs/pcm16b/audio_encoder_pcm16b.h
View File

@ -31,11 +31,6 @@ class AudioEncoderPcm16B final : public AudioEncoderPcm {
explicit AudioEncoderPcm16B(const Config& config)
: AudioEncoderPcm(config, config.sample_rate_hz) {}
explicit AudioEncoderPcm16B(const CodecInst& codec_inst);
AudioEncoderPcm16B(int payload_type, const SdpAudioFormat& format);
static constexpr const char* GetPayloadName() { return "L16"; }
static rtc::Optional<AudioCodecInfo> QueryAudioEncoder(
const SdpAudioFormat& format);
protected:
size_t EncodeCall(const int16_t* audio,