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