ref: 811e3bd8c5d769c1db99fde1f665054264551c82
dir: /tests/test_opus_custom.c/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
/* FIXME: Is there a better way to get access to opus_custom_decoder_get_size()? */
#ifdef OPUS_BUILD
#undef OPUS_BUILD
#endif
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <math.h>
#include <string.h>
#include <time.h>
#if (!defined WIN32 && !defined _WIN32) || defined(__MINGW32__)
#include <unistd.h>
#else
#include <process.h>
#define getpid _getpid
#endif
#include "opus_multistream.h"
#include "opus.h"
#include "../src/opus_private.h"
#include "test_opus_common.h"
#define MAX_PACKET (1500)
#define PI (3.141592653589793238462643)
#define RAND_SAMPLE(a) (a[fast_rand() % sizeof(a)/sizeof(a[0])])
#define RMS_THRESH (3e-6)
#define SINE_SWEEP_AMPLITUDE (0.5f)
#define SINE_SWEEP_DURATION_S (60.0f)
typedef struct {
void* encoder;
void* decoder;
OpusCustomMode *mode;
int sample_rate;
int num_channels;
int frame_size;
int float_encode;
int float_decode;
int custom_encode;
int custom_decode;
int encoder_bit_depth;
int decoder_bit_depth;
} TestCustomParams;
void* generate_sine_sweep(double amplitude, int bit_depth, int sample_rate, int channels, int use_float, double duration_seconds, int* num_samples_out) {
int i;
int num_samples;
double start_freq = 100.0;
double end_freq = sample_rate / 2.0;
void *output_buffer;
int bytes_per_sample;
/* Calculate the maximum sample value based on bit depth. */
opus_int32 max_sample_value = (1L << (bit_depth - 1)) - 1;
num_samples = (int)floor(.5f + duration_seconds * sample_rate);
/* Allocate memory for the output buffer. */
if (use_float) bit_depth = 32;
bytes_per_sample = (bit_depth == 16) ? 2 : 4;
output_buffer = malloc(num_samples * channels * bytes_per_sample);
if (output_buffer == NULL) {
fprintf(stderr, "Error allocating memory for output buffer.\n");
*num_samples_out = 0;
return NULL;
}
/* Generate the sine sweep/ */
for (i = 0; i < num_samples; i++) {
/* Calculate the time in seconds for the current sample */
double t = (double)i / sample_rate;
/* Calculate the frequency at this time point */
double b = log((end_freq + start_freq) / start_freq) / duration_seconds;
double a = start_freq / b;
double sample = amplitude * sin(2 * PI * a * exp(b * t) - (b * t) - 1);
if (use_float) {
float* output = (float*)output_buffer;
output[i * channels] = (float)sample;
if (channels == 2) {
output[i * channels + 1] = output[i * channels];
}
}
else {
/* Scale and convert to the appropriate integer type based on bit depth */
if (bit_depth == 16) {
opus_int16* output = (opus_int16*)output_buffer;
output[i * channels] = (opus_int16)floor(.5f + sample * max_sample_value);
if (channels == 2) {
output[i * channels + 1] = output[i * channels];
}
}
else if (bit_depth == 24) {
/* Assuming 24-bit samples are stored in 32-bit integers. */
opus_int32* output = (opus_int32*)output_buffer;
output[i * channels] = (opus_int32)floor(.5f + sample * max_sample_value);
if (channels == 2) {
output[i * channels + 1] = output[i * channels];
}
}
}
}
*num_samples_out = num_samples;
return output_buffer;
}
int test_encode(TestCustomParams params) {
int samp_count = 0;
void *inbuf;
void *outbuf;
OpusEncoder* enc = NULL;
OpusDecoder* dec = NULL;
OpusDecoder* dec_copy = NULL;
OpusCustomEncoder* encC = NULL;
OpusCustomDecoder* decC = NULL;
OpusCustomDecoder* decC_copy = NULL;
unsigned char packet[MAX_PACKET+257];
unsigned char packet_corrupt[MAX_PACKET+257];
int len;
int input_samples;
int samples_decoded;
int ret = 0;
#ifdef RESYNTH
int i;
double rmsd = 0;
#endif
int num_channels = params.num_channels;
int frame_size = params.frame_size;
/* Generate input data */
inbuf = generate_sine_sweep(SINE_SWEEP_AMPLITUDE,
params.encoder_bit_depth,
params.sample_rate,
num_channels,
params.float_encode,
SINE_SWEEP_DURATION_S,
&input_samples);
/* Allocate memory for output data */
if (params.float_decode || params.decoder_bit_depth == 24) {
outbuf = malloc(input_samples*num_channels*sizeof(float));
}
else {
outbuf = malloc(input_samples*num_channels*sizeof(opus_int16));
}
if (params.custom_encode) {
encC = (OpusCustomEncoder*)params.encoder;
}
else {
enc = (OpusEncoder*)params.encoder;
}
if (params.custom_decode) {
int size = opus_custom_decoder_get_size(params.mode, params.num_channels);
decC = (OpusCustomDecoder*)params.decoder;
decC_copy = malloc(size);
memcpy(decC_copy, decC, size);
}
else {
int size = opus_decoder_get_size(params.num_channels);
dec = (OpusDecoder*)params.decoder;
dec_copy = malloc(size);
memcpy(dec_copy, dec, size);
}
/* Encode data, then decode for sanity check */
do {
#ifndef DISABLE_FLOAT_API
if (params.float_encode) {
float* input = (float*)inbuf;
if (params.custom_encode) {
len = opus_custom_encode_float(encC,
&input[samp_count*num_channels],
frame_size,
packet,
MAX_PACKET);
if (len <= 0) {
fprintf(stderr, "opus_custom_encode_float() failed: %s\n", opus_strerror(len));
ret = -1;
break;
}
}
else {
len = opus_encode_float(enc,
&input[samp_count*num_channels],
frame_size,
packet,
MAX_PACKET);
if (len <= 0) {
fprintf(stderr, "opus_encode_float() failed: %s\n", opus_strerror(len));
ret = -1;
break;
}
}
} else
#endif
{
if (params.custom_encode) {
if (params.encoder_bit_depth == 24) {
opus_int32* input = (opus_int32*)inbuf;
len = opus_custom_encode24(encC,
&input[samp_count*num_channels],
frame_size,
packet,
MAX_PACKET);
if (len <= 0) {
fprintf(stderr, "opus_custom_encode24() failed: %s\n", opus_strerror(len));
ret = -1;
break;
}
}
else {
opus_int16* input = (opus_int16*)inbuf;
len = opus_custom_encode(encC,
&input[samp_count*num_channels],
frame_size,
packet,
MAX_PACKET);
if (len <= 0) {
fprintf(stderr, "opus_custom_encode() failed: %s\n", opus_strerror(len));
ret = -1;
break;
}
}
}
else {
if (params.encoder_bit_depth == 24) {
opus_int32* input = (opus_int32*)inbuf;
len = opus_encode24(enc,
&input[samp_count*num_channels],
frame_size,
packet,
MAX_PACKET);
if (len <= 0) {
fprintf(stderr, "opus_encode24() failed: %s\n", opus_strerror(len));
ret = -1;
break;
}
}
else {
opus_int16* input = (opus_int16*)inbuf;
len = opus_encode(enc,
&input[samp_count*num_channels],
frame_size,
packet,
MAX_PACKET);
if (len <= 0) {
fprintf(stderr, "opus_encode() failed: %s\n", opus_strerror(len));
ret = -1;
break;
}
}
}
}
/* Generate bit/byte errors and check that nothing bad happens. */
{
int error_pos;
int len2;
/* Draw the inverse bit error rate from an exponential distribution. */
int ber_1 = 1 - 100*log(1e-10 + fast_rand()/4294967296.);
opus_int16 scratch[1920*6];
memcpy(packet_corrupt, packet, sizeof(packet));
/* Randomly flip the 5 first bytes. */
for (error_pos=0;error_pos<5;error_pos++) {
/* 25% chance of flipping each byte. */
if (error_pos<len && fast_rand()%5 == 0) packet_corrupt[error_pos] = fast_rand()&0xFF;
}
/* Arbitrarily truncate the packet. */
len2 = (int)(1-len*log(1e-10 + fast_rand()/4294967296.));
len2 = IMIN(len, len2);
error_pos=0;
/* Generate bit errors using "run-length" flipping. */
while (1) {
error_pos += (int)-ber_1*log(1e-10 + fast_rand()/4294967296.);
if (error_pos >= len2*8) break;
packet_corrupt[error_pos/8] ^= (1<<(error_pos&7));
}
if (params.custom_decode) {
int error = opus_custom_decode(decC_copy,
packet_corrupt,
len2,
scratch,
frame_size);
if (!(error > 0 || error == OPUS_BAD_ARG || error == OPUS_INVALID_PACKET || error == OPUS_BUFFER_TOO_SMALL)) {
fprintf(stderr, "opus_custom_decode() with corrupt stream failed with: %s\n", opus_strerror(error));
test_failed();
}
} else {
int error = opus_decode(dec_copy,
packet_corrupt,
len2,
scratch,
frame_size,
0);
if (!(error > 0 || error == OPUS_BAD_ARG || error == OPUS_INVALID_PACKET || error == OPUS_BUFFER_TOO_SMALL)) {
fprintf(stderr, "opus_custom_decode() with corrupt stream failed with: %s\n", opus_strerror(error));
test_failed();
}
}
}
#ifndef DISABLE_FLOAT_API
if (params.float_decode) {
float* output = (float*)outbuf;
if (params.custom_decode) {
samples_decoded = opus_custom_decode_float(decC,
packet,
len,
&output[samp_count*num_channels],
frame_size);
if (samples_decoded != frame_size) {
fprintf(stderr, "opus_custom_decode_float() returned %d\n", samples_decoded);
ret = -1;
break;
}
}
else {
samples_decoded = opus_decode_float(dec,
packet,
len,
&output[samp_count*num_channels],
frame_size,
0);
if (samples_decoded != frame_size) {
fprintf(stderr, "opus_decode_float() returned %d\n", samples_decoded);
ret = -1;
break;
}
}
} else
#endif
{
if (params.custom_decode) {
if (params.decoder_bit_depth == 24) {
opus_int32* output = (opus_int32*)outbuf;
samples_decoded = opus_custom_decode24(decC,
packet,
len,
&output[samp_count*num_channels],
frame_size);
if (samples_decoded != frame_size) {
fprintf(stderr, "opus_custom_decode24() returned %d\n", samples_decoded);
ret = -1;
break;
}
}
else {
opus_int16* output = (opus_int16*)outbuf;
samples_decoded = opus_custom_decode(decC,
packet,
len,
&output[samp_count*num_channels],
frame_size);
if (samples_decoded != frame_size) {
fprintf(stderr, "opus_custom_decode() returned %d\n", samples_decoded);
ret = -1;
break;
}
}
}
else {
if (params.decoder_bit_depth == 24) {
opus_int32* output = (opus_int32*)outbuf;
samples_decoded = opus_decode24(dec,
packet,
len,
&output[samp_count*num_channels],
frame_size,
0);
if (samples_decoded != frame_size) {
fprintf(stderr, "opus_decode24() returned %d\n", samples_decoded);
ret = -1;
break;
}
}
else {
opus_int16* output = (opus_int16*)outbuf;
samples_decoded = opus_decode(dec,
packet,
len,
&output[samp_count*num_channels],
frame_size,
0);
if (samples_decoded != frame_size) {
fprintf(stderr, "opus_decode() returned %d\n", samples_decoded);
ret = -1;
break;
}
}
}
}
samp_count += frame_size;
} while (samp_count + frame_size <= input_samples);
#ifdef RESYNTH
/* Resynth only works with OpusCustom encoder. Also, we don't enable it if there's
a 16-bit bottleneck in the decoder that can cause clipping. */
if (params.custom_encode && (params.custom_decode
#if !defined(FIXED_POINT) || defined(ENABLE_RES24)
|| params.decoder_bit_depth > 16
#endif
)) {
if (params.float_encode) {
float* input = (float*)inbuf;
float* output = (float*)outbuf;
for (i = 0; i < samp_count * num_channels; i++) {
rmsd += (input[i]-output[i])*(input[i]-output[i]);
}
rmsd = sqrt(rmsd/(num_channels*samp_count));
}
else if (params.decoder_bit_depth == 24) {
opus_int32* input = (opus_int32*)inbuf;
opus_int32* output = (opus_int32*)outbuf;
for (i = 0; i < samp_count * num_channels; i++) {
rmsd += (input[i]-output[i])*(double)(input[i]-output[i]);
}
rmsd = sqrt(rmsd/((double)num_channels*samp_count));
rmsd /= 8388608;
}
else {
opus_int16* input = (opus_int16*)inbuf;
opus_int16* output = (opus_int16*)outbuf;
for (i = 0; i < samp_count * num_channels; i++) {
rmsd += (input[i]-output[i])*(double)(input[i]-output[i]);
}
rmsd = sqrt(rmsd/((double)num_channels*samp_count));
rmsd /= 32768;
}
if (rmsd > RMS_THRESH) {
fprintf(stderr, "Error: encoder doesn't match decoder\n");
fprintf(stderr, "RMS mismatch is %g\n", rmsd);
ret = -1;
}
else {
fprintf(stderr, "Encoder matches decoder (rms %g)\n", rmsd);
}
}
#endif
if (dec_copy) free(dec_copy);
if (decC_copy) free(decC_copy);
/* Clean up */
free(inbuf);
free(outbuf);
return ret;
}
void test_opus_custom(const int num_encoders, const int num_setting_changes) {
OpusCustomMode* mode = NULL;
OpusCustomEncoder* encC = NULL;
OpusCustomDecoder* decC = NULL;
OpusEncoder* enc = NULL;
OpusDecoder* dec = NULL;
int i, j, err;
TestCustomParams params = {0};
/* Parameters to fuzz. Some values are duplicated to increase their probability of being tested. */
int sampling_rates[5] = { 8000, 12000, 16000, 24000, 48000 };
int channels[2] = { 1, 2 };
int bitrates[10] = { 6000, 12000, 16000, 24000, 32000, 48000, 64000, 96000, 510000, OPUS_BITRATE_MAX };
int use_vbr[3] = { 0, 1, 1 };
int vbr_constraints[3] = { 0, 1, 1 };
int complexities[11] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int packet_loss_perc[4] = { 0, 1, 2, 5 };
int lsb_depths[2] = { 8, 24 };
int frame_sizes_ms_x2[4] = { 5, 10, 20, 40 }; /* x2 to avoid 2.5 ms */
#ifndef DISABLE_FLOAT_API
int use_float_encode[2] = {0, 1};
int use_float_decode[2] = {0, 1};
#endif
int use_custom_encode[2] = {0, 1};
int use_custom_decode[2] = {0, 1};
int encoder_bit_depths[2] = {16, 24};
int decoder_bit_depths[2] = {16, 24};
for (i = 0; i < num_encoders; i++) {
int frame_size_ms_x2;
params.sample_rate = RAND_SAMPLE(sampling_rates);
params.custom_encode = 1;
params.custom_decode = 1;
/* Can only mix and match Opus and OpusCustom with 48kHz */
if (params.sample_rate == 48000) {
params.custom_encode = RAND_SAMPLE(use_custom_encode);
params.custom_decode = RAND_SAMPLE(use_custom_decode);
/* No point in testing this as OpusCustom isn't involved */
if (!(params.custom_encode || params.custom_decode))
continue;
}
params.num_channels = RAND_SAMPLE(channels);
frame_size_ms_x2 = RAND_SAMPLE(frame_sizes_ms_x2);
params.frame_size = frame_size_ms_x2 * params.sample_rate / 2000;
/* OpusCustom isn't supporting this case at the moment (frame < 40) */
if ((params.sample_rate == 8000 || params.sample_rate == 12000) && frame_size_ms_x2 == 5)
continue;
if (params.custom_encode || params.custom_decode) {
mode = opus_custom_mode_create(params.sample_rate, params.frame_size, &err);
if (err != OPUS_OK || mode == NULL) {
fprintf(stderr,
"test_opus_custom error: %d kHz, %d ch, "
"custom_encode: %d, custom_decode: %d, (%d/2) ms\n",
params.sample_rate / 1000, params.num_channels,
params.custom_encode, params.custom_decode, frame_size_ms_x2);
test_failed();
}
params.mode = mode;
} else {
params.mode = NULL;
}
if (params.custom_decode) {
decC = opus_custom_decoder_create(mode, params.num_channels, &err);
if (err != OPUS_OK || decC == NULL) {
fprintf(stderr,
"test_opus_custom error: %d kHz, %d ch, "
"custom_encode: %d, custom_decode: %d, (%d/2) ms\n",
params.sample_rate / 1000, params.num_channels,
params.custom_encode, params.custom_decode, frame_size_ms_x2);
test_failed();
}
params.decoder = (void*)decC;
}
else {
dec = opus_decoder_create(params.sample_rate, params.num_channels, &err);
if (err != OPUS_OK || dec == NULL) {
fprintf(stderr,
"test_opus_custom error: %d kHz, %d ch, "
"custom_encode: %d, custom_decode: %d, (%d/2) ms\n",
params.sample_rate / 1000, params.num_channels,
params.custom_encode, params.custom_decode, frame_size_ms_x2);
test_failed();
}
params.decoder = (void*)dec;
}
if (params.custom_encode) {
encC = opus_custom_encoder_create(mode, params.num_channels, &err);
if (err != OPUS_OK || encC == NULL) {
fprintf(stderr,
"test_opus_custom error: %d kHz, %d ch, "
"custom_encode: %d, custom_decode: %d, (%d/2) ms\n",
params.sample_rate / 1000, params.num_channels,
params.custom_encode, params.custom_decode, frame_size_ms_x2);
test_failed();
}
params.encoder = (void*)encC;
}
else {
enc = opus_encoder_create(params.sample_rate, params.num_channels, OPUS_APPLICATION_RESTRICTED_LOWDELAY, &err);
if (err != OPUS_OK || enc == NULL) {
fprintf(stderr,
"test_opus_custom error: %d kHz, %d ch, "
"custom_encode: %d, custom_decode: %d, (%d/2) ms\n",
params.sample_rate / 1000, params.num_channels,
params.custom_encode, params.custom_decode, frame_size_ms_x2);
test_failed();
}
params.encoder = (void*)enc;
}
for (j = 0; j < num_setting_changes; j++) {
int bitrate = RAND_SAMPLE(bitrates);
int vbr = RAND_SAMPLE(use_vbr);
int vbr_constraint = RAND_SAMPLE(vbr_constraints);
int complexity = RAND_SAMPLE(complexities);
int pkt_loss = RAND_SAMPLE(packet_loss_perc);
int lsb_depth = RAND_SAMPLE(lsb_depths);
#ifndef DISABLE_FLOAT_API
params.float_encode = RAND_SAMPLE(use_float_encode);
params.float_decode = RAND_SAMPLE(use_float_decode);
#else
params.float_encode = 0;
params.float_decode = 0;
#endif
params.encoder_bit_depth = RAND_SAMPLE(encoder_bit_depths);
params.decoder_bit_depth = RAND_SAMPLE(decoder_bit_depths);
#ifdef RESYNTH
/* Resynth logic works best when encoder/decoder use same datatype */
params.float_decode = params.float_encode;
params.decoder_bit_depth = params.encoder_bit_depth;
#endif
if (params.custom_encode) {
if (opus_custom_encoder_ctl(encC, OPUS_SET_BITRATE(bitrate)) != OPUS_OK) test_failed();
if (opus_custom_encoder_ctl(encC, OPUS_SET_VBR(vbr)) != OPUS_OK) test_failed();
if (opus_custom_encoder_ctl(encC, OPUS_SET_VBR_CONSTRAINT(vbr_constraint)) != OPUS_OK) test_failed();
if (opus_custom_encoder_ctl(encC, OPUS_SET_COMPLEXITY(complexity)) != OPUS_OK) test_failed();
if (opus_custom_encoder_ctl(encC, OPUS_SET_PACKET_LOSS_PERC(pkt_loss)) != OPUS_OK) test_failed();
if (opus_custom_encoder_ctl(encC, OPUS_SET_LSB_DEPTH(lsb_depth)) != OPUS_OK) test_failed();
}
else {
if (opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrate)) != OPUS_OK) test_failed();
if (opus_encoder_ctl(enc, OPUS_SET_VBR(vbr)) != OPUS_OK) test_failed();
if (opus_encoder_ctl(enc, OPUS_SET_VBR_CONSTRAINT(vbr_constraint)) != OPUS_OK) test_failed();
if (opus_encoder_ctl(enc, OPUS_SET_COMPLEXITY(complexity)) != OPUS_OK) test_failed();
if (opus_encoder_ctl(enc, OPUS_SET_PACKET_LOSS_PERC(pkt_loss)) != OPUS_OK) test_failed();
if (opus_encoder_ctl(enc, OPUS_SET_LSB_DEPTH(lsb_depth)) != OPUS_OK) test_failed();
}
fprintf(stderr,
"test_opus_custom: %d kHz, %d ch, float_encode: %d, float_decode: %d, "
"encoder_bit_depth: %d, "
"decoder_bit_depth: %d, "
"custom_encode: %d, custom_decode: %d, %d bps, vbr: %d, vbr constraint: %d, complexity: %d, "
"pkt loss: %d%%, lsb depth: %d, (%d/2) ms\n",
params.sample_rate / 1000, params.num_channels, params.float_encode, params.float_decode,
params.encoder_bit_depth, params.decoder_bit_depth,
params.custom_encode, params.custom_decode, bitrate, vbr, vbr_constraint, complexity,
pkt_loss, lsb_depth, frame_size_ms_x2);
if (test_encode(params)) {
fprintf(stderr,
"test_opus_custom error: %d kHz, %d ch, float_encode: %d, float_decode: %d, "
"encoder_bit_depth: %d, "
"decoder_bit_depth: %d, "
"custom_encode: %d, custom_decode: %d, %d bps, vbr: %d, vbr constraint: %d, complexity: %d, "
"pkt loss: %d%%, lsb depth: %d, (%d/2) ms\n",
params.sample_rate / 1000, params.num_channels, params.float_encode, params.float_decode,
params.encoder_bit_depth, params.decoder_bit_depth,
params.custom_encode, params.custom_decode, bitrate, vbr, vbr_constraint, complexity,
pkt_loss, lsb_depth, frame_size_ms_x2);
test_failed();
}
}
if (params.custom_encode || params.custom_decode) {
opus_custom_mode_destroy(mode);
}
if (params.custom_decode) {
opus_custom_decoder_destroy(decC);
}
else {
opus_decoder_destroy(dec);
}
if (params.custom_encode) {
opus_custom_encoder_destroy(encC);
}
else {
opus_encoder_destroy(enc);
}
}
}
int main(int _argc, char **_argv) {
int args = 1;
char * strtol_str = NULL;
const char * env_seed;
int env_used;
int num_encoders_to_fuzz = 5;
int num_setting_changes = 40;
/* Seed the random fuzz settings */
env_used=0;
env_seed=getenv("SEED");
if (_argc > 1)
iseed = strtol(_argv[1], &strtol_str, 10); /* the first input argument might be the seed */
if(strtol_str!=NULL && strtol_str[0]=='\0') /* iseed is a valid number */
args++;
else if(env_seed) {
iseed=atoi(env_seed);
env_used=1;
}
else iseed=(opus_uint32)time(NULL)^(((opus_uint32)getpid()&65535)<<16);
Rw=Rz=iseed;
fprintf(stderr,"Testing extensions. Random seed: %u (%.4X)\n", iseed, fast_rand() % 65535);
if(env_used)fprintf(stderr," Random seed set from the environment (SEED=%s).\n", env_seed);
fprintf(stderr,"Testing various Opus/OpusCustom combinations "
#ifdef RESYNTH
"with RMS validation "
#endif
"across %d encoder(s) and %d setting change(s) each.\n", num_encoders_to_fuzz, num_setting_changes);
test_opus_custom(num_encoders_to_fuzz, num_setting_changes);
fprintf(stderr,"Tests completed successfully.\n");
return 0;
}