be93df4844220d4bc26b6a5cb07e7af4452c328e
[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    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.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, 120/factor, 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, 120/factor, fec);
114          if(out_samples!=120/factor)test_failed();
115          out_samples = opus_decode(dec[t], 0, 1, outbuf, 120/factor, fec);
116          if(out_samples!=120/factor)test_failed();
117          out_samples = opus_decode(dec[t], 0, 10, outbuf, 120/factor, fec);
118          if(out_samples!=120/factor)test_failed();
119          out_samples = opus_decode(dec[t], 0, fast_rand(), outbuf, 120/factor, fec);
120          if(out_samples!=120/factor)test_failed();
121
122          /*Zero lengths*/
123          out_samples = opus_decode(dec[t], packet, 0, outbuf, 120/factor, 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, expected[t], 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    if(no_fuzz)
202    {
203       fprintf(stdout,"  Skipping many tests which fuzz the decoder as requested.\n");
204       free(decbak);
205       for(t=0;t<5*2;t++)opus_decoder_destroy(dec[t]);
206       printf("  Decoders stopped.\n");
207
208       err=0;
209       for(i=0;i<8*2;i++)err|=outbuf_int[i]!=32749;
210       for(i=MAX_FRAME_SAMP*2;i<(MAX_FRAME_SAMP+8)*2;i++)err|=outbuf[i]!=32749;
211       if(err)test_failed();
212
213       free(outbuf_int);
214       free(packet);
215       return 0;
216    }
217
218    {
219      /*We only test a subset of the modes here simply because the longer
220        durations end up taking a long time.*/
221       static const int cmodes[4]={16,20,24,28};
222       static const opus_uint32 cres[4]={116290185,2172123586,2172123586,2172123586};
223       static const opus_uint32 lres[3]={3285687739,1481572662,694350475};
224       static const int lmodes[3]={0,4,8};
225       int mode=fast_rand()%4;
226
227       packet[0]=cmodes[mode]<<3;
228       dec_final_acc=0;
229       t=fast_rand()%10;
230
231       for(i=0;i<65536;i++)
232       {
233          int factor=48000/fsv[t>>1];
234          packet[1]=i>>8;
235          packet[2]=i&255;
236          packet[3]=255;
237          out_samples = opus_decode(dec[t], packet, 4, outbuf, MAX_FRAME_SAMP, 0);
238          if(out_samples!=120/factor)test_failed();
239          opus_decoder_ctl(dec[t], OPUS_GET_FINAL_RANGE(&dec_final_range1));
240          dec_final_acc+=dec_final_range1;
241       }
242       if(dec_final_acc!=cres[mode])test_failed();
243       fprintf(stdout,"  dec[%3d] all 3-byte prefix for length 4, mode %2d OK.\n",t,cmodes[mode]);
244
245       mode=fast_rand()%3;
246       packet[0]=lmodes[mode]<<3;
247       dec_final_acc=0;
248       t=fast_rand()%10;
249       for(i=0;i<65536;i++)
250       {
251          int factor=48000/fsv[t>>1];
252          packet[1]=i>>8;
253          packet[2]=i&255;
254          packet[3]=255;
255          out_samples = opus_decode(dec[t], packet, 4, outbuf, MAX_FRAME_SAMP, 0);
256          if(out_samples!=480/factor)test_failed();
257          opus_decoder_ctl(dec[t], OPUS_GET_FINAL_RANGE(&dec_final_range1));
258          dec_final_acc+=dec_final_range1;
259       }
260       if(dec_final_acc!=lres[mode])test_failed();
261       fprintf(stdout,"  dec[%3d] all 3-byte prefix for length 4, mode %2d OK.\n",t,lmodes[mode]);
262    }
263
264    skip=fast_rand()%7;
265    for(i=0;i<64;i++)
266    {
267       int j,expected[5*2];
268       packet[0]=i<<2;
269       for(t=0;t<5*2;t++)expected[t]=opus_decoder_get_nb_samples(dec[t],packet,1);
270       for(j=2+skip;j<1275;j+=4)
271       {
272          int jj;
273          for(jj=0;jj<j;jj++)packet[jj+1]=fast_rand()&255;
274          for(t=0;t<5*2;t++)
275          {
276             out_samples = opus_decode(dec[t], packet, j+1, outbuf, MAX_FRAME_SAMP, 0);
277             if(out_samples!=expected[t])test_failed();
278             opus_decoder_ctl(dec[t], OPUS_GET_FINAL_RANGE(&dec_final_range1));
279             if(t==0)dec_final_range2=dec_final_range1;
280             else if(dec_final_range1!=dec_final_range2)test_failed();
281          }
282       }
283    }
284    fprintf(stdout,"  dec[all] random packets, all modes (64), every 8th size from from %d bytes to maximum OK.\n",2+skip);
285
286    debruijn2(64,modes);
287    plen=(fast_rand()%18+3)*8+skip+3;
288    for(i=0;i<4096;i++)
289    {
290       int j,expected[5*2];
291       packet[0]=modes[i]<<2;
292       for(t=0;t<5*2;t++)expected[t]=opus_decoder_get_nb_samples(dec[t],packet,plen);
293       for(j=0;j<plen;j++)packet[j+1]=(fast_rand()|fast_rand())&255;
294       memcpy(decbak,dec[0],decsize);
295       if(opus_decode(decbak, packet, plen+1, outbuf, expected[0], 1)!=expected[0])test_failed();
296       memcpy(decbak,dec[0],decsize);
297       if(opus_decode(decbak,  0, 0, outbuf, MAX_FRAME_SAMP, 1)<20)test_failed();
298       memcpy(decbak,dec[0],decsize);
299       if(opus_decode(decbak,  0, 0, outbuf, MAX_FRAME_SAMP, 0)<20)test_failed();
300       for(t=0;t<5*2;t++)
301       {
302          out_samples = opus_decode(dec[t], packet, plen+1, outbuf, MAX_FRAME_SAMP, 0);
303          if(out_samples!=expected[t])test_failed();
304          if(t==0)dec_final_range2=dec_final_range1;
305          else if(dec_final_range1!=dec_final_range2)test_failed();
306       }
307    }
308    fprintf(stdout,"  dec[all] random packets, all mode pairs (4096), %d bytes/frame OK.\n",plen+1);
309
310    plen=(fast_rand()%18+3)*8+skip+3;
311    t=rand()&3;
312    for(i=0;i<4096;i++)
313    {
314       int count,j,expected;
315       packet[0]=modes[i]<<2;
316       expected=opus_decoder_get_nb_samples(dec[t],packet,plen);
317       for(count=0;count<10;count++)
318       {
319          for(j=0;j<plen;j++)packet[j+1]=(fast_rand()|fast_rand())&255;
320          out_samples = opus_decode(dec[t], packet, plen+1, outbuf, MAX_FRAME_SAMP, 0);
321          if(out_samples!=expected)test_failed();
322       }
323    }
324    fprintf(stdout,"  dec[%3d] random packets, all mode pairs (4096)*10, %d bytes/frame OK.\n",t,plen+1);
325
326    {
327       int tmodes[1]={25<<2};
328       opus_uint32 tseeds[1]={140441};
329       int tlen[1]={157};
330       opus_int32 tret[1]={480};
331       t=fast_rand()&1;
332       for(i=0;i<1;i++)
333       {
334          int j;
335          packet[0]=tmodes[i];
336          Rw=Rz=tseeds[i];
337          for(j=1;j<tlen[i];j++)packet[j]=fast_rand()&255;
338          out_samples=opus_decode(dec[t], packet, tlen[i], outbuf, MAX_FRAME_SAMP, 0);
339          if(out_samples!=tret[i])test_failed();
340       }
341       fprintf(stdout,"  dec[%3d] pre-selected random packets OK.\n",t);
342    }
343
344    free(decbak);
345    for(t=0;t<5*2;t++)opus_decoder_destroy(dec[t]);
346    printf("  Decoders stopped.\n");
347
348    err=0;
349    for(i=0;i<8*2;i++)err|=outbuf_int[i]!=32749;
350    for(i=MAX_FRAME_SAMP*2;i<(MAX_FRAME_SAMP+8)*2;i++)err|=outbuf[i]!=32749;
351    if(err)test_failed();
352
353    free(outbuf_int);
354    free(packet);
355    return 0;
356 }
357
358 int main(int _argc, char **_argv)
359 {
360    const char * oversion;
361    const char * env_seed;
362    int env_used;
363
364    if(_argc>2)
365    {
366       fprintf(stderr,"Usage: %s [<seed>]\n",_argv[0]);
367       return 1;
368    }
369
370    env_used=0;
371    env_seed=getenv("SEED");
372    if(_argc>1)iseed=atoi(_argv[1]);
373    else if(env_seed)
374    {
375       iseed=atoi(env_seed);
376       env_used=1;
377    }
378    else iseed=(opus_uint32)time(NULL)^((getpid()&65535)<<16);
379    Rw=Rz=iseed;
380
381    oversion=opus_get_version_string();
382    if(!oversion)test_failed();
383    fprintf(stderr,"Testing %s decoder. Random seed: %u (%.4X)\n", oversion, iseed, fast_rand() % 65535);
384    if(env_used)fprintf(stderr,"  Random seed set from the environment (SEED=%s).\n", env_seed);
385
386    /*Setting TEST_OPUS_NOFUZZ tells the tool not to send garbage data
387      into the decoders. This is helpful because garbage data
388      may cause the decoders to clip, which angers CLANG IOC.*/
389    test_decoder_code0(getenv("TEST_OPUS_NOFUZZ")!=NULL);
390
391    return 0;
392 }