Fix minor issues reported by scan-build
[opus.git] / tests / test_opus_encode.c
1 /* Copyright (c) 2011 Xiph.Org Foundation
2    Written by Gregory Maxwell */
3 /*
4    Redistribution and use in source and binary forms, with or without
5    modification, are permitted provided that the following conditions
6    are met:
7
8    - Redistributions of source code must retain the above copyright
9    notice, this list of conditions and the following disclaimer.
10
11    - Redistributions in binary form must reproduce the above copyright
12    notice, this list of conditions and the following disclaimer in the
13    documentation and/or other materials provided with the distribution.
14
15    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
18    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
19    OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
22    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
23    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
24    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 #ifdef HAVE_CONFIG_H
29 #include "config.h"
30 #endif
31
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <limits.h>
35 #include <stdint.h>
36 #include <math.h>
37 #include <string.h>
38 #include <time.h>
39 #if (!defined WIN32 && !defined _WIN32) || defined(__MINGW32__)
40 #include <unistd.h>
41 #endif
42 #include "opus_multistream.h"
43 #include "opus.h"
44 #include "../src/opus_private.h"
45 #include "test_opus_common.h"
46
47 #define MAX_PACKET (1500)
48 #define SAMPLES (48000*30)
49 #define SSAMPLES (SAMPLES/3)
50 #define MAX_FRAME_SAMP (5760)
51
52 #define PI (3.141592653589793238462643f)
53
54 void generate_music(short *buf, opus_int32 len)
55 {
56    opus_int32 a1,b1,a2,b2;
57    opus_int32 c1,c2,d1,d2;
58    opus_int32 i,j;
59    a1=b1=a2=b2=0;
60    c1=c2=d1=d2=0;
61    j=0;
62    /*60ms silence*/
63    for(i=0;i<2880;i++)buf[i*2]=buf[i*2+1]=0;
64    for(i=2880;i<len;i++)
65    {
66      opus_uint32 r;
67      opus_int32 v1,v2;
68      v1=v2=(((j*((j>>12)^((j>>10|j>>12)&26&j>>7)))&128)+128)<<15;
69      r=fast_rand();v1+=r&65535;v1-=r>>16;
70      r=fast_rand();v2+=r&65535;v2-=r>>16;
71      b1=v1-a1+((b1*61+32)>>6);a1=v1;
72      b2=v2-a2+((b2*61+32)>>6);a2=v2;
73      c1=(30*(c1+b1+d1)+32)>>6;d1=b1;
74      c2=(30*(c2+b2+d2)+32)>>6;d2=b2;
75      v1=(c1+128)>>8;
76      v2=(c2+128)>>8;
77      buf[i*2]=v1>32767?32767:(v1<-32768?-32768:v1);
78      buf[i*2+1]=v2>32767?32767:(v2<-32768?-32768:v2);
79      if(i%6==0)j++;
80    }
81 }
82
83 #if 0
84 static int save_ctr = 0;
85 static void int_to_char(opus_uint32 i, unsigned char ch[4])
86 {
87     ch[0] = i>>24;
88     ch[1] = (i>>16)&0xFF;
89     ch[2] = (i>>8)&0xFF;
90     ch[3] = i&0xFF;
91 }
92
93 static inline void save_packet(unsigned char* p, int len, opus_uint32 rng)
94 {
95    FILE *fout;
96    unsigned char int_field[4];
97    char name[256];
98    snprintf(name,255,"test_opus_encode.%llu.%d.bit",(unsigned long long)iseed,save_ctr);
99    fprintf(stdout,"writing %d byte packet to %s\n",len,name);
100    fout=fopen(name, "wb+");
101    if(fout==NULL)test_failed();
102    int_to_char(len, int_field);
103    fwrite(int_field, 1, 4, fout);
104    int_to_char(rng, int_field);
105    fwrite(int_field, 1, 4, fout);
106    fwrite(p, 1, len, fout);
107    fclose(fout);
108    save_ctr++;
109 }
110 #endif
111
112 int run_test1(int no_fuzz)
113 {
114    static const int fsizes[6]={960*3,960*2,120,240,480,960};
115    static const char *mstrings[3] = {"    LP","Hybrid","  MDCT"};
116    unsigned char mapping[256] = {0,1,255};
117    unsigned char db62[36];
118    opus_int32 i;
119    int rc,j,err;
120    OpusEncoder *enc;
121    OpusMSEncoder *MSenc;
122    OpusDecoder *dec;
123    OpusMSDecoder *MSdec;
124    OpusMSDecoder *MSdec_err;
125    OpusDecoder *dec_err[10];
126    short *inbuf;
127    short *outbuf;
128    short *out2buf;
129    opus_int32 bitrate_bps;
130    unsigned char packet[MAX_PACKET];
131    opus_uint32 enc_final_range;
132    opus_uint32 dec_final_range;
133    int fswitch;
134    int fsize;
135    int count;
136
137   /*FIXME: encoder api tests, fs!=48k, mono, VBR*/
138
139    fprintf(stdout,"  Encode+Decode tests.\n");
140
141    enc = opus_encoder_create(48000, 2, OPUS_APPLICATION_VOIP, &err);
142    if(err != OPUS_OK || enc==NULL)test_failed();
143
144    MSenc = opus_multistream_encoder_create(8000, 2, 2, 0, mapping, OPUS_APPLICATION_AUDIO, &err);
145    if(err != OPUS_OK || MSenc==NULL)test_failed();
146
147    /*Some multistream encoder API tests*/
148    if(opus_multistream_encoder_ctl(MSenc, OPUS_GET_BITRATE(&i))!=OPUS_OK)test_failed();
149    if(opus_multistream_encoder_ctl(MSenc, OPUS_GET_LSB_DEPTH(&i))!=OPUS_OK)test_failed();
150    if(i<16)test_failed();
151
152    {
153       OpusEncoder *tmp_enc;
154       if(opus_multistream_encoder_ctl(MSenc,  OPUS_MULTISTREAM_GET_ENCODER_STATE(1,&tmp_enc))!=OPUS_OK)test_failed();
155       if(opus_encoder_ctl(tmp_enc, OPUS_GET_LSB_DEPTH(&j))!=OPUS_OK)test_failed();
156       if(i!=j)test_failed();
157       if(opus_multistream_encoder_ctl(MSenc,  OPUS_MULTISTREAM_GET_ENCODER_STATE(2,&tmp_enc))!=OPUS_BAD_ARG)test_failed();
158    }
159
160    dec = opus_decoder_create(48000, 2, &err);
161    if(err != OPUS_OK || dec==NULL)test_failed();
162
163    MSdec = opus_multistream_decoder_create(48000, 2, 2, 0, mapping, &err);
164    if(err != OPUS_OK || MSdec==NULL)test_failed();
165
166    MSdec_err = opus_multistream_decoder_create(48000, 3, 2, 0, mapping, &err);
167    if(err != OPUS_OK || MSdec_err==NULL)test_failed();
168
169    dec_err[0]=(OpusDecoder *)malloc(opus_decoder_get_size(2));
170    memcpy(dec_err[0],dec,opus_decoder_get_size(2));
171    dec_err[1] = opus_decoder_create(48000, 1, &err);
172    dec_err[2] = opus_decoder_create(24000, 2, &err);
173    dec_err[3] = opus_decoder_create(24000, 1, &err);
174    dec_err[4] = opus_decoder_create(16000, 2, &err);
175    dec_err[5] = opus_decoder_create(16000, 1, &err);
176    dec_err[6] = opus_decoder_create(12000, 2, &err);
177    dec_err[7] = opus_decoder_create(12000, 1, &err);
178    dec_err[8] = opus_decoder_create(8000, 2, &err);
179    dec_err[9] = opus_decoder_create(8000, 1, &err);
180    for(i=0;i<10;i++)if(dec_err[i]==NULL)test_failed();
181
182    {
183       OpusEncoder *enccpy;
184       /*The opus state structures contain no pointers and can be freely copied*/
185       enccpy=(OpusEncoder *)malloc(opus_encoder_get_size(2));
186       memcpy(enccpy,enc,opus_encoder_get_size(2));
187       memset(enc,255,opus_encoder_get_size(2));
188       opus_encoder_destroy(enc);
189       enc=enccpy;
190    }
191
192    inbuf=(short *)malloc(sizeof(short)*SAMPLES*2);
193    outbuf=(short *)malloc(sizeof(short)*SAMPLES*2);
194    out2buf=(short *)malloc(sizeof(short)*MAX_FRAME_SAMP*3);
195    if(inbuf==NULL || outbuf==NULL || out2buf==NULL)test_failed();
196
197    generate_music(inbuf,SAMPLES);
198
199 /*   FILE *foo;
200    foo = fopen("foo.sw", "wb+");
201    fwrite(inbuf, 1, SAMPLES*2*2, foo);
202    fclose(foo);*/
203
204    if(opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(OPUS_AUTO))!=OPUS_OK)test_failed();
205    if(opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(-2))!=OPUS_BAD_ARG)test_failed();
206
207    for(rc=0;rc<3;rc++)
208    {
209       if(opus_encoder_ctl(enc, OPUS_SET_VBR(rc<2))!=OPUS_OK)test_failed();
210       if(opus_encoder_ctl(enc, OPUS_SET_VBR_CONSTRAINT(rc==1))!=OPUS_OK)test_failed();
211       if(opus_encoder_ctl(enc, OPUS_SET_VBR_CONSTRAINT(rc==1))!=OPUS_OK)test_failed();
212       if(opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(rc==0))!=OPUS_OK)test_failed();
213       for(j=0;j<13;j++)
214       {
215          int rate;
216          int modes[13]={0,0,0,1,1,1,1,2,2,2,2,2,2};
217          int rates[13]={6000,12000,48000,16000,32000,48000,64000,512000,13000,24000,48000,64000,96000};
218          int frame[13]={960*2,960,480,960,960,960,480,960*3,960*3,960,480,240,120};
219          rate=rates[j]+fast_rand()%rates[j];
220          count=i=0;
221          do {
222             int bw,len,out_samples,frame_size;
223             frame_size=frame[j];
224             if(fast_rand()%50==0)opus_encoder_ctl(enc, OPUS_RESET_STATE);
225             if(fast_rand()%50==0)opus_decoder_ctl(dec, OPUS_RESET_STATE);
226             if(opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(rc==0))!=OPUS_OK)test_failed();
227             if(opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(MODE_SILK_ONLY+modes[j]))!=OPUS_OK)test_failed();
228             if(opus_encoder_ctl(enc, OPUS_SET_DTX(fast_rand()&1))!=OPUS_OK)test_failed();
229             if(opus_encoder_ctl(enc, OPUS_SET_BITRATE(rate))!=OPUS_OK)test_failed();
230             if(opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS((rates[j]>=64000?2:1)))!=OPUS_OK)test_failed();
231             if(opus_encoder_ctl(enc, OPUS_SET_COMPLEXITY((count>>2)%11))!=OPUS_OK)test_failed();
232             if(opus_encoder_ctl(enc, OPUS_SET_PACKET_LOSS_PERC((fast_rand()&15)&(fast_rand()%15)))!=OPUS_OK)test_failed();
233             bw=modes[j]==0?OPUS_BANDWIDTH_NARROWBAND+(fast_rand()%3):
234                modes[j]==1?OPUS_BANDWIDTH_SUPERWIDEBAND+(fast_rand()&1):
235                            OPUS_BANDWIDTH_NARROWBAND+(fast_rand()%5);
236             if(modes[j]==2&&bw==OPUS_BANDWIDTH_MEDIUMBAND)bw+=3;
237             if(opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(bw))!=OPUS_OK)test_failed();
238             len = opus_encode(enc, &inbuf[i<<1], frame_size, packet, MAX_PACKET);
239             if(len<0 || len>MAX_PACKET)test_failed();
240             if(opus_encoder_ctl(enc, OPUS_GET_FINAL_RANGE(&enc_final_range))!=OPUS_OK)test_failed();
241             out_samples = opus_decode(dec, packet, len, &outbuf[i<<1], MAX_FRAME_SAMP, 0);
242             if(out_samples!=frame_size)test_failed();
243             if(opus_decoder_ctl(dec, OPUS_GET_FINAL_RANGE(&dec_final_range))!=OPUS_OK)test_failed();
244             if(enc_final_range!=dec_final_range)test_failed();
245             /*LBRR decode*/
246             out_samples = opus_decode(dec_err[0], packet, len, out2buf, MAX_FRAME_SAMP, (fast_rand()&3)!=0);
247             if(out_samples!=frame_size)test_failed();
248             out_samples = opus_decode(dec_err[1], packet, (fast_rand()&3)==0?0:len, out2buf, MAX_FRAME_SAMP, (fast_rand()&7)!=0);
249             if(out_samples<120)test_failed();
250             i+=frame_size;
251             count++;
252          }while(i<(SSAMPLES-MAX_FRAME_SAMP));
253          fprintf(stdout,"    Mode %s FB encode %s, %6d bps OK.\n",mstrings[modes[j]],rc==0?" VBR":rc==1?"CVBR":" CBR",rate);
254       }
255    }
256
257    if(opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(OPUS_AUTO))!=OPUS_OK)test_failed();
258    if(opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS(OPUS_AUTO))!=OPUS_OK)test_failed();
259    if(opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(0))!=OPUS_OK)test_failed();
260    if(opus_encoder_ctl(enc, OPUS_SET_DTX(0))!=OPUS_OK)test_failed();
261
262    for(rc=0;rc<3;rc++)
263    {
264       if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_VBR(rc<2))!=OPUS_OK)test_failed();
265       if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_VBR_CONSTRAINT(rc==1))!=OPUS_OK)test_failed();
266       if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_VBR_CONSTRAINT(rc==1))!=OPUS_OK)test_failed();
267       if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_INBAND_FEC(rc==0))!=OPUS_OK)test_failed();
268       for(j=0;j<16;j++)
269       {
270          int rate;
271          int modes[16]={0,0,0,0,0,0,0,0,2,2,2,2,2,2,2,2};
272          int rates[16]={4000,12000,32000,8000,16000,32000,48000,88000,4000,12000,32000,8000,16000,32000,48000,88000};
273          int frame[16]={160*1,160,80,160,160,80,40,20,160*1,160,80,160,160,80,40,20};
274          if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_INBAND_FEC(rc==0&&j==1))!=OPUS_OK)test_failed();
275          if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_FORCE_MODE(MODE_SILK_ONLY+modes[j]))!=OPUS_OK)test_failed();
276          rate=rates[j]+fast_rand()%rates[j];
277          if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_DTX(fast_rand()&1))!=OPUS_OK)test_failed();
278          if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_BITRATE(rate))!=OPUS_OK)test_failed();
279          count=i=0;
280          do {
281             int len,out_samples,frame_size,loss;
282             frame_size=frame[j];
283             if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_COMPLEXITY((count>>2)%11))!=OPUS_OK)test_failed();
284             if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_PACKET_LOSS_PERC((fast_rand()&15)&(fast_rand()%15)))!=OPUS_OK)test_failed();
285             len = opus_multistream_encode(MSenc, &inbuf[i<<1], frame_size, packet, MAX_PACKET);
286             if(len<0 || len>MAX_PACKET)test_failed();
287             if(opus_multistream_encoder_ctl(MSenc, OPUS_GET_FINAL_RANGE(&enc_final_range))!=OPUS_OK)test_failed();
288             out_samples = opus_multistream_decode(MSdec, packet, len, out2buf, MAX_FRAME_SAMP, 0);
289             if(out_samples!=frame_size*6)test_failed();
290             if(opus_multistream_decoder_ctl(MSdec, OPUS_GET_FINAL_RANGE(&dec_final_range))!=OPUS_OK)test_failed();
291             if(enc_final_range!=dec_final_range)test_failed();
292             /*LBRR decode*/
293             loss=(fast_rand()&63)==0;
294             out_samples = opus_multistream_decode(MSdec_err, packet, loss?0:len, out2buf, MAX_FRAME_SAMP, (fast_rand()&3)!=0);
295             if(loss?out_samples<120:out_samples!=(frame_size*6))test_failed();
296             i+=frame_size;
297             count++;
298          }while(i<(SSAMPLES/12-MAX_FRAME_SAMP));
299          fprintf(stdout,"    Mode %s NB dual-mono MS encode %s, %6d bps OK.\n",mstrings[modes[j]],rc==0?" VBR":rc==1?"CVBR":" CBR",rate);
300       }
301    }
302
303    bitrate_bps=512000;
304    fsize=fast_rand()%31;
305    fswitch=100;
306
307    debruijn2(6,db62);
308    count=i=0;
309    do {
310       unsigned char toc;
311       const unsigned char *frames[48];
312       short size[48];
313       int payload_offset;
314       opus_uint32 dec_final_range2;
315       int jj,dec2;
316       int len,out_samples;
317       int frame_size=fsizes[db62[fsize]];
318       opus_int32 offset=i%(SAMPLES-MAX_FRAME_SAMP);
319
320       opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrate_bps));
321
322       len = opus_encode(enc, &inbuf[offset<<1], frame_size, packet, MAX_PACKET);
323       if(len<0 || len>MAX_PACKET)test_failed();
324       count++;
325
326       opus_encoder_ctl(enc, OPUS_GET_FINAL_RANGE(&enc_final_range));
327
328       out_samples = opus_decode(dec, packet, len, &outbuf[offset<<1], MAX_FRAME_SAMP, 0);
329       if(out_samples!=frame_size)test_failed();
330
331       opus_decoder_ctl(dec, OPUS_GET_FINAL_RANGE(&dec_final_range));
332
333       /* compare final range encoder rng values of encoder and decoder */
334       if(dec_final_range!=enc_final_range)test_failed();
335
336       /* We fuzz the packet, but take care not to only corrupt the payload
337          Corrupted headers are tested elsewhere and we need to actually run
338          the decoders in order to compare them. */
339       if(opus_packet_parse(packet,len,&toc,frames,size,&payload_offset)<=0)test_failed();
340       if((fast_rand()&1023)==0)len=0;
341       for(j=(frames[0]-packet);j<len;j++)for(jj=0;jj<8;jj++)packet[j]^=((!no_fuzz)&&((fast_rand()&1023)==0))<<jj;
342       out_samples = opus_decode(dec_err[0], len>0?packet:NULL, len, out2buf, MAX_FRAME_SAMP, 0);
343       if(out_samples<0||out_samples>MAX_FRAME_SAMP)test_failed();
344       if((len>0&&out_samples!=frame_size))test_failed(); /*FIXME use lastframe*/
345
346       opus_decoder_ctl(dec_err[0], OPUS_GET_FINAL_RANGE(&dec_final_range));
347
348       /*randomly select one of the decoders to compare with*/
349       dec2=fast_rand()%9+1;
350       out_samples = opus_decode(dec_err[dec2], len>0?packet:NULL, len, out2buf, MAX_FRAME_SAMP, 0);
351       if(out_samples<0||out_samples>MAX_FRAME_SAMP)test_failed(); /*FIXME, use factor, lastframe for loss*/
352
353       opus_decoder_ctl(dec_err[dec2], OPUS_GET_FINAL_RANGE(&dec_final_range2));
354       if(len>0&&dec_final_range!=dec_final_range2)test_failed();
355
356       fswitch--;
357       if(fswitch<1)
358       {
359         int new_size;
360         fsize=(fsize+1)%36;
361         new_size=fsizes[db62[fsize]];
362         if(new_size==960||new_size==480)fswitch=2880/new_size*(fast_rand()%19+1);
363         else fswitch=(fast_rand()%(2880/new_size))+1;
364       }
365       bitrate_bps=((fast_rand()%508000+4000)+bitrate_bps)>>1;
366       i+=frame_size;
367    }while(i<SAMPLES*4);
368    fprintf(stdout,"    All framesize pairs switching encode, %d frames OK.\n",count);
369
370    opus_encoder_destroy(enc);
371    opus_multistream_encoder_destroy(MSenc);
372    opus_decoder_destroy(dec);
373    opus_multistream_decoder_destroy(MSdec);
374    opus_multistream_decoder_destroy(MSdec_err);
375    for(i=0;i<10;i++)opus_decoder_destroy(dec_err[i]);
376    free(inbuf);
377    free(outbuf);
378    free(out2buf);
379    return 0;
380 }
381
382 int main(int _argc, char **_argv)
383 {
384    const char * oversion;
385    const char * env_seed;
386    int env_used;
387
388    if(_argc>2)
389    {
390       fprintf(stderr,"Usage: %s [<seed>]\n",_argv[0]);
391       return 1;
392    }
393
394    env_used=0;
395    env_seed=getenv("SEED");
396    if(_argc>1)iseed=atoi(_argv[1]);
397    else if(env_seed)
398    {
399       iseed=atoi(env_seed);
400       env_used=1;
401    }
402    else iseed=(opus_uint32)time(NULL)^((getpid()&65535)<<16);
403    Rw=Rz=iseed;
404
405    oversion=opus_get_version_string();
406    if(!oversion)test_failed();
407    fprintf(stderr,"Testing %s encoder. Random seed: %u (%.4X)\n", oversion, iseed, fast_rand() % 65535);
408    if(env_used)fprintf(stderr,"  Random seed set from the environment (SEED=%s).\n", env_seed);
409
410    /*Setting TEST_OPUS_NOFUZZ tells the tool not to send garbage data
411      into the decoders. This is helpful because garbage data
412      may cause the decoders to clip, which angers CLANG IOC.*/
413    run_test1(getenv("TEST_OPUS_NOFUZZ")!=NULL);
414
415    fprintf(stderr,"Tests completed successfully.\n");
416
417    return 0;
418 }