1 /* Copyright (c) 2011-2013 Xiph.Org Foundation 2 Written by Gregory Maxwell */ 3 /* 4 Redistribution and use in source and binary forms, with or without 5 modification, are permitted provided that the following conditions 6 are met: 7 8 - Redistributions of source code must retain the above copyright 9 notice, this list of conditions and the following disclaimer. 10 11 - Redistributions in binary form must reproduce the above copyright 12 notice, this list of conditions and the following disclaimer in the 13 documentation and/or other materials provided with the distribution. 14 15 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 16 ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 17 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 18 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER 19 OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 20 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 21 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 22 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 23 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 24 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 25 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 */ 27 28 #ifdef HAVE_CONFIG_H 29 #include "config.h" 30 #endif 31 32 #include <stdio.h> 33 #include <stdlib.h> 34 #include <limits.h> 35 #include <stdint.h> 36 #include <math.h> 37 #include <string.h> 38 #include <time.h> 39 #if (!defined WIN32 && !defined _WIN32) || defined(__MINGW32__) 40 #include <unistd.h> 41 #else 42 #include <process.h> 43 #define getpid _getpid 44 #endif 45 #include "opus_multistream.h" 46 #include "opus.h" 47 #include "../src/opus_private.h" 48 #include "test_opus_common.h" 49 50 #define MAX_PACKET (1500) 51 #define SAMPLES (48000*30) 52 #define SSAMPLES (SAMPLES/3) 53 #define MAX_FRAME_SAMP (5760) 54 #define PI (3.141592653589793238462643f) 55 #define RAND_SAMPLE(a) (a[fast_rand() % sizeof(a)/sizeof(a[0])]) 56 57 void generate_music(short *buf, opus_int32 len) 58 { 59 opus_int32 a1,b1,a2,b2; 60 opus_int32 c1,c2,d1,d2; 61 opus_int32 i,j; 62 a1=b1=a2=b2=0; 63 c1=c2=d1=d2=0; 64 j=0; 65 /*60ms silence*/ 66 for(i=0;i<2880;i++)buf[i*2]=buf[i*2+1]=0; 67 for(i=2880;i<len;i++) 68 { 69 opus_uint32 r; 70 opus_int32 v1,v2; 71 v1=v2=(((j*((j>>12)^((j>>10|j>>12)&26&j>>7)))&128)+128)<<15; 72 r=fast_rand();v1+=r&65535;v1-=r>>16; 73 r=fast_rand();v2+=r&65535;v2-=r>>16; 74 b1=v1-a1+((b1*61+32)>>6);a1=v1; 75 b2=v2-a2+((b2*61+32)>>6);a2=v2; 76 c1=(30*(c1+b1+d1)+32)>>6;d1=b1; 77 c2=(30*(c2+b2+d2)+32)>>6;d2=b2; 78 v1=(c1+128)>>8; 79 v2=(c2+128)>>8; 80 buf[i*2]=v1>32767?32767:(v1<-32768?-32768:v1); 81 buf[i*2+1]=v2>32767?32767:(v2<-32768?-32768:v2); 82 if(i%6==0)j++; 83 } 84 } 85 86 #if 0 87 static int save_ctr = 0; 88 static void int_to_char(opus_uint32 i, unsigned char ch[4]) 89 { 90 ch[0] = i>>24; 91 ch[1] = (i>>16)&0xFF; 92 ch[2] = (i>>8)&0xFF; 93 ch[3] = i&0xFF; 94 } 95 96 static OPUS_INLINE void save_packet(unsigned char* p, int len, opus_uint32 rng) 97 { 98 FILE *fout; 99 unsigned char int_field[4]; 100 char name[256]; 101 snprintf(name,255,"test_opus_encode.%llu.%d.bit",(unsigned long long)iseed,save_ctr); 102 fprintf(stdout,"writing %d byte packet to %s\n",len,name); 103 fout=fopen(name, "wb+"); 104 if(fout==NULL)test_failed(); 105 int_to_char(len, int_field); 106 fwrite(int_field, 1, 4, fout); 107 int_to_char(rng, int_field); 108 fwrite(int_field, 1, 4, fout); 109 fwrite(p, 1, len, fout); 110 fclose(fout); 111 save_ctr++; 112 } 113 #endif 114 115 int get_frame_size_enum(int frame_size, int sampling_rate) 116 { 117 int frame_size_enum; 118 119 if(frame_size==sampling_rate/400) 120 frame_size_enum = OPUS_FRAMESIZE_2_5_MS; 121 else if(frame_size==sampling_rate/200) 122 frame_size_enum = OPUS_FRAMESIZE_5_MS; 123 else if(frame_size==sampling_rate/100) 124 frame_size_enum = OPUS_FRAMESIZE_10_MS; 125 else if(frame_size==sampling_rate/50) 126 frame_size_enum = OPUS_FRAMESIZE_20_MS; 127 else if(frame_size==sampling_rate/25) 128 frame_size_enum = OPUS_FRAMESIZE_40_MS; 129 else if(frame_size==3*sampling_rate/50) 130 frame_size_enum = OPUS_FRAMESIZE_60_MS; 131 else if(frame_size==4*sampling_rate/50) 132 frame_size_enum = OPUS_FRAMESIZE_80_MS; 133 else if(frame_size==5*sampling_rate/50) 134 frame_size_enum = OPUS_FRAMESIZE_100_MS; 135 else if(frame_size==6*sampling_rate/50) 136 frame_size_enum = OPUS_FRAMESIZE_120_MS; 137 else 138 test_failed(); 139 140 return frame_size_enum; 141 } 142 143 void test_encode(OpusEncoder *enc, int channels, int frame_size, OpusDecoder *dec, const char* debug_info) 144 { 145 int samp_count = 0; 146 opus_int16 *inbuf; 147 unsigned char packet[MAX_PACKET+257]; 148 int len; 149 opus_int16 *outbuf; 150 int out_samples; 151 152 /* Generate input data */ 153 inbuf = (opus_int16*)malloc(sizeof(*inbuf)*SSAMPLES); 154 generate_music(inbuf, SSAMPLES/2); 155 156 /* Allocate memory for output data */ 157 outbuf = (opus_int16*)malloc(sizeof(*outbuf)*MAX_FRAME_SAMP*3); 158 159 /* Encode data, then decode for sanity check */ 160 do { 161 len = opus_encode(enc, &inbuf[samp_count*channels], frame_size, packet, MAX_PACKET); 162 if(len<0 || len>MAX_PACKET) { 163 fprintf(stderr,"%s\n",debug_info); 164 fprintf(stderr,"opus_encode() returned %d\n",len); 165 test_failed(); 166 } 167 168 out_samples = opus_decode(dec, packet, len, outbuf, MAX_FRAME_SAMP, 0); 169 if(out_samples!=frame_size) { 170 fprintf(stderr,"%s\n",debug_info); 171 fprintf(stderr,"opus_decode() returned %d\n",out_samples); 172 test_failed(); 173 } 174 175 samp_count += frame_size; 176 } while (samp_count < ((SSAMPLES/2)-MAX_FRAME_SAMP)); 177 178 /* Clean up */ 179 free(inbuf); 180 free(outbuf); 181 } 182 183 void fuzz_encoder_settings(const int num_encoders, const int num_setting_changes) 184 { 185 OpusEncoder *enc; 186 OpusDecoder *dec; 187 int i,j,err; 188 189 /* Parameters to fuzz. Some values are duplicated to increase their probability of being tested. */ 190 int sampling_rates[5] = {8000, 12000, 16000, 24000, 48000}; 191 int channels[2] = {1, 2}; 192 int applications[3] = {OPUS_APPLICATION_AUDIO, OPUS_APPLICATION_VOIP, OPUS_APPLICATION_RESTRICTED_LOWDELAY}; 193 int bitrates[11] = {6000, 12000, 16000, 24000, 32000, 48000, 64000, 96000, 510000, OPUS_AUTO, OPUS_BITRATE_MAX}; 194 int force_channels[4] = {OPUS_AUTO, OPUS_AUTO, 1, 2}; 195 int use_vbr[3] = {0, 1, 1}; 196 int vbr_constraints[3] = {0, 1, 1}; 197 int complexities[11] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; 198 int max_bandwidths[6] = {OPUS_BANDWIDTH_NARROWBAND, OPUS_BANDWIDTH_MEDIUMBAND, 199 OPUS_BANDWIDTH_WIDEBAND, OPUS_BANDWIDTH_SUPERWIDEBAND, 200 OPUS_BANDWIDTH_FULLBAND, OPUS_BANDWIDTH_FULLBAND}; 201 int signals[4] = {OPUS_AUTO, OPUS_AUTO, OPUS_SIGNAL_VOICE, OPUS_SIGNAL_MUSIC}; 202 int inband_fecs[3] = {0, 0, 1}; 203 int packet_loss_perc[4] = {0, 1, 2, 5}; 204 int lsb_depths[2] = {8, 24}; 205 int prediction_disabled[3] = {0, 0, 1}; 206 int use_dtx[2] = {0, 1}; 207 int frame_sizes_ms_x2[9] = {5, 10, 20, 40, 80, 120, 160, 200, 240}; /* x2 to avoid 2.5 ms */ 208 char debug_info[512]; 209 210 for (i=0; i<num_encoders; i++) { 211 int sampling_rate = RAND_SAMPLE(sampling_rates); 212 int num_channels = RAND_SAMPLE(channels); 213 int application = RAND_SAMPLE(applications); 214 215 dec = opus_decoder_create(sampling_rate, num_channels, &err); 216 if(err!=OPUS_OK || dec==NULL)test_failed(); 217 218 enc = opus_encoder_create(sampling_rate, num_channels, application, &err); 219 if(err!=OPUS_OK || enc==NULL)test_failed(); 220 221 for (j=0; j<num_setting_changes; j++) { 222 int bitrate = RAND_SAMPLE(bitrates); 223 int force_channel = RAND_SAMPLE(force_channels); 224 int vbr = RAND_SAMPLE(use_vbr); 225 int vbr_constraint = RAND_SAMPLE(vbr_constraints); 226 int complexity = RAND_SAMPLE(complexities); 227 int max_bw = RAND_SAMPLE(max_bandwidths); 228 int sig = RAND_SAMPLE(signals); 229 int inband_fec = RAND_SAMPLE(inband_fecs); 230 int pkt_loss = RAND_SAMPLE(packet_loss_perc); 231 int lsb_depth = RAND_SAMPLE(lsb_depths); 232 int pred_disabled = RAND_SAMPLE(prediction_disabled); 233 int dtx = RAND_SAMPLE(use_dtx); 234 int frame_size_ms_x2 = RAND_SAMPLE(frame_sizes_ms_x2); 235 int frame_size = frame_size_ms_x2*sampling_rate/2000; 236 int frame_size_enum = get_frame_size_enum(frame_size, sampling_rate); 237 force_channel = IMIN(force_channel, num_channels); 238 239 sprintf(debug_info, 240 "fuzz_encoder_settings: %d kHz, %d ch, application: %d, " 241 "%d bps, force ch: %d, vbr: %d, vbr constraint: %d, complexity: %d, " 242 "max bw: %d, signal: %d, inband fec: %d, pkt loss: %d%%, lsb depth: %d, " 243 "pred disabled: %d, dtx: %d, (%d/2) ms\n", 244 sampling_rate/1000, num_channels, application, bitrate, 245 force_channel, vbr, vbr_constraint, complexity, max_bw, sig, inband_fec, 246 pkt_loss, lsb_depth, pred_disabled, dtx, frame_size_ms_x2); 247 248 if(opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrate)) != OPUS_OK) test_failed(); 249 if(opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS(force_channel)) != OPUS_OK) test_failed(); 250 if(opus_encoder_ctl(enc, OPUS_SET_VBR(vbr)) != OPUS_OK) test_failed(); 251 if(opus_encoder_ctl(enc, OPUS_SET_VBR_CONSTRAINT(vbr_constraint)) != OPUS_OK) test_failed(); 252 if(opus_encoder_ctl(enc, OPUS_SET_COMPLEXITY(complexity)) != OPUS_OK) test_failed(); 253 if(opus_encoder_ctl(enc, OPUS_SET_MAX_BANDWIDTH(max_bw)) != OPUS_OK) test_failed(); 254 if(opus_encoder_ctl(enc, OPUS_SET_SIGNAL(sig)) != OPUS_OK) test_failed(); 255 if(opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(inband_fec)) != OPUS_OK) test_failed(); 256 if(opus_encoder_ctl(enc, OPUS_SET_PACKET_LOSS_PERC(pkt_loss)) != OPUS_OK) test_failed(); 257 if(opus_encoder_ctl(enc, OPUS_SET_LSB_DEPTH(lsb_depth)) != OPUS_OK) test_failed(); 258 if(opus_encoder_ctl(enc, OPUS_SET_PREDICTION_DISABLED(pred_disabled)) != OPUS_OK) test_failed(); 259 if(opus_encoder_ctl(enc, OPUS_SET_DTX(dtx)) != OPUS_OK) test_failed(); 260 if(opus_encoder_ctl(enc, OPUS_SET_EXPERT_FRAME_DURATION(frame_size_enum)) != OPUS_OK) test_failed(); 261 262 test_encode(enc, num_channels, frame_size, dec, debug_info); 263 } 264 265 opus_encoder_destroy(enc); 266 opus_decoder_destroy(dec); 267 } 268 } 269 270 int run_test1(int no_fuzz) 271 { 272 static const int fsizes[6]={960*3,960*2,120,240,480,960}; 273 static const char *mstrings[3] = {" LP","Hybrid"," MDCT"}; 274 unsigned char mapping[256] = {0,1,255}; 275 unsigned char db62[36]; 276 opus_int32 i,j; 277 int rc,err; 278 OpusEncoder *enc; 279 OpusMSEncoder *MSenc; 280 OpusDecoder *dec; 281 OpusMSDecoder *MSdec; 282 OpusMSDecoder *MSdec_err; 283 OpusDecoder *dec_err[10]; 284 short *inbuf; 285 short *outbuf; 286 short *out2buf; 287 opus_int32 bitrate_bps; 288 unsigned char packet[MAX_PACKET+257]; 289 opus_uint32 enc_final_range; 290 opus_uint32 dec_final_range; 291 int fswitch; 292 int fsize; 293 int count; 294 295 /*FIXME: encoder api tests, fs!=48k, mono, VBR*/ 296 297 fprintf(stdout," Encode+Decode tests.\n"); 298 299 enc = opus_encoder_create(48000, 2, OPUS_APPLICATION_VOIP, &err); 300 if(err != OPUS_OK || enc==NULL)test_failed(); 301 302 for(i=0;i<2;i++) 303 { 304 int *ret_err; 305 ret_err = i?0:&err; 306 MSenc = opus_multistream_encoder_create(8000, 2, 2, 0, mapping, OPUS_UNIMPLEMENTED, ret_err); 307 if((ret_err && *ret_err != OPUS_BAD_ARG) || MSenc!=NULL)test_failed(); 308 309 MSenc = opus_multistream_encoder_create(8000, 0, 1, 0, mapping, OPUS_APPLICATION_VOIP, ret_err); 310 if((ret_err && *ret_err != OPUS_BAD_ARG) || MSenc!=NULL)test_failed(); 311 312 MSenc = opus_multistream_encoder_create(44100, 2, 2, 0, mapping, OPUS_APPLICATION_VOIP, ret_err); 313 if((ret_err && *ret_err != OPUS_BAD_ARG) || MSenc!=NULL)test_failed(); 314 315 MSenc = opus_multistream_encoder_create(8000, 2, 2, 3, mapping, OPUS_APPLICATION_VOIP, ret_err); 316 if((ret_err && *ret_err != OPUS_BAD_ARG) || MSenc!=NULL)test_failed(); 317 318 MSenc = opus_multistream_encoder_create(8000, 2, -1, 0, mapping, OPUS_APPLICATION_VOIP, ret_err); 319 if((ret_err && *ret_err != OPUS_BAD_ARG) || MSenc!=NULL)test_failed(); 320 321 MSenc = opus_multistream_encoder_create(8000, 256, 2, 0, mapping, OPUS_APPLICATION_VOIP, ret_err); 322 if((ret_err && *ret_err != OPUS_BAD_ARG) || MSenc!=NULL)test_failed(); 323 } 324 325 MSenc = opus_multistream_encoder_create(8000, 2, 2, 0, mapping, OPUS_APPLICATION_AUDIO, &err); 326 if(err != OPUS_OK || MSenc==NULL)test_failed(); 327 328 /*Some multistream encoder API tests*/ 329 if(opus_multistream_encoder_ctl(MSenc, OPUS_GET_BITRATE(&i))!=OPUS_OK)test_failed(); 330 if(opus_multistream_encoder_ctl(MSenc, OPUS_GET_LSB_DEPTH(&i))!=OPUS_OK)test_failed(); 331 if(i<16)test_failed(); 332 333 { 334 OpusEncoder *tmp_enc; 335 if(opus_multistream_encoder_ctl(MSenc, OPUS_MULTISTREAM_GET_ENCODER_STATE(1,&tmp_enc))!=OPUS_OK)test_failed(); 336 if(opus_encoder_ctl(tmp_enc, OPUS_GET_LSB_DEPTH(&j))!=OPUS_OK)test_failed(); 337 if(i!=j)test_failed(); 338 if(opus_multistream_encoder_ctl(MSenc, OPUS_MULTISTREAM_GET_ENCODER_STATE(2,&tmp_enc))!=OPUS_BAD_ARG)test_failed(); 339 } 340 341 dec = opus_decoder_create(48000, 2, &err); 342 if(err != OPUS_OK || dec==NULL)test_failed(); 343 344 MSdec = opus_multistream_decoder_create(48000, 2, 2, 0, mapping, &err); 345 if(err != OPUS_OK || MSdec==NULL)test_failed(); 346 347 MSdec_err = opus_multistream_decoder_create(48000, 3, 2, 0, mapping, &err); 348 if(err != OPUS_OK || MSdec_err==NULL)test_failed(); 349 350 dec_err[0]=(OpusDecoder *)malloc(opus_decoder_get_size(2)); 351 memcpy(dec_err[0],dec,opus_decoder_get_size(2)); 352 dec_err[1] = opus_decoder_create(48000, 1, &err); 353 dec_err[2] = opus_decoder_create(24000, 2, &err); 354 dec_err[3] = opus_decoder_create(24000, 1, &err); 355 dec_err[4] = opus_decoder_create(16000, 2, &err); 356 dec_err[5] = opus_decoder_create(16000, 1, &err); 357 dec_err[6] = opus_decoder_create(12000, 2, &err); 358 dec_err[7] = opus_decoder_create(12000, 1, &err); 359 dec_err[8] = opus_decoder_create(8000, 2, &err); 360 dec_err[9] = opus_decoder_create(8000, 1, &err); 361 for(i=0;i<10;i++)if(dec_err[i]==NULL)test_failed(); 362 363 { 364 OpusEncoder *enccpy; 365 /*The opus state structures contain no pointers and can be freely copied*/ 366 enccpy=(OpusEncoder *)malloc(opus_encoder_get_size(2)); 367 memcpy(enccpy,enc,opus_encoder_get_size(2)); 368 memset(enc,255,opus_encoder_get_size(2)); 369 opus_encoder_destroy(enc); 370 enc=enccpy; 371 } 372 373 inbuf=(short *)malloc(sizeof(short)*SAMPLES*2); 374 outbuf=(short *)malloc(sizeof(short)*SAMPLES*2); 375 out2buf=(short *)malloc(sizeof(short)*MAX_FRAME_SAMP*3); 376 if(inbuf==NULL || outbuf==NULL || out2buf==NULL)test_failed(); 377 378 generate_music(inbuf,SAMPLES); 379 380 /* FILE *foo; 381 foo = fopen("foo.sw", "wb+"); 382 fwrite(inbuf, 1, SAMPLES*2*2, foo); 383 fclose(foo);*/ 384 385 if(opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(OPUS_AUTO))!=OPUS_OK)test_failed(); 386 if(opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(-2))!=OPUS_BAD_ARG)test_failed(); 387 if(opus_encode(enc, inbuf, 500, packet, MAX_PACKET)!=OPUS_BAD_ARG)test_failed(); 388 389 for(rc=0;rc<3;rc++) 390 { 391 if(opus_encoder_ctl(enc, OPUS_SET_VBR(rc<2))!=OPUS_OK)test_failed(); 392 if(opus_encoder_ctl(enc, OPUS_SET_VBR_CONSTRAINT(rc==1))!=OPUS_OK)test_failed(); 393 if(opus_encoder_ctl(enc, OPUS_SET_VBR_CONSTRAINT(rc==1))!=OPUS_OK)test_failed(); 394 if(opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(rc==0))!=OPUS_OK)test_failed(); 395 for(j=0;j<13;j++) 396 { 397 int rate; 398 int modes[13]={0,0,0,1,1,1,1,2,2,2,2,2,2}; 399 int rates[13]={6000,12000,48000,16000,32000,48000,64000,512000,13000,24000,48000,64000,96000}; 400 int frame[13]={960*2,960,480,960,960,960,480,960*3,960*3,960,480,240,120}; 401 rate=rates[j]+fast_rand()%rates[j]; 402 count=i=0; 403 do { 404 int bw,len,out_samples,frame_size; 405 frame_size=frame[j]; 406 if((fast_rand()&255)==0) 407 { 408 if(opus_encoder_ctl(enc, OPUS_RESET_STATE)!=OPUS_OK)test_failed(); 409 if(opus_decoder_ctl(dec, OPUS_RESET_STATE)!=OPUS_OK)test_failed(); 410 if((fast_rand()&1)!=0) 411 { 412 if(opus_decoder_ctl(dec_err[fast_rand()&1], OPUS_RESET_STATE)!=OPUS_OK)test_failed(); 413 } 414 } 415 if((fast_rand()&127)==0) 416 { 417 if(opus_decoder_ctl(dec_err[fast_rand()&1], OPUS_RESET_STATE)!=OPUS_OK)test_failed(); 418 } 419 if(fast_rand()%10==0){ 420 int complex=fast_rand()%11; 421 if(opus_encoder_ctl(enc, OPUS_SET_COMPLEXITY(complex))!=OPUS_OK)test_failed(); 422 } 423 if(fast_rand()%50==0)opus_decoder_ctl(dec, OPUS_RESET_STATE); 424 if(opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(rc==0))!=OPUS_OK)test_failed(); 425 if(opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(MODE_SILK_ONLY+modes[j]))!=OPUS_OK)test_failed(); 426 if(opus_encoder_ctl(enc, OPUS_SET_DTX(fast_rand()&1))!=OPUS_OK)test_failed(); 427 if(opus_encoder_ctl(enc, OPUS_SET_BITRATE(rate))!=OPUS_OK)test_failed(); 428 if(opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS((rates[j]>=64000?2:1)))!=OPUS_OK)test_failed(); 429 if(opus_encoder_ctl(enc, OPUS_SET_COMPLEXITY((count>>2)%11))!=OPUS_OK)test_failed(); 430 if(opus_encoder_ctl(enc, OPUS_SET_PACKET_LOSS_PERC((fast_rand()&15)&(fast_rand()%15)))!=OPUS_OK)test_failed(); 431 bw=modes[j]==0?OPUS_BANDWIDTH_NARROWBAND+(fast_rand()%3): 432 modes[j]==1?OPUS_BANDWIDTH_SUPERWIDEBAND+(fast_rand()&1): 433 OPUS_BANDWIDTH_NARROWBAND+(fast_rand()%5); 434 if(modes[j]==2&&bw==OPUS_BANDWIDTH_MEDIUMBAND)bw+=3; 435 if(opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(bw))!=OPUS_OK)test_failed(); 436 len = opus_encode(enc, &inbuf[i<<1], frame_size, packet, MAX_PACKET); 437 if(len<0 || len>MAX_PACKET)test_failed(); 438 if(opus_encoder_ctl(enc, OPUS_GET_FINAL_RANGE(&enc_final_range))!=OPUS_OK)test_failed(); 439 if((fast_rand()&3)==0) 440 { 441 if(opus_packet_pad(packet,len,len+1)!=OPUS_OK)test_failed(); 442 len++; 443 } 444 if((fast_rand()&7)==0) 445 { 446 if(opus_packet_pad(packet,len,len+256)!=OPUS_OK)test_failed(); 447 len+=256; 448 } 449 if((fast_rand()&3)==0) 450 { 451 len=opus_packet_unpad(packet,len); 452 if(len<1)test_failed(); 453 } 454 out_samples = opus_decode(dec, packet, len, &outbuf[i<<1], MAX_FRAME_SAMP, 0); 455 if(out_samples!=frame_size)test_failed(); 456 if(opus_decoder_ctl(dec, OPUS_GET_FINAL_RANGE(&dec_final_range))!=OPUS_OK)test_failed(); 457 if(enc_final_range!=dec_final_range)test_failed(); 458 /*LBRR decode*/ 459 out_samples = opus_decode(dec_err[0], packet, len, out2buf, frame_size, (fast_rand()&3)!=0); 460 if(out_samples!=frame_size)test_failed(); 461 out_samples = opus_decode(dec_err[1], packet, (fast_rand()&3)==0?0:len, out2buf, MAX_FRAME_SAMP, (fast_rand()&7)!=0); 462 if(out_samples<120)test_failed(); 463 i+=frame_size; 464 count++; 465 }while(i<(SSAMPLES-MAX_FRAME_SAMP)); 466 fprintf(stdout," Mode %s FB encode %s, %6d bps OK.\n",mstrings[modes[j]],rc==0?" VBR":rc==1?"CVBR":" CBR",rate); 467 } 468 } 469 470 if(opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(OPUS_AUTO))!=OPUS_OK)test_failed(); 471 if(opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS(OPUS_AUTO))!=OPUS_OK)test_failed(); 472 if(opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(0))!=OPUS_OK)test_failed(); 473 if(opus_encoder_ctl(enc, OPUS_SET_DTX(0))!=OPUS_OK)test_failed(); 474 475 for(rc=0;rc<3;rc++) 476 { 477 if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_VBR(rc<2))!=OPUS_OK)test_failed(); 478 if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_VBR_CONSTRAINT(rc==1))!=OPUS_OK)test_failed(); 479 if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_VBR_CONSTRAINT(rc==1))!=OPUS_OK)test_failed(); 480 if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_INBAND_FEC(rc==0))!=OPUS_OK)test_failed(); 481 for(j=0;j<16;j++) 482 { 483 int rate; 484 int modes[16]={0,0,0,0,0,0,0,0,2,2,2,2,2,2,2,2}; 485 int rates[16]={4000,12000,32000,8000,16000,32000,48000,88000,4000,12000,32000,8000,16000,32000,48000,88000}; 486 int frame[16]={160*1,160,80,160,160,80,40,20,160*1,160,80,160,160,80,40,20}; 487 if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_INBAND_FEC(rc==0&&j==1))!=OPUS_OK)test_failed(); 488 if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_FORCE_MODE(MODE_SILK_ONLY+modes[j]))!=OPUS_OK)test_failed(); 489 rate=rates[j]+fast_rand()%rates[j]; 490 if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_DTX(fast_rand()&1))!=OPUS_OK)test_failed(); 491 if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_BITRATE(rate))!=OPUS_OK)test_failed(); 492 count=i=0; 493 do { 494 int len,out_samples,frame_size,loss; 495 opus_int32 pred; 496 if(opus_multistream_encoder_ctl(MSenc, OPUS_GET_PREDICTION_DISABLED(&pred))!=OPUS_OK)test_failed(); 497 if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_PREDICTION_DISABLED((int)(fast_rand()&15)<(pred?11:4)))!=OPUS_OK)test_failed(); 498 frame_size=frame[j]; 499 if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_COMPLEXITY((count>>2)%11))!=OPUS_OK)test_failed(); 500 if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_PACKET_LOSS_PERC((fast_rand()&15)&(fast_rand()%15)))!=OPUS_OK)test_failed(); 501 if((fast_rand()&255)==0) 502 { 503 if(opus_multistream_encoder_ctl(MSenc, OPUS_RESET_STATE)!=OPUS_OK)test_failed(); 504 if(opus_multistream_decoder_ctl(MSdec, OPUS_RESET_STATE)!=OPUS_OK)test_failed(); 505 if((fast_rand()&3)!=0) 506 { 507 if(opus_multistream_decoder_ctl(MSdec_err, OPUS_RESET_STATE)!=OPUS_OK)test_failed(); 508 } 509 } 510 if((fast_rand()&255)==0) 511 { 512 if(opus_multistream_decoder_ctl(MSdec_err, OPUS_RESET_STATE)!=OPUS_OK)test_failed(); 513 } 514 len = opus_multistream_encode(MSenc, &inbuf[i<<1], frame_size, packet, MAX_PACKET); 515 if(len<0 || len>MAX_PACKET)test_failed(); 516 if(opus_multistream_encoder_ctl(MSenc, OPUS_GET_FINAL_RANGE(&enc_final_range))!=OPUS_OK)test_failed(); 517 if((fast_rand()&3)==0) 518 { 519 if(opus_multistream_packet_pad(packet,len,len+1,2)!=OPUS_OK)test_failed(); 520 len++; 521 } 522 if((fast_rand()&7)==0) 523 { 524 if(opus_multistream_packet_pad(packet,len,len+256,2)!=OPUS_OK)test_failed(); 525 len+=256; 526 } 527 if((fast_rand()&3)==0) 528 { 529 len=opus_multistream_packet_unpad(packet,len,2); 530 if(len<1)test_failed(); 531 } 532 out_samples = opus_multistream_decode(MSdec, packet, len, out2buf, MAX_FRAME_SAMP, 0); 533 if(out_samples!=frame_size*6)test_failed(); 534 if(opus_multistream_decoder_ctl(MSdec, OPUS_GET_FINAL_RANGE(&dec_final_range))!=OPUS_OK)test_failed(); 535 if(enc_final_range!=dec_final_range)test_failed(); 536 /*LBRR decode*/ 537 loss=(fast_rand()&63)==0; 538 out_samples = opus_multistream_decode(MSdec_err, packet, loss?0:len, out2buf, frame_size*6, (fast_rand()&3)!=0); 539 if(out_samples!=(frame_size*6))test_failed(); 540 i+=frame_size; 541 count++; 542 }while(i<(SSAMPLES/12-MAX_FRAME_SAMP)); 543 fprintf(stdout," Mode %s NB dual-mono MS encode %s, %6d bps OK.\n",mstrings[modes[j]],rc==0?" VBR":rc==1?"CVBR":" CBR",rate); 544 } 545 } 546 547 bitrate_bps=512000; 548 fsize=fast_rand()%31; 549 fswitch=100; 550 551 debruijn2(6,db62); 552 count=i=0; 553 do { 554 unsigned char toc; 555 const unsigned char *frames[48]; 556 short size[48]; 557 int payload_offset; 558 opus_uint32 dec_final_range2; 559 int jj,dec2; 560 int len,out_samples; 561 int frame_size=fsizes[db62[fsize]]; 562 opus_int32 offset=i%(SAMPLES-MAX_FRAME_SAMP); 563 564 opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrate_bps)); 565 566 len = opus_encode(enc, &inbuf[offset<<1], frame_size, packet, MAX_PACKET); 567 if(len<0 || len>MAX_PACKET)test_failed(); 568 count++; 569 570 opus_encoder_ctl(enc, OPUS_GET_FINAL_RANGE(&enc_final_range)); 571 572 out_samples = opus_decode(dec, packet, len, &outbuf[offset<<1], MAX_FRAME_SAMP, 0); 573 if(out_samples!=frame_size)test_failed(); 574 575 opus_decoder_ctl(dec, OPUS_GET_FINAL_RANGE(&dec_final_range)); 576 577 /* compare final range encoder rng values of encoder and decoder */ 578 if(dec_final_range!=enc_final_range)test_failed(); 579 580 /* We fuzz the packet, but take care not to only corrupt the payload 581 Corrupted headers are tested elsewhere and we need to actually run 582 the decoders in order to compare them. */ 583 if(opus_packet_parse(packet,len,&toc,frames,size,&payload_offset)<=0)test_failed(); 584 if((fast_rand()&1023)==0)len=0; 585 for(j=(opus_int32)(frames[0]-packet);j<len;j++)for(jj=0;jj<8;jj++)packet[j]^=((!no_fuzz)&&((fast_rand()&1023)==0))<<jj; 586 out_samples = opus_decode(dec_err[0], len>0?packet:NULL, len, out2buf, MAX_FRAME_SAMP, 0); 587 if(out_samples<0||out_samples>MAX_FRAME_SAMP)test_failed(); 588 if((len>0&&out_samples!=frame_size))test_failed(); /*FIXME use lastframe*/ 589 590 opus_decoder_ctl(dec_err[0], OPUS_GET_FINAL_RANGE(&dec_final_range)); 591 592 /*randomly select one of the decoders to compare with*/ 593 dec2=fast_rand()%9+1; 594 out_samples = opus_decode(dec_err[dec2], len>0?packet:NULL, len, out2buf, MAX_FRAME_SAMP, 0); 595 if(out_samples<0||out_samples>MAX_FRAME_SAMP)test_failed(); /*FIXME, use factor, lastframe for loss*/ 596 597 opus_decoder_ctl(dec_err[dec2], OPUS_GET_FINAL_RANGE(&dec_final_range2)); 598 if(len>0&&dec_final_range!=dec_final_range2)test_failed(); 599 600 fswitch--; 601 if(fswitch<1) 602 { 603 int new_size; 604 fsize=(fsize+1)%36; 605 new_size=fsizes[db62[fsize]]; 606 if(new_size==960||new_size==480)fswitch=2880/new_size*(fast_rand()%19+1); 607 else fswitch=(fast_rand()%(2880/new_size))+1; 608 } 609 bitrate_bps=((fast_rand()%508000+4000)+bitrate_bps)>>1; 610 i+=frame_size; 611 }while(i<SAMPLES*4); 612 fprintf(stdout," All framesize pairs switching encode, %d frames OK.\n",count); 613 614 if(opus_encoder_ctl(enc, OPUS_RESET_STATE)!=OPUS_OK)test_failed(); 615 opus_encoder_destroy(enc); 616 if(opus_multistream_encoder_ctl(MSenc, OPUS_RESET_STATE)!=OPUS_OK)test_failed(); 617 opus_multistream_encoder_destroy(MSenc); 618 if(opus_decoder_ctl(dec, OPUS_RESET_STATE)!=OPUS_OK)test_failed(); 619 opus_decoder_destroy(dec); 620 if(opus_multistream_decoder_ctl(MSdec, OPUS_RESET_STATE)!=OPUS_OK)test_failed(); 621 opus_multistream_decoder_destroy(MSdec); 622 opus_multistream_decoder_destroy(MSdec_err); 623 for(i=0;i<10;i++)opus_decoder_destroy(dec_err[i]); 624 free(inbuf); 625 free(outbuf); 626 free(out2buf); 627 return 0; 628 } 629 630 void print_usage(char* _argv[]) 631 { 632 fprintf(stderr,"Usage: %s [<seed>] [-fuzz <num_encoders> <num_settings_per_encoder>]\n",_argv[0]); 633 } 634 635 int main(int _argc, char **_argv) 636 { 637 int args=1; 638 char * strtol_str=NULL; 639 const char * oversion; 640 const char * env_seed; 641 int env_used; 642 int num_encoders_to_fuzz=5; 643 int num_setting_changes=40; 644 645 env_used=0; 646 env_seed=getenv("SEED"); 647 if(_argc>1) 648 iseed=strtol(_argv[1], &strtol_str, 10); /* the first input argument might be the seed */ 649 if(strtol_str!=NULL && strtol_str[0]=='\0') /* iseed is a valid number */ 650 args++; 651 else if(env_seed) { 652 iseed=atoi(env_seed); 653 env_used=1; 654 } 655 else iseed=(opus_uint32)time(NULL)^(((opus_uint32)getpid()&65535)<<16); 656 Rw=Rz=iseed; 657 658 while(args<_argc) 659 { 660 if(strcmp(_argv[args], "-fuzz")==0 && _argc==(args+3)) { 661 num_encoders_to_fuzz=strtol(_argv[args+1], &strtol_str, 10); 662 if(strtol_str[0]!='\0' || num_encoders_to_fuzz<=0) { 663 print_usage(_argv); 664 return EXIT_FAILURE; 665 } 666 num_setting_changes=strtol(_argv[args+2], &strtol_str, 10); 667 if(strtol_str[0]!='\0' || num_setting_changes<=0) { 668 print_usage(_argv); 669 return EXIT_FAILURE; 670 } 671 args+=3; 672 } 673 else { 674 print_usage(_argv); 675 return EXIT_FAILURE; 676 } 677 } 678 679 oversion=opus_get_version_string(); 680 if(!oversion)test_failed(); 681 fprintf(stderr,"Testing %s encoder. Random seed: %u (%.4X)\n", oversion, iseed, fast_rand() % 65535); 682 if(env_used)fprintf(stderr," Random seed set from the environment (SEED=%s).\n", env_seed); 683 684 regression_test(); 685 686 /*Setting TEST_OPUS_NOFUZZ tells the tool not to send garbage data 687 into the decoders. This is helpful because garbage data 688 may cause the decoders to clip, which angers CLANG IOC.*/ 689 run_test1(getenv("TEST_OPUS_NOFUZZ")!=NULL); 690 691 /* Fuzz encoder settings online */ 692 if(getenv("TEST_OPUS_NOFUZZ")==NULL) { 693 fprintf(stderr,"Running fuzz_encoder_settings with %d encoder(s) and %d setting change(s) each.\n", 694 num_encoders_to_fuzz, num_setting_changes); 695 fuzz_encoder_settings(num_encoders_to_fuzz, num_setting_changes); 696 } 697 698 fprintf(stderr,"Tests completed successfully.\n"); 699 700 return 0; 701 } 702
