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