Adds 3rd clause to CELT license
[opus.git] / tests / test_opus_decode.c
1 /* Copyright (c) 2011 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    - Neither the name of Internet Society, IETF or IETF Trust, nor the
16    names of specific contributors, may be used to endorse or promote
17    products derived from this software without specific prior written
18    permission.
19
20    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
24    OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
26    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
27    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
28    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
29    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
30    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 */
32
33 #ifdef HAVE_CONFIG_H
34 #include "config.h"
35 #endif
36
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <limits.h>
40 #include <stdint.h>
41 #include <math.h>
42 #include <string.h>
43 #include <time.h>
44 #include <unistd.h>
45 #include "opus.h"
46 #include "test_opus_common.h"
47
48 #define MAX_PACKET (1500)
49 #define MAX_FRAME_SAMP (5760)
50 extern int jackpot;
51
52 int test_decoder_code0(int no_fuzz)
53 {
54    static const opus_int32 fsv[5]={48000,24000,16000,12000,8000};
55    int err,skip,plen;
56    int out_samples,fec;
57    int t;
58    opus_int32 i;
59    OpusDecoder *dec[5*2];
60    opus_int32 decsize;
61    OpusDecoder *decbak;
62    opus_uint32 dec_final_range1,dec_final_range2,dec_final_acc;
63    unsigned char *packet;
64    unsigned char modes[4096];
65    short *outbuf_int;
66    short *outbuf;
67
68    dec_final_range1=dec_final_range2=2;
69
70    packet=malloc(sizeof(unsigned char)*MAX_PACKET);
71    if(packet==NULL)test_failed();
72
73    outbuf_int=malloc(sizeof(short)*(MAX_FRAME_SAMP+16)*2);
74    for(i=0;i<(MAX_FRAME_SAMP+16)*2;i++)outbuf_int[i]=32749;
75    outbuf=&outbuf_int[8*2];
76
77    fprintf(stdout,"  Starting %d decoders...\n",5*2);
78    for(t=0;t<5*2;t++)
79    {
80       int fs=fsv[t>>1];
81       int c=(t&1)+1;
82       err=OPUS_INTERNAL_ERROR;
83       dec[t] = opus_decoder_create(fs, c, &err);
84       if(err!=OPUS_OK || dec[t]==NULL)test_failed();
85       fprintf(stdout,"    opus_decoder_create(%5d,%d) OK. Copy ",fs,c);
86       {
87          OpusDecoder *dec2;
88          /*The opus state structures contain no pointers and can be freely copied*/
89          dec2=(OpusDecoder *)malloc(opus_decoder_get_size(c));
90          if(dec2==NULL)test_failed();
91          memcpy(dec2,dec[t],opus_decoder_get_size(c));
92          memset(dec[t],255,opus_decoder_get_size(c));
93          opus_decoder_destroy(dec[t]);
94          printf("OK.\n");
95          dec[t]=dec2;
96       }
97    }
98
99    decsize=opus_decoder_get_size(1);
100    decbak=(OpusDecoder *)malloc(decsize);
101    if(decbak==NULL)test_failed();
102
103    for(t=0;t<5*2;t++)
104    {
105       int factor=48000/fsv[t>>1];
106       for(fec=0;fec<2;fec++)
107       {
108          /*Test PLC on a fresh decoder*/
109          out_samples = opus_decode(dec[t], 0, 0, outbuf, MAX_FRAME_SAMP, fec);
110          if(out_samples!=120/factor)test_failed();
111
112          /*Test null pointer input*/
113          out_samples = opus_decode(dec[t], 0, -1, outbuf, MAX_FRAME_SAMP, fec);
114          if(out_samples!=120/factor)test_failed();
115          out_samples = opus_decode(dec[t], 0, 1, outbuf, MAX_FRAME_SAMP, fec);
116          if(out_samples!=120/factor)test_failed();
117          out_samples = opus_decode(dec[t], 0, 10, outbuf, MAX_FRAME_SAMP, fec);
118          if(out_samples!=120/factor)test_failed();
119          out_samples = opus_decode(dec[t], 0, fast_rand(), outbuf, MAX_FRAME_SAMP, fec);
120          if(out_samples!=120/factor)test_failed();
121
122          /*Zero lengths*/
123          out_samples = opus_decode(dec[t], packet, 0, outbuf, MAX_FRAME_SAMP, fec);
124          if(out_samples!=120/factor)test_failed();
125
126          /*Zero buffer*/
127          outbuf[0]=32749;
128          out_samples = opus_decode(dec[t], packet, 0, outbuf, 0, fec);
129          if(out_samples>0)test_failed();
130          out_samples = opus_decode(dec[t], packet, 0, 0, 0, fec);
131          if(out_samples>0)test_failed();
132          if(outbuf[0]!=32749)test_failed();
133
134          /*Invalid lengths*/
135          out_samples = opus_decode(dec[t], packet, -1, outbuf, MAX_FRAME_SAMP, fec);
136          if(out_samples>=0)test_failed();
137          out_samples = opus_decode(dec[t], packet, INT_MIN, outbuf, MAX_FRAME_SAMP, fec);
138          if(out_samples>=0)test_failed();
139          out_samples = opus_decode(dec[t], packet, -1, outbuf, -1, fec);
140          if(out_samples>=0)test_failed();
141
142          /*Crazy FEC values*/
143          out_samples = opus_decode(dec[t], packet, 1, outbuf, MAX_FRAME_SAMP, fec?-1:2);
144          if(out_samples>=0)test_failed();
145
146          /*Reset the decoder*/
147          if(opus_decoder_ctl(dec[t], OPUS_RESET_STATE)!=OPUS_OK)test_failed();
148       }
149    }
150    fprintf(stdout,"  dec[all] initial frame PLC OK.\n");
151
152    /*Count code 0 tests*/
153    for(i=0;i<64;i++)
154    {
155       int j,expected[5*2];
156       packet[0]=i<<2;
157       packet[1]=255;
158       packet[2]=255;
159       err=opus_packet_get_nb_channels(packet);
160       if(err!=(i&1)+1)test_failed();
161
162       for(t=0;t<5*2;t++){
163          expected[t]=opus_decoder_get_nb_samples(dec[t],packet,1);
164          if(expected[t]>2880)test_failed();
165       }
166
167       for(j=0;j<256;j++)
168       {
169          packet[1]=j;
170          for(t=0;t<5*2;t++)
171          {
172             out_samples = opus_decode(dec[t], packet, 3, outbuf, MAX_FRAME_SAMP, 0);
173             if(out_samples!=expected[t])test_failed();
174             opus_decoder_ctl(dec[t], OPUS_GET_FINAL_RANGE(&dec_final_range1));
175             if(t==0)dec_final_range2=dec_final_range1;
176             else if(dec_final_range1!=dec_final_range2)test_failed();
177          }
178       }
179
180       for(t=0;t<5*2;t++){
181          int factor=48000/fsv[t>>1];
182          /* The PLC is run for 6 frames in order to get better PLC coverage. */
183          for(j=0;j<6;j++)
184          {
185             out_samples = opus_decode(dec[t], 0, 0, outbuf, MAX_FRAME_SAMP, 0);
186             if(out_samples!=expected[t])test_failed();
187          }
188          /* Run the PLC once at 2.5ms, as a simulation of someone trying to
189             do small drift corrections. */
190          if(expected[t]!=120/factor)
191          {
192             out_samples = opus_decode(dec[t], 0, 0, outbuf, 120/factor, 0);
193             if(out_samples!=120/factor)test_failed();
194          }
195          out_samples = opus_decode(dec[t], packet, 2, outbuf, expected[t]-1, 0);
196          if(out_samples>0)test_failed();
197       }
198    }
199    fprintf(stdout,"  dec[all] all 2-byte prefix for length 3 and PLC, all modes (64) OK.\n");
200
201    {
202      /*We only test a subset of the modes here simply because the longer
203        durations end up taking a long time.*/
204       static const int cmodes[4]={16,20,24,28};
205       static const opus_uint32 cres[4]={116290185,2172123586,2172123586,2172123586};
206       static const opus_uint32 lres[3]={3285687739,1481572662,694350475};
207       static const int lmodes[3]={0,4,8};
208       int mode=fast_rand()%4;
209
210       packet[0]=cmodes[mode]<<3;
211       dec_final_acc=0;
212       t=fast_rand()%10;
213
214       for(i=0;i<65536;i++)
215       {
216          int factor=48000/fsv[t>>1];
217          packet[1]=i>>8;
218          packet[2]=i&255;
219          packet[3]=255;
220          out_samples = opus_decode(dec[t], packet, 4, outbuf, MAX_FRAME_SAMP, 0);
221          if(out_samples!=120/factor)test_failed();
222          opus_decoder_ctl(dec[t], OPUS_GET_FINAL_RANGE(&dec_final_range1));
223          dec_final_acc+=dec_final_range1;
224       }
225       if(dec_final_acc!=cres[mode])test_failed();
226       fprintf(stdout,"  dec[%3d] all 3-byte prefix for length 4, mode %2d OK.\n",t,cmodes[mode]);
227
228       mode=fast_rand()%3;
229       packet[0]=lmodes[mode]<<3;
230       dec_final_acc=0;
231       t=fast_rand()%10;
232       for(i=0;i<65536;i++)
233       {
234          int factor=48000/fsv[t>>1];
235          packet[1]=i>>8;
236          packet[2]=i&255;
237          packet[3]=255;
238          out_samples = opus_decode(dec[t], packet, 4, outbuf, MAX_FRAME_SAMP, 0);
239          if(out_samples!=480/factor)test_failed();
240          opus_decoder_ctl(dec[t], OPUS_GET_FINAL_RANGE(&dec_final_range1));
241          dec_final_acc+=dec_final_range1;
242       }
243       if(dec_final_acc!=lres[mode])test_failed();
244       fprintf(stdout,"  dec[%3d] all 3-byte prefix for length 4, mode %2d OK.\n",t,lmodes[mode]);
245    }
246
247    if(no_fuzz)
248    {
249       fprintf(stdout,"  Skipping many tests which fuzz the decoder as requested.\n");
250       for(t=0;t<5*2;t++)opus_decoder_destroy(dec[t]);
251       printf("  Decoders stopped.\n");
252       free(outbuf_int);
253       free(packet);
254       return 0;
255    }
256
257    skip=fast_rand()%7;
258    for(i=0;i<64;i++)
259    {
260       int j,expected[5*2];
261       packet[0]=i<<2;
262       for(t=0;t<5*2;t++)expected[t]=opus_decoder_get_nb_samples(dec[t],packet,1);
263       for(j=2+skip;j<1275;j+=4)
264       {
265          int jj;
266          for(jj=0;jj<j;jj++)packet[jj+1]=fast_rand()&255;
267          for(t=0;t<5*2;t++)
268          {
269             out_samples = opus_decode(dec[t], packet, j+1, outbuf, MAX_FRAME_SAMP, 0);
270             if(out_samples!=expected[t])test_failed();
271             opus_decoder_ctl(dec[t], OPUS_GET_FINAL_RANGE(&dec_final_range1));
272             if(t==0)dec_final_range2=dec_final_range1;
273             else if(dec_final_range1!=dec_final_range2)test_failed();
274          }
275       }
276    }
277    fprintf(stdout,"  dec[all] random packets, all modes (64), every 8th size from from %d bytes to maximum OK.\n",2+skip);
278
279    debruijn2(64,modes);
280    plen=(fast_rand()%18+3)*8+skip+3;
281    for(i=0;i<4096;i++)
282    {
283       int j,expected[5*2];
284       packet[0]=modes[i]<<2;
285       for(t=0;t<5*2;t++)expected[t]=opus_decoder_get_nb_samples(dec[t],packet,plen);
286       for(j=0;j<plen;j++)packet[j+1]=(fast_rand()|fast_rand())&255;
287       memcpy(decbak,dec[0],decsize);
288       if(opus_decode(decbak, packet, plen+1, outbuf, MAX_FRAME_SAMP, 1)!=expected[0])test_failed();
289       memcpy(decbak,dec[0],decsize);
290       if(opus_decode(decbak,  0, 0, outbuf, MAX_FRAME_SAMP, 1)<20)test_failed();
291       memcpy(decbak,dec[0],decsize);
292       if(opus_decode(decbak,  0, 0, outbuf, MAX_FRAME_SAMP, 0)<20)test_failed();
293       for(t=0;t<5*2;t++)
294       {
295          out_samples = opus_decode(dec[t], packet, plen+1, outbuf, MAX_FRAME_SAMP, 0);
296          if(out_samples!=expected[t])test_failed();
297          if(t==0)dec_final_range2=dec_final_range1;
298          else if(dec_final_range1!=dec_final_range2)test_failed();
299       }
300    }
301    fprintf(stdout,"  dec[all] random packets, all mode pairs (4096), %d bytes/frame OK.\n",plen+1);
302
303    plen=(fast_rand()%18+3)*8+skip+3;
304    t=rand()&3;
305    for(i=0;i<4096;i++)
306    {
307       int count,j,expected;
308       packet[0]=modes[i]<<2;
309       expected=opus_decoder_get_nb_samples(dec[t],packet,plen);
310       for(count=0;count<10;count++)
311       {
312          for(j=0;j<plen;j++)packet[j+1]=(fast_rand()|fast_rand())&255;
313          out_samples = opus_decode(dec[t], packet, plen+1, outbuf, MAX_FRAME_SAMP, 0);
314          if(out_samples!=expected)test_failed();
315       }
316    }
317    fprintf(stdout,"  dec[%3d] random packets, all mode pairs (4096)*10, %d bytes/frame OK.\n",t,plen+1);
318
319    {
320       int tmodes[1]={25<<2};
321       opus_uint32 tseeds[1]={140441};
322       int tlen[1]={157};
323       opus_int32 tret[1]={480};
324       t=fast_rand()&1;
325       for(i=0;i<1;i++)
326       {
327          int j;
328          packet[0]=tmodes[i];
329          Rw=Rz=tseeds[i];
330          for(j=1;j<tlen[i];j++)packet[j]=fast_rand()&255;
331          out_samples=opus_decode(dec[t], packet, tlen[i], outbuf, MAX_FRAME_SAMP, 0);
332          if(out_samples!=tret[i])test_failed();
333       }
334       fprintf(stdout,"  dec[%3d] pre-selected random packets OK.\n",t);
335    }
336
337    for(t=0;t<5*2;t++)opus_decoder_destroy(dec[t]);
338    printf("  Decoders stopped.\n");
339
340    err=0;
341    for(i=0;i<8*2;i++)err|=outbuf_int[i]!=32749;
342    for(i=MAX_FRAME_SAMP*2;i<(MAX_FRAME_SAMP+8)*2;i++)err|=outbuf[i]!=32749;
343    if(err)test_failed();
344
345    free(outbuf_int);
346    free(packet);
347    return 0;
348 }
349
350 int main(int _argc, char **_argv)
351 {
352    const char * oversion;
353    const char * env_seed;
354    int env_used;
355
356    if(_argc>2)
357    {
358       fprintf(stderr,"Usage: %s [<seed>]\n",_argv[0]);
359       return 1;
360    }
361
362    env_used=0;
363    env_seed=getenv("SEED");
364    if(_argc>1)iseed=atoi(_argv[1]);
365    else if(env_seed)
366    {
367       iseed=atoi(env_seed);
368       env_used=1;
369    }
370    else iseed=(opus_uint32)time(NULL)^((getpid()&65535)<<16);
371    Rw=Rz=iseed;
372
373    oversion=opus_get_version_string();
374    if(!oversion)test_failed();
375    fprintf(stderr,"Testing %s decoder. Random seed: %u (%.4X)\n", oversion, iseed, fast_rand() % 65535);
376    if(env_used)fprintf(stderr,"  Random seed set from the environment (SEED=%s).\n", env_seed);
377
378    /*Setting TEST_OPUS_NOFUZZ tells the tool not to send garbage data
379      into the decoders. This is helpful because garbage data
380      may cause the decoders to clip, which angers CLANG IOC.*/
381    test_decoder_code0(getenv("TEST_OPUS_NOFUZZ")!=NULL);
382
383    return 0;
384 }