75642fcd9a
This CL makes it possible to replace the payload in an RTP stream with audio from another (PCM) file. The new payload will be encoded as PCM16b. The RTP headers will be updated to reflect this change of payload type. BUG=2834 R=turaj@webrtc.org Review URL: https://webrtc-codereview.appspot.com/7659004 git-svn-id: http://webrtc.googlecode.com/svn/trunk@5490 4adac7df-926f-26a2-2b94-8c16560cd09d
627 lines
24 KiB
C++
627 lines
24 KiB
C++
/*
|
|
* Copyright (c) 2013 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.
|
|
*/
|
|
|
|
// TODO(hlundin): The functionality in this file should be moved into one or
|
|
// several classes.
|
|
|
|
#include <assert.h>
|
|
#include <stdio.h>
|
|
|
|
#include <algorithm>
|
|
#include <iostream>
|
|
#include <string>
|
|
|
|
#include "google/gflags.h"
|
|
#include "webrtc/modules/audio_coding/codecs/pcm16b/include/pcm16b.h"
|
|
#include "webrtc/modules/audio_coding/neteq4/interface/neteq.h"
|
|
#include "webrtc/modules/audio_coding/neteq4/test/NETEQTEST_RTPpacket.h"
|
|
#include "webrtc/modules/audio_coding/neteq4/test/NETEQTEST_DummyRTPpacket.h"
|
|
#include "webrtc/modules/audio_coding/neteq4/tools/input_audio_file.h"
|
|
#include "webrtc/modules/interface/module_common_types.h"
|
|
#include "webrtc/system_wrappers/interface/scoped_ptr.h"
|
|
#include "webrtc/system_wrappers/interface/trace.h"
|
|
#include "webrtc/test/testsupport/fileutils.h"
|
|
#include "webrtc/typedefs.h"
|
|
|
|
using webrtc::NetEq;
|
|
using webrtc::WebRtcRTPHeader;
|
|
|
|
// Flag validators.
|
|
static bool ValidatePayloadType(const char* flagname, int32_t value) {
|
|
if (value >= 0 && value <= 127) // Value is ok.
|
|
return true;
|
|
printf("Invalid value for --%s: %d\n", flagname, static_cast<int>(value));
|
|
return false;
|
|
}
|
|
|
|
// Define command line flags.
|
|
DEFINE_int32(pcmu, 0, "RTP payload type for PCM-u");
|
|
static const bool pcmu_dummy =
|
|
google::RegisterFlagValidator(&FLAGS_pcmu, &ValidatePayloadType);
|
|
DEFINE_int32(pcma, 8, "RTP payload type for PCM-a");
|
|
static const bool pcma_dummy =
|
|
google::RegisterFlagValidator(&FLAGS_pcma, &ValidatePayloadType);
|
|
DEFINE_int32(ilbc, 102, "RTP payload type for iLBC");
|
|
static const bool ilbc_dummy =
|
|
google::RegisterFlagValidator(&FLAGS_ilbc, &ValidatePayloadType);
|
|
DEFINE_int32(isac, 103, "RTP payload type for iSAC");
|
|
static const bool isac_dummy =
|
|
google::RegisterFlagValidator(&FLAGS_isac, &ValidatePayloadType);
|
|
DEFINE_int32(isac_swb, 104, "RTP payload type for iSAC-swb (32 kHz)");
|
|
static const bool isac_swb_dummy =
|
|
google::RegisterFlagValidator(&FLAGS_isac_swb, &ValidatePayloadType);
|
|
DEFINE_int32(pcm16b, 93, "RTP payload type for PCM16b-nb (8 kHz)");
|
|
static const bool pcm16b_dummy =
|
|
google::RegisterFlagValidator(&FLAGS_pcm16b, &ValidatePayloadType);
|
|
DEFINE_int32(pcm16b_wb, 94, "RTP payload type for PCM16b-wb (16 kHz)");
|
|
static const bool pcm16b_wb_dummy =
|
|
google::RegisterFlagValidator(&FLAGS_pcm16b_wb, &ValidatePayloadType);
|
|
DEFINE_int32(pcm16b_swb32, 95, "RTP payload type for PCM16b-swb32 (32 kHz)");
|
|
static const bool pcm16b_swb32_dummy =
|
|
google::RegisterFlagValidator(&FLAGS_pcm16b_swb32, &ValidatePayloadType);
|
|
DEFINE_int32(pcm16b_swb48, 96, "RTP payload type for PCM16b-swb48 (48 kHz)");
|
|
static const bool pcm16b_swb48_dummy =
|
|
google::RegisterFlagValidator(&FLAGS_pcm16b_swb48, &ValidatePayloadType);
|
|
DEFINE_int32(g722, 9, "RTP payload type for G.722");
|
|
static const bool g722_dummy =
|
|
google::RegisterFlagValidator(&FLAGS_g722, &ValidatePayloadType);
|
|
DEFINE_int32(avt, 106, "RTP payload type for AVT/DTMF");
|
|
static const bool avt_dummy =
|
|
google::RegisterFlagValidator(&FLAGS_avt, &ValidatePayloadType);
|
|
DEFINE_int32(red, 117, "RTP payload type for redundant audio (RED)");
|
|
static const bool red_dummy =
|
|
google::RegisterFlagValidator(&FLAGS_red, &ValidatePayloadType);
|
|
DEFINE_int32(cn_nb, 13, "RTP payload type for comfort noise (8 kHz)");
|
|
static const bool cn_nb_dummy =
|
|
google::RegisterFlagValidator(&FLAGS_cn_nb, &ValidatePayloadType);
|
|
DEFINE_int32(cn_wb, 98, "RTP payload type for comfort noise (16 kHz)");
|
|
static const bool cn_wb_dummy =
|
|
google::RegisterFlagValidator(&FLAGS_cn_wb, &ValidatePayloadType);
|
|
DEFINE_int32(cn_swb32, 99, "RTP payload type for comfort noise (32 kHz)");
|
|
static const bool cn_swb32_dummy =
|
|
google::RegisterFlagValidator(&FLAGS_cn_swb32, &ValidatePayloadType);
|
|
DEFINE_int32(cn_swb48, 100, "RTP payload type for comfort noise (48 kHz)");
|
|
static const bool cn_swb48_dummy =
|
|
google::RegisterFlagValidator(&FLAGS_cn_swb48, &ValidatePayloadType);
|
|
DEFINE_bool(codec_map, false, "Prints the mapping between RTP payload type and "
|
|
"codec");
|
|
DEFINE_bool(dummy_rtp, false, "The input file contains ""dummy"" RTP data, "
|
|
"i.e., only headers");
|
|
DEFINE_string(replacement_audio_file, "",
|
|
"A PCM file that will be used to populate ""dummy"" RTP packets");
|
|
|
|
// Declaring helper functions (defined further down in this file).
|
|
std::string CodecName(webrtc::NetEqDecoder codec);
|
|
void RegisterPayloadTypes(NetEq* neteq);
|
|
void PrintCodecMapping();
|
|
size_t ReplacePayload(webrtc::test::InputAudioFile* replacement_audio_file,
|
|
webrtc::scoped_ptr<int16_t[]>* replacement_audio,
|
|
webrtc::scoped_ptr<uint8_t[]>* payload,
|
|
size_t* payload_mem_size_bytes,
|
|
size_t* frame_size_samples,
|
|
WebRtcRTPHeader* rtp_header,
|
|
NETEQTEST_RTPpacket* next_rtp);
|
|
int CodecSampleRate(uint8_t payload_type);
|
|
int CodecTimestampRate(uint8_t payload_type);
|
|
bool IsComfortNosie(uint8_t payload_type);
|
|
|
|
int main(int argc, char* argv[]) {
|
|
static const int kMaxChannels = 5;
|
|
static const int kMaxSamplesPerMs = 48000 / 1000;
|
|
static const int kOutputBlockSizeMs = 10;
|
|
|
|
std::string program_name = argv[0];
|
|
std::string usage = "Tool for decoding an RTP dump file using NetEq.\n"
|
|
"Run " + program_name + " --helpshort for usage.\n"
|
|
"Example usage:\n" + program_name +
|
|
" input.rtp output.pcm\n";
|
|
google::SetUsageMessage(usage);
|
|
google::ParseCommandLineFlags(&argc, &argv, true);
|
|
|
|
if (FLAGS_codec_map) {
|
|
PrintCodecMapping();
|
|
}
|
|
|
|
if (argc != 3) {
|
|
if (FLAGS_codec_map) {
|
|
// We have already printed the codec map. Just end the program.
|
|
return 0;
|
|
}
|
|
// Print usage information.
|
|
std::cout << google::ProgramUsage();
|
|
return 0;
|
|
}
|
|
|
|
FILE* in_file = fopen(argv[1], "rb");
|
|
if (!in_file) {
|
|
std::cerr << "Cannot open input file " << argv[1] << std::endl;
|
|
exit(1);
|
|
}
|
|
std::cout << "Input file: " << argv[1] << std::endl;
|
|
|
|
FILE* out_file = fopen(argv[2], "wb");
|
|
if (!in_file) {
|
|
std::cerr << "Cannot open output file " << argv[2] << std::endl;
|
|
exit(1);
|
|
}
|
|
std::cout << "Output file: " << argv[2] << std::endl;
|
|
|
|
// Check if a replacement audio file was provided, and if so, open it.
|
|
bool replace_payload = false;
|
|
webrtc::scoped_ptr<webrtc::test::InputAudioFile> replacement_audio_file;
|
|
if (!FLAGS_replacement_audio_file.empty()) {
|
|
replacement_audio_file.reset(
|
|
new webrtc::test::InputAudioFile(FLAGS_replacement_audio_file));
|
|
replace_payload = true;
|
|
}
|
|
|
|
// Read RTP file header.
|
|
if (NETEQTEST_RTPpacket::skipFileHeader(in_file) != 0) {
|
|
std::cerr << "Wrong format in RTP file" << std::endl;
|
|
exit(1);
|
|
}
|
|
|
|
// Enable tracing.
|
|
webrtc::Trace::CreateTrace();
|
|
webrtc::Trace::SetTraceFile((webrtc::test::OutputPath() +
|
|
"neteq_trace.txt").c_str());
|
|
webrtc::Trace::set_level_filter(webrtc::kTraceAll);
|
|
|
|
// Initialize NetEq instance.
|
|
int sample_rate_hz = 16000;
|
|
NetEq* neteq = NetEq::Create(sample_rate_hz);
|
|
RegisterPayloadTypes(neteq);
|
|
|
|
// Read first packet.
|
|
NETEQTEST_RTPpacket* rtp;
|
|
NETEQTEST_RTPpacket* next_rtp = NULL;
|
|
if (!FLAGS_dummy_rtp) {
|
|
rtp = new NETEQTEST_RTPpacket();
|
|
if (replace_payload) {
|
|
next_rtp = new NETEQTEST_RTPpacket();
|
|
}
|
|
} else {
|
|
rtp = new NETEQTEST_DummyRTPpacket();
|
|
if (replace_payload) {
|
|
next_rtp = new NETEQTEST_DummyRTPpacket();
|
|
}
|
|
}
|
|
rtp->readFromFile(in_file);
|
|
if (rtp->dataLen() < 0) {
|
|
std::cout << "Warning: RTP file is empty" << std::endl;
|
|
}
|
|
|
|
// Set up variables for audio replacement if needed.
|
|
size_t input_frame_size_timestamps = 0;
|
|
webrtc::scoped_ptr<int16_t[]> replacement_audio;
|
|
webrtc::scoped_ptr<uint8_t[]> payload;
|
|
size_t payload_mem_size_bytes = 0;
|
|
if (replace_payload) {
|
|
// Initially assume that the frame size is 30 ms at the initial sample rate.
|
|
// This value will be replaced with the correct one as soon as two
|
|
// consecutive packets are found.
|
|
input_frame_size_timestamps = 30 * sample_rate_hz / 1000;
|
|
replacement_audio.reset(new int16_t[input_frame_size_timestamps]);
|
|
payload_mem_size_bytes = 2 * input_frame_size_timestamps;
|
|
payload.reset(new uint8_t[payload_mem_size_bytes]);
|
|
assert(next_rtp);
|
|
next_rtp->readFromFile(in_file);
|
|
}
|
|
|
|
// This is the main simulation loop.
|
|
int time_now_ms = rtp->time(); // Start immediately with the first packet.
|
|
int next_input_time_ms = rtp->time();
|
|
int next_output_time_ms = time_now_ms;
|
|
if (time_now_ms % kOutputBlockSizeMs != 0) {
|
|
// Make sure that next_output_time_ms is rounded up to the next multiple
|
|
// of kOutputBlockSizeMs. (Legacy bit-exactness.)
|
|
next_output_time_ms +=
|
|
kOutputBlockSizeMs - time_now_ms % kOutputBlockSizeMs;
|
|
}
|
|
while (rtp->dataLen() >= 0) {
|
|
// Check if it is time to insert packet.
|
|
while (time_now_ms >= next_input_time_ms && rtp->dataLen() >= 0) {
|
|
if (rtp->dataLen() > 0) {
|
|
// Parse RTP header.
|
|
WebRtcRTPHeader rtp_header;
|
|
rtp->parseHeader(&rtp_header);
|
|
uint8_t* payload_ptr = rtp->payload();
|
|
size_t payload_len = rtp->payloadLen();
|
|
if (replace_payload) {
|
|
payload_len = ReplacePayload(replacement_audio_file.get(),
|
|
&replacement_audio,
|
|
&payload,
|
|
&payload_mem_size_bytes,
|
|
&input_frame_size_timestamps,
|
|
&rtp_header,
|
|
next_rtp);
|
|
payload_ptr = payload.get();
|
|
}
|
|
int error = neteq->InsertPacket(rtp_header, payload_ptr,
|
|
static_cast<int>(payload_len),
|
|
rtp->time() * sample_rate_hz / 1000);
|
|
if (error != NetEq::kOK) {
|
|
std::cerr << "InsertPacket returned error code " <<
|
|
neteq->LastError() << std::endl;
|
|
}
|
|
}
|
|
// Get next packet from file.
|
|
rtp->readFromFile(in_file);
|
|
if (replace_payload) {
|
|
// At this point |rtp| contains the packet *after* |next_rtp|.
|
|
// Swap RTP packet objects between |rtp| and |next_rtp|.
|
|
NETEQTEST_RTPpacket* temp_rtp = rtp;
|
|
rtp = next_rtp;
|
|
next_rtp = temp_rtp;
|
|
}
|
|
next_input_time_ms = rtp->time();
|
|
}
|
|
|
|
// Check if it is time to get output audio.
|
|
if (time_now_ms >= next_output_time_ms) {
|
|
static const int kOutDataLen = kOutputBlockSizeMs * kMaxSamplesPerMs *
|
|
kMaxChannels;
|
|
int16_t out_data[kOutDataLen];
|
|
int num_channels;
|
|
int samples_per_channel;
|
|
int error = neteq->GetAudio(kOutDataLen, out_data, &samples_per_channel,
|
|
&num_channels, NULL);
|
|
if (error != NetEq::kOK) {
|
|
std::cerr << "GetAudio returned error code " <<
|
|
neteq->LastError() << std::endl;
|
|
} else {
|
|
// Calculate sample rate from output size.
|
|
sample_rate_hz = 1000 * samples_per_channel / kOutputBlockSizeMs;
|
|
}
|
|
|
|
// Write to file.
|
|
// TODO(hlundin): Make writing to file optional.
|
|
size_t write_len = samples_per_channel * num_channels;
|
|
if (fwrite(out_data, sizeof(out_data[0]), write_len, out_file) !=
|
|
write_len) {
|
|
std::cerr << "Error while writing to file" << std::endl;
|
|
webrtc::Trace::ReturnTrace();
|
|
exit(1);
|
|
}
|
|
next_output_time_ms += kOutputBlockSizeMs;
|
|
}
|
|
// Advance time to next event.
|
|
time_now_ms = std::min(next_input_time_ms, next_output_time_ms);
|
|
}
|
|
|
|
std::cout << "Simulation done" << std::endl;
|
|
|
|
fclose(in_file);
|
|
fclose(out_file);
|
|
delete rtp;
|
|
delete next_rtp;
|
|
delete neteq;
|
|
webrtc::Trace::ReturnTrace();
|
|
return 0;
|
|
}
|
|
|
|
|
|
// Help functions.
|
|
|
|
// Maps a codec type to a printable name string.
|
|
std::string CodecName(webrtc::NetEqDecoder codec) {
|
|
switch (codec) {
|
|
case webrtc::kDecoderPCMu:
|
|
return "PCM-u";
|
|
case webrtc::kDecoderPCMa:
|
|
return "PCM-a";
|
|
case webrtc::kDecoderILBC:
|
|
return "iLBC";
|
|
case webrtc::kDecoderISAC:
|
|
return "iSAC";
|
|
case webrtc::kDecoderISACswb:
|
|
return "iSAC-swb (32 kHz)";
|
|
case webrtc::kDecoderPCM16B:
|
|
return "PCM16b-nb (8 kHz)";
|
|
case webrtc::kDecoderPCM16Bwb:
|
|
return "PCM16b-wb (16 kHz)";
|
|
case webrtc::kDecoderPCM16Bswb32kHz:
|
|
return "PCM16b-swb32 (32 kHz)";
|
|
case webrtc::kDecoderPCM16Bswb48kHz:
|
|
return "PCM16b-swb48 (48 kHz)";
|
|
case webrtc::kDecoderG722:
|
|
return "G.722";
|
|
case webrtc::kDecoderRED:
|
|
return "redundant audio (RED)";
|
|
case webrtc::kDecoderAVT:
|
|
return "AVT/DTMF";
|
|
case webrtc::kDecoderCNGnb:
|
|
return "comfort noise (8 kHz)";
|
|
case webrtc::kDecoderCNGwb:
|
|
return "comfort noise (16 kHz)";
|
|
case webrtc::kDecoderCNGswb32kHz:
|
|
return "comfort noise (32 kHz)";
|
|
case webrtc::kDecoderCNGswb48kHz:
|
|
return "comfort noise (48 kHz)";
|
|
default:
|
|
assert(false);
|
|
return "undefined";
|
|
}
|
|
}
|
|
|
|
// Registers all decoders in |neteq|.
|
|
void RegisterPayloadTypes(NetEq* neteq) {
|
|
assert(neteq);
|
|
int error;
|
|
error = neteq->RegisterPayloadType(webrtc::kDecoderPCMu, FLAGS_pcmu);
|
|
if (error) {
|
|
std::cerr << "Cannot register payload type " << FLAGS_pcmu <<
|
|
" as " << CodecName(webrtc::kDecoderPCMu).c_str() << std::endl;
|
|
exit(1);
|
|
}
|
|
error = neteq->RegisterPayloadType(webrtc::kDecoderPCMa, FLAGS_pcma);
|
|
if (error) {
|
|
std::cerr << "Cannot register payload type " << FLAGS_pcma <<
|
|
" as " << CodecName(webrtc::kDecoderPCMa).c_str() << std::endl;
|
|
exit(1);
|
|
}
|
|
error = neteq->RegisterPayloadType(webrtc::kDecoderILBC, FLAGS_ilbc);
|
|
if (error) {
|
|
std::cerr << "Cannot register payload type " << FLAGS_ilbc <<
|
|
" as " << CodecName(webrtc::kDecoderILBC).c_str() << std::endl;
|
|
exit(1);
|
|
}
|
|
error = neteq->RegisterPayloadType(webrtc::kDecoderISAC, FLAGS_isac);
|
|
if (error) {
|
|
std::cerr << "Cannot register payload type " << FLAGS_isac <<
|
|
" as " << CodecName(webrtc::kDecoderISAC).c_str() << std::endl;
|
|
exit(1);
|
|
}
|
|
error = neteq->RegisterPayloadType(webrtc::kDecoderISACswb, FLAGS_isac_swb);
|
|
if (error) {
|
|
std::cerr << "Cannot register payload type " << FLAGS_isac_swb <<
|
|
" as " << CodecName(webrtc::kDecoderISACswb).c_str() << std::endl;
|
|
exit(1);
|
|
}
|
|
error = neteq->RegisterPayloadType(webrtc::kDecoderPCM16B, FLAGS_pcm16b);
|
|
if (error) {
|
|
std::cerr << "Cannot register payload type " << FLAGS_pcm16b <<
|
|
" as " << CodecName(webrtc::kDecoderPCM16B).c_str() << std::endl;
|
|
exit(1);
|
|
}
|
|
error = neteq->RegisterPayloadType(webrtc::kDecoderPCM16Bwb,
|
|
FLAGS_pcm16b_wb);
|
|
if (error) {
|
|
std::cerr << "Cannot register payload type " << FLAGS_pcm16b_wb <<
|
|
" as " << CodecName(webrtc::kDecoderPCM16Bwb).c_str() << std::endl;
|
|
exit(1);
|
|
}
|
|
error = neteq->RegisterPayloadType(webrtc::kDecoderPCM16Bswb32kHz,
|
|
FLAGS_pcm16b_swb32);
|
|
if (error) {
|
|
std::cerr << "Cannot register payload type " << FLAGS_pcm16b_swb32 <<
|
|
" as " << CodecName(webrtc::kDecoderPCM16Bswb32kHz).c_str() <<
|
|
std::endl;
|
|
exit(1);
|
|
}
|
|
error = neteq->RegisterPayloadType(webrtc::kDecoderPCM16Bswb48kHz,
|
|
FLAGS_pcm16b_swb48);
|
|
if (error) {
|
|
std::cerr << "Cannot register payload type " << FLAGS_pcm16b_swb48 <<
|
|
" as " << CodecName(webrtc::kDecoderPCM16Bswb48kHz).c_str() <<
|
|
std::endl;
|
|
exit(1);
|
|
}
|
|
error = neteq->RegisterPayloadType(webrtc::kDecoderG722, FLAGS_g722);
|
|
if (error) {
|
|
std::cerr << "Cannot register payload type " << FLAGS_g722 <<
|
|
" as " << CodecName(webrtc::kDecoderG722).c_str() << std::endl;
|
|
exit(1);
|
|
}
|
|
error = neteq->RegisterPayloadType(webrtc::kDecoderAVT, FLAGS_avt);
|
|
if (error) {
|
|
std::cerr << "Cannot register payload type " << FLAGS_avt <<
|
|
" as " << CodecName(webrtc::kDecoderAVT).c_str() << std::endl;
|
|
exit(1);
|
|
}
|
|
error = neteq->RegisterPayloadType(webrtc::kDecoderRED, FLAGS_red);
|
|
if (error) {
|
|
std::cerr << "Cannot register payload type " << FLAGS_red <<
|
|
" as " << CodecName(webrtc::kDecoderRED).c_str() << std::endl;
|
|
exit(1);
|
|
}
|
|
error = neteq->RegisterPayloadType(webrtc::kDecoderCNGnb, FLAGS_cn_nb);
|
|
if (error) {
|
|
std::cerr << "Cannot register payload type " << FLAGS_cn_nb <<
|
|
" as " << CodecName(webrtc::kDecoderCNGnb).c_str() << std::endl;
|
|
exit(1);
|
|
}
|
|
error = neteq->RegisterPayloadType(webrtc::kDecoderCNGwb, FLAGS_cn_wb);
|
|
if (error) {
|
|
std::cerr << "Cannot register payload type " << FLAGS_cn_wb <<
|
|
" as " << CodecName(webrtc::kDecoderCNGwb).c_str() << std::endl;
|
|
exit(1);
|
|
}
|
|
error = neteq->RegisterPayloadType(webrtc::kDecoderCNGswb32kHz,
|
|
FLAGS_cn_swb32);
|
|
if (error) {
|
|
std::cerr << "Cannot register payload type " << FLAGS_cn_swb32 <<
|
|
" as " << CodecName(webrtc::kDecoderCNGswb32kHz).c_str() << std::endl;
|
|
exit(1);
|
|
}
|
|
error = neteq->RegisterPayloadType(webrtc::kDecoderCNGswb48kHz,
|
|
FLAGS_cn_swb48);
|
|
if (error) {
|
|
std::cerr << "Cannot register payload type " << FLAGS_cn_swb48 <<
|
|
" as " << CodecName(webrtc::kDecoderCNGswb48kHz).c_str() << std::endl;
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
void PrintCodecMapping() {
|
|
std::cout << CodecName(webrtc::kDecoderPCMu).c_str() << ": " << FLAGS_pcmu <<
|
|
std::endl;
|
|
std::cout << CodecName(webrtc::kDecoderPCMa).c_str() << ": " << FLAGS_pcma <<
|
|
std::endl;
|
|
std::cout << CodecName(webrtc::kDecoderILBC).c_str() << ": " << FLAGS_ilbc <<
|
|
std::endl;
|
|
std::cout << CodecName(webrtc::kDecoderISAC).c_str() << ": " << FLAGS_isac <<
|
|
std::endl;
|
|
std::cout << CodecName(webrtc::kDecoderISACswb).c_str() << ": " <<
|
|
FLAGS_isac_swb << std::endl;
|
|
std::cout << CodecName(webrtc::kDecoderPCM16B).c_str() << ": " <<
|
|
FLAGS_pcm16b << std::endl;
|
|
std::cout << CodecName(webrtc::kDecoderPCM16Bwb).c_str() << ": " <<
|
|
FLAGS_pcm16b_wb << std::endl;
|
|
std::cout << CodecName(webrtc::kDecoderPCM16Bswb32kHz).c_str() << ": " <<
|
|
FLAGS_pcm16b_swb32 << std::endl;
|
|
std::cout << CodecName(webrtc::kDecoderPCM16Bswb48kHz).c_str() << ": " <<
|
|
FLAGS_pcm16b_swb48 << std::endl;
|
|
std::cout << CodecName(webrtc::kDecoderG722).c_str() << ": " << FLAGS_g722 <<
|
|
std::endl;
|
|
std::cout << CodecName(webrtc::kDecoderAVT).c_str() << ": " << FLAGS_avt <<
|
|
std::endl;
|
|
std::cout << CodecName(webrtc::kDecoderRED).c_str() << ": " << FLAGS_red <<
|
|
std::endl;
|
|
std::cout << CodecName(webrtc::kDecoderCNGnb).c_str() << ": " <<
|
|
FLAGS_cn_nb << std::endl;
|
|
std::cout << CodecName(webrtc::kDecoderCNGwb).c_str() << ": " <<
|
|
FLAGS_cn_wb << std::endl;
|
|
std::cout << CodecName(webrtc::kDecoderCNGswb32kHz).c_str() << ": " <<
|
|
FLAGS_cn_swb32 << std::endl;
|
|
std::cout << CodecName(webrtc::kDecoderCNGswb48kHz).c_str() << ": " <<
|
|
FLAGS_cn_swb48 << std::endl;
|
|
}
|
|
|
|
size_t ReplacePayload(webrtc::test::InputAudioFile* replacement_audio_file,
|
|
webrtc::scoped_ptr<int16_t[]>* replacement_audio,
|
|
webrtc::scoped_ptr<uint8_t[]>* payload,
|
|
size_t* payload_mem_size_bytes,
|
|
size_t* frame_size_samples,
|
|
WebRtcRTPHeader* rtp_header,
|
|
NETEQTEST_RTPpacket* next_rtp) {
|
|
size_t payload_len = 0;
|
|
// Check for CNG.
|
|
if (IsComfortNosie(rtp_header->header.payloadType)) {
|
|
// If CNG, simply insert a zero-energy one-byte payload.
|
|
if (*payload_mem_size_bytes < 1) {
|
|
(*payload).reset(new uint8_t[1]);
|
|
*payload_mem_size_bytes = 1;
|
|
}
|
|
(*payload)[0] = 127; // Max attenuation of CNG.
|
|
payload_len = 1;
|
|
} else {
|
|
if (next_rtp->payloadLen() > 0) {
|
|
// Check if payload length has changed.
|
|
if (next_rtp->sequenceNumber() == rtp_header->header.sequenceNumber + 1) {
|
|
if (*frame_size_samples !=
|
|
next_rtp->timeStamp() - rtp_header->header.timestamp) {
|
|
*frame_size_samples =
|
|
next_rtp->timeStamp() - rtp_header->header.timestamp;
|
|
(*replacement_audio).reset(
|
|
new int16_t[*frame_size_samples]);
|
|
*payload_mem_size_bytes = 2 * *frame_size_samples;
|
|
(*payload).reset(new uint8_t[*payload_mem_size_bytes]);
|
|
}
|
|
}
|
|
}
|
|
// Get new speech.
|
|
assert((*replacement_audio).get());
|
|
if (CodecTimestampRate(rtp_header->header.payloadType) !=
|
|
CodecSampleRate(rtp_header->header.payloadType) ||
|
|
rtp_header->header.payloadType == FLAGS_red ||
|
|
rtp_header->header.payloadType == FLAGS_avt) {
|
|
// Some codecs have different sample and timestamp rates. And neither
|
|
// RED nor DTMF is supported for replacement.
|
|
std::cerr << "Codec not supported for audio replacement." <<
|
|
std::endl;
|
|
webrtc::Trace::ReturnTrace();
|
|
exit(1);
|
|
}
|
|
assert(*frame_size_samples > 0);
|
|
if (!replacement_audio_file->Read(*frame_size_samples,
|
|
(*replacement_audio).get())) {
|
|
std::cerr << "Could no read replacement audio file." << std::endl;
|
|
webrtc::Trace::ReturnTrace();
|
|
exit(1);
|
|
}
|
|
// Encode it as PCM16.
|
|
assert((*payload).get());
|
|
payload_len = WebRtcPcm16b_Encode((*replacement_audio).get(),
|
|
static_cast<int16_t>(*frame_size_samples),
|
|
(*payload).get());
|
|
assert(payload_len == 2 * *frame_size_samples);
|
|
// Change payload type to PCM16.
|
|
switch (CodecSampleRate(rtp_header->header.payloadType)) {
|
|
case 8000:
|
|
rtp_header->header.payloadType = FLAGS_pcm16b;
|
|
break;
|
|
case 16000:
|
|
rtp_header->header.payloadType = FLAGS_pcm16b_wb;
|
|
break;
|
|
case 32000:
|
|
rtp_header->header.payloadType = FLAGS_pcm16b_swb32;
|
|
break;
|
|
case 48000:
|
|
rtp_header->header.payloadType = FLAGS_pcm16b_swb48;
|
|
break;
|
|
default:
|
|
std::cerr << "Payload type " <<
|
|
static_cast<int>(rtp_header->header.payloadType) <<
|
|
" not supported or unknown." << std::endl;
|
|
webrtc::Trace::ReturnTrace();
|
|
exit(1);
|
|
assert(false);
|
|
}
|
|
}
|
|
return payload_len;
|
|
}
|
|
|
|
int CodecSampleRate(uint8_t payload_type) {
|
|
if (payload_type == FLAGS_pcmu ||
|
|
payload_type == FLAGS_pcma ||
|
|
payload_type == FLAGS_ilbc ||
|
|
payload_type == FLAGS_pcm16b ||
|
|
payload_type == FLAGS_cn_nb) {
|
|
return 8000;
|
|
} else if (payload_type == FLAGS_isac ||
|
|
payload_type == FLAGS_pcm16b_wb ||
|
|
payload_type == FLAGS_g722 ||
|
|
payload_type == FLAGS_cn_wb) {
|
|
return 16000;
|
|
} else if (payload_type == FLAGS_isac_swb ||
|
|
payload_type == FLAGS_pcm16b_swb32 ||
|
|
payload_type == FLAGS_cn_swb32) {
|
|
return 32000;
|
|
} else if (payload_type == FLAGS_pcm16b_swb48 ||
|
|
payload_type == FLAGS_cn_swb48) {
|
|
return 48000;
|
|
} else if (payload_type == FLAGS_avt ||
|
|
payload_type == FLAGS_red) {
|
|
return 0;
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
int CodecTimestampRate(uint8_t payload_type) {
|
|
if (payload_type == FLAGS_g722) {
|
|
return 8000;
|
|
} else {
|
|
return CodecSampleRate(payload_type);
|
|
}
|
|
}
|
|
|
|
bool IsComfortNosie(uint8_t payload_type) {
|
|
if (payload_type == FLAGS_cn_nb ||
|
|
payload_type == FLAGS_cn_wb ||
|
|
payload_type == FLAGS_cn_swb32 ||
|
|
payload_type == FLAGS_cn_swb48) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|