Fix NEON optimizations buffer read overrun
[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 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
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
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
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
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 }