// Copyright (c) 2012-2017 VideoStitch SAS
// Copyright (c) 2018 stitchEm
#include "gpu/testing.hpp"
#include "common/audioUtils.hpp"
#include "libvideostitch/audio.hpp"
#include <audio/converter.hpp>
#include <audio/resampler.hpp>
#include <cmath>
#include <iostream>
namespace VideoStitch {
namespace Testing {
using namespace VideoStitch::Audio;
static const size_t nSamples = 3;
void convUINT8_P() {
uint8_t *raw[MAX_AUDIO_CHANNELS];
auto audio = new uint8_t[nSamples * sizeof(uint8_t)];
auto dummy = new uint8_t[nSamples * sizeof(uint8_t)];
raw[0] = audio;
raw[1] = dummy;
uint8_t values[nSamples] = {0, 128, 255};
for (size_t i = 0; i < nSamples; i++) {
*audio++ = values[i];
*dummy++ = 0x55;
}
Samples samples;
{
Samples init(SamplingRate::SR_48000, SamplingDepth::UINT8_P, ChannelLayout::STEREO, 0, raw, nSamples);
samples = init.clone();
}
AudioTrack output(SPEAKER_FRONT_LEFT);
convertSamplesToMonoDouble(samples, output, 2, SamplingDepth::UINT8_P);
std::cout << "UINT8_P: " << output[0] << ", " << output[1] << ", " << output[2] << std::endl;
ENSURE_EQ(-1.0, output[0]); /* -1.0 */
ENSURE_EQ(0.0, output[1]); /* 0.0 */
ENSURE_EQ(1.0, output[2]); /* 1.0 */
}
void convUINT8() {
uint8_t *raw[MAX_AUDIO_CHANNELS];
auto audio = new uint8_t[nSamples * 2 * sizeof(uint8_t)];
raw[0] = audio;
uint8_t values[nSamples] = {0, 128, 255};
for (size_t i = 0; i < nSamples; i++) {
*audio++ = values[i];
*audio++ = 0x55;
}
Samples init;
{
Samples tmp(SamplingRate::SR_48000, SamplingDepth::UINT8, ChannelLayout::STEREO, 0, raw, nSamples);
// operator=(Samples&&)
init = tmp.clone();
}
// Samples(Samples&&)
Samples samples{std::move(init)};
AudioTrack output(SPEAKER_FRONT_LEFT);
convertSamplesToMonoDouble(samples, output, 2, SamplingDepth::UINT8);
std::cout << "UINT8: " << output[0] << ", " << output[1] << ", " << output[2] << std::endl;
ENSURE_EQ(-1.0, output[0]); /* -1.0 */
ENSURE_EQ(0.0, output[1]); /* 0.0 */
ENSURE_EQ(1.0, output[2]); /* 1.0 */
}
void convINT16_P() {
uint8_t *raw[MAX_AUDIO_CHANNELS];
raw[0] = new uint8_t[nSamples * sizeof(int16_t)];
raw[1] = new uint8_t[nSamples * sizeof(int16_t)];
int16_t *audio = (int16_t *)raw[0];
int16_t *dummy = (int16_t *)raw[1];
int16_t values[nSamples] = {static_cast<int16_t>(0x8000), 0, 0x7FFF};
for (size_t i = 0; i < nSamples; i++) {
*audio++ = values[i];
*dummy++ = 0x5555;
}
Samples init;
{
Samples tmp(SamplingRate::SR_48000, SamplingDepth::INT16_P, ChannelLayout::STEREO, 0, raw, nSamples);
// operator=(Samples&&)
init = tmp.clone();
}
// Samples(Samples&&)
Samples samples{std::move(init)};
AudioTrack output(SPEAKER_FRONT_LEFT);
convertSamplesToMonoDouble(samples, output, 2, SamplingDepth::INT16_P);
std::cout << "INT16_P: " << output[0] << ", " << output[1] << ", " << output[2] << std::endl;
ENSURE_EQ(-1.0, output[0]); /* -1.0 */
ENSURE_EQ(0.0, output[1]); /* 0.0 */
ENSURE_EQ(1.0, output[2]); /* 1.0 */
}
void convINT16() {
uint8_t *raw[MAX_AUDIO_CHANNELS];
raw[0] = new uint8_t[nSamples * 2 * sizeof(int16_t)];
int16_t *audio = (int16_t *)raw[0];
int16_t values[nSamples] = {static_cast<int16_t>(0x8000), 0, 0x7FFF};
for (size_t i = 0; i < nSamples; i++) {
*audio++ = values[i];
*audio++ = 0x5555;
}
Samples samples;
{
Samples init(SamplingRate::SR_48000, SamplingDepth::INT16, ChannelLayout::STEREO, 0, raw, nSamples);
samples = init.clone();
}
AudioTrack output(SPEAKER_FRONT_LEFT);
Audio::convertSamplesToMonoDouble(samples, output, 2, SamplingDepth::INT16);
std::cout << "INT16: " << output[0] << ", " << output[1] << ", " << output[2] << std::endl;
ENSURE_EQ(-1.0, output[0]); /* -1.0 */
ENSURE_EQ(0.0, output[1]); /* 0.0 */
ENSURE_EQ(1.0, output[2]); /* 1.0 */
}
void convINT24_P() {
const size_t sampleBytes = 3;
uint8_t *raw[MAX_AUDIO_CHANNELS];
auto audio = new uint8_t[nSamples * sampleBytes];
auto dummy = new uint8_t[nSamples * sampleBytes];
raw[0] = audio;
raw[1] = dummy;
uint32_t values[nSamples] = {0x800000, 0, 0x7FFFFF};
uint32_t dummyVal = 0x555555;
for (size_t i = 0; i < nSamples; i++) {
audio[i * sampleBytes] = static_cast<uint8_t>(values[i]);
audio[i * sampleBytes + 1] = static_cast<uint8_t>(values[i] >> 8);
audio[i * sampleBytes + 2] = static_cast<uint8_t>(values[i] >> 16);
dummy[i * sampleBytes] = static_cast<uint8_t>(dummyVal);
dummy[i * sampleBytes + 1] = static_cast<uint8_t>(dummyVal >> 8);
dummy[i * sampleBytes + 2] = static_cast<uint8_t>(dummyVal >> 16);
}
Samples samples;
{
Samples init(SamplingRate::SR_48000, SamplingDepth::INT24_P, ChannelLayout::STEREO, 0, raw, nSamples);
samples = init.clone();
}
AudioTrack output(SPEAKER_FRONT_LEFT);
convertSamplesToMonoDouble(samples, output, 2, SamplingDepth::INT24_P);
std::cout << "INT24_P: " << output[0] << ", " << output[1] << ", " << output[2] << std::endl;
ENSURE_EQ(-1.0, output[0]); /* -1.0 */
ENSURE_EQ(0.0, output[1]); /* 0.0 */
ENSURE_EQ(1.0, output[2]); /* 1.0 */
}
void convINT24() {
const size_t sampleBytes = 3;
uint8_t *raw[MAX_AUDIO_CHANNELS];
auto audio = new uint8_t[nSamples * 2 * sampleBytes];
raw[0] = audio;
uint32_t values[nSamples] = {0x800000, 0, 0x7FFFFF};
uint32_t dummyVal = 0x555555;
for (size_t i = 0; i < nSamples; i++) {
audio[2 * i * sampleBytes] = static_cast<uint8_t>(values[i]);
audio[2 * i * sampleBytes + 1] = static_cast<uint8_t>(values[i] >> 8);
audio[2 * i * sampleBytes + 2] = static_cast<uint8_t>(values[i] >> 16);
audio[2 * i * sampleBytes + 3] = static_cast<uint8_t>(dummyVal);
audio[2 * i * sampleBytes + 4] = static_cast<uint8_t>(dummyVal >> 8);
audio[2 * i * sampleBytes + 5] = static_cast<uint8_t>(dummyVal >> 16);
}
Samples samples;
{
Samples init(SamplingRate::SR_48000, SamplingDepth::INT24, ChannelLayout::STEREO, 0, raw, nSamples);
samples = init.clone();
}
AudioTrack output(SPEAKER_FRONT_LEFT);
convertSamplesToMonoDouble(samples, output, 2, SamplingDepth::INT24);
std::cout << "INT24: " << output[0] << ", " << output[1] << ", " << output[2] << std::endl;
ENSURE_EQ(-1.0, output[0]); /* -1.0 */
ENSURE_EQ(0.0, output[1]); /* 0.0 */
ENSURE_EQ(1.0, output[2]); /* 1.0 */
}
void convFLT32_P() {
uint8_t *raw[MAX_AUDIO_CHANNELS];
raw[0] = new uint8_t[nSamples * sizeof(float)];
raw[1] = new uint8_t[nSamples * sizeof(float)];
float *audio = (float *)raw[0];
float *dummy = (float *)raw[1];
float values[nSamples] = {-1.0, 0, 1.0};
for (size_t i = 0; i < nSamples; i++) {
*audio++ = values[i];
*dummy++ = 0.5;
}
Samples samples;
{
Samples init(SamplingRate::SR_48000, SamplingDepth::FLT_P, ChannelLayout::STEREO, 0, raw, nSamples);
samples = init.clone();
}
AudioTrack output(SPEAKER_FRONT_LEFT);
convertSamplesToMonoDouble(samples, output, 2, SamplingDepth::FLT_P);
std::cout << "FLT32_P: " << output[0] << ", " << output[1] << ", " << output[2] << std::endl;
ENSURE_EQ(-1.0, output[0]); /* -1.0 */
ENSURE_EQ(0.0, output[1]); /* 0.0 */
ENSURE_EQ(1.0, output[2]); /* 1.0 */
}
void convFLT32() {
uint8_t *raw[MAX_AUDIO_CHANNELS];
raw[0] = new uint8_t[nSamples * 2 * sizeof(float)];
float *audio = (float *)raw[0];
float values[nSamples] = {-1, 0, 1};
for (size_t i = 0; i < nSamples; i++) {
*audio++ = values[i];
*audio++ = 0.5;
}
Samples samples;
{
Samples init(SamplingRate::SR_48000, SamplingDepth::FLT, ChannelLayout::STEREO, 0, raw, nSamples);
samples = init.clone();
}
AudioTrack output(SPEAKER_FRONT_LEFT);
convertSamplesToMonoDouble(samples, output, 2, SamplingDepth::FLT);
std::cout << "FLT32: " << output[0] << ", " << output[1] << ", " << output[2] << std::endl;
ENSURE_EQ(-1.0, output[0]); /* -1.0 */
ENSURE_EQ(0.0, output[1]); /* 0.0 */
ENSURE_EQ(1.0, output[2]); /* 1.0 */
}
void reInitSamples(audioSample_t *s) {
s[0] = -1.0;
s[1] = 0.;
s[2] = 1.0;
}
void convToPlanar() {
audioSample_t in[3] = {-1.0, 0., 1.0};
{
uint8_t *out = reinterpret_cast<uint8_t *>(in);
int res = convertToSamplesPlanar(in, 3, SamplingDepth::UINT8_P);
ENSURE_EQ(res, 3, "check number of samples converted");
ENSURE_EQ(0, (int)out[0], "check minimum value"); // -1.0 -> 0
ENSURE_EQ(128, (int)out[1], "check value 0"); // 0.0 -> 128
ENSURE_EQ(255, (int)out[2], "check maximum value"); // 1.0 -> 255
std::cout << "Test conversion audioSamples to UINT8_P OK" << std::endl;
reInitSamples(in);
}
{
int16_t *out = reinterpret_cast<int16_t *>(in);
int res = convertToSamplesPlanar(in, 3, SamplingDepth::INT16_P);
ENSURE_EQ(res, 3, "check number of samples converted");
ENSURE_EQ(-32768, (int)out[0], "check minimum value"); // -1.0 -> -32768
ENSURE_EQ(0, (int)out[1], "check value 0"); // 0.0 -> 0
ENSURE_EQ(32767, (int)out[2], "check maximum value"); // 1.0 -> 32767
std::cout << "Test conversion audioSamples to INT16_P OK" << std::endl;
reInitSamples(in);
}
{
int32_t *out = reinterpret_cast<int32_t *>(in);
int res = convertToSamplesPlanar(in, 3, SamplingDepth::INT32_P);
ENSURE_EQ(res, 3, "check number of samples converted");
ENSURE_EQ(INT32_MIN, (int32_t)out[0], "check minimum value"); // -1.0 -> -2147483648
ENSURE_EQ(0, (int32_t)out[1], "check value 0"); // 0.0 -> 0
ENSURE_EQ(INT32_MAX, (int32_t)out[2], "check maximum value"); // 1.0 -> 2147483647
std::cout << "Test conversion audioSamples to INT32_P OK" << std::endl;
reInitSamples(in);
}
{
// TODO test INT24_P
}
{
float *out = reinterpret_cast<float *>(in);
int res = convertToSamplesPlanar(in, 3, SamplingDepth::FLT_P);
ENSURE_EQ(res, 3, "check number of samples converted");
ENSURE_EQ((float)-1., out[0], "check minimum value"); // -1.0 -> -1.0
ENSURE_EQ((float)0., out[1], "check value 0"); // 0.0 -> 0.0
ENSURE_EQ((float)1., out[2], "check maximum value"); // 1.0 -> 1.0
std::cout << "Test conversion audioSamples to FLT_P OK" << std::endl;
reInitSamples(in);
}
{
double *out = reinterpret_cast<double *>(in);
int res = convertToSamplesPlanar(in, 3, SamplingDepth::DBL_P);
ENSURE_EQ(res, 3, "check number of samples converted");
ENSURE_EQ(-1., out[0], "check minimum value"); // -1.0 -> -1.0
ENSURE_EQ(0., out[1], "check value 0"); // 0.0 -> 0.0
ENSURE_EQ(1., out[2], "check maximum value"); // 1.0 -> 1.0
std::cout << "Test conversion audioSamples to DBL_P OK" << std::endl;
reInitSamples(in);
}
}
void testConvInterLeavedData() {
int nSamples = 2;
audioSample_t **inData = new audioSample_t *[MAX_AUDIO_CHANNELS];
ChannelLayout inL = STEREO;
int nChannels = getNbChannelsFromChannelLayout(inL);
inData[0] = (audioSample_t *)calloc(nSamples, sizeof(audioSample_t));
inData[1] = (audioSample_t *)calloc(nSamples, sizeof(audioSample_t));
inData[0][0] = 0.5;
inData[0][1] = 1.;
inData[1][0] = -0.5;
inData[1][1] = -1.;
// Planar Stereo -> interleave UINT8
{
uint8_t *outData = new uint8_t[nSamples * nChannels];
convertToSamplesInterleaved(inData, nChannels, nSamples, outData, SamplingDepth::UINT8);
ENSURE_EQ(192, (int)outData[0], "test interleaver"); /* 0.5 */
ENSURE_EQ(63, (int)outData[1], "test interleaver"); /* -0.5 */
ENSURE_EQ((int)UINT8_MAX, (int)outData[2], "test interleaver"); /* 1.0 */
ENSURE_EQ(0, (int)outData[3], "test interleaver"); /* -1.0 */
std::cout << "test planar stereo -> interleave UINT8 OK" << std::endl;
delete[] outData;
}
// Planar Stereo -> interleave INT16
{
int16_t *outData = new int16_t[nSamples * nChannels];
convertToSamplesInterleaved(inData, nChannels, nSamples, (uint8_t *)outData, SamplingDepth::INT16);
ENSURE_EQ(INT16_MAX / 2 + 1, (int)outData[0], "test interleaver"); /* 0.5 */
ENSURE_EQ(INT16_MIN / 2, (int)outData[1], "test interleaver"); /* -0.5 */
ENSURE_EQ((int)INT16_MAX, (int)outData[2], "test interleaver"); /* 1.0 */
ENSURE_EQ(INT16_MIN, (int)outData[3], "test interleaver"); /* -1.0 */
delete[] outData;
std::cout << "test planar stereo -> interleave INT16 OK" << std::endl;
}
// Planar Stereo -> interleave INT24
{
uint8_t *outData = new uint8_t[nSamples * nChannels * 3];
convertToSamplesInterleaved(inData, nChannels, nSamples, (uint8_t *)outData, SamplingDepth::INT24);
int tmp;
std::memcpy(&tmp, outData, sizeof(int));
ENSURE_EQ(INT24_MAX / 2 + 1, tmp, "test interleaver"); /* 0.5 */
std::memcpy(&tmp, outData + 3, sizeof(int));
ENSURE_EQ(INT24_MIN / 2, tmp, "test interleaver"); /* -0.5 */
std::memcpy(&tmp, outData + 6, sizeof(int));
ENSURE_EQ(INT24_MAX, tmp, "test interleaver"); /* 1.0 */
delete[] outData;
std::cout << "test planar stereo -> interleave INT24 OK" << std::endl;
}
// Planar Stereo -> interleave INT32
{
int32_t *outData = new int32_t[nSamples * nChannels];
convertToSamplesInterleaved(inData, nChannels, nSamples, (uint8_t *)outData, SamplingDepth::INT32);
ENSURE_EQ(INT32_MAX / 2 + 1, (int)outData[0], "test interleaver"); /* 0.5 */
ENSURE_EQ(INT32_MIN / 2, (int)outData[1], "test interleaver"); /* -0.5 */
ENSURE_EQ(INT32_MAX, (int)outData[2], "test interleaver"); /* 1.0 */
ENSURE_EQ(INT32_MIN, (int)outData[3], "test interleaver"); /* -1.0 */
delete[] outData;
std::cout << "test planar stereo -> interleave INT32 OK" << std::endl;
}
// Planar Stereo -> interleave FLT
{
float *outData = new float[nSamples * nChannels];
convertToSamplesInterleaved(inData, nChannels, nSamples, (uint8_t *)outData, SamplingDepth::FLT);
ENSURE_EQ(outData[0], (float)inData[0][0], "test interleaver");
ENSURE_EQ(outData[1], (float)inData[1][0], "test interleaver");
ENSURE_EQ(outData[2], (float)inData[0][1], "test interleaver");
ENSURE_EQ(outData[3], (float)inData[1][1], "test interleaver");
delete[] outData;
std::cout << "test planar stereo -> interleave FLT OK" << std::endl;
}
// Planar Stereo -> interleave DBL
{
double *outData = new double[nSamples * nChannels];
convertToSamplesInterleaved(inData, nChannels, nSamples, (uint8_t *)outData, SamplingDepth::DBL);
ENSURE_EQ(inData[0][0], outData[0], "test interleaver"); /* 0.5 */
ENSURE_EQ(inData[1][0], outData[1], "test interleaver"); /* -0.5 */
ENSURE_EQ(inData[0][1], outData[2], "test interleaver"); /* 1.0 */
ENSURE_EQ(inData[1][1], outData[3], "test interleaver"); /* -1.0 */
delete[] outData;
std::cout << "test planar stereo -> interleave DBL OK" << std::endl;
}
free(inData[0]);
free(inData[1]);
delete[] inData;
}
audioSample_t **callocTestata(int nSamples, ChannelLayout l) {
audioSample_t **data = new audioSample_t *[MAX_AUDIO_CHANNELS];
ChannelMap mask = SPEAKER_FRONT_LEFT;
for (int i = 0; i < MAX_AUDIO_CHANNELS; i++) {
if (mask & l) {
data[i] = (audioSample_t *)calloc(nSamples, sizeof(audioSample_t));
} else {
data[i] = nullptr;
}
mask = (ChannelMap)(mask << 1);
}
return data;
}
void freeTestata(audioSample_t **data) {
for (int i = 0; i < MAX_AUDIO_CHANNELS; i++) {
if (data[i]) {
free(data[i]);
}
}
free(data);
}
audioSample_t **initData(int nSamples, ChannelLayout l) {
audioSample_t **data = new audioSample_t *[MAX_AUDIO_CHANNELS];
ChannelMap mask = SPEAKER_FRONT_LEFT;
for (int i = 0; i < MAX_AUDIO_CHANNELS; i++) {
if (mask & l) {
data[i] = (audioSample_t *)calloc(nSamples, sizeof(audioSample_t));
data[i][0] = 1.;
data[i][1] = 2.;
} else {
data[i] = nullptr;
}
mask = (ChannelMap)(mask << 1);
}
return data;
}
void testMonoConversion(ChannelLayout inL, ChannelLayout outL) {
AudioBlock inData;
Samples outData;
inData.setChannelLayout(inL);
inData.resize(3);
inData[SPEAKER_FRONT_LEFT][0] = 1.;
inData[SPEAKER_FRONT_LEFT][1] = 2.;
inData[SPEAKER_FRONT_LEFT][2] = 3.;
AudioResampler *rsp = AudioResampler::create(SamplingRate::SR_22050, SamplingDepth::DBL_P, SamplingRate::SR_22050,
SamplingDepth::DBL_P, outL, 3);
rsp->resample(inData, outData);
ENSURE_EQ((int)SamplingDepth::DBL_P, (int)outData.getSamplingDepth(),
"Check sampling depth"); // just in case the resampler is going crazy
ENSURE_EQ((int)SamplingRate::SR_22050, (int)outData.getSamplingRate(),
"Check sampling rate"); // just in case the resampler is going crazy
ENSURE_EQ(outL, outData.getChannelLayout(), "Check output channel layout");
ENSURE_EQ(3, (int)outData.getNbOfSamples(), "Check nb samples");
audioSample_t **dbl = (audioSample_t **)outData.getSamples().data();
/// Check pan law conversion for MONO to any layout without center channel
/// In that case, the mono signal is duplicated on the front_left and the front_right channel with a -4.5 dB
/// attenuation
ChannelMap m = (ChannelMap)0x1;
bool hasCenterSpeaker = (((SPEAKER_FRONT_CENTER | SPEAKER_BACK_CENTER) & outL) != 0);
for (int c = 0; c < MAX_AUDIO_CHANNELS; ++c) {
m = (ChannelMap)((int64_t)(m) << 1);
for (int s = 0; s < 3; ++s) {
if (m & SPEAKER_FRONT_CENTER & outL) {
// Check front center speaker
ENSURE_EQ(inData[SPEAKER_FRONT_LEFT][s], dbl[getChannelIndexFromChannelMap(m)][s],
"Check front center output samples");
} else if (m & SPEAKER_BACK_CENTER & outL && !(SPEAKER_FRONT_CENTER & outL)) {
// Check back center speaker if no front center speaker
ENSURE_EQ(inData[SPEAKER_FRONT_LEFT][s], dbl[getChannelIndexFromChannelMap(m)][s],
"Check back center output samples");
} else if (m & SPEAKER_FRONT_LEFT && !hasCenterSpeaker) {
// Check left channel if no center speaker
ENSURE_EQ(kMonoToStereoNorm * inData[SPEAKER_FRONT_LEFT][s], dbl[getChannelIndexFromChannelMap(m)][s],
"Check front left output samples");
} else if (m & SPEAKER_FRONT_RIGHT && !hasCenterSpeaker) {
// Check right channel if no center speaker
ENSURE_EQ(kMonoToStereoNorm * inData[SPEAKER_FRONT_LEFT][s], dbl[getChannelIndexFromChannelMap(m)][s],
"Check front right output samples");
} else if (m & outL) {
// other speakers should be set to zero
std::stringstream ss;
ss << "Check output samples of " << getStringFromChannelType(m);
ENSURE_EQ((audioSample_t)0, dbl[getChannelIndexFromChannelMap(m)][s], ss.str().c_str());
}
}
}
delete rsp;
}
void testAnyOtherConversion(ChannelLayout inL, ChannelLayout outL) {
std::cout << "Test conversion " << getStringFromChannelLayout(inL) << " to " << getStringFromChannelLayout(outL)
<< std::endl;
ChannelLayout intersect = (ChannelLayout)(inL & outL);
// assert( intersect != outL );
assert(inL != MONO);
AudioBlock inData;
Samples outData;
inData.setChannelLayout(inL);
inData.resize(3);
ChannelMap m = (ChannelMap)0x1;
for (int c = 0; c < MAX_AUDIO_CHANNELS; ++c) {
if (m & inL) {
inData[m][0] = 1.;
inData[m][1] = 2.;
inData[m][2] = 3.;
}
m = (ChannelMap)((int64_t)(m) << 1);
}
AudioResampler *rsp = AudioResampler::create(SamplingRate::SR_22050, SamplingDepth::DBL_P, SamplingRate::SR_22050,
SamplingDepth::DBL_P, outL, 3);
rsp->resample(inData, outData);
ENSURE_EQ((int)SamplingDepth::DBL_P, (int)outData.getSamplingDepth(),
"Check sampling depth"); // just in case the resampler is going crazy
ENSURE_EQ((int)SamplingRate::SR_22050, (int)outData.getSamplingRate(),
"Check sampling rate"); // just in case the resampler is going crazy
ENSURE_EQ(outL, outData.getChannelLayout(), "Check output channel layout");
ENSURE_EQ(3, (int)outData.getNbOfSamples(), "Check nb samples");
audioSample_t **dbl = (audioSample_t **)outData.getSamples().data();
m = (ChannelMap)0x1;
for (int c = 0; c < MAX_AUDIO_CHANNELS; ++c) {
for (int s = 0; s < 3; ++s) {
if (m & intersect) {
ENSURE_EQ(inData[m][s], dbl[getChannelIndexFromChannelMap(m)][s], "Check sample value");
} else if (m & outL) {
ENSURE_EQ(0., dbl[getChannelIndexFromChannelMap(m)][s], "Check sample value");
}
}
m = (ChannelMap)((int64_t)(m) << 1);
}
delete rsp;
}
/// This test tests only the layout conversion by the resampler
/// That's why we force the sampling rate and the sampling depth to be the same in input and output
/// We check only the output layout and the values of the output samples
void convLayoutSamples() {
std::cout << "Test MONO -> STEREO" << std::endl;
testMonoConversion(MONO, STEREO);
std::cout << "Test MONO -> _2POINT1" << std::endl;
testMonoConversion(MONO, _2POINT1);
std::cout << "Test MONO -> 2_1" << std::endl;
testMonoConversion(MONO, _2_1);
std::cout << "Test MONO -> SURROUND" << std::endl;
testMonoConversion(MONO, SURROUND);
std::cout << "Test MONO -> _3POINT1" << std::endl;
testMonoConversion(MONO, _3POINT1);
std::cout << "Test MONO -> _4POINT0" << std::endl;
testMonoConversion(MONO, _4POINT0);
std::cout << "Test MONO -> _4POINT1" << std::endl;
testMonoConversion(MONO, _4POINT1);
std::cout << "Test MONO -> _2_2" << std::endl;
testMonoConversion(MONO, _2_2);
std::cout << "Test MONO -> QUAD" << std::endl;
testMonoConversion(MONO, QUAD);
std::cout << "Test MONO -> _5POINT0" << std::endl;
testMonoConversion(MONO, _5POINT0);
std::cout << "Test MONO -> _5POINT1" << std::endl;
testMonoConversion(MONO, _5POINT1);
std::cout << "Test MONO -> _5POINT0_BACK" << std::endl;
testMonoConversion(MONO, _5POINT0_BACK);
std::cout << "Test MONO -> _5POINT1_BACK" << std::endl;
testMonoConversion(MONO, _5POINT1_BACK);
std::cout << "Test MONO -> _6POINT0" << std::endl;
testMonoConversion(MONO, _6POINT0);
std::cout << "Test MONO -> _6POINT0_FRONT" << std::endl;
testMonoConversion(MONO, _6POINT0_FRONT);
std::cout << "Test MONO -> HEXAGONAL" << std::endl;
testMonoConversion(MONO, HEXAGONAL);
std::cout << "Test MONO -> _6POINT1" << std::endl;
testMonoConversion(MONO, _6POINT1);
std::cout << "Test MONO -> _6POINT1_BACK" << std::endl;
testMonoConversion(MONO, _6POINT1_BACK);
std::cout << "Test MONO -> _6POINT1_FRONT" << std::endl;
testMonoConversion(MONO, _6POINT1_FRONT);
std::cout << "Test MONO -> _7POINT0" << std::endl;
testMonoConversion(MONO, _7POINT0);
std::cout << "Test MONO -> _7POINT0_FRONT" << std::endl;
testMonoConversion(MONO, _7POINT0_FRONT);
std::cout << "Test MONO -> _7POINT1" << std::endl;
testMonoConversion(MONO, _7POINT1);
std::cout << "Test MONO -> _7POINT1_WIDE" << std::endl;
testMonoConversion(MONO, _7POINT1_WIDE);
std::cout << "Test MONO -> _7POINT1_WIDE_BACK" << std::endl;
testMonoConversion(MONO, _7POINT1_WIDE_BACK);
std::cout << "Test MONO -> OCTAGONAL" << std::endl;
testMonoConversion(MONO, OCTAGONAL);
std::vector<ChannelLayout> layouts = {UNKNOWN, MONO,
STEREO, _2POINT1,
_2_1, SURROUND,
_3POINT1, _4POINT0,
_4POINT1, _2_2,
QUAD, _5POINT0,
_5POINT1, _5POINT0_BACK,
_5POINT1_BACK, _6POINT0,
_6POINT0_FRONT, HEXAGONAL,
_6POINT1, _6POINT1_BACK,
_6POINT1_FRONT, _7POINT0,
_7POINT0_FRONT, _7POINT1,
_7POINT1_WIDE, _7POINT1_WIDE_BACK,
OCTAGONAL, AMBISONICS_WXY,
AMBISONICS_WXYZ};
for (auto inL : layouts) {
if (inL != UNKNOWN && inL != MONO && inL != AMBISONICS_WXY && inL != AMBISONICS_WXYZ) {
for (auto outL : layouts) {
if (outL != UNKNOWN && outL != AMBISONICS_WXY && outL != AMBISONICS_WXYZ) {
testAnyOtherConversion(inL, outL);
}
}
}
}
}
///
/// \brief resamplerTest
/// This test the audio resampler
/// \param refPath reference file
/// \param outPath output file
/// \param outrate output sampling rate
///
void resamplerTest(const std::string &refPath, const std::string &outPath, const double outrate) {
int blockSize = 512;
// Read input file
WavReader refFile(refPath);
refFile.printInfo();
ChannelLayout layout = MONO;
if (refFile.getChannels() == 2) {
layout = STEREO;
}
// Create resampler
AudioResampler *rsp = AudioResampler::create(getSamplingRateFromInt(static_cast<int>(refFile.getSampleRate())),
SamplingDepth::DBL_P, getSamplingRateFromInt(static_cast<int>(outrate)),
SamplingDepth::DBL_P, layout, blockSize);
ENSURE_EQ(blockSize, rsp->getBlockSize(), "check resampler block size");
int nSamples = refFile.getnSamples(), nReadSamples = 0;
int nSamplesToRead = nSamples;
int nResampled = 0;
WavWriter outFile(outPath.c_str(), layout, outrate);
while (nSamplesToRead > 0) {
AudioBlock inBlock(layout);
AudioBlock outBlock(layout);
Samples audioInSamples;
// read reference file
if (nSamplesToRead >= blockSize) {
nReadSamples = blockSize;
} else if (nReadSamples > 0) {
nReadSamples = nSamplesToRead;
} else {
break;
}
refFile.step(inBlock, nReadSamples);
// Convert AudioBlock to Samples
audioBlock2Samples(audioInSamples, inBlock);
// Resample Samples to AudioBlock
rsp->resample(audioInSamples, outBlock);
nResampled += outBlock[SPEAKER_FRONT_LEFT].size();
// Write results in outFile
outFile.step(outBlock);
nSamplesToRead -= nReadSamples;
}
outFile.close();
delete rsp;
}
/// Test that there is no crash if the resampler tries to resample to an invalid configuration
void invalidResamplerTest(const std::string &refPath) {
int blockSize = 512;
// Read input file
WavReader refFile(refPath);
refFile.printInfo();
ChannelLayout layout = MONO;
if (refFile.getChannels() == 2) {
layout = STEREO;
}
// Create resampler
std::vector<std::unique_ptr<AudioResampler>> rsps;
{
for (const double outrate : {44100., 48000., 12345., 0., -1.}) {
for (const SamplingDepth depth : {SamplingDepth::FLT, SamplingDepth::SD_NONE}) {
AudioResampler *rsp = AudioResampler::create(
getSamplingRateFromInt(static_cast<int>(refFile.getSampleRate())), SamplingDepth::DBL_P,
getSamplingRateFromInt(static_cast<int>(outrate)), depth, layout, blockSize);
ENSURE_EQ(blockSize, rsp->getBlockSize(), "check resampler block size");
rsps.emplace_back(rsp);
}
}
}
int nSamples = refFile.getnSamples(), nReadSamples = 0;
int nSamplesToRead = nSamples;
while (nSamplesToRead > 0) {
AudioBlock inBlock(layout);
Samples audioInSamples;
// read reference file
if (nSamplesToRead >= blockSize) {
nReadSamples = blockSize;
} else if (nReadSamples > 0) {
nReadSamples = nSamplesToRead;
} else {
break;
}
refFile.step(inBlock, nReadSamples);
// Convert AudioBlock to Samples
audioBlock2Samples(audioInSamples, inBlock);
for (const auto &rsp : rsps) {
AudioBlock outBlock(layout);
Samples inCopy{audioInSamples.clone()};
// Resample Samples to AudioBlock
rsp->resample(inCopy, outBlock);
}
nSamplesToRead -= nReadSamples;
}
}
void testAudioBlockAndInterLeaved() {
AudioBlock in(_3POINT1);
in.resize(3);
in[SPEAKER_FRONT_LEFT][0] = 1;
in[SPEAKER_FRONT_LEFT][1] = 2;
in[SPEAKER_FRONT_LEFT][2] = 3;
in[SPEAKER_FRONT_RIGHT][0] = 4;
in[SPEAKER_FRONT_RIGHT][1] = 5;
in[SPEAKER_FRONT_RIGHT][2] = 6;
in[SPEAKER_FRONT_CENTER][0] = 7;
in[SPEAKER_FRONT_CENTER][1] = 8;
in[SPEAKER_FRONT_CENTER][2] = 9;
in[SPEAKER_LOW_FREQUENCY][0] = 10;
in[SPEAKER_LOW_FREQUENCY][1] = 11;
in[SPEAKER_LOW_FREQUENCY][2] = 12;
std::unique_ptr<audioSample_t[]> out(
new audioSample_t[in.numSamples() * getNbChannelsFromChannelLayout(in.getLayout())]);
convertAudioBlockToInterleavedSamples(in, out.get());
ENSURE_EQ(1., out.get()[0], "Check sample value.");
ENSURE_EQ(4., out.get()[1], "Check sample value.");
ENSURE_EQ(7., out.get()[2], "Check sample value.");
ENSURE_EQ(10., out.get()[3], "Check sample value.");
ENSURE_EQ(2., out.get()[4], "Check sample value.");
ENSURE_EQ(5., out.get()[5], "Check sample value.");
ENSURE_EQ(8., out.get()[6], "Check sample value.");
ENSURE_EQ(11., out.get()[7], "Check sample value.");
ENSURE_EQ(3., out.get()[8], "Check sample value.");
ENSURE_EQ(6., out.get()[9], "Check sample value.");
ENSURE_EQ(9., out.get()[10], "Check sample value.");
ENSURE_EQ(12., out.get()[11], "Check sample value.");
AudioBlock inAgain;
convertInterleavedSamplesToAudioBlock(out.get(), (int)in.numSamples(), in.getLayout(), inAgain);
ENSURE(inAgain.getLayout() == in.getLayout(), "Check layout");
ENSURE(inAgain.numSamples() == in.numSamples(), "Check layout");
for (const auto &track : inAgain) {
for (size_t s = 0; s < in.numSamples(); s++) {
ENSURE(in[track.channel()][s] == track[s], "Check sample value");
}
}
}
} // namespace Testing
} // namespace VideoStitch
int main(int /* argc */, char ** /* argv */) {
VideoStitch::Testing::initTest();
VideoStitch::Testing::convUINT8_P();
VideoStitch::Testing::convUINT8();
VideoStitch::Testing::convINT16_P();
VideoStitch::Testing::convINT16();
VideoStitch::Testing::convINT24_P();
VideoStitch::Testing::convINT24();
VideoStitch::Testing::convFLT32_P();
VideoStitch::Testing::convFLT32();
VideoStitch::Testing::convToPlanar();
VideoStitch::Testing::convLayoutSamples();
VideoStitch::Testing::testConvInterLeavedData();
VideoStitch::Testing::testAudioBlockAndInterLeaved();
// Test resampler mono 44k1 -> 48k
std::cout << "RUN Test resampler mono 44k1 -> mono 48k" << std::endl;
std::string testData = VideoStitch::Testing::getDataFolder();
VideoStitch::Testing::resamplerTest("data/snd/cos44k1.wav", testData + "/rsp.wav", 48000.);
VideoStitch::Testing::compareWavFile("data/snd/ref_rsp_48k.wav", testData + "/rsp.wav", 0.01, 20);
std::cout << "RUN Test resampler mono 44k1 -> mono 48k : PASSED" << std::endl;
// Test resampler stereo 48k -> stereo 44k1
std::cout << "RUN Test resampler stereo 48k -> stereo 44k1" << std::endl;
VideoStitch::Testing::resamplerTest("data/snd/test_rsp_48k_stereo.wav", testData + "/rsp_stereo.wav", 44100.);
VideoStitch::Testing::compareWavFile("data/snd/ref_rsp_cos44k1_stereo.wav", testData + "/rsp_stereo.wav",
10. / 32267., 20);
std::cout << "Test resampler stereo 48k -> stereo 44k1 : PASSED" << std::endl;
VideoStitch::Testing::invalidResamplerTest("data/snd/ref_rsp_cos44k1_stereo.wav");
return 0;
}