Avoid an inconsequential memory leak in tests/test_opus_decode.c.
[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};
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    dec = opus_decoder_create(48000, 2, &err);
148    if(err != OPUS_OK || dec==NULL)test_failed();
149
150    MSdec = opus_multistream_decoder_create(48000, 2, 2, 0, mapping, &err);
151    if(err != OPUS_OK || MSdec==NULL)test_failed();
152
153    MSdec_err = opus_multistream_decoder_create(48000, 1, 2, 0, mapping, &err);
154    if(err != OPUS_OK || MSdec_err==NULL)test_failed();
155
156    dec_err[0]=(OpusDecoder *)malloc(opus_decoder_get_size(2));
157    memcpy(dec_err[0],dec,opus_decoder_get_size(2));
158    dec_err[1] = opus_decoder_create(48000, 1, &err);
159    dec_err[2] = opus_decoder_create(24000, 2, &err);
160    dec_err[3] = opus_decoder_create(24000, 1, &err);
161    dec_err[4] = opus_decoder_create(16000, 2, &err);
162    dec_err[5] = opus_decoder_create(16000, 1, &err);
163    dec_err[6] = opus_decoder_create(12000, 2, &err);
164    dec_err[7] = opus_decoder_create(12000, 1, &err);
165    dec_err[8] = opus_decoder_create(8000, 2, &err);
166    dec_err[9] = opus_decoder_create(8000, 1, &err);
167    for(i=0;i<10;i++)if(dec_err[i]==NULL)test_failed();
168
169    {
170       OpusEncoder *enccpy;
171       /*The opus state structures contain no pointers and can be freely copied*/
172       enccpy=(OpusEncoder *)malloc(opus_encoder_get_size(2));
173       memcpy(enccpy,enc,opus_encoder_get_size(2));
174       memset(enc,255,opus_encoder_get_size(2));
175       opus_encoder_destroy(enc);
176       enc=enccpy;
177    }
178
179    inbuf=(short *)malloc(sizeof(short)*SAMPLES*2);
180    outbuf=(short *)malloc(sizeof(short)*SAMPLES*2);
181    out2buf=(short *)malloc(sizeof(short)*MAX_FRAME_SAMP*2);
182    if(inbuf==NULL || outbuf==NULL || out2buf==NULL)test_failed();
183
184    generate_music(inbuf,SAMPLES);
185
186 /*   FILE *foo;
187    foo = fopen("foo.sw", "wb+");
188    fwrite(inbuf, 1, SAMPLES*2*2, foo);
189    fclose(foo);*/
190
191    if(opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(OPUS_AUTO))!=OPUS_OK)test_failed();
192    if(opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(-2))!=OPUS_BAD_ARG)test_failed();
193
194    for(rc=0;rc<3;rc++)
195    {
196       if(opus_encoder_ctl(enc, OPUS_SET_VBR(rc<2))!=OPUS_OK)test_failed();
197       if(opus_encoder_ctl(enc, OPUS_SET_VBR_CONSTRAINT(rc==1))!=OPUS_OK)test_failed();
198       if(opus_encoder_ctl(enc, OPUS_SET_VBR_CONSTRAINT(rc==1))!=OPUS_OK)test_failed();
199       if(opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(rc==0))!=OPUS_OK)test_failed();
200       for(j=0;j<13;j++)
201       {
202          int rate;
203          int modes[13]={0,0,0,1,1,1,1,2,2,2,2,2,2};
204          int rates[13]={6000,12000,48000,16000,32000,48000,64000,512000,13000,24000,48000,64000,96000};
205          int frame[13]={960*2,960,480,960,960,960,480,960*3,960*3,960,480,240,120};
206          rate=rates[j]+fast_rand()%rates[j];
207          count=i=0;
208          do {
209             int bw,len,out_samples,frame_size;
210             frame_size=frame[j];
211             if(fast_rand()%50==0)opus_encoder_ctl(enc, OPUS_RESET_STATE);
212             if(fast_rand()%50==0)opus_decoder_ctl(dec, OPUS_RESET_STATE);
213             if(opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(rc==0))!=OPUS_OK)test_failed();
214             if(opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(MODE_SILK_ONLY+modes[j]))!=OPUS_OK)test_failed();
215             if(opus_encoder_ctl(enc, OPUS_SET_DTX(fast_rand()&1))!=OPUS_OK)test_failed();
216             if(opus_encoder_ctl(enc, OPUS_SET_BITRATE(rate))!=OPUS_OK)test_failed();
217             if(opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS((rates[j]>=64000?2:1)))!=OPUS_OK)test_failed();
218             if(opus_encoder_ctl(enc, OPUS_SET_COMPLEXITY((count>>2)%11))!=OPUS_OK)test_failed();
219             if(opus_encoder_ctl(enc, OPUS_SET_PACKET_LOSS_PERC((fast_rand()&15)&(fast_rand()%15)))!=OPUS_OK)test_failed();
220             bw=modes[j]==0?OPUS_BANDWIDTH_NARROWBAND+(fast_rand()%3):
221                modes[j]==1?OPUS_BANDWIDTH_SUPERWIDEBAND+(fast_rand()&1):
222                            OPUS_BANDWIDTH_NARROWBAND+(fast_rand()%5);
223             if(modes[j]==2&&bw==OPUS_BANDWIDTH_MEDIUMBAND)bw+=3;
224             if(opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(bw))!=OPUS_OK)test_failed();
225             len = opus_encode(enc, &inbuf[i<<1], frame_size, packet, MAX_PACKET);
226             if(len<0 || len>MAX_PACKET)test_failed();
227             if(opus_encoder_ctl(enc, OPUS_GET_FINAL_RANGE(&enc_final_range))!=OPUS_OK)test_failed();
228             out_samples = opus_decode(dec, packet, len, &outbuf[i<<1], MAX_FRAME_SAMP, 0);
229             if(out_samples!=frame_size)test_failed();
230             if(opus_decoder_ctl(dec, OPUS_GET_FINAL_RANGE(&dec_final_range))!=OPUS_OK)test_failed();
231             if(enc_final_range!=dec_final_range)test_failed();
232             /*LBRR decode*/
233             out_samples = opus_decode(dec_err[0], packet, len, out2buf, MAX_FRAME_SAMP, (fast_rand()&3)!=0);
234             if(out_samples!=frame_size)test_failed();
235             out_samples = opus_decode(dec_err[1], packet, (fast_rand()&3)==0?0:len, out2buf, MAX_FRAME_SAMP, (fast_rand()&7)!=0);
236             if(out_samples<120)test_failed();
237             i+=frame_size;
238             count++;
239          }while(i<(SSAMPLES-MAX_FRAME_SAMP));
240          fprintf(stdout,"    Mode %s FB encode %s, %6d bps OK.\n",mstrings[modes[j]],rc==0?" VBR":rc==1?"CVBR":" CBR",rate);
241       }
242    }
243
244    if(opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(OPUS_AUTO))!=OPUS_OK)test_failed();
245    if(opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS(OPUS_AUTO))!=OPUS_OK)test_failed();
246    if(opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(0))!=OPUS_OK)test_failed();
247    if(opus_encoder_ctl(enc, OPUS_SET_DTX(0))!=OPUS_OK)test_failed();
248
249    for(rc=0;rc<3;rc++)
250    {
251       if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_VBR(rc<2))!=OPUS_OK)test_failed();
252       if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_VBR_CONSTRAINT(rc==1))!=OPUS_OK)test_failed();
253       if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_VBR_CONSTRAINT(rc==1))!=OPUS_OK)test_failed();
254       if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_INBAND_FEC(rc==0))!=OPUS_OK)test_failed();
255       for(j=0;j<16;j++)
256       {
257          int rate;
258          int modes[16]={0,0,0,0,0,0,0,0,2,2,2,2,2,2,2,2};
259          int rates[16]={4000,12000,32000,8000,16000,32000,48000,88000,4000,12000,32000,8000,16000,32000,48000,88000};
260          int frame[16]={160*1,160,80,160,160,80,40,20,160*1,160,80,160,160,80,40,20};
261          if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_INBAND_FEC(rc==0&&j==1))!=OPUS_OK)test_failed();
262          if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_FORCE_MODE(MODE_SILK_ONLY+modes[j]))!=OPUS_OK)test_failed();
263          rate=rates[j]+fast_rand()%rates[j];
264          if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_DTX(fast_rand()&1))!=OPUS_OK)test_failed();
265          if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_BITRATE(rate))!=OPUS_OK)test_failed();
266          count=i=0;
267          do {
268             int len,out_samples,frame_size,loss;
269             frame_size=frame[j];
270             if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_COMPLEXITY((count>>2)%11))!=OPUS_OK)test_failed();
271             if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_PACKET_LOSS_PERC((fast_rand()&15)&(fast_rand()%15)))!=OPUS_OK)test_failed();
272             len = opus_multistream_encode(MSenc, &inbuf[i<<1], frame_size, packet, MAX_PACKET);
273             if(len<0 || len>MAX_PACKET)test_failed();
274             if(opus_multistream_encoder_ctl(MSenc, OPUS_GET_FINAL_RANGE(&enc_final_range))!=OPUS_OK)test_failed();
275             out_samples = opus_multistream_decode(MSdec, packet, len, out2buf, MAX_FRAME_SAMP, 0);
276             if(out_samples!=frame_size*6)test_failed();
277             if(opus_multistream_decoder_ctl(MSdec, OPUS_GET_FINAL_RANGE(&dec_final_range))!=OPUS_OK)test_failed();
278             if(enc_final_range!=dec_final_range)test_failed();
279             /*LBRR decode*/
280             loss=(fast_rand()&63)==0;
281             out_samples = opus_multistream_decode(MSdec_err, packet, loss?0:len, out2buf, MAX_FRAME_SAMP, (fast_rand()&3)!=0);
282             if(loss?out_samples<120:out_samples!=(frame_size*6))test_failed();
283             i+=frame_size;
284             count++;
285          }while(i<(SSAMPLES/12-MAX_FRAME_SAMP));
286          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);
287       }
288    }
289
290    bitrate_bps=512000;
291    fsize=fast_rand()%31;
292    fswitch=100;
293
294    debruijn2(6,db62);
295    count=i=0;
296    do {
297       unsigned char toc;
298       const unsigned char *frames[48];
299       short size[48];
300       int payload_offset;
301       opus_uint32 dec_final_range2;
302       int jj,dec2;
303       int len,out_samples;
304       int frame_size=fsizes[db62[fsize]];
305       opus_int32 offset=i%(SAMPLES-MAX_FRAME_SAMP);
306
307       opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrate_bps));
308
309       len = opus_encode(enc, &inbuf[offset<<1], frame_size, packet, MAX_PACKET);
310       if(len<0 || len>MAX_PACKET)test_failed();
311       count++;
312
313       opus_encoder_ctl(enc, OPUS_GET_FINAL_RANGE(&enc_final_range));
314
315       out_samples = opus_decode(dec, packet, len, &outbuf[offset<<1], MAX_FRAME_SAMP, 0);
316       if(out_samples!=frame_size)test_failed();
317
318       opus_decoder_ctl(dec, OPUS_GET_FINAL_RANGE(&dec_final_range));
319
320       /* compare final range encoder rng values of encoder and decoder */
321       if(dec_final_range!=enc_final_range)test_failed();
322
323       /* We fuzz the packet, but take care not to only corrupt the payload
324          Corrupted headers are tested elsewhere and we need to actually run
325          the decoders in order to compare them. */
326       if(opus_packet_parse(packet,len,&toc,frames,size,&payload_offset)<=0)test_failed();
327       if((fast_rand()&1023)==0)len=0;
328       for(j=(frames[0]-packet);j<len;j++)for(jj=0;jj<8;jj++)packet[j]^=((!no_fuzz)&&((fast_rand()&1023)==0))<<jj;
329       out_samples = opus_decode(dec_err[0], len>0?packet:NULL, len, out2buf, MAX_FRAME_SAMP, 0);
330       if(out_samples<0||out_samples>MAX_FRAME_SAMP)test_failed();
331       if((len>0&&out_samples!=frame_size))test_failed(); /*FIXME use lastframe*/
332
333       opus_decoder_ctl(dec_err[0], OPUS_GET_FINAL_RANGE(&dec_final_range));
334
335       /*randomly select one of the decoders to compare with*/
336       dec2=fast_rand()%9+1;
337       out_samples = opus_decode(dec_err[dec2], len>0?packet:NULL, len, out2buf, MAX_FRAME_SAMP, 0);
338       if(out_samples<0||out_samples>MAX_FRAME_SAMP)test_failed(); /*FIXME, use factor, lastframe for loss*/
339
340       opus_decoder_ctl(dec_err[dec2], OPUS_GET_FINAL_RANGE(&dec_final_range2));
341       if(len>0&&dec_final_range!=dec_final_range2)test_failed();
342
343       fswitch--;
344       if(fswitch<1)
345       {
346         int new_size;
347         fsize=(fsize+1)%36;
348         new_size=fsizes[db62[fsize]];
349         if(new_size==960||new_size==480)fswitch=2880/new_size*(fast_rand()%19+1);
350         else fswitch=(fast_rand()%(2880/new_size))+1;
351       }
352       bitrate_bps=((fast_rand()%508000+4000)+bitrate_bps)>>1;
353       i+=frame_size;
354    }while(i<SAMPLES*4);
355    fprintf(stdout,"    All framesize pairs switching encode, %d frames OK.\n",count);
356
357    opus_encoder_destroy(enc);
358    opus_multistream_encoder_destroy(MSenc);
359    opus_decoder_destroy(dec);
360    opus_multistream_decoder_destroy(MSdec);
361    opus_multistream_decoder_destroy(MSdec_err);
362    for(i=0;i<10;i++)opus_decoder_destroy(dec_err[i]);
363    free(inbuf);
364    free(outbuf);
365    free(out2buf);
366    return 0;
367 }
368
369 int main(int _argc, char **_argv)
370 {
371    const char * oversion;
372    const char * env_seed;
373    int env_used;
374
375    if(_argc>2)
376    {
377       fprintf(stderr,"Usage: %s [<seed>]\n",_argv[0]);
378       return 1;
379    }
380
381    env_used=0;
382    env_seed=getenv("SEED");
383    if(_argc>1)iseed=atoi(_argv[1]);
384    else if(env_seed)
385    {
386       iseed=atoi(env_seed);
387       env_used=1;
388    }
389    else iseed=(opus_uint32)time(NULL)^((getpid()&65535)<<16);
390    Rw=Rz=iseed;
391
392    oversion=opus_get_version_string();
393    if(!oversion)test_failed();
394    fprintf(stderr,"Testing %s encoder. Random seed: %u (%.4X)\n", oversion, iseed, fast_rand() % 65535);
395    if(env_used)fprintf(stderr,"  Random seed set from the environment (SEED=%s).\n", env_seed);
396
397    /*Setting TEST_OPUS_NOFUZZ tells the tool not to send garbage data
398      into the decoders. This is helpful because garbage data
399      may cause the decoders to clip, which angers CLANG IOC.*/
400    run_test1(getenv("TEST_OPUS_NOFUZZ")!=NULL);
401
402    fprintf(stderr,"Tests completed successfully.\n");
403
404    return 0;
405 }