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