Update bandwidth and opusCanSwitch before generating SILK DTX ToC
[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 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
388    for(rc=0;rc<3;rc++)
389    {
390       if(opus_encoder_ctl(enc, OPUS_SET_VBR(rc<2))!=OPUS_OK)test_failed();
391       if(opus_encoder_ctl(enc, OPUS_SET_VBR_CONSTRAINT(rc==1))!=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_INBAND_FEC(rc==0))!=OPUS_OK)test_failed();
394       for(j=0;j<13;j++)
395       {
396          int rate;
397          int modes[13]={0,0,0,1,1,1,1,2,2,2,2,2,2};
398          int rates[13]={6000,12000,48000,16000,32000,48000,64000,512000,13000,24000,48000,64000,96000};
399          int frame[13]={960*2,960,480,960,960,960,480,960*3,960*3,960,480,240,120};
400          rate=rates[j]+fast_rand()%rates[j];
401          count=i=0;
402          do {
403             int bw,len,out_samples,frame_size;
404             frame_size=frame[j];
405             if((fast_rand()&255)==0)
406             {
407                if(opus_encoder_ctl(enc, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
408                if(opus_decoder_ctl(dec, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
409                if((fast_rand()&1)!=0)
410                {
411                   if(opus_decoder_ctl(dec_err[fast_rand()&1], OPUS_RESET_STATE)!=OPUS_OK)test_failed();
412                }
413             }
414             if((fast_rand()&127)==0)
415             {
416                if(opus_decoder_ctl(dec_err[fast_rand()&1], OPUS_RESET_STATE)!=OPUS_OK)test_failed();
417             }
418             if(fast_rand()%10==0){
419                int complex=fast_rand()%11;
420                if(opus_encoder_ctl(enc, OPUS_SET_COMPLEXITY(complex))!=OPUS_OK)test_failed();
421             }
422             if(fast_rand()%50==0)opus_decoder_ctl(dec, OPUS_RESET_STATE);
423             if(opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(rc==0))!=OPUS_OK)test_failed();
424             if(opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(MODE_SILK_ONLY+modes[j]))!=OPUS_OK)test_failed();
425             if(opus_encoder_ctl(enc, OPUS_SET_DTX(fast_rand()&1))!=OPUS_OK)test_failed();
426             if(opus_encoder_ctl(enc, OPUS_SET_BITRATE(rate))!=OPUS_OK)test_failed();
427             if(opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS((rates[j]>=64000?2:1)))!=OPUS_OK)test_failed();
428             if(opus_encoder_ctl(enc, OPUS_SET_COMPLEXITY((count>>2)%11))!=OPUS_OK)test_failed();
429             if(opus_encoder_ctl(enc, OPUS_SET_PACKET_LOSS_PERC((fast_rand()&15)&(fast_rand()%15)))!=OPUS_OK)test_failed();
430             bw=modes[j]==0?OPUS_BANDWIDTH_NARROWBAND+(fast_rand()%3):
431                modes[j]==1?OPUS_BANDWIDTH_SUPERWIDEBAND+(fast_rand()&1):
432                            OPUS_BANDWIDTH_NARROWBAND+(fast_rand()%5);
433             if(modes[j]==2&&bw==OPUS_BANDWIDTH_MEDIUMBAND)bw+=3;
434             if(opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(bw))!=OPUS_OK)test_failed();
435             len = opus_encode(enc, &inbuf[i<<1], frame_size, packet, MAX_PACKET);
436             if(len<0 || len>MAX_PACKET)test_failed();
437             if(opus_encoder_ctl(enc, OPUS_GET_FINAL_RANGE(&enc_final_range))!=OPUS_OK)test_failed();
438             if((fast_rand()&3)==0)
439             {
440                if(opus_packet_pad(packet,len,len+1)!=OPUS_OK)test_failed();
441                len++;
442             }
443             if((fast_rand()&7)==0)
444             {
445                if(opus_packet_pad(packet,len,len+256)!=OPUS_OK)test_failed();
446                len+=256;
447             }
448             if((fast_rand()&3)==0)
449             {
450                len=opus_packet_unpad(packet,len);
451                if(len<1)test_failed();
452             }
453             out_samples = opus_decode(dec, packet, len, &outbuf[i<<1], MAX_FRAME_SAMP, 0);
454             if(out_samples!=frame_size)test_failed();
455             if(opus_decoder_ctl(dec, OPUS_GET_FINAL_RANGE(&dec_final_range))!=OPUS_OK)test_failed();
456             if(enc_final_range!=dec_final_range)test_failed();
457             /*LBRR decode*/
458             out_samples = opus_decode(dec_err[0], packet, len, out2buf, frame_size, (fast_rand()&3)!=0);
459             if(out_samples!=frame_size)test_failed();
460             out_samples = opus_decode(dec_err[1], packet, (fast_rand()&3)==0?0:len, out2buf, MAX_FRAME_SAMP, (fast_rand()&7)!=0);
461             if(out_samples<120)test_failed();
462             i+=frame_size;
463             count++;
464          }while(i<(SSAMPLES-MAX_FRAME_SAMP));
465          fprintf(stdout,"    Mode %s FB encode %s, %6d bps OK.\n",mstrings[modes[j]],rc==0?" VBR":rc==1?"CVBR":" CBR",rate);
466       }
467    }
468
469    if(opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(OPUS_AUTO))!=OPUS_OK)test_failed();
470    if(opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS(OPUS_AUTO))!=OPUS_OK)test_failed();
471    if(opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(0))!=OPUS_OK)test_failed();
472    if(opus_encoder_ctl(enc, OPUS_SET_DTX(0))!=OPUS_OK)test_failed();
473
474    for(rc=0;rc<3;rc++)
475    {
476       if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_VBR(rc<2))!=OPUS_OK)test_failed();
477       if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_VBR_CONSTRAINT(rc==1))!=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_INBAND_FEC(rc==0))!=OPUS_OK)test_failed();
480       for(j=0;j<16;j++)
481       {
482          int rate;
483          int modes[16]={0,0,0,0,0,0,0,0,2,2,2,2,2,2,2,2};
484          int rates[16]={4000,12000,32000,8000,16000,32000,48000,88000,4000,12000,32000,8000,16000,32000,48000,88000};
485          int frame[16]={160*1,160,80,160,160,80,40,20,160*1,160,80,160,160,80,40,20};
486          if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_INBAND_FEC(rc==0&&j==1))!=OPUS_OK)test_failed();
487          if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_FORCE_MODE(MODE_SILK_ONLY+modes[j]))!=OPUS_OK)test_failed();
488          rate=rates[j]+fast_rand()%rates[j];
489          if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_DTX(fast_rand()&1))!=OPUS_OK)test_failed();
490          if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_BITRATE(rate))!=OPUS_OK)test_failed();
491          count=i=0;
492          do {
493             int len,out_samples,frame_size,loss;
494             opus_int32 pred;
495             if(opus_multistream_encoder_ctl(MSenc, OPUS_GET_PREDICTION_DISABLED(&pred))!=OPUS_OK)test_failed();
496             if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_PREDICTION_DISABLED((int)(fast_rand()&15)<(pred?11:4)))!=OPUS_OK)test_failed();
497             frame_size=frame[j];
498             if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_COMPLEXITY((count>>2)%11))!=OPUS_OK)test_failed();
499             if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_PACKET_LOSS_PERC((fast_rand()&15)&(fast_rand()%15)))!=OPUS_OK)test_failed();
500             if((fast_rand()&255)==0)
501             {
502                if(opus_multistream_encoder_ctl(MSenc, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
503                if(opus_multistream_decoder_ctl(MSdec, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
504                if((fast_rand()&3)!=0)
505                {
506                   if(opus_multistream_decoder_ctl(MSdec_err, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
507                }
508             }
509             if((fast_rand()&255)==0)
510             {
511                if(opus_multistream_decoder_ctl(MSdec_err, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
512             }
513             len = opus_multistream_encode(MSenc, &inbuf[i<<1], frame_size, packet, MAX_PACKET);
514             if(len<0 || len>MAX_PACKET)test_failed();
515             if(opus_multistream_encoder_ctl(MSenc, OPUS_GET_FINAL_RANGE(&enc_final_range))!=OPUS_OK)test_failed();
516             if((fast_rand()&3)==0)
517             {
518                if(opus_multistream_packet_pad(packet,len,len+1,2)!=OPUS_OK)test_failed();
519                len++;
520             }
521             if((fast_rand()&7)==0)
522             {
523                if(opus_multistream_packet_pad(packet,len,len+256,2)!=OPUS_OK)test_failed();
524                len+=256;
525             }
526             if((fast_rand()&3)==0)
527             {
528                len=opus_multistream_packet_unpad(packet,len,2);
529                if(len<1)test_failed();
530             }
531             out_samples = opus_multistream_decode(MSdec, packet, len, out2buf, MAX_FRAME_SAMP, 0);
532             if(out_samples!=frame_size*6)test_failed();
533             if(opus_multistream_decoder_ctl(MSdec, OPUS_GET_FINAL_RANGE(&dec_final_range))!=OPUS_OK)test_failed();
534             if(enc_final_range!=dec_final_range)test_failed();
535             /*LBRR decode*/
536             loss=(fast_rand()&63)==0;
537             out_samples = opus_multistream_decode(MSdec_err, packet, loss?0:len, out2buf, frame_size*6, (fast_rand()&3)!=0);
538             if(out_samples!=(frame_size*6))test_failed();
539             i+=frame_size;
540             count++;
541          }while(i<(SSAMPLES/12-MAX_FRAME_SAMP));
542          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);
543       }
544    }
545
546    bitrate_bps=512000;
547    fsize=fast_rand()%31;
548    fswitch=100;
549
550    debruijn2(6,db62);
551    count=i=0;
552    do {
553       unsigned char toc;
554       const unsigned char *frames[48];
555       short size[48];
556       int payload_offset;
557       opus_uint32 dec_final_range2;
558       int jj,dec2;
559       int len,out_samples;
560       int frame_size=fsizes[db62[fsize]];
561       opus_int32 offset=i%(SAMPLES-MAX_FRAME_SAMP);
562
563       opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrate_bps));
564
565       len = opus_encode(enc, &inbuf[offset<<1], frame_size, packet, MAX_PACKET);
566       if(len<0 || len>MAX_PACKET)test_failed();
567       count++;
568
569       opus_encoder_ctl(enc, OPUS_GET_FINAL_RANGE(&enc_final_range));
570
571       out_samples = opus_decode(dec, packet, len, &outbuf[offset<<1], MAX_FRAME_SAMP, 0);
572       if(out_samples!=frame_size)test_failed();
573
574       opus_decoder_ctl(dec, OPUS_GET_FINAL_RANGE(&dec_final_range));
575
576       /* compare final range encoder rng values of encoder and decoder */
577       if(dec_final_range!=enc_final_range)test_failed();
578
579       /* We fuzz the packet, but take care not to only corrupt the payload
580          Corrupted headers are tested elsewhere and we need to actually run
581          the decoders in order to compare them. */
582       if(opus_packet_parse(packet,len,&toc,frames,size,&payload_offset)<=0)test_failed();
583       if((fast_rand()&1023)==0)len=0;
584       for(j=(frames[0]-packet);j<len;j++)for(jj=0;jj<8;jj++)packet[j]^=((!no_fuzz)&&((fast_rand()&1023)==0))<<jj;
585       out_samples = opus_decode(dec_err[0], len>0?packet:NULL, len, out2buf, MAX_FRAME_SAMP, 0);
586       if(out_samples<0||out_samples>MAX_FRAME_SAMP)test_failed();
587       if((len>0&&out_samples!=frame_size))test_failed(); /*FIXME use lastframe*/
588
589       opus_decoder_ctl(dec_err[0], OPUS_GET_FINAL_RANGE(&dec_final_range));
590
591       /*randomly select one of the decoders to compare with*/
592       dec2=fast_rand()%9+1;
593       out_samples = opus_decode(dec_err[dec2], len>0?packet:NULL, len, out2buf, MAX_FRAME_SAMP, 0);
594       if(out_samples<0||out_samples>MAX_FRAME_SAMP)test_failed(); /*FIXME, use factor, lastframe for loss*/
595
596       opus_decoder_ctl(dec_err[dec2], OPUS_GET_FINAL_RANGE(&dec_final_range2));
597       if(len>0&&dec_final_range!=dec_final_range2)test_failed();
598
599       fswitch--;
600       if(fswitch<1)
601       {
602         int new_size;
603         fsize=(fsize+1)%36;
604         new_size=fsizes[db62[fsize]];
605         if(new_size==960||new_size==480)fswitch=2880/new_size*(fast_rand()%19+1);
606         else fswitch=(fast_rand()%(2880/new_size))+1;
607       }
608       bitrate_bps=((fast_rand()%508000+4000)+bitrate_bps)>>1;
609       i+=frame_size;
610    }while(i<SAMPLES*4);
611    fprintf(stdout,"    All framesize pairs switching encode, %d frames OK.\n",count);
612
613    if(opus_encoder_ctl(enc, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
614    opus_encoder_destroy(enc);
615    if(opus_multistream_encoder_ctl(MSenc, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
616    opus_multistream_encoder_destroy(MSenc);
617    if(opus_decoder_ctl(dec, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
618    opus_decoder_destroy(dec);
619    if(opus_multistream_decoder_ctl(MSdec, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
620    opus_multistream_decoder_destroy(MSdec);
621    opus_multistream_decoder_destroy(MSdec_err);
622    for(i=0;i<10;i++)opus_decoder_destroy(dec_err[i]);
623    free(inbuf);
624    free(outbuf);
625    free(out2buf);
626    return 0;
627 }
628
629 void print_usage(char* _argv[])
630 {
631    fprintf(stderr,"Usage: %s [<seed>] [-fuzz <num_encoders> <num_settings_per_encoder>]\n",_argv[0]);
632 }
633
634 int main(int _argc, char **_argv)
635 {
636    int args=1;
637    char * strtol_str=NULL;
638    const char * oversion;
639    const char * env_seed;
640    int env_used;
641    int num_encoders_to_fuzz=5;
642    int num_setting_changes=40;
643
644    env_used=0;
645    env_seed=getenv("SEED");
646    if(_argc>1)
647       iseed=strtol(_argv[1], &strtol_str, 10);  /* the first input argument might be the seed */
648    if(strtol_str!=NULL && strtol_str[0]=='\0')   /* iseed is a valid number */
649       args++;
650    else if(env_seed) {
651       iseed=atoi(env_seed);
652       env_used=1;
653    }
654    else iseed=(opus_uint32)time(NULL)^(((opus_uint32)getpid()&65535)<<16);
655    Rw=Rz=iseed;
656
657    while(args<_argc)
658    {
659       if(strcmp(_argv[args], "-fuzz")==0 && _argc==(args+3)) {
660          num_encoders_to_fuzz=strtol(_argv[args+1], &strtol_str, 10);
661          if(strtol_str[0]!='\0' || num_encoders_to_fuzz<=0) {
662             print_usage(_argv);
663             return EXIT_FAILURE;
664          }
665          num_setting_changes=strtol(_argv[args+2], &strtol_str, 10);
666          if(strtol_str[0]!='\0' || num_setting_changes<=0) {
667             print_usage(_argv);
668             return EXIT_FAILURE;
669          }
670          args+=3;
671       }
672       else {
673         print_usage(_argv);
674         return EXIT_FAILURE;
675       }
676    }
677
678    oversion=opus_get_version_string();
679    if(!oversion)test_failed();
680    fprintf(stderr,"Testing %s encoder. Random seed: %u (%.4X)\n", oversion, iseed, fast_rand() % 65535);
681    if(env_used)fprintf(stderr,"  Random seed set from the environment (SEED=%s).\n", env_seed);
682
683    /*Setting TEST_OPUS_NOFUZZ tells the tool not to send garbage data
684      into the decoders. This is helpful because garbage data
685      may cause the decoders to clip, which angers CLANG IOC.*/
686    run_test1(getenv("TEST_OPUS_NOFUZZ")!=NULL);
687
688    /* Fuzz encoder settings online */
689    if(getenv("TEST_OPUS_NOFUZZ")==NULL) {
690       fprintf(stderr,"Running fuzz_encoder_settings with %d encoder(s) and %d setting change(s) each.\n",
691               num_encoders_to_fuzz, num_setting_changes);
692       fuzz_encoder_settings(num_encoders_to_fuzz, num_setting_changes);
693    }
694
695    fprintf(stderr,"Tests completed successfully.\n");
696
697    return 0;
698 }