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

Revert "[ACM] iSAC audio codec removed"

Browse Source 
This reverts commit b46c4bf27ba5c417fcba7f200d80fa4634e7e1a1.

Reason for revert: breaks a downstream project

Original change's description:
> [ACM] iSAC audio codec removed
>
> Note: this CL has to leave behind one part of iSAC, which is its VAD
> currently used by AGC1 in APM. The target visibility has been
> restricted and the VAD will be removed together with AGC1 when the
> time comes.
>
> Tested: see https://chromium-review.googlesource.com/c/chromium/src/+/4013319
>
> Bug: webrtc:14450
> Change-Id: I69cc518b16280eae62a1f1977cdbfa24c08cf5f9
> Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/282421
> Reviewed-by: Henrik Lundin <henrik.lundin@webrtc.org>
> Reviewed-by: Sam Zackrisson <saza@webrtc.org>
> Reviewed-by: Henrik Boström <hbos@webrtc.org>
> Commit-Queue: Alessio Bazzica <alessiob@webrtc.org>
> Cr-Commit-Position: refs/heads/main@{#38652}

Bug: webrtc:14450
Change-Id: Ice138004e84e8c5f896684e8d01133d4b2a77bb7
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/283800
Reviewed-by: Alessio Bazzica <alessiob@webrtc.org>
Commit-Queue: Mirko Bonadei <mbonadei@webrtc.org>
Auto-Submit: Alessio Bazzica <alessiob@webrtc.org>
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Owners-Override: Mirko Bonadei <mbonadei@webrtc.org>
Bot-Commit: rubber-stamper@appspot.gserviceaccount.com <rubber-stamper@appspot.gserviceaccount.com>
Cr-Commit-Position: refs/heads/main@{#38655}
This commit is contained in:
Alessio Bazzica
2022-11-16 19:13:25 +00:00
committed by WebRTC LUCI CQ
parent cb2b133bf0
commit fbeb76ab51
164 changed files with 39429 additions and 117 deletions
Download Patch File Download Diff File Expand all files Collapse all files

156
modules/audio_coding/neteq/audio_decoder_unittest.cc
View File

@ -22,6 +22,10 @@
#include "modules/audio_coding/codecs/g722/audio_encoder_g722.h"
#include "modules/audio_coding/codecs/ilbc/audio_decoder_ilbc.h"
#include "modules/audio_coding/codecs/ilbc/audio_encoder_ilbc.h"
#include "modules/audio_coding/codecs/isac/fix/include/audio_decoder_isacfix.h"
#include "modules/audio_coding/codecs/isac/fix/include/audio_encoder_isacfix.h"
#include "modules/audio_coding/codecs/isac/main/include/audio_decoder_isac.h"
#include "modules/audio_coding/codecs/isac/main/include/audio_encoder_isac.h"
#include "modules/audio_coding/codecs/opus/audio_decoder_opus.h"
#include "modules/audio_coding/codecs/pcm16b/audio_decoder_pcm16b.h"
#include "modules/audio_coding/codecs/pcm16b/audio_encoder_pcm16b.h"
@ -191,8 +195,8 @@ class AudioDecoderTest : public ::testing::Test {
processed_samples += frame_size_;
}
// For some codecs it doesn't make sense to check expected number of bytes,
// since the number can vary for different platforms. Opus is such a codec.
// In this case expected_bytes is set to 0.
// since the number can vary for different platforms. Opus and iSAC are
// such codecs. In this case expected_bytes is set to 0.
if (expected_bytes) {
EXPECT_EQ(expected_bytes, encoded_bytes);
}
@ -343,6 +347,66 @@ class AudioDecoderIlbcTest : public AudioDecoderTest {
}
};
class AudioDecoderIsacFloatTest : public AudioDecoderTest {
protected:
AudioDecoderIsacFloatTest() : AudioDecoderTest() {
codec_input_rate_hz_ = 16000;
frame_size_ = 480;
data_length_ = 10 * frame_size_;
AudioEncoderIsacFloatImpl::Config config;
config.payload_type = payload_type_;
config.sample_rate_hz = codec_input_rate_hz_;
config.frame_size_ms =
1000 * static_cast<int>(frame_size_) / codec_input_rate_hz_;
audio_encoder_.reset(new AudioEncoderIsacFloatImpl(config));
audio_encoder_->OnReceivedOverhead(kOverheadBytesPerPacket);
AudioDecoderIsacFloatImpl::Config decoder_config;
decoder_config.sample_rate_hz = codec_input_rate_hz_;
decoder_ = new AudioDecoderIsacFloatImpl(decoder_config);
}
};
class AudioDecoderIsacSwbTest : public AudioDecoderTest {
protected:
AudioDecoderIsacSwbTest() : AudioDecoderTest() {
codec_input_rate_hz_ = 32000;
frame_size_ = 960;
data_length_ = 10 * frame_size_;
AudioEncoderIsacFloatImpl::Config config;
config.payload_type = payload_type_;
config.sample_rate_hz = codec_input_rate_hz_;
config.frame_size_ms =
1000 * static_cast<int>(frame_size_) / codec_input_rate_hz_;
audio_encoder_.reset(new AudioEncoderIsacFloatImpl(config));
audio_encoder_->OnReceivedOverhead(kOverheadBytesPerPacket);
AudioDecoderIsacFloatImpl::Config decoder_config;
decoder_config.sample_rate_hz = codec_input_rate_hz_;
decoder_ = new AudioDecoderIsacFloatImpl(decoder_config);
}
};
class AudioDecoderIsacFixTest : public AudioDecoderTest {
protected:
AudioDecoderIsacFixTest() : AudioDecoderTest() {
codec_input_rate_hz_ = 16000;
frame_size_ = 480;
data_length_ = 10 * frame_size_;
AudioEncoderIsacFixImpl::Config config;
config.payload_type = payload_type_;
config.sample_rate_hz = codec_input_rate_hz_;
config.frame_size_ms =
1000 * static_cast<int>(frame_size_) / codec_input_rate_hz_;
audio_encoder_.reset(new AudioEncoderIsacFixImpl(config));
audio_encoder_->OnReceivedOverhead(kOverheadBytesPerPacket);
AudioDecoderIsacFixImpl::Config decoder_config;
decoder_config.sample_rate_hz = codec_input_rate_hz_;
decoder_ = new AudioDecoderIsacFixImpl(decoder_config);
}
};
class AudioDecoderG722Test : public AudioDecoderTest {
protected:
AudioDecoderG722Test() : AudioDecoderTest() {
@ -469,6 +533,94 @@ TEST_F(AudioDecoderIlbcTest, SetTargetBitrate) {
TestSetAndGetTargetBitratesWithFixedCodec(audio_encoder_.get(), 13333);
}
TEST_F(AudioDecoderIsacFloatTest, EncodeDecode) {
int tolerance = 3399;
double mse = 434951.0;
int delay = 48; // Delay from input to output.
EncodeDecodeTest(0, tolerance, mse, delay);
ReInitTest();
EXPECT_FALSE(decoder_->HasDecodePlc());
}
TEST_F(AudioDecoderIsacFloatTest, SetTargetBitrate) {
const int overhead_rate =
8 * kOverheadBytesPerPacket * codec_input_rate_hz_ / frame_size_;
EXPECT_EQ(10000,
SetAndGetTargetBitrate(audio_encoder_.get(), 9999 + overhead_rate));
EXPECT_EQ(10000, SetAndGetTargetBitrate(audio_encoder_.get(),
10000 + overhead_rate));
EXPECT_EQ(23456, SetAndGetTargetBitrate(audio_encoder_.get(),
23456 + overhead_rate));
EXPECT_EQ(32000, SetAndGetTargetBitrate(audio_encoder_.get(),
32000 + overhead_rate));
EXPECT_EQ(32000, SetAndGetTargetBitrate(audio_encoder_.get(),
32001 + overhead_rate));
}
TEST_F(AudioDecoderIsacSwbTest, EncodeDecode) {
int tolerance = 19757;
double mse = 8.18e6;
int delay = 160; // Delay from input to output.
EncodeDecodeTest(0, tolerance, mse, delay);
ReInitTest();
EXPECT_FALSE(decoder_->HasDecodePlc());
}
TEST_F(AudioDecoderIsacSwbTest, SetTargetBitrate) {
const int overhead_rate =
8 * kOverheadBytesPerPacket * codec_input_rate_hz_ / frame_size_;
EXPECT_EQ(10000,
SetAndGetTargetBitrate(audio_encoder_.get(), 9999 + overhead_rate));
EXPECT_EQ(10000, SetAndGetTargetBitrate(audio_encoder_.get(),
10000 + overhead_rate));
EXPECT_EQ(23456, SetAndGetTargetBitrate(audio_encoder_.get(),
23456 + overhead_rate));
EXPECT_EQ(56000, SetAndGetTargetBitrate(audio_encoder_.get(),
56000 + overhead_rate));
EXPECT_EQ(56000, SetAndGetTargetBitrate(audio_encoder_.get(),
56001 + overhead_rate));
}
// Run bit exactness test only for release builds.
#if defined(NDEBUG)
TEST_F(AudioDecoderIsacFixTest, EncodeDecode) {
int tolerance = 11034;
double mse = 3.46e6;
int delay = 54; // Delay from input to output.
#if defined(WEBRTC_ANDROID) && defined(WEBRTC_ARCH_ARM)
static const int kEncodedBytes = 685;
#elif defined(WEBRTC_MAC) && defined(WEBRTC_ARCH_ARM64) // M1 Mac
static const int kEncodedBytes = 673;
#elif defined(WEBRTC_ARCH_ARM64)
static const int kEncodedBytes = 673;
#elif defined(WEBRTC_WIN) && defined(_MSC_VER) && !defined(__clang__)
static const int kEncodedBytes = 671;
#elif defined(WEBRTC_IOS) && defined(WEBRTC_ARCH_X86_64)
static const int kEncodedBytes = 671;
#else
static const int kEncodedBytes = 671;
#endif
EncodeDecodeTest(kEncodedBytes, tolerance, mse, delay);
ReInitTest();
EXPECT_FALSE(decoder_->HasDecodePlc());
}
#endif
TEST_F(AudioDecoderIsacFixTest, SetTargetBitrate) {
const int overhead_rate =
8 * kOverheadBytesPerPacket * codec_input_rate_hz_ / frame_size_;
EXPECT_EQ(10000,
SetAndGetTargetBitrate(audio_encoder_.get(), 9999 + overhead_rate));
EXPECT_EQ(10000, SetAndGetTargetBitrate(audio_encoder_.get(),
10000 + overhead_rate));
EXPECT_EQ(23456, SetAndGetTargetBitrate(audio_encoder_.get(),
23456 + overhead_rate));
EXPECT_EQ(32000, SetAndGetTargetBitrate(audio_encoder_.get(),
32000 + overhead_rate));
EXPECT_EQ(32000, SetAndGetTargetBitrate(audio_encoder_.get(),
32001 + overhead_rate));
}
TEST_F(AudioDecoderG722Test, EncodeDecode) {
int tolerance = 6176;
double mse = 238630.0;

102
modules/audio_coding/neteq/test/neteq_isac_quality_test.cc Normal file
View File

@ -0,0 +1,102 @@
/*
* Copyright (c) 2014 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 "absl/flags/flag.h"
#include "modules/audio_coding/codecs/isac/fix/include/isacfix.h"
#include "modules/audio_coding/neteq/tools/neteq_quality_test.h"
ABSL_FLAG(int, bit_rate_kbps, 32, "Target bit rate (kbps).");
using ::testing::InitGoogleTest;
namespace webrtc {
namespace test {
namespace {
static const int kIsacBlockDurationMs = 30;
static const int kIsacInputSamplingKhz = 16;
static const int kIsacOutputSamplingKhz = 16;
} // namespace
class NetEqIsacQualityTest : public NetEqQualityTest {
protected:
NetEqIsacQualityTest();
void SetUp() override;
void TearDown() override;
int EncodeBlock(int16_t* in_data,
size_t block_size_samples,
rtc::Buffer* payload,
size_t max_bytes) override;
private:
ISACFIX_MainStruct* isac_encoder_;
int bit_rate_kbps_;
};
NetEqIsacQualityTest::NetEqIsacQualityTest()
: NetEqQualityTest(kIsacBlockDurationMs,
kIsacInputSamplingKhz,
kIsacOutputSamplingKhz,
SdpAudioFormat("isac", 16000, 1)),
isac_encoder_(NULL),
bit_rate_kbps_(absl::GetFlag(FLAGS_bit_rate_kbps)) {
// Flag validation
RTC_CHECK(absl::GetFlag(FLAGS_bit_rate_kbps) >= 10 &&
absl::GetFlag(FLAGS_bit_rate_kbps) <= 32)
<< "Invalid bit rate, should be between 10 and 32 kbps.";
}
void NetEqIsacQualityTest::SetUp() {
ASSERT_EQ(1u, channels_) << "iSAC supports only mono audio.";
// Create encoder memory.
WebRtcIsacfix_Create(&isac_encoder_);
ASSERT_TRUE(isac_encoder_ != NULL);
EXPECT_EQ(0, WebRtcIsacfix_EncoderInit(isac_encoder_, 1));
// Set bitrate and block length.
EXPECT_EQ(0, WebRtcIsacfix_Control(isac_encoder_, bit_rate_kbps_ * 1000,
kIsacBlockDurationMs));
NetEqQualityTest::SetUp();
}
void NetEqIsacQualityTest::TearDown() {
// Free memory.
EXPECT_EQ(0, WebRtcIsacfix_Free(isac_encoder_));
NetEqQualityTest::TearDown();
}
int NetEqIsacQualityTest::EncodeBlock(int16_t* in_data,
size_t block_size_samples,
rtc::Buffer* payload,
size_t max_bytes) {
// ISAC takes 10 ms for every call.
const int subblocks = kIsacBlockDurationMs / 10;
const int subblock_length = 10 * kIsacInputSamplingKhz;
int value = 0;
int pointer = 0;
for (int idx = 0; idx < subblocks; idx++, pointer += subblock_length) {
// The Isac encoder does not perform encoding (and returns 0) until it
// receives a sequence of sub-blocks that amount to the frame duration.
EXPECT_EQ(0, value);
payload->AppendData(max_bytes, [&](rtc::ArrayView<uint8_t> payload) {
value = WebRtcIsacfix_Encode(isac_encoder_, &in_data[pointer],
payload.data());
return (value >= 0) ? static_cast<size_t>(value) : 0;
});
}
EXPECT_GT(value, 0);
return value;
}
TEST_F(NetEqIsacQualityTest, Test) {
Simulate();
}
} // namespace test
} // namespace webrtc

10
modules/audio_coding/neteq/tools/rtp_encode.cc
View File

@ -30,6 +30,7 @@
#include "api/audio_codecs/g711/audio_encoder_g711.h"
#include "api/audio_codecs/g722/audio_encoder_g722.h"
#include "api/audio_codecs/ilbc/audio_encoder_ilbc.h"
#include "api/audio_codecs/isac/audio_encoder_isac.h"
#include "api/audio_codecs/opus/audio_encoder_opus.h"
#include "modules/audio_coding/codecs/cng/audio_encoder_cng.h"
#include "modules/audio_coding/include/audio_coding_module.h"
@ -70,6 +71,7 @@ enum class CodecType {
kPcm16b32,
kPcm16b48,
kIlbc,
kIsac
};
struct CodecTypeAndInfo {
@ -92,7 +94,8 @@ const std::map<std::string, CodecTypeAndInfo>& CodecList() {
{"pcm16b_16", {CodecType::kPcm16b16, 94, false}},
{"pcm16b_32", {CodecType::kPcm16b32, 95, false}},
{"pcm16b_48", {CodecType::kPcm16b48, 96, false}},
{"ilbc", {CodecType::kIlbc, 102, false}}};
{"ilbc", {CodecType::kIlbc, 102, false}},
{"isac", {CodecType::kIsac, 103, false}}};
return *codec_list;
}
@ -233,6 +236,11 @@ std::unique_ptr<AudioEncoder> CreateEncoder(CodecType codec_type,
return AudioEncoderIlbc::MakeAudioEncoder(
GetCodecConfig<AudioEncoderIlbc>(), payload_type);
}
case CodecType::kIsac: {
return AudioEncoderIsac::MakeAudioEncoder(
GetCodecConfig<AudioEncoderIsac>(), payload_type);
}
}
RTC_DCHECK_NOTREACHED();
return nullptr;