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