b2f78e3137475d7292edca6c0fb3155bc4893fcf
[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 FOUNDATION OR
19    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 #include <unistd.h>
40 #include "opus.h"
41 #include "test_opus_common.h"
42
43 #define MAX_PACKET (1500)
44 #define MAX_FRAME_SAMP (5760)
45 extern int jackpot;
46
47 int test_decoder_code0(void)
48 {
49    static const opus_int32 fsv[5]={48000,24000,16000,12000,8000};
50    int err,skip,plen;
51    int out_samples,fec;
52    int t;
53    opus_int32 i;
54    OpusDecoder *dec[5*2];
55    opus_int32 decsize;
56    OpusDecoder *decbak;
57    opus_uint32 dec_final_range1,dec_final_range2,dec_final_acc;
58    unsigned char *packet;
59    unsigned char modes[4096];
60    short *outbuf_int;
61    short *outbuf;
62
63    dec_final_range1=dec_final_range2=2;
64
65    packet=malloc(sizeof(unsigned char)*MAX_PACKET);
66    if(packet==NULL)test_failed();
67
68    outbuf_int=malloc(sizeof(short)*(MAX_FRAME_SAMP+16)*2);
69    for(i=0;i<(MAX_FRAME_SAMP+16)*2;i++)outbuf_int[i]=32749;
70    outbuf=&outbuf_int[8*2];
71
72    fprintf(stdout,"  Starting %d decoders...\n",5*2);
73    for(t=0;t<5*2;t++)
74    {
75       int fs=fsv[t>>1];
76       int c=(t&1)+1;
77       err=OPUS_INTERNAL_ERROR;
78       dec[t] = opus_decoder_create(fs, c, &err);
79       if(err!=OPUS_OK || dec[t]==NULL)test_failed();
80       fprintf(stdout,"    opus_decoder_create(%5d,%d) OK. Copy ",fs,c);
81       {
82          OpusDecoder *dec2;
83          /*The opus state structures contain no pointers and can be freely copied*/
84          dec2=(OpusDecoder *)malloc(opus_decoder_get_size(c));
85          if(dec2==NULL)test_failed();
86          memcpy(dec2,dec[t],opus_decoder_get_size(c));
87          memset(dec[t],255,opus_decoder_get_size(c));
88          opus_decoder_destroy(dec[t]);
89          printf("OK.\n");
90          dec[t]=dec2;
91       }
92    }
93
94    decsize=opus_decoder_get_size(1);
95    decbak=(OpusDecoder *)malloc(decsize);
96    if(decbak==NULL)test_failed();
97
98    for(t=0;t<5*2;t++)
99    {
100       int factor=48000/fsv[t>>1];
101       for(fec=0;fec<2;fec++)
102       {
103          /*Test PLC on a fresh decoder*/
104          out_samples = opus_decode(dec[t], 0, 0, outbuf, MAX_FRAME_SAMP, fec);
105          if(out_samples!=120/factor)test_failed();
106
107          /*Test null pointer input*/
108          out_samples = opus_decode(dec[t], 0, -1, outbuf, MAX_FRAME_SAMP, fec);
109          if(out_samples!=120/factor)test_failed();
110          out_samples = opus_decode(dec[t], 0, 1, outbuf, MAX_FRAME_SAMP, fec);
111          if(out_samples!=120/factor)test_failed();
112          out_samples = opus_decode(dec[t], 0, 10, outbuf, MAX_FRAME_SAMP, fec);
113          if(out_samples!=120/factor)test_failed();
114          out_samples = opus_decode(dec[t], 0, fast_rand(), outbuf, MAX_FRAME_SAMP, fec);
115          if(out_samples!=120/factor)test_failed();
116
117          /*Zero lengths*/
118          out_samples = opus_decode(dec[t], packet, 0, outbuf, MAX_FRAME_SAMP, fec);
119          if(out_samples!=120/factor)test_failed();
120
121          /*Zero buffer*/
122          outbuf[0]=32749;
123          out_samples = opus_decode(dec[t], packet, 0, outbuf, 0, fec);
124          if(out_samples>0)test_failed();
125          out_samples = opus_decode(dec[t], packet, 0, 0, 0, fec);
126          if(out_samples>0)test_failed();
127          if(outbuf[0]!=32749)test_failed();
128
129          /*Invalid lengths*/
130          out_samples = opus_decode(dec[t], packet, -1, outbuf, MAX_FRAME_SAMP, fec);
131          if(out_samples>=0)test_failed();
132          out_samples = opus_decode(dec[t], packet, INT_MIN, outbuf, MAX_FRAME_SAMP, fec);
133          if(out_samples>=0)test_failed();
134          out_samples = opus_decode(dec[t], packet, -1, outbuf, -1, fec);
135          if(out_samples>=0)test_failed();
136
137          /*Crazy FEC values*/
138          out_samples = opus_decode(dec[t], packet, 1, outbuf, MAX_FRAME_SAMP, fec?-1:2);
139          if(out_samples>=0)test_failed();
140
141          /*Reset the decoder*/
142          if(opus_decoder_ctl(dec[t], OPUS_RESET_STATE)!=OPUS_OK)test_failed();
143       }
144    }
145    fprintf(stdout,"  dec[all] initial frame PLC OK.\n");
146
147    /*Count code 0 tests*/
148    for(i=0;i<64;i++)
149    {
150       int j,expected[5*2];
151       packet[0]=i<<2;
152       packet[1]=255;
153       packet[2]=255;
154       err=opus_packet_get_nb_channels(packet);
155       if(err!=(i&1)+1)test_failed();
156
157       for(t=0;t<5*2;t++){
158          expected[t]=opus_decoder_get_nb_samples(dec[t],packet,1);
159          if(expected[t]>2880)test_failed();
160       }
161
162       for(j=0;j<256;j++)
163       {
164          packet[1]=j;
165          for(t=0;t<5*2;t++)
166          {
167             out_samples = opus_decode(dec[t], packet, 3, outbuf, MAX_FRAME_SAMP, 0);
168             if(out_samples!=expected[t])test_failed();
169             opus_decoder_ctl(dec[t], OPUS_GET_FINAL_RANGE(&dec_final_range1));
170             if(t==0)dec_final_range2=dec_final_range1;
171             else if(dec_final_range1!=dec_final_range2)test_failed();
172          }
173       }
174
175       for(t=0;t<5*2;t++){
176          int factor=48000/fsv[t>>1];
177          /* The PLC is run for 6 frames in order to get better PLC coverage. */
178          for(j=0;j<6;j++)
179          {
180             out_samples = opus_decode(dec[t], 0, 0, outbuf, MAX_FRAME_SAMP, 0);
181             if(out_samples!=expected[t])test_failed();
182          }
183          /* Run the PLC once at 2.5ms, as a simulation of someone trying to
184             do small drift corrections. */
185          if(expected[t]!=120/factor)
186          {
187             out_samples = opus_decode(dec[t], 0, 0, outbuf, 120/factor, 0);
188             if(out_samples!=120/factor)test_failed();
189          }
190          out_samples = opus_decode(dec[t], packet, 2, outbuf, expected[t]-1, 0);
191          if(out_samples>0)test_failed();
192       }
193    }
194    fprintf(stdout,"  dec[all] all 2-byte prefix for length 3 and PLC, all modes (64) OK.\n");
195
196    {
197      /*We only test a subset of the modes here simply because the longer
198        durations end up taking a long time.*/
199       static const int cmodes[4]={16,20,24,28};
200       static const opus_uint32 cres[4]={116290185,2172123586,2172123586,2172123586};
201       static const opus_uint32 lres[3]={3285687739,1481572662,694350475};
202       static const int lmodes[3]={0,4,8};
203       int mode=fast_rand()%4;
204
205       packet[0]=cmodes[mode]<<3;
206       dec_final_acc=0;
207       t=fast_rand()%10;
208
209       for(i=0;i<65536;i++)
210       {
211          int factor=48000/fsv[t>>1];
212          packet[1]=i>>8;
213          packet[2]=i&255;
214          packet[3]=255;
215          out_samples = opus_decode(dec[t], packet, 4, outbuf, MAX_FRAME_SAMP, 0);
216          if(out_samples!=120/factor)test_failed();
217          opus_decoder_ctl(dec[t], OPUS_GET_FINAL_RANGE(&dec_final_range1));
218          dec_final_acc+=dec_final_range1;
219       }
220       if(dec_final_acc!=cres[mode])test_failed();
221       fprintf(stdout,"  dec[%3d] all 3-byte prefix for length 4, mode %2d OK.\n",t,cmodes[mode]);
222
223       mode=fast_rand()%3;
224       packet[0]=lmodes[mode]<<3;
225       dec_final_acc=0;
226       t=fast_rand()%10;
227       for(i=0;i<65536;i++)
228       {
229          int factor=48000/fsv[t>>1];
230          packet[1]=i>>8;
231          packet[2]=i&255;
232          packet[3]=255;
233          out_samples = opus_decode(dec[t], packet, 4, outbuf, MAX_FRAME_SAMP, 0);
234          if(out_samples!=480/factor)test_failed();
235          opus_decoder_ctl(dec[t], OPUS_GET_FINAL_RANGE(&dec_final_range1));
236          dec_final_acc+=dec_final_range1;
237       }
238       if(dec_final_acc!=lres[mode])test_failed();
239       fprintf(stdout,"  dec[%3d] all 3-byte prefix for length 4, mode %2d OK.\n",t,lmodes[mode]);
240    }
241
242    skip=fast_rand()%7;
243    for(i=0;i<64;i++)
244    {
245       int j,expected[5*2];
246       packet[0]=i<<2;
247       for(t=0;t<5*2;t++)expected[t]=opus_decoder_get_nb_samples(dec[t],packet,1);
248       for(j=2+skip;j<1275;j+=4)
249       {
250          int jj;
251          for(jj=0;jj<j;jj++)packet[jj+1]=fast_rand()&255;
252          for(t=0;t<5*2;t++)
253          {
254             out_samples = opus_decode(dec[t], packet, j+1, outbuf, MAX_FRAME_SAMP, 0);
255             if(out_samples!=expected[t])test_failed();
256             opus_decoder_ctl(dec[t], OPUS_GET_FINAL_RANGE(&dec_final_range1));
257             if(t==0)dec_final_range2=dec_final_range1;
258             else if(dec_final_range1!=dec_final_range2)test_failed();
259          }
260       }
261    }
262    fprintf(stdout,"  dec[all] random packets, all modes (64), every 8th size from from %d bytes to maximum OK.\n",2+skip);
263
264    debruijn2(64,modes);
265    plen=(fast_rand()%18+3)*8+skip+3;
266    for(i=0;i<4096;i++)
267    {
268       int j,expected[5*2];
269       packet[0]=modes[i]<<2;
270       for(t=0;t<5*2;t++)expected[t]=opus_decoder_get_nb_samples(dec[t],packet,plen);
271       for(j=0;j<plen;j++)packet[j+1]=(fast_rand()|fast_rand())&255;
272       memcpy(decbak,dec[0],decsize);
273       if(opus_decode(decbak, packet, plen+1, outbuf, MAX_FRAME_SAMP, 1)!=expected[0])test_failed();
274       memcpy(decbak,dec[0],decsize);
275       if(opus_decode(decbak,  0, 0, outbuf, MAX_FRAME_SAMP, 1)<20)test_failed();
276       memcpy(decbak,dec[0],decsize);
277       if(opus_decode(decbak,  0, 0, outbuf, MAX_FRAME_SAMP, 0)<20)test_failed();
278       for(t=0;t<5*2;t++)
279       {
280          out_samples = opus_decode(dec[t], packet, plen+1, outbuf, MAX_FRAME_SAMP, 0);
281          if(out_samples!=expected[t])test_failed();
282          if(t==0)dec_final_range2=dec_final_range1;
283          else if(dec_final_range1!=dec_final_range2)test_failed();
284       }
285    }
286    fprintf(stdout,"  dec[all] random packets, all mode pairs (4096), %d bytes/frame OK.\n",plen+1);
287
288    plen=(fast_rand()%18+3)*8+skip+3;
289    t=rand()&3;
290    for(i=0;i<4096;i++)
291    {
292       int count,j,expected;
293       packet[0]=modes[i]<<2;
294       expected=opus_decoder_get_nb_samples(dec[t],packet,plen);
295       for(count=0;count<10;count++)
296       {
297          for(j=0;j<plen;j++)packet[j+1]=(fast_rand()|fast_rand())&255;
298          out_samples = opus_decode(dec[t], packet, plen+1, outbuf, MAX_FRAME_SAMP, 0);
299          if(out_samples!=expected)test_failed();
300       }
301    }
302    fprintf(stdout,"  dec[%3d] random packets, all mode pairs (4096)*10, %d bytes/frame OK.\n",t,plen+1);
303
304    {
305       int tmodes[1]={25<<2};
306       opus_uint32 tseeds[1]={140441};
307       int tlen[1]={157};
308       opus_int32 tret[1]={480};
309       t=fast_rand()&1;
310       for(i=0;i<1;i++)
311       {
312          int j;
313          packet[0]=tmodes[i];
314          Rw=Rz=tseeds[i];
315          for(j=1;j<tlen[i];j++)packet[j]=fast_rand()&255;
316          out_samples=opus_decode(dec[t], packet, tlen[i], outbuf, MAX_FRAME_SAMP, 0);
317          if(out_samples!=tret[i])test_failed();
318       }
319       fprintf(stdout,"  dec[%3d] pre-selected random packets OK.\n",t);
320    }
321
322    for(t=0;t<5*2;t++)opus_decoder_destroy(dec[t]);
323    printf("  Decoders stopped.\n");
324
325    err=0;
326    for(i=0;i<8*2;i++)err|=outbuf_int[i]!=32749;
327    for(i=MAX_FRAME_SAMP*2;i<(MAX_FRAME_SAMP+8)*2;i++)err|=outbuf[i]!=32749;
328    if(err)test_failed();
329
330    free(outbuf_int);
331    free(packet);
332    return 0;
333 }
334
335 int main(int _argc, char **_argv)
336 {
337    const char * oversion;
338    const char * env_seed;
339    int env_used;
340
341    if(_argc>2)
342    {
343       fprintf(stderr,"Usage: %s [<seed>]\n",_argv[0]);
344       return 1;
345    }
346
347    env_used=0;
348    env_seed=getenv("SEED");
349    if(_argc>1)iseed=atoi(_argv[1]);
350    else if(env_seed)
351    {
352       iseed=atoi(env_seed);
353       env_used=1;
354    }
355    else iseed=(opus_uint32)time(NULL)^((getpid()&65535)<<16);
356    Rw=Rz=iseed;
357
358    oversion=opus_get_version_string();
359    if(!oversion)test_failed();
360    fprintf(stderr,"Testing %s decoder. Random seed: %u (%.4X)\n", oversion, iseed, fast_rand() % 65535);
361    if(env_used)fprintf(stderr,"  Random seed set from the environment (SEED=%s).\n", env_seed);
362
363    test_decoder_code0();
364
365    return 0;
366 }