Add tests for GET_LAST_PACKET_DURATION.
[opus.git] / tests / test_opus_api.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 /* This tests the API presented by the libopus system.
29    It does not attempt to extensively exercise the codec internals.
30    The strategy here is to simply the API interface invariants:
31    That sane options are accepted, insane options are rejected,
32    and that nothing blows up. In particular we don't actually test
33    that settings are heeded by the codec (though we do check that
34    get after set returns a sane value when it should). Other
35    tests check the actual codec behavior.
36    In cases where its reasonable to do so we test exhaustively,
37    but its not reasonable to do so in all cases.
38    Although these tests are simple they found several library bugs
39    when they were initially developed. */
40
41 /* These tests are more sensitive if compiled with -DVALGRIND and
42    run inside valgrind. Malloc failure testing requires glibc. */
43
44 #ifdef HAVE_CONFIG_H
45 #include "config.h"
46 #endif
47
48 #include <stdio.h>
49 #include <stdlib.h>
50 #include <stdint.h>
51 #include <string.h>
52 #include "arch.h"
53 #include "opus_multistream.h"
54 #include "opus.h"
55 #include "test_opus_common.h"
56
57 #ifdef VALGRIND
58 #include <valgrind/memcheck.h>
59 #define VG_UNDEF(x,y) VALGRIND_MAKE_MEM_UNDEFINED((x),(y))
60 #define VG_CHECK(x,y) VALGRIND_CHECK_MEM_IS_DEFINED((x),(y))
61 #else
62 #define VG_UNDEF(x,y)
63 #define VG_CHECK(x,y)
64 #endif
65
66 #if defined(HAVE___MALLOC_HOOK)
67 #define MALLOC_FAIL
68 #include "os_support.h"
69 #include <malloc.h>
70
71 static const opus_int32 opus_apps[3] = {OPUS_APPLICATION_VOIP,
72        OPUS_APPLICATION_AUDIO,OPUS_APPLICATION_RESTRICTED_LOWDELAY};
73
74 void *malloc_hook(__attribute__((unused)) size_t size,
75                   __attribute__((unused)) const void *caller)
76 {
77    return 0;
78 }
79 #endif
80
81 static const opus_int32 opus_rates[5] = {48000,24000,16000,12000,8000};
82
83 opus_int32 test_dec_api(void)
84 {
85    opus_uint32 dec_final_range;
86    OpusDecoder *dec;
87    OpusDecoder *dec2;
88    opus_int32 i,j,cfgs;
89    unsigned char packet[1276];
90 #ifndef DISABLE_FLOAT_API
91    float fbuf[960*2];
92 #endif
93    short sbuf[960*2];
94    int c,err;
95    opus_int32 *nullvalue;
96    nullvalue=0;
97
98    cfgs=0;
99    /*First test invalid configurations which should fail*/
100    fprintf(stdout,"\n  Decoder basic API tests\n");
101    fprintf(stdout,"  ---------------------------------------------------\n");
102    for(c=0;c<4;c++)
103    {
104       i=opus_decoder_get_size(c);
105       if(((c==1||c==2)&&(i<=2048||i>1<<16))||((c!=1&&c!=2)&&i!=0))test_failed();
106       fprintf(stdout,"    opus_decoder_get_size(%d)=%d ...............%s OK.\n",c,i,i>0?"":"....");
107       cfgs++;
108    }
109
110    /*Test with unsupported sample rates*/
111    for(c=0;c<4;c++)
112    {
113       for(i=-7;i<=96000;i++)
114       {
115          int fs;
116          if((i==8000||i==12000||i==16000||i==24000||i==48000)&&(c==1||c==2))continue;
117          switch(i)
118          {
119            case(-5):fs=-8000;break;
120            case(-6):fs=INT32_MAX;break;
121            case(-7):fs=INT32_MIN;break;
122            default:fs=i;
123          }
124          err = OPUS_OK;
125          VG_UNDEF(&err,sizeof(err));
126          dec = opus_decoder_create(fs, c, &err);
127          if(err!=OPUS_BAD_ARG || dec!=NULL)test_failed();
128          cfgs++;
129          dec = opus_decoder_create(fs, c, 0);
130          if(dec!=NULL)test_failed();
131          cfgs++;
132          dec=malloc(opus_decoder_get_size(2));
133          if(dec==NULL)test_failed();
134          err = opus_decoder_init(dec,fs,c);
135          if(err!=OPUS_BAD_ARG)test_failed();
136          cfgs++;
137          free(dec);
138       }
139    }
140
141    VG_UNDEF(&err,sizeof(err));
142    dec = opus_decoder_create(48000, 2, &err);
143    if(err!=OPUS_OK || dec==NULL)test_failed();
144    VG_CHECK(dec,opus_decoder_get_size(2));
145    cfgs++;
146
147    fprintf(stdout,"    opus_decoder_create() ........................ OK.\n");
148    fprintf(stdout,"    opus_decoder_init() .......................... OK.\n");
149
150    VG_UNDEF(&dec_final_range,sizeof(dec_final_range));
151    err=opus_decoder_ctl(dec, OPUS_GET_FINAL_RANGE(&dec_final_range));
152    if(err!=OPUS_OK)test_failed();
153    VG_CHECK(&dec_final_range,sizeof(dec_final_range));
154    fprintf(stdout,"    OPUS_GET_FINAL_RANGE ......................... OK.\n");
155    cfgs++;
156
157    err=opus_decoder_ctl(dec,OPUS_UNIMPLEMENTED);
158    if(err!=OPUS_UNIMPLEMENTED)test_failed();
159    fprintf(stdout,"    OPUS_UNIMPLEMENTED ........................... OK.\n");
160    cfgs++;
161
162    VG_UNDEF(&i,sizeof(i));
163    err=opus_decoder_ctl(dec, OPUS_GET_BANDWIDTH(&i));
164    if(err != OPUS_OK || i!=0)test_failed();
165    fprintf(stdout,"    OPUS_GET_BANDWIDTH ........................... OK.\n");
166    cfgs++;
167
168    /*GET_PITCH has different execution paths depending on the previously decoded frame.*/
169    err=opus_decoder_ctl(dec, OPUS_GET_PITCH(nullvalue));
170    if(err!=OPUS_BAD_ARG)test_failed();
171    cfgs++;
172    VG_UNDEF(&i,sizeof(i));
173    err=opus_decoder_ctl(dec, OPUS_GET_PITCH(&i));
174    if(err != OPUS_OK || i>0 || i<-1)test_failed();
175    cfgs++;
176    VG_UNDEF(packet,sizeof(packet));
177    packet[0]=63<<2;packet[1]=packet[2]=0;
178    if(opus_decode(dec, packet, 3, sbuf, 960, 0)!=960)test_failed();
179    cfgs++;
180    VG_UNDEF(&i,sizeof(i));
181    err=opus_decoder_ctl(dec, OPUS_GET_PITCH(&i));
182    if(err != OPUS_OK || i>0 || i<-1)test_failed();
183    cfgs++;
184    packet[0]=1;
185    if(opus_decode(dec, packet, 1, sbuf, 960, 0)!=960)test_failed();
186    cfgs++;
187    VG_UNDEF(&i,sizeof(i));
188    err=opus_decoder_ctl(dec, OPUS_GET_PITCH(&i));
189    if(err != OPUS_OK || i>0 || i<-1)test_failed();
190    cfgs++;
191    fprintf(stdout,"    OPUS_GET_PITCH ............................... OK.\n");
192
193    VG_UNDEF(&i,sizeof(i));
194    err=opus_decoder_ctl(dec, OPUS_GET_GAIN(&i));
195    VG_CHECK(&i,sizeof(i));
196    if(err != OPUS_OK || i!=0)test_failed();
197    cfgs++;
198    err=opus_decoder_ctl(dec, OPUS_GET_GAIN(nullvalue));
199    if(err != OPUS_BAD_ARG)test_failed();
200    cfgs++;
201    err=opus_decoder_ctl(dec, OPUS_SET_GAIN(-32769));
202    if(err != OPUS_BAD_ARG)test_failed();
203    cfgs++;
204    err=opus_decoder_ctl(dec, OPUS_SET_GAIN(32768));
205    if(err != OPUS_BAD_ARG)test_failed();
206    cfgs++;
207    err=opus_decoder_ctl(dec, OPUS_SET_GAIN(-15));
208    if(err != OPUS_OK)test_failed();
209    cfgs++;
210    VG_UNDEF(&i,sizeof(i));
211    err=opus_decoder_ctl(dec, OPUS_GET_GAIN(&i));
212    VG_CHECK(&i,sizeof(i));
213    if(err != OPUS_OK || i!=-15)test_failed();
214    cfgs++;
215    fprintf(stdout,"    OPUS_SET_GAIN ................................ OK.\n");
216    fprintf(stdout,"    OPUS_GET_GAIN ................................ OK.\n");
217
218    /*Reset the decoder*/
219    dec2=malloc(opus_decoder_get_size(2));
220    memcpy(dec2,dec,opus_decoder_get_size(2));
221    if(opus_decoder_ctl(dec, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
222    if(memcmp(dec2,dec,opus_decoder_get_size(2))==0)test_failed();
223    free(dec2);
224    fprintf(stdout,"    OPUS_RESET_STATE ............................. OK.\n");
225    cfgs++;
226
227    VG_UNDEF(packet,sizeof(packet));
228    packet[0]=0;
229    if(opus_decoder_get_nb_samples(dec,packet,1)!=480)test_failed();
230    if(opus_packet_get_nb_samples(packet,1,48000)!=480)test_failed();
231    if(opus_packet_get_nb_samples(packet,1,96000)!=960)test_failed();
232    if(opus_packet_get_nb_samples(packet,1,32000)!=320)test_failed();
233    if(opus_packet_get_nb_samples(packet,1,8000)!=80)test_failed();
234    packet[0]=3;
235    if(opus_packet_get_nb_samples(packet,1,24000)!=OPUS_INVALID_PACKET)test_failed();
236    packet[0]=(63<<2)|3;
237    packet[1]=63;
238    if(opus_packet_get_nb_samples(packet,0,24000)!=OPUS_BAD_ARG)test_failed();
239    if(opus_packet_get_nb_samples(packet,2,48000)!=OPUS_INVALID_PACKET)test_failed();
240    if(opus_decoder_get_nb_samples(dec,packet,2)!=OPUS_INVALID_PACKET)test_failed();
241    fprintf(stdout,"    opus_{packet,decoder}_get_nb_samples() ....... OK.\n");
242    cfgs+=9;
243
244    if(OPUS_BAD_ARG!=opus_packet_get_nb_frames(packet,0))test_failed();
245    for(i=0;i<256;i++) {
246      int l1res[4]={1,2,2,OPUS_INVALID_PACKET};
247      packet[0]=i;
248      if(l1res[packet[0]&3]!=opus_packet_get_nb_frames(packet,1))test_failed();
249      cfgs++;
250      for(j=0;j<256;j++) {
251        packet[1]=j;
252        if(((packet[0]&3)!=3?l1res[packet[0]&3]:packet[1]&63)!=opus_packet_get_nb_frames(packet,2))test_failed();
253        cfgs++;
254      }
255    }
256    fprintf(stdout,"    opus_packet_get_nb_frames() .................. OK.\n");
257
258    for(i=0;i<256;i++) {
259      int bw;
260      packet[0]=i;
261      bw=packet[0]>>4;
262      bw=OPUS_BANDWIDTH_NARROWBAND+(((((bw&7)*9)&(63-(bw&8)))+2+12*((bw&8)!=0))>>4);
263      if(bw!=opus_packet_get_bandwidth(packet))test_failed();
264      cfgs++;
265    }
266    fprintf(stdout,"    opus_packet_get_bandwidth() .................. OK.\n");
267
268    for(i=0;i<256;i++) {
269      int fp3s,rate;
270      packet[0]=i;
271      fp3s=packet[0]>>3;
272      fp3s=((((3-(fp3s&3))*13&119)+9)>>2)*((fp3s>13)*(3-((fp3s&3)==3))+1)*25;
273      for(rate=0;rate<5;rate++) {
274        if((opus_rates[rate]*3/fp3s)!=opus_packet_get_samples_per_frame(packet,opus_rates[rate]))test_failed();
275        cfgs++;
276      }
277    }
278    fprintf(stdout,"    opus_packet_get_samples_per_frame() .......... OK.\n");
279
280    packet[0]=(63<<2)+3;
281    packet[1]=49;
282    for(j=2;j<51;j++)packet[j]=0;
283    VG_UNDEF(sbuf,sizeof(sbuf));
284    if(opus_decode(dec, packet, 51, sbuf, 960, 0)!=OPUS_INVALID_PACKET)test_failed();
285    cfgs++;
286    packet[0]=(63<<2);
287    packet[1]=packet[2]=0;
288    if(opus_decode(dec, packet, -1, sbuf, 960, 0)!=OPUS_BAD_ARG)test_failed();
289    cfgs++;
290    if(opus_decode(dec, packet, 3, sbuf, 60, 0)!=OPUS_BUFFER_TOO_SMALL)test_failed();
291    cfgs++;
292    if(opus_decode(dec, packet, 3, sbuf, 480, 0)!=OPUS_BUFFER_TOO_SMALL)test_failed();
293    cfgs++;
294    if(opus_decode(dec, packet, 3, sbuf, 960, 0)!=960)test_failed();
295    cfgs++;
296    fprintf(stdout,"    opus_decode() ................................ OK.\n");
297 #ifndef DISABLE_FLOAT_API
298    VG_UNDEF(fbuf,sizeof(fbuf));
299    if(opus_decode_float(dec, packet, 3, fbuf, 960, 0)!=960)test_failed();
300    cfgs++;
301    fprintf(stdout,"    opus_decode_float() .......................... OK.\n");
302 #endif
303
304 #if 0
305    /*These tests are disabled because the library crashes with null states*/
306    if(opus_decoder_ctl(0,OPUS_RESET_STATE)         !=OPUS_INVALID_STATE)test_failed();
307    if(opus_decoder_init(0,48000,1)                 !=OPUS_INVALID_STATE)test_failed();
308    if(opus_decode(0,packet,1,outbuf,2880,0)        !=OPUS_INVALID_STATE)test_failed();
309    if(opus_decode_float(0,packet,1,0,2880,0)       !=OPUS_INVALID_STATE)test_failed();
310    if(opus_decoder_get_nb_samples(0,packet,1)      !=OPUS_INVALID_STATE)test_failed();
311    if(opus_packet_get_nb_frames(NULL,1)            !=OPUS_BAD_ARG)test_failed();
312    if(opus_packet_get_bandwidth(NULL)              !=OPUS_BAD_ARG)test_failed();
313    if(opus_packet_get_samples_per_frame(NULL,48000)!=OPUS_BAD_ARG)test_failed();
314 #endif
315    opus_decoder_destroy(dec);
316    cfgs++;
317    fprintf(stdout,"                   All decoder interface tests passed\n");
318    fprintf(stdout,"                             (%6d API invocations)\n",cfgs);
319    return cfgs;
320 }
321
322 opus_int32 test_msdec_api(void)
323 {
324    opus_uint32 dec_final_range;
325    OpusMSDecoder *dec;
326    OpusDecoder *streamdec;
327    opus_int32 i,j,cfgs;
328    unsigned char packet[1276];
329    unsigned char mapping[256];
330 #ifndef DISABLE_FLOAT_API
331    float fbuf[960*2];
332 #endif
333    short sbuf[960*2];
334    int a,b,c,err;
335 #if 0
336    /*Relevant test not enabled for multistream*/
337    int *nullvalue;
338    nullvalue=0;
339 #endif
340
341    mapping[0]=0;
342    mapping[1]=1;
343    for(i=2;i<256;i++)VG_UNDEF(&mapping[i],sizeof(unsigned char));
344
345    cfgs=0;
346    /*First test invalid configurations which should fail*/
347    fprintf(stdout,"\n  Multistream decoder basic API tests\n");
348    fprintf(stdout,"  ---------------------------------------------------\n");
349    for(a=-1;a<4;a++)
350    {
351       for(b=-1;b<4;b++)
352       {
353          i=opus_multistream_decoder_get_size(a,b);
354          if(((a>0&&b<=a&&b>=0)&&(i<=2048||i>((1<<16)*a)))||((a<1||b>a||b<0)&&i!=0))test_failed();
355          fprintf(stdout,"    opus_multistream_decoder_get_size(%2d,%2d)=%d %sOK.\n",a,b,i,i>0?"":"... ");
356          cfgs++;
357       }
358    }
359
360    /*Test with unsupported sample rates*/
361    for(c=1;c<3;c++)
362    {
363       for(i=-7;i<=96000;i++)
364       {
365          int fs;
366          if((i==8000||i==12000||i==16000||i==24000||i==48000)&&(c==1||c==2))continue;
367          switch(i)
368          {
369            case(-5):fs=-8000;break;
370            case(-6):fs=INT32_MAX;break;
371            case(-7):fs=INT32_MIN;break;
372            default:fs=i;
373          }
374          err = OPUS_OK;
375          VG_UNDEF(&err,sizeof(err));
376          dec = opus_multistream_decoder_create(fs, c, 1, c-1, mapping, &err);
377          if(err!=OPUS_BAD_ARG || dec!=NULL)test_failed();
378          cfgs++;
379          dec = opus_multistream_decoder_create(fs, c, 1, c-1, mapping, 0);
380          if(dec!=NULL)test_failed();
381          cfgs++;
382          dec=malloc(opus_multistream_decoder_get_size(1,1));
383          if(dec==NULL)test_failed();
384          err = opus_multistream_decoder_init(dec,fs,c,1,c-1, mapping);
385          if(err!=OPUS_BAD_ARG)test_failed();
386          cfgs++;
387          free(dec);
388       }
389    }
390
391    for(c=0;c<2;c++)
392    {
393       int *ret_err;
394       ret_err = c?0:&err;
395
396       mapping[0]=0;
397       mapping[1]=1;
398       for(i=2;i<256;i++)VG_UNDEF(&mapping[i],sizeof(unsigned char));
399
400       VG_UNDEF(ret_err,sizeof(*ret_err));
401       dec = opus_multistream_decoder_create(48000, 2, 1, 0, mapping, ret_err);
402       if(ret_err){VG_CHECK(ret_err,sizeof(*ret_err));}
403       if((ret_err && *ret_err!=OPUS_BAD_ARG) || dec!=NULL)test_failed();
404       cfgs++;
405
406       VG_UNDEF(ret_err,sizeof(*ret_err));
407       mapping[0]=mapping[1]=0;
408       dec = opus_multistream_decoder_create(48000, 2, 1, 0, mapping, ret_err);
409       if(ret_err){VG_CHECK(ret_err,sizeof(*ret_err));}
410       if((ret_err && *ret_err!=OPUS_OK) || dec==NULL)test_failed();
411       cfgs++;
412       opus_multistream_decoder_destroy(dec);
413       cfgs++;
414
415       VG_UNDEF(ret_err,sizeof(*ret_err));
416       dec = opus_multistream_decoder_create(48000, 1, 4, 1, mapping, ret_err);
417       if(ret_err){VG_CHECK(ret_err,sizeof(*ret_err));}
418       if((ret_err && *ret_err!=OPUS_OK) || dec==NULL)test_failed();
419       cfgs++;
420
421       err = opus_multistream_decoder_init(dec,48000, 1, 0, 0, mapping);
422       if(err!=OPUS_BAD_ARG)test_failed();
423       cfgs++;
424
425       err = opus_multistream_decoder_init(dec,48000, 1, 1, -1, mapping);
426       if(err!=OPUS_BAD_ARG)test_failed();
427       cfgs++;
428
429       opus_multistream_decoder_destroy(dec);
430       cfgs++;
431
432       VG_UNDEF(ret_err,sizeof(*ret_err));
433       dec = opus_multistream_decoder_create(48000, 2, 1, 1, mapping, ret_err);
434       if(ret_err){VG_CHECK(ret_err,sizeof(*ret_err));}
435       if((ret_err && *ret_err!=OPUS_OK) || dec==NULL)test_failed();
436       cfgs++;
437       opus_multistream_decoder_destroy(dec);
438       cfgs++;
439
440       VG_UNDEF(ret_err,sizeof(*ret_err));
441       dec = opus_multistream_decoder_create(48000, 255, 255, 1, mapping, ret_err);
442       if(ret_err){VG_CHECK(ret_err,sizeof(*ret_err));}
443       if((ret_err && *ret_err!=OPUS_BAD_ARG) || dec!=NULL)test_failed();
444       cfgs++;
445
446       VG_UNDEF(ret_err,sizeof(*ret_err));
447       dec = opus_multistream_decoder_create(48000, -1, 1, 1, mapping, ret_err);
448       if(ret_err){VG_CHECK(ret_err,sizeof(*ret_err));}
449       if((ret_err && *ret_err!=OPUS_BAD_ARG) || dec!=NULL)test_failed();
450       cfgs++;
451
452       VG_UNDEF(ret_err,sizeof(*ret_err));
453       dec = opus_multistream_decoder_create(48000, 0, 1, 1, mapping, ret_err);
454       if(ret_err){VG_CHECK(ret_err,sizeof(*ret_err));}
455       if((ret_err && *ret_err!=OPUS_BAD_ARG) || dec!=NULL)test_failed();
456       cfgs++;
457
458       VG_UNDEF(ret_err,sizeof(*ret_err));
459       dec = opus_multistream_decoder_create(48000, 1, -1, 2, mapping, ret_err);
460       if(ret_err){VG_CHECK(ret_err,sizeof(*ret_err));}
461       if((ret_err && *ret_err!=OPUS_BAD_ARG) || dec!=NULL)test_failed();
462       cfgs++;
463
464       VG_UNDEF(ret_err,sizeof(*ret_err));
465       dec = opus_multistream_decoder_create(48000, 1, -1, -1, mapping, ret_err);
466       if(ret_err){VG_CHECK(ret_err,sizeof(*ret_err));}
467       if((ret_err && *ret_err!=OPUS_BAD_ARG) || dec!=NULL)test_failed();
468       cfgs++;
469
470       VG_UNDEF(ret_err,sizeof(*ret_err));
471       dec = opus_multistream_decoder_create(48000, 256, 255, 1, mapping, ret_err);
472       if(ret_err){VG_CHECK(ret_err,sizeof(*ret_err));}
473       if((ret_err && *ret_err!=OPUS_BAD_ARG) || dec!=NULL)test_failed();
474       cfgs++;
475
476       VG_UNDEF(ret_err,sizeof(*ret_err));
477       dec = opus_multistream_decoder_create(48000, 256, 255, 0, mapping, ret_err);
478       if(ret_err){VG_CHECK(ret_err,sizeof(*ret_err));}
479       if((ret_err && *ret_err!=OPUS_BAD_ARG) || dec!=NULL)test_failed();
480       cfgs++;
481
482       VG_UNDEF(ret_err,sizeof(*ret_err));
483       mapping[0]=255;
484       mapping[1]=1;
485       mapping[2]=2;
486       dec = opus_multistream_decoder_create(48000, 3, 2, 0, mapping, ret_err);
487       if(ret_err){VG_CHECK(ret_err,sizeof(*ret_err));}
488       if((ret_err && *ret_err!=OPUS_BAD_ARG) || dec!=NULL)test_failed();
489       cfgs++;
490
491       VG_UNDEF(ret_err,sizeof(*ret_err));
492       mapping[0]=0;
493       mapping[1]=0;
494       mapping[2]=0;
495       dec = opus_multistream_decoder_create(48000, 3, 2, 1, mapping, ret_err);
496       if(ret_err){VG_CHECK(ret_err,sizeof(*ret_err));}
497       if((ret_err && *ret_err!=OPUS_OK) || dec==NULL)test_failed();
498       cfgs++;
499       opus_multistream_decoder_destroy(dec);
500       cfgs++;
501
502       VG_UNDEF(ret_err,sizeof(*ret_err));
503       mapping[0]=0;
504       mapping[1]=255;
505       mapping[2]=1;
506       mapping[3]=2;
507       mapping[4]=3;
508       dec = opus_multistream_decoder_create(48001, 5, 4, 1, mapping, ret_err);
509       if(ret_err){VG_CHECK(ret_err,sizeof(*ret_err));}
510       if((ret_err && *ret_err!=OPUS_BAD_ARG) || dec!=NULL)test_failed();
511       cfgs++;
512    }
513
514    VG_UNDEF(&err,sizeof(err));
515    mapping[0]=0;
516    mapping[1]=255;
517    mapping[2]=1;
518    mapping[3]=2;
519    dec = opus_multistream_decoder_create(48000, 4, 2, 1, mapping, &err);
520    VG_CHECK(&err,sizeof(err));
521    if(err!=OPUS_OK || dec==NULL)test_failed();
522    cfgs++;
523
524    fprintf(stdout,"    opus_multistream_decoder_create() ............ OK.\n");
525    fprintf(stdout,"    opus_multistream_decoder_init() .............. OK.\n");
526
527    VG_UNDEF(&dec_final_range,sizeof(dec_final_range));
528    err=opus_multistream_decoder_ctl(dec, OPUS_GET_FINAL_RANGE(&dec_final_range));
529    if(err!=OPUS_OK)test_failed();
530    VG_CHECK(&dec_final_range,sizeof(dec_final_range));
531    fprintf(stdout,"    OPUS_GET_FINAL_RANGE ......................... OK.\n");
532    cfgs++;
533
534    streamdec=0;
535    VG_UNDEF(&streamdec,sizeof(streamdec));
536    err=opus_multistream_decoder_ctl(dec, OPUS_MULTISTREAM_GET_DECODER_STATE(-1,&streamdec));
537    if(err!=OPUS_BAD_ARG)test_failed();
538    cfgs++;
539    err=opus_multistream_decoder_ctl(dec, OPUS_MULTISTREAM_GET_DECODER_STATE(1,&streamdec));
540    if(err!=OPUS_OK||streamdec==NULL)test_failed();
541    VG_CHECK(streamdec,opus_decoder_get_size(1));
542    cfgs++;
543    err=opus_multistream_decoder_ctl(dec, OPUS_MULTISTREAM_GET_DECODER_STATE(2,&streamdec));
544    if(err!=OPUS_BAD_ARG)test_failed();
545    cfgs++;
546    err=opus_multistream_decoder_ctl(dec, OPUS_MULTISTREAM_GET_DECODER_STATE(0,&streamdec));
547    if(err!=OPUS_OK||streamdec==NULL)test_failed();
548    VG_CHECK(streamdec,opus_decoder_get_size(1));
549    fprintf(stdout,"    OPUS_MULTISTREAM_GET_DECODER_STATE ........... OK.\n");
550    cfgs++;
551
552    for(j=0;j<2;j++)
553    {
554       OpusDecoder *od;
555       err=opus_multistream_decoder_ctl(dec,OPUS_MULTISTREAM_GET_DECODER_STATE(j,&od));
556       if(err != OPUS_OK)test_failed();
557       VG_UNDEF(&i,sizeof(i));
558       err=opus_decoder_ctl(od, OPUS_GET_GAIN(&i));
559       VG_CHECK(&i,sizeof(i));
560       if(err != OPUS_OK || i!=0)test_failed();
561       cfgs++;
562    }
563    err=opus_multistream_decoder_ctl(dec,OPUS_SET_GAIN(15));
564    if(err!=OPUS_OK)test_failed();
565    fprintf(stdout,"    OPUS_SET_GAIN ................................ OK.\n");
566    for(j=0;j<2;j++)
567    {
568       OpusDecoder *od;
569       err=opus_multistream_decoder_ctl(dec,OPUS_MULTISTREAM_GET_DECODER_STATE(j,&od));
570       if(err != OPUS_OK)test_failed();
571       VG_UNDEF(&i,sizeof(i));
572       err=opus_decoder_ctl(od, OPUS_GET_GAIN(&i));
573       VG_CHECK(&i,sizeof(i));
574       if(err != OPUS_OK || i!=15)test_failed();
575       cfgs++;
576    }
577    fprintf(stdout,"    OPUS_GET_GAIN ................................ OK.\n");
578
579    VG_UNDEF(&i,sizeof(i));
580    err=opus_multistream_decoder_ctl(dec, OPUS_GET_BANDWIDTH(&i));
581    if(err != OPUS_OK || i!=0)test_failed();
582    fprintf(stdout,"    OPUS_GET_BANDWIDTH ........................... OK.\n");
583    cfgs++;
584
585    err=opus_multistream_decoder_ctl(dec,OPUS_UNIMPLEMENTED);
586    if(err!=OPUS_UNIMPLEMENTED)test_failed();
587    fprintf(stdout,"    OPUS_UNIMPLEMENTED ........................... OK.\n");
588    cfgs++;
589
590 #if 0
591    /*Currently unimplemented for multistream*/
592    /*GET_PITCH has different execution paths depending on the previously decoded frame.*/
593    err=opus_multistream_decoder_ctl(dec, OPUS_GET_PITCH(nullvalue));
594    if(err!=OPUS_BAD_ARG)test_failed();
595    cfgs++;
596    VG_UNDEF(&i,sizeof(i));
597    err=opus_multistream_decoder_ctl(dec, OPUS_GET_PITCH(&i));
598    if(err != OPUS_OK || i>0 || i<-1)test_failed();
599    cfgs++;
600    VG_UNDEF(packet,sizeof(packet));
601    packet[0]=63<<2;packet[1]=packet[2]=0;
602    if(opus_multistream_decode(dec, packet, 3, sbuf, 960, 0)!=960)test_failed();
603    cfgs++;
604    VG_UNDEF(&i,sizeof(i));
605    err=opus_multistream_decoder_ctl(dec, OPUS_GET_PITCH(&i));
606    if(err != OPUS_OK || i>0 || i<-1)test_failed();
607    cfgs++;
608    packet[0]=1;
609    if(opus_multistream_decode(dec, packet, 1, sbuf, 960, 0)!=960)test_failed();
610    cfgs++;
611    VG_UNDEF(&i,sizeof(i));
612    err=opus_multistream_decoder_ctl(dec, OPUS_GET_PITCH(&i));
613    if(err != OPUS_OK || i>0 || i<-1)test_failed();
614    cfgs++;
615    fprintf(stdout,"    OPUS_GET_PITCH ............................... OK.\n");
616 #endif
617
618    /*Reset the decoder*/
619    if(opus_multistream_decoder_ctl(dec, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
620    fprintf(stdout,"    OPUS_RESET_STATE ............................. OK.\n");
621    cfgs++;
622
623    opus_multistream_decoder_destroy(dec);
624    cfgs++;
625    VG_UNDEF(&err,sizeof(err));
626    dec = opus_multistream_decoder_create(48000, 2, 1, 1, mapping, &err);
627    if(err!=OPUS_OK || dec==NULL)test_failed();
628    cfgs++;
629
630    packet[0]=(63<<2)+3;
631    packet[1]=49;
632    for(j=2;j<51;j++)packet[j]=0;
633    VG_UNDEF(sbuf,sizeof(sbuf));
634    if(opus_multistream_decode(dec, packet, 51, sbuf, 960, 0)!=OPUS_INVALID_PACKET)test_failed();
635    cfgs++;
636    packet[0]=(63<<2);
637    packet[1]=packet[2]=0;
638    if(opus_multistream_decode(dec, packet, -1, sbuf, 960, 0)!=OPUS_BAD_ARG){printf("%d\n",opus_multistream_decode(dec, packet, -1, sbuf, 960, 0));test_failed();}
639    cfgs++;
640    if(opus_multistream_decode(dec, packet, 3, sbuf, 60, 0)!=OPUS_BUFFER_TOO_SMALL)test_failed();
641    cfgs++;
642    if(opus_multistream_decode(dec, packet, 3, sbuf, 480, 0)!=OPUS_BUFFER_TOO_SMALL)test_failed();
643    cfgs++;
644    if(opus_multistream_decode(dec, packet, 3, sbuf, 960, 0)!=960)test_failed();
645    cfgs++;
646    fprintf(stdout,"    opus_multistream_decode() .................... OK.\n");
647 #ifndef DISABLE_FLOAT_API
648    VG_UNDEF(fbuf,sizeof(fbuf));
649    if(opus_multistream_decode_float(dec, packet, 3, fbuf, 960, 0)!=960)test_failed();
650    cfgs++;
651    fprintf(stdout,"    opus_multistream_decode_float() .............. OK.\n");
652 #endif
653
654 #if 0
655    /*These tests are disabled because the library crashes with null states*/
656    if(opus_multistream_decoder_ctl(0,OPUS_RESET_STATE)         !=OPUS_INVALID_STATE)test_failed();
657    if(opus_multistream_decoder_init(0,48000,1)                 !=OPUS_INVALID_STATE)test_failed();
658    if(opus_multistream_decode(0,packet,1,outbuf,2880,0)        !=OPUS_INVALID_STATE)test_failed();
659    if(opus_multistream_decode_float(0,packet,1,0,2880,0)       !=OPUS_INVALID_STATE)test_failed();
660    if(opus_multistream_decoder_get_nb_samples(0,packet,1)      !=OPUS_INVALID_STATE)test_failed();
661 #endif
662    opus_multistream_decoder_destroy(dec);
663    cfgs++;
664    fprintf(stdout,"       All multistream decoder interface tests passed\n");
665    fprintf(stdout,"                             (%6d API invocations)\n",cfgs);
666    return cfgs;
667 }
668
669 #ifdef VALGRIND
670 #define UNDEFINE_FOR_PARSE  toc=-1; \
671    frames[0]=(unsigned char *)0; \
672    frames[1]=(unsigned char *)0; \
673    payload_offset=-1; \
674    VG_UNDEF(&toc,sizeof(toc)); \
675    VG_UNDEF(frames,sizeof(frames));\
676    VG_UNDEF(&payload_offset,sizeof(payload_offset));
677 #else
678 #define UNDEFINE_FOR_PARSE  toc=-1; \
679    frames[0]=(unsigned char *)0; \
680    frames[1]=(unsigned char *)0; \
681    payload_offset=-1;
682 #endif
683
684 /* This test exercises the heck out of the libopus parser.
685    It is much larger than the parser itself in part because
686    it tries to hit a lot of corner cases that could never
687    fail with the libopus code, but might be problematic for
688    other implementations. */
689 opus_int32 test_parse(void)
690 {
691    opus_int32 i,j,jj,sz;
692    unsigned char packet[1276];
693    opus_int32 cfgs,cfgs_total;
694    unsigned char toc;
695    const unsigned char *frames[48];
696    short size[48];
697    int payload_offset, ret;
698    fprintf(stdout,"\n  Packet header parsing tests\n");
699    fprintf(stdout,"  ---------------------------------------------------\n");
700    memset(packet,0,sizeof(char)*1276);
701    packet[0]=63<<2;
702    if(opus_packet_parse(packet,1,&toc,frames,0,&payload_offset)!=OPUS_BAD_ARG)test_failed();
703    cfgs_total=cfgs=1;
704    /*code 0*/
705    for(i=0;i<64;i++)
706    {
707       UNDEFINE_FOR_PARSE
708       ret=opus_packet_parse(packet,4,&toc,frames,size,&payload_offset);
709       cfgs++;
710       if(ret!=1)test_failed();
711       if(size[0]!=3)test_failed();
712       if(frames[0]!=packet+1)test_failed();
713    }
714    fprintf(stdout,"    code 0 (%2d cases) ............................ OK.\n",cfgs);
715    cfgs_total+=cfgs;cfgs=0;
716
717    /*code 1, two frames of the same size*/
718    for(i=0;i<64;i++)
719    {
720       packet[0]=(i<<2)+1;
721       for(jj=0;jj<=1275*2+3;jj++)
722       {
723          UNDEFINE_FOR_PARSE
724          ret=opus_packet_parse(packet,jj,&toc,frames,size,&payload_offset);
725          cfgs++;
726          if((jj&1)==1 && jj<=2551)
727          {
728             /* Must pass if payload length even (packet length odd) and
729                size<=2551, must fail otherwise. */
730             if(ret!=2)test_failed();
731             if(size[0]!=size[1] || size[0]!=((jj-1)>>1))test_failed();
732             if(frames[0]!=packet+1)test_failed();
733             if(frames[1]!=frames[0]+size[0])test_failed();
734             if((toc>>2)!=i)test_failed();
735          } else if(ret!=OPUS_INVALID_PACKET)test_failed();
736       }
737    }
738    fprintf(stdout,"    code 1 (%6d cases) ........................ OK.\n",cfgs);
739    cfgs_total+=cfgs;cfgs=0;
740
741    for(i=0;i<64;i++)
742    {
743       /*code 2, length code overflow*/
744       packet[0]=(i<<2)+2;
745       UNDEFINE_FOR_PARSE
746       ret=opus_packet_parse(packet,1,&toc,frames,size,&payload_offset);
747       cfgs++;
748       if(ret!=OPUS_INVALID_PACKET)test_failed();
749       packet[1]=252;
750       UNDEFINE_FOR_PARSE
751       ret=opus_packet_parse(packet,2,&toc,frames,size,&payload_offset);
752       cfgs++;
753       if(ret!=OPUS_INVALID_PACKET)test_failed();
754       for(j=0;j<1275;j++)
755       {
756          if(j<252)packet[1]=j;
757          else{packet[1]=252+(j&3);packet[2]=(j-252)>>2;}
758          /*Code 2, one too short*/
759          UNDEFINE_FOR_PARSE
760          ret=opus_packet_parse(packet,j+(j<252?2:3)-1,&toc,frames,size,&payload_offset);
761          cfgs++;
762          if(ret!=OPUS_INVALID_PACKET)test_failed();
763          /*Code 2, one too long*/
764          UNDEFINE_FOR_PARSE
765          ret=opus_packet_parse(packet,j+(j<252?2:3)+1276,&toc,frames,size,&payload_offset);
766          cfgs++;
767          if(ret!=OPUS_INVALID_PACKET)test_failed();
768          /*Code 2, second zero*/
769          UNDEFINE_FOR_PARSE
770          ret=opus_packet_parse(packet,j+(j<252?2:3),&toc,frames,size,&payload_offset);
771          cfgs++;
772          if(ret!=2)test_failed();
773          if(size[0]!=j||size[1]!=0)test_failed();
774          if(frames[1]!=frames[0]+size[0])test_failed();
775          if((toc>>2)!=i)test_failed();
776          /*Code 2, normal*/
777          UNDEFINE_FOR_PARSE
778          ret=opus_packet_parse(packet,(j<<1)+4,&toc,frames,size,&payload_offset);
779          cfgs++;
780          if(ret!=2)test_failed();
781          if(size[0]!=j||size[1]!=(j<<1)+3-j-(j<252?1:2))test_failed();
782          if(frames[1]!=frames[0]+size[0])test_failed();
783          if((toc>>2)!=i)test_failed();
784       }
785    }
786    fprintf(stdout,"    code 2 (%6d cases) ........................ OK.\n",cfgs);
787    cfgs_total+=cfgs;cfgs=0;
788
789    for(i=0;i<64;i++)
790    {
791       packet[0]=(i<<2)+3;
792       /*code 3, length code overflow*/
793       UNDEFINE_FOR_PARSE
794       ret=opus_packet_parse(packet,1,&toc,frames,size,&payload_offset);
795       cfgs++;
796       if(ret!=OPUS_INVALID_PACKET)test_failed();
797    }
798    fprintf(stdout,"    code 3 m-truncation (%2d cases) ............... OK.\n",cfgs);
799    cfgs_total+=cfgs;cfgs=0;
800
801    for(i=0;i<64;i++)
802    {
803       /*code 3, m is zero or 49-63*/
804       packet[0]=(i<<2)+3;
805       for(jj=49;jj<=64;jj++)
806       {
807         packet[1]=0+(jj&63); /*CBR, no padding*/
808         UNDEFINE_FOR_PARSE
809         ret=opus_packet_parse(packet,1275,&toc,frames,size,&payload_offset);
810         cfgs++;
811         if(ret!=OPUS_INVALID_PACKET)test_failed();
812         packet[1]=128+(jj&63); /*VBR, no padding*/
813         UNDEFINE_FOR_PARSE
814         ret=opus_packet_parse(packet,1275,&toc,frames,size,&payload_offset);
815         cfgs++;
816         if(ret!=OPUS_INVALID_PACKET)test_failed();
817         packet[1]=64+(jj&63); /*CBR, padding*/
818         UNDEFINE_FOR_PARSE
819         ret=opus_packet_parse(packet,1275,&toc,frames,size,&payload_offset);
820         cfgs++;
821         if(ret!=OPUS_INVALID_PACKET)test_failed();
822         packet[1]=128+64+(jj&63); /*VBR, padding*/
823         UNDEFINE_FOR_PARSE
824         ret=opus_packet_parse(packet,1275,&toc,frames,size,&payload_offset);
825         cfgs++;
826         if(ret!=OPUS_INVALID_PACKET)test_failed();
827       }
828    }
829    fprintf(stdout,"    code 3 m=0,49-64 (%2d cases) ................ OK.\n",cfgs);
830    cfgs_total+=cfgs;cfgs=0;
831
832    for(i=0;i<64;i++)
833    {
834       packet[0]=(i<<2)+3;
835       /*code 3, m is one, cbr*/
836       packet[1]=1;
837       for(j=0;j<1276;j++)
838       {
839         UNDEFINE_FOR_PARSE
840         ret=opus_packet_parse(packet,j+2,&toc,frames,size,&payload_offset);
841         cfgs++;
842         if(ret!=1)test_failed();
843         if(size[0]!=j)test_failed();
844         if((toc>>2)!=i)test_failed();
845       }
846       UNDEFINE_FOR_PARSE
847       ret=opus_packet_parse(packet,1276+2,&toc,frames,size,&payload_offset);
848       cfgs++;
849       if(ret!=OPUS_INVALID_PACKET)test_failed();
850    }
851    fprintf(stdout,"    code 3 m=1 CBR (%2d cases) ................. OK.\n",cfgs);
852    cfgs_total+=cfgs;cfgs=0;
853
854    for(i=0;i<64;i++)
855    {
856       int frame_samp;
857       /*code 3, m>1 CBR*/
858       packet[0]=(i<<2)+3;
859       frame_samp=opus_packet_get_samples_per_frame(packet,48000);
860       for(j=2;j<49;j++)
861       {
862          packet[1]=j;
863          for(sz=2;sz<((j+2)*1275);sz++)
864          {
865             UNDEFINE_FOR_PARSE
866             ret=opus_packet_parse(packet,sz,&toc,frames,size,&payload_offset);
867             cfgs++;
868             /*Must be <=120ms, must be evenly divisible, can't have frames>1275 bytes*/
869             if(frame_samp*j<=5760 && (sz-2)%j==0 && (sz-2)/j<1276)
870             {
871                if(ret!=j)test_failed();
872                for(jj=1;jj<ret;jj++)if(frames[jj]!=frames[jj-1]+size[jj-1])test_failed();
873                if((toc>>2)!=i)test_failed();
874             } else if(ret!=OPUS_INVALID_PACKET)test_failed();
875          }
876       }
877       /*Super jumbo packets*/
878       packet[1]=5760/frame_samp;
879       UNDEFINE_FOR_PARSE
880       ret=opus_packet_parse(packet,1275*packet[1]+2,&toc,frames,size,&payload_offset);
881       cfgs++;
882       if(ret!=packet[1])test_failed();
883       for(jj=0;jj<ret;jj++)if(size[jj]!=1275)test_failed();
884    }
885    fprintf(stdout,"    code 3 m=1-48 CBR (%2d cases) .......... OK.\n",cfgs);
886    cfgs_total+=cfgs;cfgs=0;
887
888    for(i=0;i<64;i++)
889    {
890       int frame_samp;
891       /*Code 3 VBR, m one*/
892       packet[0]=(i<<2)+3;
893       packet[1]=128+1;
894       frame_samp=opus_packet_get_samples_per_frame(packet,48000);
895       for(jj=0;jj<1276;jj++)
896       {
897          UNDEFINE_FOR_PARSE
898          ret=opus_packet_parse(packet,2+jj,&toc,frames,size,&payload_offset);
899          cfgs++;
900          if(ret!=1)test_failed();
901          if(size[0]!=jj)test_failed();
902          if((toc>>2)!=i)test_failed();
903       }
904       UNDEFINE_FOR_PARSE
905       ret=opus_packet_parse(packet,2+1276,&toc,frames,size,&payload_offset);
906       cfgs++;
907       if(ret!=OPUS_INVALID_PACKET)test_failed();
908       for(j=2;j<49;j++)
909       {
910          packet[1]=128+j;
911          /*Length code overflow*/
912          UNDEFINE_FOR_PARSE
913          ret=opus_packet_parse(packet,2+j-2,&toc,frames,size,&payload_offset);
914          cfgs++;
915          if(ret!=OPUS_INVALID_PACKET)test_failed();
916          packet[2]=252;
917          packet[3]=0;
918          for(jj=4;jj<2+j;jj++)packet[jj]=0;
919          UNDEFINE_FOR_PARSE
920          ret=opus_packet_parse(packet,2+j,&toc,frames,size,&payload_offset);
921          cfgs++;
922          if(ret!=OPUS_INVALID_PACKET)test_failed();
923          /*One byte too short*/
924          for(jj=2;jj<2+j;jj++)packet[jj]=0;
925          UNDEFINE_FOR_PARSE
926          ret=opus_packet_parse(packet,2+j-2,&toc,frames,size,&payload_offset);
927          cfgs++;
928          if(ret!=OPUS_INVALID_PACKET)test_failed();
929          /*One byte too short thanks to length coding*/
930          packet[2]=252;
931          packet[3]=0;
932          for(jj=4;jj<2+j;jj++)packet[jj]=0;
933          UNDEFINE_FOR_PARSE
934          ret=opus_packet_parse(packet,2+j+252-1,&toc,frames,size,&payload_offset);
935          cfgs++;
936          if(ret!=OPUS_INVALID_PACKET)test_failed();
937          /*Most expensive way of coding zeros*/
938          for(jj=2;jj<2+j;jj++)packet[jj]=0;
939          UNDEFINE_FOR_PARSE
940          ret=opus_packet_parse(packet,2+j-1,&toc,frames,size,&payload_offset);
941          cfgs++;
942          if(frame_samp*j<=5760){
943             if(ret!=j)test_failed();
944             for(jj=0;jj<j;jj++)if(size[jj]!=0)test_failed();
945             if((toc>>2)!=i)test_failed();
946          } else if(ret!=OPUS_INVALID_PACKET)test_failed();
947          /*Quasi-CBR use of mode 3*/
948          for(sz=0;sz<8;sz++)
949          {
950             const int tsz[8]={50,201,403,700,1472,5110,20400,61298};
951             int pos=0;
952             int as=(tsz[sz]+i-j-2)/j;
953             for(jj=0;jj<j-1;jj++)
954             {
955               if(as<252){packet[2+pos]=as;pos++;}
956               else{packet[2+pos]=252+(as&3);packet[3+pos]=(as-252)>>2;pos+=2;}
957             }
958             UNDEFINE_FOR_PARSE
959             ret=opus_packet_parse(packet,tsz[sz]+i,&toc,frames,size,&payload_offset);
960             cfgs++;
961             if(frame_samp*j<=5760 && as<1276 && (tsz[sz]+i-2-pos-as*(j-1))<1276){
962                if(ret!=j)test_failed();
963                for(jj=0;jj<j-1;jj++)if(size[jj]!=as)test_failed();
964                if(size[j-1]!=(tsz[sz]+i-2-pos-as*(j-1)))test_failed();
965                if((toc>>2)!=i)test_failed();
966             } else if(ret!=OPUS_INVALID_PACKET)test_failed();
967          }
968       }
969    }
970    fprintf(stdout,"    code 3 m=1-48 VBR (%2d cases) ............. OK.\n",cfgs);
971    cfgs_total+=cfgs;cfgs=0;
972
973    for(i=0;i<64;i++)
974    {
975       packet[0]=(i<<2)+3;
976       /*Padding*/
977       packet[1]=128+1+64;
978       /*Overflow the length coding*/
979       for(jj=2;jj<127;jj++)packet[jj]=255;
980       UNDEFINE_FOR_PARSE
981       ret=opus_packet_parse(packet,127,&toc,frames,size,&payload_offset);
982       cfgs++;
983       if(ret!=OPUS_INVALID_PACKET)test_failed();
984
985       for(sz=0;sz<4;sz++)
986       {
987          const int tsz[4]={0,72,512,1275};
988          for(jj=sz;jj<65025;jj+=11)
989          {
990             int pos;
991             for(pos=0;pos<jj/254;pos++)packet[2+pos]=255;
992             packet[2+pos]=jj%254;
993             pos++;
994             if(sz==0&&i==63)
995             {
996                /*Code more padding than there is room in the packet*/
997                UNDEFINE_FOR_PARSE
998                ret=opus_packet_parse(packet,2+jj+pos-1,&toc,frames,size,&payload_offset);
999                cfgs++;
1000                if(ret!=OPUS_INVALID_PACKET)test_failed();
1001             }
1002             UNDEFINE_FOR_PARSE
1003             ret=opus_packet_parse(packet,2+jj+tsz[sz]+i+pos,&toc,frames,size,&payload_offset);
1004             cfgs++;
1005             if(tsz[sz]+i<1276)
1006             {
1007                if(ret!=1)test_failed();
1008                if(size[0]!=tsz[sz]+i)test_failed();
1009                if((toc>>2)!=i)test_failed();
1010             } else if (ret!=OPUS_INVALID_PACKET)test_failed();
1011          }
1012       }
1013    }
1014    fprintf(stdout,"    code 3 padding (%2d cases) ............... OK.\n",cfgs);
1015    cfgs_total+=cfgs;
1016    fprintf(stdout,"    opus_packet_parse ............................ OK.\n");
1017    fprintf(stdout,"                      All packet parsing tests passed\n");
1018    fprintf(stdout,"                          (%d API invocations)\n",cfgs_total);
1019    return cfgs_total;
1020 }
1021
1022 /* This is a helper macro for the encoder tests.
1023    The encoder api tests all have a pattern of set-must-fail, set-must-fail,
1024    set-must-pass, get-and-compare, set-must-pass, get-and-compare. */
1025 #define CHECK_SETGET(setcall,getcall,badv,badv2,goodv,goodv2,sok,gok) \
1026    i=(badv);\
1027    if(opus_encoder_ctl(enc,setcall)==OPUS_OK)test_failed();\
1028    i=(badv2);\
1029    if(opus_encoder_ctl(enc,setcall)==OPUS_OK)test_failed();\
1030    j=i=(goodv);\
1031    if(opus_encoder_ctl(enc,setcall)!=OPUS_OK)test_failed();\
1032    i=-12345;\
1033    VG_UNDEF(&i,sizeof(i)); \
1034    err=opus_encoder_ctl(enc,getcall);\
1035    if(err!=OPUS_OK || i!=j)test_failed();\
1036    j=i=(goodv2);\
1037    if(opus_encoder_ctl(enc,setcall)!=OPUS_OK)test_failed();\
1038    fprintf(stdout,sok);\
1039    i=-12345;\
1040    VG_UNDEF(&i,sizeof(i)); \
1041    err=opus_encoder_ctl(enc,getcall);\
1042    if(err!=OPUS_OK || i!=j)test_failed();\
1043    fprintf(stdout,gok);\
1044    cfgs+=6;
1045
1046 opus_int32 test_enc_api(void)
1047 {
1048    opus_uint32 enc_final_range;
1049    OpusEncoder *enc;
1050    opus_int32 i,j;
1051    unsigned char packet[1276];
1052 #ifndef DISABLE_FLOAT_API
1053    float fbuf[960*2];
1054 #endif
1055    short sbuf[960*2];
1056    int c,err,cfgs;
1057
1058    cfgs=0;
1059    /*First test invalid configurations which should fail*/
1060    fprintf(stdout,"\n  Encoder basic API tests\n");
1061    fprintf(stdout,"  ---------------------------------------------------\n");
1062    for(c=0;c<4;c++)
1063    {
1064       i=opus_encoder_get_size(c);
1065       if(((c==1||c==2)&&(i<=2048||i>1<<17))||((c!=1&&c!=2)&&i!=0))test_failed();
1066       fprintf(stdout,"    opus_encoder_get_size(%d)=%d ...............%s OK.\n",c,i,i>0?"":"....");
1067       cfgs++;
1068    }
1069
1070    /*Test with unsupported sample rates, channel counts*/
1071    for(c=0;c<4;c++)
1072    {
1073       for(i=-7;i<=96000;i++)
1074       {
1075          int fs;
1076          if((i==8000||i==12000||i==16000||i==24000||i==48000)&&(c==1||c==2))continue;
1077          switch(i)
1078          {
1079            case(-5):fs=-8000;break;
1080            case(-6):fs=INT32_MAX;break;
1081            case(-7):fs=INT32_MIN;break;
1082            default:fs=i;
1083          }
1084          err = OPUS_OK;
1085          VG_UNDEF(&err,sizeof(err));
1086          enc = opus_encoder_create(fs, c, OPUS_APPLICATION_VOIP, &err);
1087          if(err!=OPUS_BAD_ARG || enc!=NULL)test_failed();
1088          cfgs++;
1089          enc = opus_encoder_create(fs, c, OPUS_APPLICATION_VOIP, 0);
1090          if(enc!=NULL)test_failed();
1091          cfgs++;
1092          opus_encoder_destroy(enc);
1093          enc=malloc(opus_encoder_get_size(2));
1094          if(enc==NULL)test_failed();
1095          err = opus_encoder_init(enc, fs, c, OPUS_APPLICATION_VOIP);
1096          if(err!=OPUS_BAD_ARG)test_failed();
1097          cfgs++;
1098          free(enc);
1099       }
1100    }
1101
1102    enc = opus_encoder_create(48000, 2, OPUS_AUTO, NULL);
1103    if(enc!=NULL)test_failed();
1104    cfgs++;
1105
1106    VG_UNDEF(&err,sizeof(err));
1107    enc = opus_encoder_create(48000, 2, OPUS_AUTO, &err);
1108    if(err!=OPUS_BAD_ARG || enc!=NULL)test_failed();
1109    cfgs++;
1110
1111    VG_UNDEF(&err,sizeof(err));
1112    enc = opus_encoder_create(48000, 2, OPUS_APPLICATION_VOIP, NULL);
1113    if(enc==NULL)test_failed();
1114    opus_encoder_destroy(enc);
1115    cfgs++;
1116
1117    VG_UNDEF(&err,sizeof(err));
1118    enc = opus_encoder_create(48000, 2, OPUS_APPLICATION_RESTRICTED_LOWDELAY, &err);
1119    if(err!=OPUS_OK || enc==NULL)test_failed();
1120    cfgs++;
1121    err=opus_encoder_ctl(enc,OPUS_GET_LOOKAHEAD(&i));
1122    if(err!=OPUS_OK || i<0 || i>32766)test_failed();
1123    opus_encoder_destroy(enc);
1124    cfgs++;
1125
1126    VG_UNDEF(&err,sizeof(err));
1127    enc = opus_encoder_create(48000, 2, OPUS_APPLICATION_AUDIO, &err);
1128    if(err!=OPUS_OK || enc==NULL)test_failed();
1129    cfgs++;
1130    err=opus_encoder_ctl(enc,OPUS_GET_LOOKAHEAD(&i));
1131    if(err!=OPUS_OK || i<0 || i>32766)test_failed();
1132    opus_encoder_destroy(enc);
1133    cfgs++;
1134
1135    VG_UNDEF(&err,sizeof(err));
1136    enc = opus_encoder_create(48000, 2, OPUS_APPLICATION_VOIP, &err);
1137    if(err!=OPUS_OK || enc==NULL)test_failed();
1138    cfgs++;
1139
1140    fprintf(stdout,"    opus_encoder_create() ........................ OK.\n");
1141    fprintf(stdout,"    opus_encoder_init() .......................... OK.\n");
1142
1143    i=-12345;
1144    VG_UNDEF(&i,sizeof(i));
1145    err=opus_encoder_ctl(enc,OPUS_GET_LOOKAHEAD(&i));
1146    if(err!=OPUS_OK || i<0 || i>32766)test_failed();
1147    cfgs++;
1148    fprintf(stdout,"    OPUS_GET_LOOKAHEAD ........................... OK.\n");
1149
1150    if(opus_encoder_ctl(enc,OPUS_UNIMPLEMENTED)!=OPUS_UNIMPLEMENTED)test_failed();
1151    fprintf(stdout,"    OPUS_UNIMPLEMENTED ........................... OK.\n");
1152    cfgs++;
1153
1154    CHECK_SETGET(OPUS_SET_APPLICATION(i),OPUS_GET_APPLICATION(&i),-1,OPUS_AUTO,
1155      OPUS_APPLICATION_AUDIO,OPUS_APPLICATION_RESTRICTED_LOWDELAY,
1156      "    OPUS_SET_APPLICATION ......................... OK.\n",
1157      "    OPUS_GET_APPLICATION ......................... OK.\n")
1158
1159    if(opus_encoder_ctl(enc,OPUS_SET_BITRATE(1073741832))!=OPUS_OK)test_failed();
1160    cfgs++;
1161    VG_UNDEF(&i,sizeof(i));
1162    if(opus_encoder_ctl(enc,OPUS_GET_BITRATE(&i))!=OPUS_OK)test_failed();
1163    if(i>700000||i<256000)test_failed();
1164    cfgs++;
1165    CHECK_SETGET(OPUS_SET_BITRATE(i),OPUS_GET_BITRATE(&i),-12345,0,
1166      500,256000,
1167      "    OPUS_SET_BITRATE ............................. OK.\n",
1168      "    OPUS_GET_BITRATE ............................. OK.\n")
1169
1170    CHECK_SETGET(OPUS_SET_FORCE_CHANNELS(i),OPUS_GET_FORCE_CHANNELS(&i),-1,3,
1171      1,OPUS_AUTO,
1172      "    OPUS_SET_FORCE_CHANNELS ...................... OK.\n",
1173      "    OPUS_GET_FORCE_CHANNELS ...................... OK.\n")
1174
1175    i=-2;
1176    if(opus_encoder_ctl(enc,OPUS_SET_BANDWIDTH(i))==OPUS_OK)test_failed();
1177    cfgs++;
1178    i=OPUS_BANDWIDTH_FULLBAND+1;
1179    if(opus_encoder_ctl(enc,OPUS_SET_BANDWIDTH(i))==OPUS_OK)test_failed();
1180    cfgs++;
1181    i=OPUS_BANDWIDTH_NARROWBAND;
1182    if(opus_encoder_ctl(enc,OPUS_SET_BANDWIDTH(i))!=OPUS_OK)test_failed();
1183    cfgs++;
1184    i=OPUS_BANDWIDTH_FULLBAND;
1185    if(opus_encoder_ctl(enc,OPUS_SET_BANDWIDTH(i))!=OPUS_OK)test_failed();
1186    cfgs++;
1187    i=OPUS_BANDWIDTH_WIDEBAND;
1188    if(opus_encoder_ctl(enc,OPUS_SET_BANDWIDTH(i))!=OPUS_OK)test_failed();
1189    cfgs++;
1190    i=OPUS_BANDWIDTH_MEDIUMBAND;
1191    if(opus_encoder_ctl(enc,OPUS_SET_BANDWIDTH(i))!=OPUS_OK)test_failed();
1192    cfgs++;
1193    fprintf(stdout,"    OPUS_SET_BANDWIDTH ........................... OK.\n");
1194    /*We don't test if the bandwidth has actually changed.
1195      because the change may be delayed until the encoder is advanced.*/
1196    i=-12345;
1197    VG_UNDEF(&i,sizeof(i));
1198    err=opus_encoder_ctl(enc,OPUS_GET_BANDWIDTH(&i));
1199    if(err!=OPUS_OK || (i!=OPUS_BANDWIDTH_NARROWBAND&&
1200       i!=OPUS_BANDWIDTH_MEDIUMBAND&&i!=OPUS_BANDWIDTH_WIDEBAND&&
1201       i!=OPUS_BANDWIDTH_FULLBAND&&i!=OPUS_AUTO))test_failed();
1202    cfgs++;
1203    if(opus_encoder_ctl(enc,OPUS_SET_BANDWIDTH(OPUS_AUTO))!=OPUS_OK)test_failed();
1204    cfgs++;
1205    fprintf(stdout,"    OPUS_GET_BANDWIDTH ........................... OK.\n");
1206
1207    i=-2;
1208    if(opus_encoder_ctl(enc,OPUS_SET_MAX_BANDWIDTH(i))==OPUS_OK)test_failed();
1209    cfgs++;
1210    i=OPUS_BANDWIDTH_FULLBAND+1;
1211    if(opus_encoder_ctl(enc,OPUS_SET_MAX_BANDWIDTH(i))==OPUS_OK)test_failed();
1212    cfgs++;
1213    i=OPUS_BANDWIDTH_NARROWBAND;
1214    if(opus_encoder_ctl(enc,OPUS_SET_MAX_BANDWIDTH(i))!=OPUS_OK)test_failed();
1215    cfgs++;
1216    i=OPUS_BANDWIDTH_FULLBAND;
1217    if(opus_encoder_ctl(enc,OPUS_SET_MAX_BANDWIDTH(i))!=OPUS_OK)test_failed();
1218    cfgs++;
1219    i=OPUS_BANDWIDTH_WIDEBAND;
1220    if(opus_encoder_ctl(enc,OPUS_SET_MAX_BANDWIDTH(i))!=OPUS_OK)test_failed();
1221    cfgs++;
1222    i=OPUS_BANDWIDTH_MEDIUMBAND;
1223    if(opus_encoder_ctl(enc,OPUS_SET_MAX_BANDWIDTH(i))!=OPUS_OK)test_failed();
1224    cfgs++;
1225    fprintf(stdout,"    OPUS_SET_MAX_BANDWIDTH ....................... OK.\n");
1226    /*We don't test if the bandwidth has actually changed.
1227      because the change may be delayed until the encoder is advanced.*/
1228    i=-12345;
1229    VG_UNDEF(&i,sizeof(i));
1230    err=opus_encoder_ctl(enc,OPUS_GET_MAX_BANDWIDTH(&i));
1231    if(err!=OPUS_OK || (i!=OPUS_BANDWIDTH_NARROWBAND&&
1232       i!=OPUS_BANDWIDTH_MEDIUMBAND&&i!=OPUS_BANDWIDTH_WIDEBAND&&
1233       i!=OPUS_BANDWIDTH_FULLBAND))test_failed();
1234    cfgs++;
1235    fprintf(stdout,"    OPUS_GET_MAX_BANDWIDTH ....................... OK.\n");
1236
1237    CHECK_SETGET(OPUS_SET_DTX(i),OPUS_GET_DTX(&i),-1,2,
1238      1,0,
1239      "    OPUS_SET_DTX ................................. OK.\n",
1240      "    OPUS_GET_DTX ................................. OK.\n")
1241
1242    CHECK_SETGET(OPUS_SET_COMPLEXITY(i),OPUS_GET_COMPLEXITY(&i),-1,11,
1243      0,10,
1244      "    OPUS_SET_COMPLEXITY .......................... OK.\n",
1245      "    OPUS_GET_COMPLEXITY .......................... OK.\n")
1246
1247    CHECK_SETGET(OPUS_SET_INBAND_FEC(i),OPUS_GET_INBAND_FEC(&i),-1,2,
1248      1,0,
1249      "    OPUS_SET_INBAND_FEC .......................... OK.\n",
1250      "    OPUS_GET_INBAND_FEC .......................... OK.\n")
1251
1252    CHECK_SETGET(OPUS_SET_PACKET_LOSS_PERC(i),OPUS_GET_PACKET_LOSS_PERC(&i),-1,101,
1253      100,0,
1254      "    OPUS_SET_PACKET_LOSS_PERC .................... OK.\n",
1255      "    OPUS_GET_PACKET_LOSS_PERC .................... OK.\n")
1256
1257    CHECK_SETGET(OPUS_SET_VBR(i),OPUS_GET_VBR(&i),-1,2,
1258      1,0,
1259      "    OPUS_SET_VBR ................................. OK.\n",
1260      "    OPUS_GET_VBR ................................. OK.\n")
1261
1262    /*CHECK_SETGET(OPUS_SET_VOICE_RATIO(i),OPUS_GET_VOICE_RATIO(&i),-2,101,
1263      0,50,
1264      "    OPUS_SET_VOICE_RATIO ......................... OK.\n",
1265      "    OPUS_GET_VOICE_RATIO ......................... OK.\n")
1266    */
1267
1268    CHECK_SETGET(OPUS_SET_VBR_CONSTRAINT(i),OPUS_GET_VBR_CONSTRAINT(&i),-1,2,
1269      1,0,
1270      "    OPUS_SET_VBR_CONSTRAINT ...................... OK.\n",
1271      "    OPUS_GET_VBR_CONSTRAINT ...................... OK.\n")
1272
1273    CHECK_SETGET(OPUS_SET_SIGNAL(i),OPUS_GET_SIGNAL(&i),-12345,0x7FFFFFFF,
1274      OPUS_SIGNAL_MUSIC,OPUS_AUTO,
1275      "    OPUS_SET_SIGNAL .............................. OK.\n",
1276      "    OPUS_GET_SIGNAL .............................. OK.\n")
1277
1278    CHECK_SETGET(OPUS_SET_LSB_DEPTH(i),OPUS_GET_LSB_DEPTH(&i),7,25,16,24,
1279      "    OPUS_SET_LSB_DEPTH ........................... OK.\n",
1280      "    OPUS_GET_LSB_DEPTH ........................... OK.\n")
1281
1282    /*OPUS_SET_FORCE_MODE is not tested here because it's not a public API, however the encoder tests use it*/
1283
1284    if(opus_encoder_ctl(enc,OPUS_GET_FINAL_RANGE(&enc_final_range))!=OPUS_OK)test_failed();
1285    cfgs++;
1286    fprintf(stdout,"    OPUS_GET_FINAL_RANGE ......................... OK.\n");
1287
1288    /*Reset the encoder*/
1289    if(opus_encoder_ctl(enc, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
1290    cfgs++;
1291    fprintf(stdout,"    OPUS_RESET_STATE ............................. OK.\n");
1292
1293    memset(sbuf,0,sizeof(short)*2*960);
1294    VG_UNDEF(packet,sizeof(packet));
1295    i=opus_encode(enc, sbuf, 960, packet, sizeof(packet));
1296    if(i<1 || (i>(opus_int32)sizeof(packet)))test_failed();
1297    VG_CHECK(packet,i);
1298    cfgs++;
1299    fprintf(stdout,"    opus_encode() ................................ OK.\n");
1300 #ifndef DISABLE_FLOAT_API
1301    memset(fbuf,0,sizeof(float)*2*960);
1302    VG_UNDEF(packet,sizeof(packet));
1303    i=opus_encode_float(enc, fbuf, 960, packet, sizeof(packet));
1304    if(i<1 || (i>(opus_int32)sizeof(packet)))test_failed();
1305    VG_CHECK(packet,i);
1306    cfgs++;
1307    fprintf(stdout,"    opus_encode_float() .......................... OK.\n");
1308 #endif
1309
1310 #if 0
1311    /*These tests are disabled because the library crashes with null states*/
1312    if(opus_encoder_ctl(0,OPUS_RESET_STATE)               !=OPUS_INVALID_STATE)test_failed();
1313    if(opus_encoder_init(0,48000,1,OPUS_APPLICATION_VOIP) !=OPUS_INVALID_STATE)test_failed();
1314    if(opus_encode(0,sbuf,960,packet,sizeof(packet))      !=OPUS_INVALID_STATE)test_failed();
1315    if(opus_encode_float(0,fbuf,960,packet,sizeof(packet))!=OPUS_INVALID_STATE)test_failed();
1316 #endif
1317    opus_encoder_destroy(enc);
1318    cfgs++;
1319    fprintf(stdout,"                   All encoder interface tests passed\n");
1320    fprintf(stdout,"                             (%d API invocations)\n",cfgs);
1321    return cfgs;
1322 }
1323
1324 #define max_out (1276*48+48*2+2)
1325 int test_repacketizer_api(void)
1326 {
1327    int ret,cfgs,i,j,k;
1328    OpusRepacketizer *rp;
1329    unsigned char *packet;
1330    unsigned char *po;
1331    cfgs=0;
1332    fprintf(stdout,"\n  Repacketizer tests\n");
1333    fprintf(stdout,"  ---------------------------------------------------\n");
1334
1335    packet=malloc(max_out);
1336    if(packet==NULL)test_failed();
1337    po=malloc(max_out);
1338    if(po==NULL)test_failed();
1339    memset(packet,0,max_out);
1340
1341    i=opus_repacketizer_get_size();
1342    if(i<=0)test_failed();
1343    cfgs++;
1344    fprintf(stdout,"    opus_repacketizer_get_size()=%d ............. OK.\n",i);
1345
1346    rp=malloc(i);
1347    rp=opus_repacketizer_init(rp);
1348    if(rp==NULL)test_failed();
1349    cfgs++;
1350    free(rp);
1351    fprintf(stdout,"    opus_repacketizer_init ....................... OK.\n");
1352
1353    rp=opus_repacketizer_create();
1354    if(rp==NULL)test_failed();
1355    cfgs++;
1356    fprintf(stdout,"    opus_repacketizer_create ..................... OK.\n");
1357
1358    if(opus_repacketizer_get_nb_frames(rp)!=0)test_failed();
1359    cfgs++;
1360    fprintf(stdout,"    opus_repacketizer_get_nb_frames .............. OK.\n");
1361
1362    /*Length overflows*/
1363    VG_UNDEF(packet,4);
1364    if(opus_repacketizer_cat(rp,packet,0)!=OPUS_INVALID_PACKET)test_failed(); /* Zero len */
1365    cfgs++;
1366    packet[0]=1;
1367    if(opus_repacketizer_cat(rp,packet,2)!=OPUS_INVALID_PACKET)test_failed(); /* Odd payload code 1 */
1368    cfgs++;
1369    packet[0]=2;
1370    if(opus_repacketizer_cat(rp,packet,1)!=OPUS_INVALID_PACKET)test_failed(); /* Code 2 overflow one */
1371    cfgs++;
1372    packet[0]=3;
1373    if(opus_repacketizer_cat(rp,packet,1)!=OPUS_INVALID_PACKET)test_failed(); /* Code 3 no count */
1374    cfgs++;
1375    packet[0]=2;
1376    packet[1]=255;
1377    if(opus_repacketizer_cat(rp,packet,2)!=OPUS_INVALID_PACKET)test_failed(); /* Code 2 overflow two */
1378    cfgs++;
1379    packet[0]=2;
1380    packet[1]=250;
1381    if(opus_repacketizer_cat(rp,packet,251)!=OPUS_INVALID_PACKET)test_failed(); /* Code 2 overflow three */
1382    cfgs++;
1383    packet[0]=3;
1384    packet[1]=0;
1385    if(opus_repacketizer_cat(rp,packet,2)!=OPUS_INVALID_PACKET)test_failed(); /* Code 3 m=0 */
1386    cfgs++;
1387    packet[1]=49;
1388    if(opus_repacketizer_cat(rp,packet,100)!=OPUS_INVALID_PACKET)test_failed(); /* Code 3 m=49 */
1389    cfgs++;
1390    packet[0]=0;
1391    if(opus_repacketizer_cat(rp,packet,3)!=OPUS_OK)test_failed();
1392    cfgs++;
1393    packet[0]=1<<2;
1394    if(opus_repacketizer_cat(rp,packet,3)!=OPUS_INVALID_PACKET)test_failed(); /* Change in TOC */
1395    cfgs++;
1396
1397    /* Code 0,1,3 CBR -> Code 0,1,3 CBR */
1398    opus_repacketizer_init(rp);
1399    for(j=0;j<32;j++)
1400    {
1401       /* TOC types, test half with stereo */
1402       int maxi;
1403       packet[0]=((j<<1)+(j&1))<<2;
1404       maxi=960/opus_packet_get_samples_per_frame(packet,8000);
1405       for(i=1;i<=maxi;i++)
1406       {
1407          /* Number of CBR frames in the input packets */
1408          int maxp;
1409          packet[0]=((j<<1)+(j&1))<<2;
1410          if(i>1)packet[0]+=i==2?1:3;
1411          packet[1]=i>2?i:0;
1412          maxp=960/(i*opus_packet_get_samples_per_frame(packet,8000));
1413          for(k=0;k<=(1275+75);k+=3)
1414          {
1415             /*Payload size*/
1416             opus_int32 cnt,rcnt;
1417             if(k%i!=0)continue; /* Only testing CBR here, payload must be a multiple of the count */
1418             for(cnt=0;cnt<maxp+2;cnt++)
1419             {
1420                if(cnt>0)
1421                {
1422                   ret=opus_repacketizer_cat(rp,packet,k+(i>2?2:1));
1423                   if((cnt<=maxp&&k<=(1275*i))?ret!=OPUS_OK:ret!=OPUS_INVALID_PACKET)test_failed();
1424                   cfgs++;
1425                }
1426                rcnt=k<=(1275*i)?(cnt<maxp?cnt:maxp):0;
1427                if(opus_repacketizer_get_nb_frames(rp)!=rcnt*i)test_failed();
1428                cfgs++;
1429                ret=opus_repacketizer_out_range(rp,0,rcnt*i,po,max_out);
1430                if(rcnt>0)
1431                {
1432                   int len;
1433                   len=k*rcnt+((rcnt*i)>2?2:1);
1434                   if(ret!=len)test_failed();
1435                   if((rcnt*i)<2&&(po[0]&3)!=0)test_failed();                      /* Code 0 */
1436                   if((rcnt*i)==2&&(po[0]&3)!=1)test_failed();                     /* Code 1 */
1437                   if((rcnt*i)>2&&(((po[0]&3)!=3)||(po[1]!=rcnt*i)))test_failed(); /* Code 3 CBR */
1438                   cfgs++;
1439                   if(opus_repacketizer_out(rp,po,len)!=len)test_failed();
1440                   cfgs++;
1441                   if(opus_repacketizer_out(rp,po,len-1)!=OPUS_BUFFER_TOO_SMALL)test_failed();
1442                   cfgs++;
1443                   if(len>1)
1444                   {
1445                      if(opus_repacketizer_out(rp,po,1)!=OPUS_BUFFER_TOO_SMALL)test_failed();
1446                      cfgs++;
1447                   }
1448                   if(opus_repacketizer_out(rp,po,0)!=OPUS_BUFFER_TOO_SMALL)test_failed();
1449                   cfgs++;
1450                } else if (ret!=OPUS_BAD_ARG)test_failed();                        /* M must not be 0 */
1451             }
1452             opus_repacketizer_init(rp);
1453          }
1454       }
1455    }
1456
1457    /*Change in input count code, CBR out*/
1458    opus_repacketizer_init(rp);
1459    packet[0]=0;
1460    if(opus_repacketizer_cat(rp,packet,5)!=OPUS_OK)test_failed();
1461    cfgs++;
1462    packet[0]+=1;
1463    if(opus_repacketizer_cat(rp,packet,9)!=OPUS_OK)test_failed();
1464    cfgs++;
1465    i=opus_repacketizer_out(rp,po,max_out);
1466    if((i!=(4+8+2))||((po[0]&3)!=3)||((po[1]&63)!=3)||((po[1]>>7)!=0))test_failed();
1467    cfgs++;
1468    i=opus_repacketizer_out_range(rp,0,1,po,max_out);
1469    if(i!=5||(po[0]&3)!=0)test_failed();
1470    cfgs++;
1471    i=opus_repacketizer_out_range(rp,1,2,po,max_out);
1472    if(i!=5||(po[0]&3)!=0)test_failed();
1473    cfgs++;
1474
1475    /*Change in input count code, VBR out*/
1476    opus_repacketizer_init(rp);
1477    packet[0]=1;
1478    if(opus_repacketizer_cat(rp,packet,9)!=OPUS_OK)test_failed();
1479    cfgs++;
1480    packet[0]=0;
1481    if(opus_repacketizer_cat(rp,packet,3)!=OPUS_OK)test_failed();
1482    cfgs++;
1483    i=opus_repacketizer_out(rp,po,max_out);
1484    if((i!=(2+8+2+2))||((po[0]&3)!=3)||((po[1]&63)!=3)||((po[1]>>7)!=1))test_failed();
1485    cfgs++;
1486
1487    /*VBR in, VBR out*/
1488    opus_repacketizer_init(rp);
1489    packet[0]=2;
1490    packet[1]=4;
1491    if(opus_repacketizer_cat(rp,packet,8)!=OPUS_OK)test_failed();
1492    cfgs++;
1493    if(opus_repacketizer_cat(rp,packet,8)!=OPUS_OK)test_failed();
1494    cfgs++;
1495    i=opus_repacketizer_out(rp,po,max_out);
1496    if((i!=(2+1+1+1+4+2+4+2))||((po[0]&3)!=3)||((po[1]&63)!=4)||((po[1]>>7)!=1))test_failed();
1497    cfgs++;
1498
1499    /*VBR in, CBR out*/
1500    opus_repacketizer_init(rp);
1501    packet[0]=2;
1502    packet[1]=4;
1503    if(opus_repacketizer_cat(rp,packet,10)!=OPUS_OK)test_failed();
1504    cfgs++;
1505    if(opus_repacketizer_cat(rp,packet,10)!=OPUS_OK)test_failed();
1506    cfgs++;
1507    i=opus_repacketizer_out(rp,po,max_out);
1508    if((i!=(2+4+4+4+4))||((po[0]&3)!=3)||((po[1]&63)!=4)||((po[1]>>7)!=0))test_failed();
1509    cfgs++;
1510
1511    /*Count 0 in, VBR out*/
1512    for(j=0;j<32;j++)
1513    {
1514       /* TOC types, test half with stereo */
1515       int maxi,sum,rcnt;
1516       packet[0]=((j<<1)+(j&1))<<2;
1517       maxi=960/opus_packet_get_samples_per_frame(packet,8000);
1518       sum=0;
1519       rcnt=0;
1520       opus_repacketizer_init(rp);
1521       for(i=1;i<=maxi+2;i++)
1522       {
1523          int len;
1524          ret=opus_repacketizer_cat(rp,packet,i);
1525          if(rcnt<maxi)
1526          {
1527             if(ret!=OPUS_OK)test_failed();
1528             rcnt++;
1529             sum+=i-1;
1530          } else if (ret!=OPUS_INVALID_PACKET)test_failed();
1531          cfgs++;
1532          len=sum+(rcnt<2?1:rcnt<3?2:2+rcnt-1);
1533          if(opus_repacketizer_out(rp,po,max_out)!=len)test_failed();
1534          if(rcnt>2&&(po[1]&63)!=rcnt)test_failed();
1535          if(rcnt==2&&(po[0]&3)!=2)test_failed();
1536          if(rcnt==1&&(po[0]&3)!=0)test_failed();
1537          cfgs++;
1538          if(opus_repacketizer_out(rp,po,len)!=len)test_failed();
1539          cfgs++;
1540          if(opus_repacketizer_out(rp,po,len-1)!=OPUS_BUFFER_TOO_SMALL)test_failed();
1541          cfgs++;
1542          if(len>1)
1543          {
1544             if(opus_repacketizer_out(rp,po,1)!=OPUS_BUFFER_TOO_SMALL)test_failed();
1545             cfgs++;
1546          }
1547          if(opus_repacketizer_out(rp,po,0)!=OPUS_BUFFER_TOO_SMALL)test_failed();
1548          cfgs++;
1549       }
1550    }
1551
1552    fprintf(stdout,"    opus_repacketizer_cat ........................ OK.\n");
1553    fprintf(stdout,"    opus_repacketizer_out ........................ OK.\n");
1554    fprintf(stdout,"    opus_repacketizer_out_range .................. OK.\n");
1555
1556    opus_repacketizer_destroy(rp);
1557    cfgs++;
1558    free(packet);
1559    free(po);
1560    fprintf(stdout,"                        All repacketizer tests passed\n");
1561    fprintf(stdout,"                            (%7d API invocations)\n",cfgs);
1562
1563    return cfgs;
1564 }
1565
1566 #ifdef MALLOC_FAIL
1567 /* GLIBC 2.14 declares __malloc_hook as deprecated, generating a warning
1568  * under GCC. However, this is the cleanest way to test malloc failure
1569  * handling in our codebase, and the lack of thread safety isn't an
1570  * issue here. We therefore disable the warning for this function.
1571  */
1572 #if OPUS_GNUC_PREREQ(4,6)
1573 /* Save the current warning settings */
1574 #pragma GCC diagnostic push
1575 #endif
1576 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
1577
1578 typedef void *(*mhook)(size_t __size, __const __malloc_ptr_t);
1579 #endif
1580
1581 int test_malloc_fail(void)
1582 {
1583 #ifdef MALLOC_FAIL
1584    OpusDecoder *dec;
1585    OpusEncoder *enc;
1586    OpusRepacketizer *rp;
1587    unsigned char mapping[256] = {0,1};
1588    OpusMSDecoder *msdec;
1589    OpusMSEncoder *msenc;
1590    int rate,c,app,cfgs,err,useerr;
1591    int *ep;
1592    mhook orig_malloc;
1593    cfgs=0;
1594 #endif
1595    fprintf(stdout,"\n  malloc() failure tests\n");
1596    fprintf(stdout,"  ---------------------------------------------------\n");
1597 #ifdef MALLOC_FAIL
1598    orig_malloc=__malloc_hook;
1599    __malloc_hook=malloc_hook;
1600    ep=(int *)opus_alloc(sizeof(int));
1601    if(ep!=NULL)
1602    {
1603       if(ep)free(ep);
1604       __malloc_hook=orig_malloc;
1605 #endif
1606       fprintf(stdout,"    opus_decoder_create() ................... SKIPPED.\n");
1607       fprintf(stdout,"    opus_encoder_create() ................... SKIPPED.\n");
1608       fprintf(stdout,"    opus_repacketizer_create() .............. SKIPPED.\n");
1609       fprintf(stdout,"    opus_multistream_decoder_create() ....... SKIPPED.\n");
1610       fprintf(stdout,"    opus_multistream_encoder_create() ....... SKIPPED.\n");
1611       fprintf(stdout,"(Test only supported with GLIBC and without valgrind)\n");
1612       return 0;
1613 #ifdef MALLOC_FAIL
1614    }
1615    for(useerr=0;useerr<2;useerr++)
1616    {
1617       ep=useerr?&err:0;
1618       for(rate=0;rate<5;rate++)
1619       {
1620         for(c=1;c<3;c++)
1621         {
1622            err=1;
1623            if(useerr)
1624            {
1625               VG_UNDEF(&err,sizeof(err));
1626            }
1627            dec=opus_decoder_create(opus_rates[rate], c, ep);
1628            if(dec!=NULL||(useerr&&err!=OPUS_ALLOC_FAIL))
1629            {
1630               __malloc_hook=orig_malloc;
1631               test_failed();
1632            }
1633            cfgs++;
1634            msdec=opus_multistream_decoder_create(opus_rates[rate], c, 1, c-1, mapping, ep);
1635            if(msdec!=NULL||(useerr&&err!=OPUS_ALLOC_FAIL))
1636            {
1637               __malloc_hook=orig_malloc;
1638               test_failed();
1639            }
1640            cfgs++;
1641            for(app=0;app<3;app++)
1642            {
1643               if(useerr)
1644               {
1645                  VG_UNDEF(&err,sizeof(err));
1646               }
1647               enc=opus_encoder_create(opus_rates[rate], c, opus_apps[app],ep);
1648               if(enc!=NULL||(useerr&&err!=OPUS_ALLOC_FAIL))
1649               {
1650                  __malloc_hook=orig_malloc;
1651                  test_failed();
1652               }
1653               cfgs++;
1654               msenc=opus_multistream_encoder_create(opus_rates[rate], c, 1, c-1, mapping, opus_apps[app],ep);
1655               if(msenc!=NULL||(useerr&&err!=OPUS_ALLOC_FAIL))
1656               {
1657                  __malloc_hook=orig_malloc;
1658                  test_failed();
1659               }
1660               cfgs++;
1661            }
1662         }
1663      }
1664    }
1665    rp=opus_repacketizer_create();
1666    if(rp!=NULL)
1667    {
1668       __malloc_hook=orig_malloc;
1669       test_failed();
1670    }
1671    cfgs++;
1672    __malloc_hook=orig_malloc;
1673    fprintf(stdout,"    opus_decoder_create() ........................ OK.\n");
1674    fprintf(stdout,"    opus_encoder_create() ........................ OK.\n");
1675    fprintf(stdout,"    opus_repacketizer_create() ................... OK.\n");
1676    fprintf(stdout,"    opus_multistream_decoder_create() ............ OK.\n");
1677    fprintf(stdout,"    opus_multistream_encoder_create() ............ OK.\n");
1678    fprintf(stdout,"                      All malloc failure tests passed\n");
1679    fprintf(stdout,"                                 (%2d API invocations)\n",cfgs);
1680    return cfgs;
1681 #endif
1682 }
1683
1684 #ifdef MALLOC_FAIL
1685 #if __GNUC_PREREQ(4,6)
1686 #pragma GCC diagnostic pop /* restore -Wdeprecated-declarations */
1687 #endif
1688 #endif
1689
1690 int main(int _argc, char **_argv)
1691 {
1692    opus_int32 total;
1693    const char * oversion;
1694    if(_argc>1)
1695    {
1696       fprintf(stderr,"Usage: %s\n",_argv[0]);
1697       return 1;
1698    }
1699    iseed=0;
1700
1701    oversion=opus_get_version_string();
1702    if(!oversion)test_failed();
1703    fprintf(stderr,"Testing the %s API deterministically\n", oversion);
1704    if(opus_strerror(-32768)==NULL)test_failed();
1705    if(opus_strerror(32767)==NULL)test_failed();
1706    if(strlen(opus_strerror(0))<1)test_failed();
1707    total=4;
1708
1709    total+=test_dec_api();
1710    total+=test_msdec_api();
1711    total+=test_parse();
1712    total+=test_enc_api();
1713    total+=test_repacketizer_api();
1714    total+=test_malloc_fail();
1715
1716    fprintf(stderr,"\nAll API tests passed.\nThe libopus API was invoked %d times.\n",total);
1717
1718    return 0;
1719 }