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
301 enc = opus_encoder_create(48000, 2, OPUS_APPLICATION_VOIP, &err);
302 if(err != OPUS_OK || enc==NULL)test_failed();
303
304 for(i=0;i<2;i++)
305 {
306 int *ret_err;
307 ret_err = i?0:&err;
308 MSenc = opus_multistream_encoder_create(8000, 2, 2, 0, mapping, OPUS_UNIMPLEMENTED, ret_err);
309 if((ret_err && *ret_err != OPUS_BAD_ARG) || MSenc!=NULL)test_failed();
310
311 MSenc = opus_multistream_encoder_create(8000, 0, 1, 0, mapping, OPUS_APPLICATION_VOIP, ret_err);
312 if((ret_err && *ret_err != OPUS_BAD_ARG) || MSenc!=NULL)test_failed();
313
314 MSenc = opus_multistream_encoder_create(44100, 2, 2, 0, mapping, OPUS_APPLICATION_VOIP, ret_err);
315 if((ret_err && *ret_err != OPUS_BAD_ARG) || MSenc!=NULL)test_failed();
316
317 MSenc = opus_multistream_encoder_create(8000, 2, 2, 3, mapping, OPUS_APPLICATION_VOIP, ret_err);
318 if((ret_err && *ret_err != OPUS_BAD_ARG) || MSenc!=NULL)test_failed();
319
320 MSenc = opus_multistream_encoder_create(8000, 2, -1, 0, mapping, OPUS_APPLICATION_VOIP, ret_err);
321 if((ret_err && *ret_err != OPUS_BAD_ARG) || MSenc!=NULL)test_failed();
322
323 MSenc = opus_multistream_encoder_create(8000, 256, 2, 0, mapping, OPUS_APPLICATION_VOIP, ret_err);
324 if((ret_err && *ret_err != OPUS_BAD_ARG) || MSenc!=NULL)test_failed();
325 }
326
327 MSenc = opus_multistream_encoder_create(8000, 2, 2, 0, mapping, OPUS_APPLICATION_AUDIO, &err);
328 if(err != OPUS_OK || MSenc==NULL)test_failed();
329
330 /*Some multistream encoder API tests*/
331 if(opus_multistream_encoder_ctl(MSenc, OPUS_GET_BITRATE(&i))!=OPUS_OK)test_failed();
332 if(opus_multistream_encoder_ctl(MSenc, OPUS_GET_LSB_DEPTH(&i))!=OPUS_OK)test_failed();
333 if(i<16)test_failed();
334
335 {
336 OpusEncoder *tmp_enc;
337 if(opus_multistream_encoder_ctl(MSenc, OPUS_MULTISTREAM_GET_ENCODER_STATE(1,&tmp_enc))!=OPUS_OK)test_failed();
338 if(opus_encoder_ctl(tmp_enc, OPUS_GET_LSB_DEPTH(&j))!=OPUS_OK)test_failed();
339 if(i!=j)test_failed();
340 if(opus_multistream_encoder_ctl(MSenc, OPUS_MULTISTREAM_GET_ENCODER_STATE(2,&tmp_enc))!=OPUS_BAD_ARG)test_failed();
341 }
342
343 dec = opus_decoder_create(48000, 2, &err);
344 if(err != OPUS_OK || dec==NULL)test_failed();
345
346 MSdec = opus_multistream_decoder_create(48000, 2, 2, 0, mapping, &err);
347 if(err != OPUS_OK || MSdec==NULL)test_failed();
348
349 MSdec_err = opus_multistream_decoder_create(48000, 3, 2, 0, mapping, &err);
350 if(err != OPUS_OK || MSdec_err==NULL)test_failed();
351
352 dec_err[0]=(OpusDecoder *)malloc(opus_decoder_get_size(2));
353 memcpy(dec_err[0],dec,opus_decoder_get_size(2));
354 dec_err[1] = opus_decoder_create(48000, 1, &err);
355 dec_err[2] = opus_decoder_create(24000, 2, &err);
356 dec_err[3] = opus_decoder_create(24000, 1, &err);
357 dec_err[4] = opus_decoder_create(16000, 2, &err);
358 dec_err[5] = opus_decoder_create(16000, 1, &err);
359 dec_err[6] = opus_decoder_create(12000, 2, &err);
360 dec_err[7] = opus_decoder_create(12000, 1, &err);
361 dec_err[8] = opus_decoder_create(8000, 2, &err);
362 dec_err[9] = opus_decoder_create(8000, 1, &err);
363 for(i=0;i<10;i++)if(dec_err[i]==NULL)test_failed();
364
365 {
366 OpusEncoder *enccpy;
367 /*The opus state structures contain no pointers and can be freely copied*/
368 enccpy=(OpusEncoder *)malloc(opus_encoder_get_size(2));
369 memcpy(enccpy,enc,opus_encoder_get_size(2));
370 memset(enc,255,opus_encoder_get_size(2));
371 opus_encoder_destroy(enc);
372 enc=enccpy;
373 }
374
375 inbuf=(short *)malloc(sizeof(short)*SAMPLES*2);
376 outbuf=(short *)malloc(sizeof(short)*SAMPLES*2);
377 out2buf=(short *)malloc(sizeof(short)*MAX_FRAME_SAMP*3);
378 if(inbuf==NULL || outbuf==NULL || out2buf==NULL)test_failed();
379
380 generate_music(inbuf,SAMPLES);
381
382 /* FILE *foo;
383 foo = fopen("foo.sw", "wb+");
384 fwrite(inbuf, 1, SAMPLES*2*2, foo);
385 fclose(foo);*/
386
387 if(opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(OPUS_AUTO))!=OPUS_OK)test_failed();
388 if(opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(-2))!=OPUS_BAD_ARG)test_failed();
389 if(opus_encode(enc, inbuf, 500, packet, MAX_PACKET)!=OPUS_BAD_ARG)test_failed();
390
391 for(rc=0;rc<3;rc++)
392 {
393 if(opus_encoder_ctl(enc, OPUS_SET_VBR(rc<2))!=OPUS_OK)test_failed();
394 if(opus_encoder_ctl(enc, OPUS_SET_VBR_CONSTRAINT(rc==1))!=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_INBAND_FEC(rc==0))!=OPUS_OK)test_failed();
397 for(j=0;j<13;j++)
398 {
399 int rate;
400 int modes[13]={0,0,0,1,1,1,1,2,2,2,2,2,2};
401 int rates[13]={6000,12000,48000,16000,32000,48000,64000,512000,13000,24000,48000,64000,96000};
402 int frame[13]={960*2,960,480,960,960,960,480,960*3,960*3,960,480,240,120};
403 rate=rates[j]+fast_rand()%rates[j];
404 count=i=0;
405 do {
406 int bw,len,out_samples,frame_size;
407 frame_size=frame[j];
408 if((fast_rand()&255)==0)
409 {
410 if(opus_encoder_ctl(enc, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
411 if(opus_decoder_ctl(dec, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
412 if((fast_rand()&1)!=0)
413 {
414 if(opus_decoder_ctl(dec_err[fast_rand()&1], OPUS_RESET_STATE)!=OPUS_OK)test_failed();
415 }
416 }
417 if((fast_rand()&127)==0)
418 {
419 if(opus_decoder_ctl(dec_err[fast_rand()&1], OPUS_RESET_STATE)!=OPUS_OK)test_failed();
420 }
421 if(fast_rand()%10==0){
422 int complex=fast_rand()%11;
423 if(opus_encoder_ctl(enc, OPUS_SET_COMPLEXITY(complex))!=OPUS_OK)test_failed();
424 }
425 if(fast_rand()%50==0)opus_decoder_ctl(dec, OPUS_RESET_STATE);
426 if(opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(rc==0))!=OPUS_OK)test_failed();
427 if(opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(MODE_SILK_ONLY+modes[j]))!=OPUS_OK)test_failed();
428 if(opus_encoder_ctl(enc, OPUS_SET_DTX(fast_rand()&1))!=OPUS_OK)test_failed();
429 if(opus_encoder_ctl(enc, OPUS_SET_BITRATE(rate))!=OPUS_OK)test_failed();
430 if(opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS((rates[j]>=64000?2:1)))!=OPUS_OK)test_failed();
431 if(opus_encoder_ctl(enc, OPUS_SET_COMPLEXITY((count>>2)%11))!=OPUS_OK)test_failed();
432 if(opus_encoder_ctl(enc, OPUS_SET_PACKET_LOSS_PERC((fast_rand()&15)&(fast_rand()%15)))!=OPUS_OK)test_failed();
433 bw=modes[j]==0?OPUS_BANDWIDTH_NARROWBAND+(fast_rand()%3):
434 modes[j]==1?OPUS_BANDWIDTH_SUPERWIDEBAND+(fast_rand()&1):
435 OPUS_BANDWIDTH_NARROWBAND+(fast_rand()%5);
436 if(modes[j]==2&&bw==OPUS_BANDWIDTH_MEDIUMBAND)bw+=3;
437 if(opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(bw))!=OPUS_OK)test_failed();
438 len = opus_encode(enc, &inbuf[i<<1], frame_size, packet, MAX_PACKET);
439 if(len<0 || len>MAX_PACKET)test_failed();
440 if(opus_encoder_ctl(enc, OPUS_GET_FINAL_RANGE(&enc_final_range))!=OPUS_OK)test_failed();
441 if((fast_rand()&3)==0)
442 {
443 if(opus_packet_pad(packet,len,len+1)!=OPUS_OK)test_failed();
444 len++;
445 }
446 if((fast_rand()&7)==0)
447 {
448 if(opus_packet_pad(packet,len,len+256)!=OPUS_OK)test_failed();
449 len+=256;
450 }
451 if((fast_rand()&3)==0)
452 {
453 len=opus_packet_unpad(packet,len);
454 if(len<1)test_failed();
455 }
456 out_samples = opus_decode(dec, packet, len, &outbuf[i<<1], MAX_FRAME_SAMP, 0);
457 if(out_samples!=frame_size)test_failed();
458 if(opus_decoder_ctl(dec, OPUS_GET_FINAL_RANGE(&dec_final_range))!=OPUS_OK)test_failed();
459 if(enc_final_range!=dec_final_range)test_failed();
460 /*LBRR decode*/
461 out_samples = opus_decode(dec_err[0], packet, len, out2buf, frame_size, (fast_rand()&3)!=0);
462 if(out_samples!=frame_size)test_failed();
463 out_samples = opus_decode(dec_err[1], packet, (fast_rand()&3)==0?0:len, out2buf, MAX_FRAME_SAMP, (fast_rand()&7)!=0);
464 if(out_samples<120)test_failed();
465 i+=frame_size;
466 count++;
467 }while(i<(SSAMPLES-MAX_FRAME_SAMP));
468 fprintf(stdout," Mode %s FB encode %s, %6d bps OK.\n",mstrings[modes[j]],rc==0?" VBR":rc==1?"CVBR":" CBR",rate);
469 }
470 }
471
472 if(opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(OPUS_AUTO))!=OPUS_OK)test_failed();
473 if(opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS(OPUS_AUTO))!=OPUS_OK)test_failed();
474 if(opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(0))!=OPUS_OK)test_failed();
475 if(opus_encoder_ctl(enc, OPUS_SET_DTX(0))!=OPUS_OK)test_failed();
476
477 for(rc=0;rc<3;rc++)
478 {
479 if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_VBR(rc<2))!=OPUS_OK)test_failed();
480 if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_VBR_CONSTRAINT(rc==1))!=OPUS_OK)test_failed();
481 if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_VBR_CONSTRAINT(rc==1))!=OPUS_OK)test_failed();
482 if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_INBAND_FEC(rc==0))!=OPUS_OK)test_failed();
483 for(j=0;j<16;j++)
484 {
485 int rate;
486 int modes[16]={0,0,0,0,0,0,0,0,2,2,2,2,2,2,2,2};
487 int rates[16]={4000,12000,32000,8000,16000,32000,48000,88000,4000,12000,32000,8000,16000,32000,48000,88000};
488 int frame[16]={160*1,160,80,160,160,80,40,20,160*1,160,80,160,160,80,40,20};
489 if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_INBAND_FEC(rc==0&&j==1))!=OPUS_OK)test_failed();
490 if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_FORCE_MODE(MODE_SILK_ONLY+modes[j]))!=OPUS_OK)test_failed();
491 rate=rates[j]+fast_rand()%rates[j];
492 if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_DTX(fast_rand()&1))!=OPUS_OK)test_failed();
493 if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_BITRATE(rate))!=OPUS_OK)test_failed();
494 count=i=0;
495 do {
496 int len,out_samples,frame_size,loss;
497 opus_int32 pred;
498 if(opus_multistream_encoder_ctl(MSenc, OPUS_GET_PREDICTION_DISABLED(&pred))!=OPUS_OK)test_failed();
499 if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_PREDICTION_DISABLED((int)(fast_rand()&15)<(pred?11:4)))!=OPUS_OK)test_failed();
500 frame_size=frame[j];
501 if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_COMPLEXITY((count>>2)%11))!=OPUS_OK)test_failed();
502 if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_PACKET_LOSS_PERC((fast_rand()&15)&(fast_rand()%15)))!=OPUS_OK)test_failed();
503 if((fast_rand()&255)==0)
504 {
505 if(opus_multistream_encoder_ctl(MSenc, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
506 if(opus_multistream_decoder_ctl(MSdec, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
507 if((fast_rand()&3)!=0)
508 {
509 if(opus_multistream_decoder_ctl(MSdec_err, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
510 }
511 }
512 if((fast_rand()&255)==0)
513 {
514 if(opus_multistream_decoder_ctl(MSdec_err, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
515 }
516 len = opus_multistream_encode(MSenc, &inbuf[i<<1], frame_size, packet, MAX_PACKET);
517 if(len<0 || len>MAX_PACKET)test_failed();
518 if(opus_multistream_encoder_ctl(MSenc, OPUS_GET_FINAL_RANGE(&enc_final_range))!=OPUS_OK)test_failed();
519 if((fast_rand()&3)==0)
520 {
521 if(opus_multistream_packet_pad(packet,len,len+1,2)!=OPUS_OK)test_failed();
522 len++;
523 }
524 if((fast_rand()&7)==0)
525 {
526 if(opus_multistream_packet_pad(packet,len,len+256,2)!=OPUS_OK)test_failed();
527 len+=256;
528 }
529 if((fast_rand()&3)==0)
530 {
531 len=opus_multistream_packet_unpad(packet,len,2);
532 if(len<1)test_failed();
533 }
534 out_samples = opus_multistream_decode(MSdec, packet, len, out2buf, MAX_FRAME_SAMP, 0);
535 if(out_samples!=frame_size*6)test_failed();
536 if(opus_multistream_decoder_ctl(MSdec, OPUS_GET_FINAL_RANGE(&dec_final_range))!=OPUS_OK)test_failed();
537 if(enc_final_range!=dec_final_range)test_failed();
538 /*LBRR decode*/
539 loss=(fast_rand()&63)==0;
540 out_samples = opus_multistream_decode(MSdec_err, packet, loss?0:len, out2buf, frame_size*6, (fast_rand()&3)!=0);
541 if(out_samples!=(frame_size*6))test_failed();
542 i+=frame_size;
543 count++;
544 }while(i<(SSAMPLES/12-MAX_FRAME_SAMP));
545 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);
546 }
547 }
548
549 bitrate_bps=512000;
550 fsize=fast_rand()%31;
551 fswitch=100;
552
553 debruijn2(6,db62);
554 count=i=0;
555 do {
556 unsigned char toc;
557 const unsigned char *frames[48];
558 short size[48];
559 int payload_offset;
560 opus_uint32 dec_final_range2;
561 int jj,dec2;
562 int len,out_samples;
563 int frame_size=fsizes[db62[fsize]];
564 opus_int32 offset=i%(SAMPLES-MAX_FRAME_SAMP);
565
566 opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrate_bps));
567
568 len = opus_encode(enc, &inbuf[offset<<1], frame_size, packet, MAX_PACKET);
569 if(len<0 || len>MAX_PACKET)test_failed();
570 count++;
571
572 opus_encoder_ctl(enc, OPUS_GET_FINAL_RANGE(&enc_final_range));
573
574 out_samples = opus_decode(dec, packet, len, &outbuf[offset<<1], MAX_FRAME_SAMP, 0);
575 if(out_samples!=frame_size)test_failed();
576
577 opus_decoder_ctl(dec, OPUS_GET_FINAL_RANGE(&dec_final_range));
578
579 /* compare final range encoder rng values of encoder and decoder */
580 if(dec_final_range!=enc_final_range)test_failed();
581
582 /* We fuzz the packet, but take care not to only corrupt the payload
583 Corrupted headers are tested elsewhere and we need to actually run
584 the decoders in order to compare them. */
585 if(opus_packet_parse(packet,len,&toc,frames,size,&payload_offset)<=0)test_failed();
586 if((fast_rand()&1023)==0)len=0;
587 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;
588 out_samples = opus_decode(dec_err[0], len>0?packet:NULL, len, out2buf, MAX_FRAME_SAMP, 0);
589 if(out_samples<0||out_samples>MAX_FRAME_SAMP)test_failed();
590 if((len>0&&out_samples!=frame_size))test_failed(); /*FIXME use lastframe*/
591
592 opus_decoder_ctl(dec_err[0], OPUS_GET_FINAL_RANGE(&dec_final_range));
593
594 /*randomly select one of the decoders to compare with*/
595 dec2=fast_rand()%9+1;
596 out_samples = opus_decode(dec_err[dec2], len>0?packet:NULL, len, out2buf, MAX_FRAME_SAMP, 0);
597 if(out_samples<0||out_samples>MAX_FRAME_SAMP)test_failed(); /*FIXME, use factor, lastframe for loss*/
598
599 opus_decoder_ctl(dec_err[dec2], OPUS_GET_FINAL_RANGE(&dec_final_range2));
600 if(len>0&&dec_final_range!=dec_final_range2)test_failed();
601
602 fswitch--;
603 if(fswitch<1)
604 {
605 int new_size;
606 fsize=(fsize+1)%36;
607 new_size=fsizes[db62[fsize]];
608 if(new_size==960||new_size==480)fswitch=2880/new_size*(fast_rand()%19+1);
609 else fswitch=(fast_rand()%(2880/new_size))+1;
610 }
611 bitrate_bps=((fast_rand()%508000+4000)+bitrate_bps)>>1;
612 i+=frame_size;
613 }while(i<SAMPLES*4);
614 fprintf(stdout," All framesize pairs switching encode, %d frames OK.\n",count);
615
616 if(opus_encoder_ctl(enc, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
617 opus_encoder_destroy(enc);
618 if(opus_multistream_encoder_ctl(MSenc, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
619 opus_multistream_encoder_destroy(MSenc);
620 if(opus_decoder_ctl(dec, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
621 opus_decoder_destroy(dec);
622 if(opus_multistream_decoder_ctl(MSdec, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
623 opus_multistream_decoder_destroy(MSdec);
624 opus_multistream_decoder_destroy(MSdec_err);
625 for(i=0;i<10;i++)opus_decoder_destroy(dec_err[i]);
626 free(inbuf);
627 free(outbuf);
628 free(out2buf);
629 return 0;
630 }
631
print_usage(char * _argv[])632 void print_usage(char* _argv[])
633 {
634 fprintf(stderr,"Usage: %s [<seed>] [-fuzz <num_encoders> <num_settings_per_encoder>]\n",_argv[0]);
635 }
636
main(int _argc,char ** _argv)637 int main(int _argc, char **_argv)
638 {
639 int args=1;
640 char * strtol_str=NULL;
641 const char * oversion;
642 const char * env_seed;
643 int env_used;
644 int num_encoders_to_fuzz=5;
645 int num_setting_changes=40;
646
647 env_used=0;
648 env_seed=getenv("SEED");
649 if(_argc>1)
650 iseed=strtol(_argv[1], &strtol_str, 10); /* the first input argument might be the seed */
651 if(strtol_str!=NULL && strtol_str[0]=='\0') /* iseed is a valid number */
652 args++;
653 else if(env_seed) {
654 iseed=atoi(env_seed);
655 env_used=1;
656 }
657 else iseed=(opus_uint32)time(NULL)^(((opus_uint32)getpid()&65535)<<16);
658 Rw=Rz=iseed;
659
660 while(args<_argc)
661 {
662 if(strcmp(_argv[args], "-fuzz")==0 && _argc==(args+3)) {
663 num_encoders_to_fuzz=strtol(_argv[args+1], &strtol_str, 10);
664 if(strtol_str[0]!='\0' || num_encoders_to_fuzz<=0) {
665 print_usage(_argv);
666 return EXIT_FAILURE;
667 }
668 num_setting_changes=strtol(_argv[args+2], &strtol_str, 10);
669 if(strtol_str[0]!='\0' || num_setting_changes<=0) {
670 print_usage(_argv);
671 return EXIT_FAILURE;
672 }
673 args+=3;
674 }
675 else {
676 print_usage(_argv);
677 return EXIT_FAILURE;
678 }
679 }
680
681 oversion=opus_get_version_string();
682 if(!oversion)test_failed();
683 fprintf(stderr,"Testing %s encoder. Random seed: %u (%.4X)\n", oversion, iseed, fast_rand() % 65535);
684 if(env_used)fprintf(stderr," Random seed set from the environment (SEED=%s).\n", env_seed);
685
686 regression_test();
687
688 /*Setting TEST_OPUS_NOFUZZ tells the tool not to send garbage data
689 into the decoders. This is helpful because garbage data
690 may cause the decoders to clip, which angers CLANG IOC.*/
691 run_test1(getenv("TEST_OPUS_NOFUZZ")!=NULL);
692
693 /* Fuzz encoder settings online */
694 if(getenv("TEST_OPUS_NOFUZZ")==NULL) {
695 fprintf(stderr,"Running fuzz_encoder_settings with %d encoder(s) and %d setting change(s) each.\n",
696 num_encoders_to_fuzz, num_setting_changes);
697 fuzz_encoder_settings(num_encoders_to_fuzz, num_setting_changes);
698 }
699
700 fprintf(stderr,"Tests completed successfully.\n");
701
702 return 0;
703 }
704