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
generate_music(short * buf,opus_int32 len)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
get_frame_size_enum(int frame_size,int sampling_rate)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
test_encode(OpusEncoder * enc,int channels,int frame_size,OpusDecoder * dec)143 int test_encode(OpusEncoder *enc, int channels, int frame_size, OpusDecoder *dec)
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 int ret = 0;
152
153 /* Generate input data */
154 inbuf = (opus_int16*)malloc(sizeof(*inbuf)*SSAMPLES);
155 generate_music(inbuf, SSAMPLES/2);
156
157 /* Allocate memory for output data */
158 outbuf = (opus_int16*)malloc(sizeof(*outbuf)*MAX_FRAME_SAMP*3);
159
160 /* Encode data, then decode for sanity check */
161 do {
162 len = opus_encode(enc, &inbuf[samp_count*channels], frame_size, packet, MAX_PACKET);
163 if(len<0 || len>MAX_PACKET) {
164 fprintf(stderr,"opus_encode() returned %d\n",len);
165 ret = -1;
166 break;
167 }
168
169 out_samples = opus_decode(dec, packet, len, outbuf, MAX_FRAME_SAMP, 0);
170 if(out_samples!=frame_size) {
171 fprintf(stderr,"opus_decode() returned %d\n",out_samples);
172 ret = -1;
173 break;
174 }
175
176 samp_count += frame_size;
177 } while (samp_count < ((SSAMPLES/2)-MAX_FRAME_SAMP));
178
179 /* Clean up */
180 free(inbuf);
181 free(outbuf);
182 return ret;
183 }
184
fuzz_encoder_settings(const int num_encoders,const int num_setting_changes)185 void fuzz_encoder_settings(const int num_encoders, const int num_setting_changes)
186 {
187 OpusEncoder *enc;
188 OpusDecoder *dec;
189 int i,j,err;
190
191 /* Parameters to fuzz. Some values are duplicated to increase their probability of being tested. */
192 int sampling_rates[5] = {8000, 12000, 16000, 24000, 48000};
193 int channels[2] = {1, 2};
194 int applications[3] = {OPUS_APPLICATION_AUDIO, OPUS_APPLICATION_VOIP, OPUS_APPLICATION_RESTRICTED_LOWDELAY};
195 int bitrates[11] = {6000, 12000, 16000, 24000, 32000, 48000, 64000, 96000, 510000, OPUS_AUTO, OPUS_BITRATE_MAX};
196 int force_channels[4] = {OPUS_AUTO, OPUS_AUTO, 1, 2};
197 int use_vbr[3] = {0, 1, 1};
198 int vbr_constraints[3] = {0, 1, 1};
199 int complexities[11] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
200 int max_bandwidths[6] = {OPUS_BANDWIDTH_NARROWBAND, OPUS_BANDWIDTH_MEDIUMBAND,
201 OPUS_BANDWIDTH_WIDEBAND, OPUS_BANDWIDTH_SUPERWIDEBAND,
202 OPUS_BANDWIDTH_FULLBAND, OPUS_BANDWIDTH_FULLBAND};
203 int signals[4] = {OPUS_AUTO, OPUS_AUTO, OPUS_SIGNAL_VOICE, OPUS_SIGNAL_MUSIC};
204 int inband_fecs[3] = {0, 0, 1};
205 int packet_loss_perc[4] = {0, 1, 2, 5};
206 int lsb_depths[2] = {8, 24};
207 int prediction_disabled[3] = {0, 0, 1};
208 int use_dtx[2] = {0, 1};
209 int frame_sizes_ms_x2[9] = {5, 10, 20, 40, 80, 120, 160, 200, 240}; /* x2 to avoid 2.5 ms */
210
211 for (i=0; i<num_encoders; i++) {
212 int sampling_rate = RAND_SAMPLE(sampling_rates);
213 int num_channels = RAND_SAMPLE(channels);
214 int application = RAND_SAMPLE(applications);
215
216 dec = opus_decoder_create(sampling_rate, num_channels, &err);
217 if(err!=OPUS_OK || dec==NULL)test_failed();
218
219 enc = opus_encoder_create(sampling_rate, num_channels, application, &err);
220 if(err!=OPUS_OK || enc==NULL)test_failed();
221
222 for (j=0; j<num_setting_changes; j++) {
223 int bitrate = RAND_SAMPLE(bitrates);
224 int force_channel = RAND_SAMPLE(force_channels);
225 int vbr = RAND_SAMPLE(use_vbr);
226 int vbr_constraint = RAND_SAMPLE(vbr_constraints);
227 int complexity = RAND_SAMPLE(complexities);
228 int max_bw = RAND_SAMPLE(max_bandwidths);
229 int sig = RAND_SAMPLE(signals);
230 int inband_fec = RAND_SAMPLE(inband_fecs);
231 int pkt_loss = RAND_SAMPLE(packet_loss_perc);
232 int lsb_depth = RAND_SAMPLE(lsb_depths);
233 int pred_disabled = RAND_SAMPLE(prediction_disabled);
234 int dtx = RAND_SAMPLE(use_dtx);
235 int frame_size_ms_x2 = RAND_SAMPLE(frame_sizes_ms_x2);
236 int frame_size = frame_size_ms_x2*sampling_rate/2000;
237 int frame_size_enum = get_frame_size_enum(frame_size, sampling_rate);
238 force_channel = IMIN(force_channel, num_channels);
239
240 if(opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrate)) != OPUS_OK) test_failed();
241 if(opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS(force_channel)) != OPUS_OK) test_failed();
242 if(opus_encoder_ctl(enc, OPUS_SET_VBR(vbr)) != OPUS_OK) test_failed();
243 if(opus_encoder_ctl(enc, OPUS_SET_VBR_CONSTRAINT(vbr_constraint)) != OPUS_OK) test_failed();
244 if(opus_encoder_ctl(enc, OPUS_SET_COMPLEXITY(complexity)) != OPUS_OK) test_failed();
245 if(opus_encoder_ctl(enc, OPUS_SET_MAX_BANDWIDTH(max_bw)) != OPUS_OK) test_failed();
246 if(opus_encoder_ctl(enc, OPUS_SET_SIGNAL(sig)) != OPUS_OK) test_failed();
247 if(opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(inband_fec)) != OPUS_OK) test_failed();
248 if(opus_encoder_ctl(enc, OPUS_SET_PACKET_LOSS_PERC(pkt_loss)) != OPUS_OK) test_failed();
249 if(opus_encoder_ctl(enc, OPUS_SET_LSB_DEPTH(lsb_depth)) != OPUS_OK) test_failed();
250 if(opus_encoder_ctl(enc, OPUS_SET_PREDICTION_DISABLED(pred_disabled)) != OPUS_OK) test_failed();
251 if(opus_encoder_ctl(enc, OPUS_SET_DTX(dtx)) != OPUS_OK) test_failed();
252 if(opus_encoder_ctl(enc, OPUS_SET_EXPERT_FRAME_DURATION(frame_size_enum)) != OPUS_OK) test_failed();
253
254 if(test_encode(enc, num_channels, frame_size, dec)) {
255 fprintf(stderr,
256 "fuzz_encoder_settings: %d kHz, %d ch, application: %d, "
257 "%d bps, force ch: %d, vbr: %d, vbr constraint: %d, complexity: %d, "
258 "max bw: %d, signal: %d, inband fec: %d, pkt loss: %d%%, lsb depth: %d, "
259 "pred disabled: %d, dtx: %d, (%d/2) ms\n",
260 sampling_rate/1000, num_channels, application, bitrate,
261 force_channel, vbr, vbr_constraint, complexity, max_bw, sig, inband_fec,
262 pkt_loss, lsb_depth, pred_disabled, dtx, frame_size_ms_x2);
263 test_failed();
264 }
265 }
266
267 opus_encoder_destroy(enc);
268 opus_decoder_destroy(dec);
269 }
270 }
271
run_test1(int no_fuzz)272 int run_test1(int no_fuzz)
273 {
274 static const int fsizes[6]={960*3,960*2,120,240,480,960};
275 static const char *mstrings[3] = {" LP","Hybrid"," MDCT"};
276 unsigned char mapping[256] = {0,1,255};
277 unsigned char db62[36];
278 opus_int32 i,j;
279 int rc,err;
280 OpusEncoder *enc;
281 OpusMSEncoder *MSenc;
282 OpusDecoder *dec;
283 OpusMSDecoder *MSdec;
284 OpusMSDecoder *MSdec_err;
285 OpusDecoder *dec_err[10];
286 short *inbuf;
287 short *outbuf;
288 short *out2buf;
289 opus_int32 bitrate_bps;
290 unsigned char packet[MAX_PACKET+257];
291 opus_uint32 enc_final_range;
292 opus_uint32 dec_final_range;
293 int fswitch;
294 int fsize;
295 int count;
296
297 /*FIXME: encoder api tests, fs!=48k, mono, VBR*/
298
299 fprintf(stdout," Encode+Decode tests.\n");
300 fflush(stdout);
301
302 enc = opus_encoder_create(48000, 2, OPUS_APPLICATION_VOIP, &err);
303 if(err != OPUS_OK || enc==NULL)test_failed();
304
305 for(i=0;i<2;i++)
306 {
307 int *ret_err;
308 ret_err = i?0:&err;
309 MSenc = opus_multistream_encoder_create(8000, 2, 2, 0, mapping, OPUS_UNIMPLEMENTED, ret_err);
310 if((ret_err && *ret_err != OPUS_BAD_ARG) || MSenc!=NULL)test_failed();
311
312 MSenc = opus_multistream_encoder_create(8000, 0, 1, 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(44100, 2, 2, 0, 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, 2, 3, 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, 2, -1, 0, mapping, OPUS_APPLICATION_VOIP, ret_err);
322 if((ret_err && *ret_err != OPUS_BAD_ARG) || MSenc!=NULL)test_failed();
323
324 MSenc = opus_multistream_encoder_create(8000, 256, 2, 0, mapping, OPUS_APPLICATION_VOIP, ret_err);
325 if((ret_err && *ret_err != OPUS_BAD_ARG) || MSenc!=NULL)test_failed();
326 }
327
328 MSenc = opus_multistream_encoder_create(8000, 2, 2, 0, mapping, OPUS_APPLICATION_AUDIO, &err);
329 if(err != OPUS_OK || MSenc==NULL)test_failed();
330
331 /*Some multistream encoder API tests*/
332 if(opus_multistream_encoder_ctl(MSenc, OPUS_GET_BITRATE(&i))!=OPUS_OK)test_failed();
333 if(opus_multistream_encoder_ctl(MSenc, OPUS_GET_LSB_DEPTH(&i))!=OPUS_OK)test_failed();
334 if(i<16)test_failed();
335
336 {
337 OpusEncoder *tmp_enc;
338 if(opus_multistream_encoder_ctl(MSenc, OPUS_MULTISTREAM_GET_ENCODER_STATE(1,&tmp_enc))!=OPUS_OK)test_failed();
339 if(opus_encoder_ctl(tmp_enc, OPUS_GET_LSB_DEPTH(&j))!=OPUS_OK)test_failed();
340 if(i!=j)test_failed();
341 if(opus_multistream_encoder_ctl(MSenc, OPUS_MULTISTREAM_GET_ENCODER_STATE(2,&tmp_enc))!=OPUS_BAD_ARG)test_failed();
342 }
343
344 dec = opus_decoder_create(48000, 2, &err);
345 if(err != OPUS_OK || dec==NULL)test_failed();
346
347 MSdec = opus_multistream_decoder_create(48000, 2, 2, 0, mapping, &err);
348 if(err != OPUS_OK || MSdec==NULL)test_failed();
349
350 MSdec_err = opus_multistream_decoder_create(48000, 3, 2, 0, mapping, &err);
351 if(err != OPUS_OK || MSdec_err==NULL)test_failed();
352
353 dec_err[0]=(OpusDecoder *)malloc(opus_decoder_get_size(2));
354 memcpy(dec_err[0],dec,opus_decoder_get_size(2));
355 dec_err[1] = opus_decoder_create(48000, 1, &err);
356 dec_err[2] = opus_decoder_create(24000, 2, &err);
357 dec_err[3] = opus_decoder_create(24000, 1, &err);
358 dec_err[4] = opus_decoder_create(16000, 2, &err);
359 dec_err[5] = opus_decoder_create(16000, 1, &err);
360 dec_err[6] = opus_decoder_create(12000, 2, &err);
361 dec_err[7] = opus_decoder_create(12000, 1, &err);
362 dec_err[8] = opus_decoder_create(8000, 2, &err);
363 dec_err[9] = opus_decoder_create(8000, 1, &err);
364 for(i=0;i<10;i++)if(dec_err[i]==NULL)test_failed();
365
366 {
367 OpusEncoder *enccpy;
368 /*The opus state structures contain no pointers and can be freely copied*/
369 enccpy=(OpusEncoder *)malloc(opus_encoder_get_size(2));
370 memcpy(enccpy,enc,opus_encoder_get_size(2));
371 memset(enc,255,opus_encoder_get_size(2));
372 opus_encoder_destroy(enc);
373 enc=enccpy;
374 }
375
376 inbuf=(short *)malloc(sizeof(short)*SAMPLES*2);
377 outbuf=(short *)malloc(sizeof(short)*SAMPLES*2);
378 out2buf=(short *)malloc(sizeof(short)*MAX_FRAME_SAMP*3);
379 if(inbuf==NULL || outbuf==NULL || out2buf==NULL)test_failed();
380
381 generate_music(inbuf,SAMPLES);
382
383 /* FILE *foo;
384 foo = fopen("foo.sw", "wb+");
385 fwrite(inbuf, 1, SAMPLES*2*2, foo);
386 fclose(foo);*/
387
388 if(opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(OPUS_AUTO))!=OPUS_OK)test_failed();
389 if(opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(-2))!=OPUS_BAD_ARG)test_failed();
390 if(opus_encode(enc, inbuf, 500, packet, MAX_PACKET)!=OPUS_BAD_ARG)test_failed();
391
392 for(rc=0;rc<3;rc++)
393 {
394 if(opus_encoder_ctl(enc, OPUS_SET_VBR(rc<2))!=OPUS_OK)test_failed();
395 if(opus_encoder_ctl(enc, OPUS_SET_VBR_CONSTRAINT(rc==1))!=OPUS_OK)test_failed();
396 if(opus_encoder_ctl(enc, OPUS_SET_VBR_CONSTRAINT(rc==1))!=OPUS_OK)test_failed();
397 if(opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(rc==0))!=OPUS_OK)test_failed();
398 for(j=0;j<13;j++)
399 {
400 int rate;
401 int modes[13]={0,0,0,1,1,1,1,2,2,2,2,2,2};
402 int rates[13]={6000,12000,48000,16000,32000,48000,64000,512000,13000,24000,48000,64000,96000};
403 int frame[13]={960*2,960,480,960,960,960,480,960*3,960*3,960,480,240,120};
404 rate=rates[j]+fast_rand()%rates[j];
405 count=i=0;
406 do {
407 int bw,len,out_samples,frame_size;
408 frame_size=frame[j];
409 if((fast_rand()&255)==0)
410 {
411 if(opus_encoder_ctl(enc, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
412 if(opus_decoder_ctl(dec, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
413 if((fast_rand()&1)!=0)
414 {
415 if(opus_decoder_ctl(dec_err[fast_rand()&1], OPUS_RESET_STATE)!=OPUS_OK)test_failed();
416 }
417 }
418 if((fast_rand()&127)==0)
419 {
420 if(opus_decoder_ctl(dec_err[fast_rand()&1], OPUS_RESET_STATE)!=OPUS_OK)test_failed();
421 }
422 if(fast_rand()%10==0){
423 int complex=fast_rand()%11;
424 if(opus_encoder_ctl(enc, OPUS_SET_COMPLEXITY(complex))!=OPUS_OK)test_failed();
425 }
426 if(fast_rand()%50==0)opus_decoder_ctl(dec, OPUS_RESET_STATE);
427 if(opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(rc==0))!=OPUS_OK)test_failed();
428 if(opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(MODE_SILK_ONLY+modes[j]))!=OPUS_OK)test_failed();
429 if(opus_encoder_ctl(enc, OPUS_SET_DTX(fast_rand()&1))!=OPUS_OK)test_failed();
430 if(opus_encoder_ctl(enc, OPUS_SET_BITRATE(rate))!=OPUS_OK)test_failed();
431 if(opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS((rates[j]>=64000?2:1)))!=OPUS_OK)test_failed();
432 if(opus_encoder_ctl(enc, OPUS_SET_COMPLEXITY((count>>2)%11))!=OPUS_OK)test_failed();
433 if(opus_encoder_ctl(enc, OPUS_SET_PACKET_LOSS_PERC((fast_rand()&15)&(fast_rand()%15)))!=OPUS_OK)test_failed();
434 bw=modes[j]==0?OPUS_BANDWIDTH_NARROWBAND+(fast_rand()%3):
435 modes[j]==1?OPUS_BANDWIDTH_SUPERWIDEBAND+(fast_rand()&1):
436 OPUS_BANDWIDTH_NARROWBAND+(fast_rand()%5);
437 if(modes[j]==2&&bw==OPUS_BANDWIDTH_MEDIUMBAND)bw+=3;
438 if(opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(bw))!=OPUS_OK)test_failed();
439 len = opus_encode(enc, &inbuf[i<<1], frame_size, packet, MAX_PACKET);
440 if(len<0 || len>MAX_PACKET)test_failed();
441 if(opus_encoder_ctl(enc, OPUS_GET_FINAL_RANGE(&enc_final_range))!=OPUS_OK)test_failed();
442 if((fast_rand()&3)==0)
443 {
444 if(opus_packet_pad(packet,len,len+1)!=OPUS_OK)test_failed();
445 len++;
446 }
447 if((fast_rand()&7)==0)
448 {
449 if(opus_packet_pad(packet,len,len+256)!=OPUS_OK)test_failed();
450 len+=256;
451 }
452 if((fast_rand()&3)==0)
453 {
454 len=opus_packet_unpad(packet,len);
455 if(len<1)test_failed();
456 }
457 out_samples = opus_decode(dec, packet, len, &outbuf[i<<1], MAX_FRAME_SAMP, 0);
458 if(out_samples!=frame_size)test_failed();
459 if(opus_decoder_ctl(dec, OPUS_GET_FINAL_RANGE(&dec_final_range))!=OPUS_OK)test_failed();
460 if(enc_final_range!=dec_final_range)test_failed();
461 /*LBRR decode*/
462 out_samples = opus_decode(dec_err[0], packet, len, out2buf, frame_size, (fast_rand()&3)!=0);
463 if(out_samples!=frame_size)test_failed();
464 out_samples = opus_decode(dec_err[1], packet, (fast_rand()&3)==0?0:len, out2buf, MAX_FRAME_SAMP, (fast_rand()&7)!=0);
465 if(out_samples<120)test_failed();
466 i+=frame_size;
467 count++;
468 }while(i<(SSAMPLES-MAX_FRAME_SAMP));
469 fprintf(stdout," Mode %s FB encode %s, %6d bps OK.\n",mstrings[modes[j]],rc==0?" VBR":rc==1?"CVBR":" CBR",rate);
470 fflush(stdout);
471 }
472 }
473
474 if(opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(OPUS_AUTO))!=OPUS_OK)test_failed();
475 if(opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS(OPUS_AUTO))!=OPUS_OK)test_failed();
476 if(opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(0))!=OPUS_OK)test_failed();
477 if(opus_encoder_ctl(enc, OPUS_SET_DTX(0))!=OPUS_OK)test_failed();
478
479 for(rc=0;rc<3;rc++)
480 {
481 if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_VBR(rc<2))!=OPUS_OK)test_failed();
482 if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_VBR_CONSTRAINT(rc==1))!=OPUS_OK)test_failed();
483 if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_VBR_CONSTRAINT(rc==1))!=OPUS_OK)test_failed();
484 if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_INBAND_FEC(rc==0))!=OPUS_OK)test_failed();
485 for(j=0;j<16;j++)
486 {
487 int rate;
488 int modes[16]={0,0,0,0,0,0,0,0,2,2,2,2,2,2,2,2};
489 int rates[16]={4000,12000,32000,8000,16000,32000,48000,88000,4000,12000,32000,8000,16000,32000,48000,88000};
490 int frame[16]={160*1,160,80,160,160,80,40,20,160*1,160,80,160,160,80,40,20};
491 if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_INBAND_FEC(rc==0&&j==1))!=OPUS_OK)test_failed();
492 if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_FORCE_MODE(MODE_SILK_ONLY+modes[j]))!=OPUS_OK)test_failed();
493 rate=rates[j]+fast_rand()%rates[j];
494 if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_DTX(fast_rand()&1))!=OPUS_OK)test_failed();
495 if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_BITRATE(rate))!=OPUS_OK)test_failed();
496 count=i=0;
497 do {
498 int len,out_samples,frame_size,loss;
499 opus_int32 pred;
500 if(opus_multistream_encoder_ctl(MSenc, OPUS_GET_PREDICTION_DISABLED(&pred))!=OPUS_OK)test_failed();
501 if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_PREDICTION_DISABLED((int)(fast_rand()&15)<(pred?11:4)))!=OPUS_OK)test_failed();
502 frame_size=frame[j];
503 if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_COMPLEXITY((count>>2)%11))!=OPUS_OK)test_failed();
504 if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_PACKET_LOSS_PERC((fast_rand()&15)&(fast_rand()%15)))!=OPUS_OK)test_failed();
505 if((fast_rand()&255)==0)
506 {
507 if(opus_multistream_encoder_ctl(MSenc, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
508 if(opus_multistream_decoder_ctl(MSdec, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
509 if((fast_rand()&3)!=0)
510 {
511 if(opus_multistream_decoder_ctl(MSdec_err, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
512 }
513 }
514 if((fast_rand()&255)==0)
515 {
516 if(opus_multistream_decoder_ctl(MSdec_err, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
517 }
518 len = opus_multistream_encode(MSenc, &inbuf[i<<1], frame_size, packet, MAX_PACKET);
519 if(len<0 || len>MAX_PACKET)test_failed();
520 if(opus_multistream_encoder_ctl(MSenc, OPUS_GET_FINAL_RANGE(&enc_final_range))!=OPUS_OK)test_failed();
521 if((fast_rand()&3)==0)
522 {
523 if(opus_multistream_packet_pad(packet,len,len+1,2)!=OPUS_OK)test_failed();
524 len++;
525 }
526 if((fast_rand()&7)==0)
527 {
528 if(opus_multistream_packet_pad(packet,len,len+256,2)!=OPUS_OK)test_failed();
529 len+=256;
530 }
531 if((fast_rand()&3)==0)
532 {
533 len=opus_multistream_packet_unpad(packet,len,2);
534 if(len<1)test_failed();
535 }
536 out_samples = opus_multistream_decode(MSdec, packet, len, out2buf, MAX_FRAME_SAMP, 0);
537 if(out_samples!=frame_size*6)test_failed();
538 if(opus_multistream_decoder_ctl(MSdec, OPUS_GET_FINAL_RANGE(&dec_final_range))!=OPUS_OK)test_failed();
539 if(enc_final_range!=dec_final_range)test_failed();
540 /*LBRR decode*/
541 loss=(fast_rand()&63)==0;
542 out_samples = opus_multistream_decode(MSdec_err, packet, loss?0:len, out2buf, frame_size*6, (fast_rand()&3)!=0);
543 if(out_samples!=(frame_size*6))test_failed();
544 i+=frame_size;
545 count++;
546 }while(i<(SSAMPLES/12-MAX_FRAME_SAMP));
547 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);
548 fflush(stdout);
549 }
550 }
551
552 bitrate_bps=512000;
553 fsize=fast_rand()%31;
554 fswitch=100;
555
556 debruijn2(6,db62);
557 count=i=0;
558 do {
559 unsigned char toc;
560 const unsigned char *frames[48];
561 short size[48];
562 int payload_offset;
563 opus_uint32 dec_final_range2;
564 int jj,dec2;
565 int len,out_samples;
566 int frame_size=fsizes[db62[fsize]];
567 opus_int32 offset=i%(SAMPLES-MAX_FRAME_SAMP);
568
569 opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrate_bps));
570
571 len = opus_encode(enc, &inbuf[offset<<1], frame_size, packet, MAX_PACKET);
572 if(len<0 || len>MAX_PACKET)test_failed();
573 count++;
574
575 opus_encoder_ctl(enc, OPUS_GET_FINAL_RANGE(&enc_final_range));
576
577 out_samples = opus_decode(dec, packet, len, &outbuf[offset<<1], MAX_FRAME_SAMP, 0);
578 if(out_samples!=frame_size)test_failed();
579
580 opus_decoder_ctl(dec, OPUS_GET_FINAL_RANGE(&dec_final_range));
581
582 /* compare final range encoder rng values of encoder and decoder */
583 if(dec_final_range!=enc_final_range)test_failed();
584
585 /* We fuzz the packet, but take care not to only corrupt the payload
586 Corrupted headers are tested elsewhere and we need to actually run
587 the decoders in order to compare them. */
588 if(opus_packet_parse(packet,len,&toc,frames,size,&payload_offset)<=0)test_failed();
589 if((fast_rand()&1023)==0)len=0;
590 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;
591 out_samples = opus_decode(dec_err[0], len>0?packet:NULL, len, out2buf, MAX_FRAME_SAMP, 0);
592 if(out_samples<0||out_samples>MAX_FRAME_SAMP)test_failed();
593 if((len>0&&out_samples!=frame_size))test_failed(); /*FIXME use lastframe*/
594
595 opus_decoder_ctl(dec_err[0], OPUS_GET_FINAL_RANGE(&dec_final_range));
596
597 /*randomly select one of the decoders to compare with*/
598 dec2=fast_rand()%9+1;
599 out_samples = opus_decode(dec_err[dec2], len>0?packet:NULL, len, out2buf, MAX_FRAME_SAMP, 0);
600 if(out_samples<0||out_samples>MAX_FRAME_SAMP)test_failed(); /*FIXME, use factor, lastframe for loss*/
601
602 opus_decoder_ctl(dec_err[dec2], OPUS_GET_FINAL_RANGE(&dec_final_range2));
603 if(len>0&&dec_final_range!=dec_final_range2)test_failed();
604
605 fswitch--;
606 if(fswitch<1)
607 {
608 int new_size;
609 fsize=(fsize+1)%36;
610 new_size=fsizes[db62[fsize]];
611 if(new_size==960||new_size==480)fswitch=2880/new_size*(fast_rand()%19+1);
612 else fswitch=(fast_rand()%(2880/new_size))+1;
613 }
614 bitrate_bps=((fast_rand()%508000+4000)+bitrate_bps)>>1;
615 i+=frame_size;
616 }while(i<SAMPLES*4);
617 fprintf(stdout," All framesize pairs switching encode, %d frames OK.\n",count);
618 fflush(stdout);
619
620 if(opus_encoder_ctl(enc, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
621 opus_encoder_destroy(enc);
622 if(opus_multistream_encoder_ctl(MSenc, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
623 opus_multistream_encoder_destroy(MSenc);
624 if(opus_decoder_ctl(dec, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
625 opus_decoder_destroy(dec);
626 if(opus_multistream_decoder_ctl(MSdec, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
627 opus_multistream_decoder_destroy(MSdec);
628 opus_multistream_decoder_destroy(MSdec_err);
629 for(i=0;i<10;i++)opus_decoder_destroy(dec_err[i]);
630 free(inbuf);
631 free(outbuf);
632 free(out2buf);
633 return 0;
634 }
635
print_usage(char * _argv[])636 void print_usage(char* _argv[])
637 {
638 fprintf(stderr,"Usage: %s [<seed>] [-fuzz <num_encoders> <num_settings_per_encoder>]\n",_argv[0]);
639 }
640
main(int _argc,char ** _argv)641 int main(int _argc, char **_argv)
642 {
643 int args=1;
644 char * strtol_str=NULL;
645 const char * oversion;
646 const char * env_seed;
647 int env_used;
648 int num_encoders_to_fuzz=5;
649 int num_setting_changes=40;
650
651 env_used=0;
652 env_seed=getenv("SEED");
653 if(_argc>1)
654 iseed=strtol(_argv[1], &strtol_str, 10); /* the first input argument might be the seed */
655 if(strtol_str!=NULL && strtol_str[0]=='\0') /* iseed is a valid number */
656 args++;
657 else if(env_seed) {
658 iseed=atoi(env_seed);
659 env_used=1;
660 }
661 else iseed=(opus_uint32)time(NULL)^(((opus_uint32)getpid()&65535)<<16);
662 Rw=Rz=iseed;
663
664 while(args<_argc)
665 {
666 if(strcmp(_argv[args], "-fuzz")==0 && _argc==(args+3)) {
667 num_encoders_to_fuzz=strtol(_argv[args+1], &strtol_str, 10);
668 if(strtol_str[0]!='\0' || num_encoders_to_fuzz<=0) {
669 print_usage(_argv);
670 return EXIT_FAILURE;
671 }
672 num_setting_changes=strtol(_argv[args+2], &strtol_str, 10);
673 if(strtol_str[0]!='\0' || num_setting_changes<=0) {
674 print_usage(_argv);
675 return EXIT_FAILURE;
676 }
677 args+=3;
678 }
679 else {
680 print_usage(_argv);
681 return EXIT_FAILURE;
682 }
683 }
684
685 oversion=opus_get_version_string();
686 if(!oversion)test_failed();
687 fprintf(stderr,"Testing %s encoder. Random seed: %u (%.4X)\n", oversion, iseed, fast_rand() % 65535);
688 if(env_used)fprintf(stderr," Random seed set from the environment (SEED=%s).\n", env_seed);
689
690 regression_test();
691
692 /*Setting TEST_OPUS_NOFUZZ tells the tool not to send garbage data
693 into the decoders. This is helpful because garbage data
694 may cause the decoders to clip, which angers CLANG IOC.*/
695 run_test1(getenv("TEST_OPUS_NOFUZZ")!=NULL);
696
697 /* Fuzz encoder settings online */
698 if(getenv("TEST_OPUS_NOFUZZ")==NULL) {
699 fprintf(stderr,"Running fuzz_encoder_settings with %d encoder(s) and %d setting change(s) each.\n",
700 num_encoders_to_fuzz, num_setting_changes);
701 fuzz_encoder_settings(num_encoders_to_fuzz, num_setting_changes);
702 }
703
704 fprintf(stderr,"Tests completed successfully.\n");
705
706 return 0;
707 }
708