Make the MALLOC_FAIL test solely dependent on HAVE___MALLOC_HOOK.
[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 FOUNDATION OR
19    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
22    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
23    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
24    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 #ifdef HAVE_CONFIG_H
29 #include "config.h"
30 #endif
31
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <limits.h>
35 #include <stdint.h>
36 #include <math.h>
37 #include <string.h>
38 #include <time.h>
39 #include <unistd.h>
40 #include "../include/opus.h"
41 #include "../src/opus_private.h"
42 #include "test_opus_common.h"
43
44 #define MAX_PACKET (1500)
45 #define SAMPLES (48000*30)
46 #define SSAMPLES (SAMPLES/3)
47 #define MAX_FRAME_SAMP (288000)
48
49 #define PI (3.141592653589793238462643f)
50
51 void generate_music(short *buf, opus_int32 len)
52 {
53    opus_int32 a1,b1,a2,b2;
54    opus_int32 c1,c2,d1,d2;
55    opus_int32 i,j;
56    a1=b1=a2=b2=0;
57    c1=c2=d1=d2=0;
58    j=0;
59    /*60ms silence*/
60    for(i=0;i<2880;i++)buf[i*2]=buf[i*2+1]=0;
61    for(i=2880;i<len;i++)
62    {
63      opus_uint32 r;
64      opus_int32 v1,v2;
65      v1=v2=(((j*((j>>12)^((j>>10|j>>12)&26&j>>7)))&128)+128)<<15;
66      r=fast_rand();v1+=r&65535;v1-=r>>16;
67      r=fast_rand();v2+=r&65535;v2-=r>>16;
68      b1=v1-a1+((b1*61+32)>>6);a1=v1;
69      b2=v2-a2+((b2*61+32)>>6);a2=v2;
70      c1=(30*(c1+b1+d1)+32)>>6;d1=b1;
71      c2=(30*(c2+b2+d2)+32)>>6;d2=b2;
72      v1=(c1+128)>>8;
73      v2=(c2+128)>>8;
74      buf[i*2]=v1>32767?32767:(v1<-32768?-32768:v1);
75      buf[i*2+1]=v2>32767?32767:(v2<-32768?-32768:v2);
76      if(i%6==0)j++;
77    }
78 }
79
80 #if 0
81 static int save_ctr = 0;
82 static void int_to_char(opus_uint32 i, unsigned char ch[4])
83 {
84     ch[0] = i>>24;
85     ch[1] = (i>>16)&0xFF;
86     ch[2] = (i>>8)&0xFF;
87     ch[3] = i&0xFF;
88 }
89
90 static inline void save_packet(unsigned char* p, int len, opus_uint32 rng)
91 {
92    FILE *fout;
93    unsigned char int_field[4];
94    char name[256];
95    snprintf(name,255,"test_opus_encode.%llu.%d.bit",(unsigned long long)iseed,save_ctr);
96    fprintf(stdout,"writing %d byte packet to %s\n",len,name);
97    fout=fopen(name, "wb+");
98    if(fout==NULL)test_failed();
99    int_to_char(len, int_field);
100    fwrite(int_field, 1, 4, fout);
101    int_to_char(rng, int_field);
102    fwrite(int_field, 1, 4, fout);
103    fwrite(p, 1, len, fout);
104    fclose(fout);
105    save_ctr++;
106 }
107 #endif
108
109 int run_test1(void)
110 {
111    static const int fsizes[6]={960*3,960*2,120,240,480,960};
112    static const char *mstrings[3] = {"    LP","Hybrid","  MDCT"};
113    unsigned char db62[36];
114    opus_int32 i;
115    int rc,j,err;
116    OpusEncoder *enc;
117    OpusEncoder *enc2;
118    OpusDecoder *dec;
119    OpusDecoder *dec_err[10];
120    short *inbuf;
121    short *outbuf;
122    short *out2buf;
123    opus_int32 bitrate_bps;
124    unsigned char packet[MAX_PACKET];
125    opus_uint32 enc_final_range;
126    opus_uint32 dec_final_range;
127    int fswitch;
128    int fsize;
129    int count;
130
131   /*FIXME: encoder api tests, fs!=48k, mono, VBR*/
132
133    fprintf(stdout,"  Encode+Decode tests.\n");
134
135    enc = opus_encoder_create(48000, 2, OPUS_APPLICATION_VOIP, &err);
136    if(err != OPUS_OK || enc==NULL)test_failed();
137
138    enc2 = opus_encoder_create(8000, 2, OPUS_APPLICATION_VOIP, &err);
139    if(err != OPUS_OK || enc==NULL)test_failed();
140
141    dec = opus_decoder_create(48000, 2, &err);
142    if(err != OPUS_OK || dec==NULL)test_failed();
143
144    dec_err[0]=(OpusDecoder *)malloc(opus_decoder_get_size(2));
145    memcpy(dec_err[0],dec,opus_decoder_get_size(2));
146    dec_err[1] = opus_decoder_create(48000, 1, &err);
147    dec_err[2] = opus_decoder_create(24000, 2, &err);
148    dec_err[3] = opus_decoder_create(24000, 1, &err);
149    dec_err[4] = opus_decoder_create(16000, 2, &err);
150    dec_err[5] = opus_decoder_create(16000, 1, &err);
151    dec_err[6] = opus_decoder_create(12000, 2, &err);
152    dec_err[7] = opus_decoder_create(12000, 1, &err);
153    dec_err[8] = opus_decoder_create(8000, 2, &err);
154    dec_err[9] = opus_decoder_create(8000, 1, &err);
155    for(i=0;i<10;i++)if(dec_err[i]==NULL)test_failed();
156
157    {
158       OpusEncoder *enccpy;
159       /*The opus state structures contain no pointers and can be freely copied*/
160       enccpy=(OpusEncoder *)malloc(opus_encoder_get_size(2));
161       memcpy(enccpy,enc,opus_encoder_get_size(2));
162       memset(enc,255,opus_encoder_get_size(2));
163       opus_encoder_destroy(enc);
164       enc=enccpy;
165    }
166
167    inbuf=(short *)malloc(sizeof(short)*SAMPLES*2);
168    outbuf=(short *)malloc(sizeof(short)*SAMPLES*2);
169    out2buf=(short *)malloc(sizeof(short)*MAX_FRAME_SAMP*2);
170    if(inbuf==NULL || outbuf==NULL || out2buf==NULL)test_failed();
171
172    generate_music(inbuf,SAMPLES);
173
174 /*   FILE *foo;
175    foo = fopen("foo.sw", "wb+");
176    fwrite(inbuf, 1, SAMPLES*2*2, foo);
177    fclose(foo);*/
178
179    if(opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(OPUS_AUTO))!=OPUS_OK)test_failed();
180    if(opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(-2))!=OPUS_BAD_ARG)test_failed();
181
182    for(rc=0;rc<3;rc++)
183    {
184       if(opus_encoder_ctl(enc, OPUS_SET_VBR(rc<2))!=OPUS_OK)test_failed();
185       if(opus_encoder_ctl(enc, OPUS_SET_VBR_CONSTRAINT(rc==1))!=OPUS_OK)test_failed();
186       if(opus_encoder_ctl(enc, OPUS_SET_VBR_CONSTRAINT(rc==1))!=OPUS_OK)test_failed();
187       if(opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(rc==0))!=OPUS_OK)test_failed();
188       for(j=0;j<13;j++)
189       {
190          int rate;
191          int modes[13]={0,0,0,1,1,1,1,2,2,2,2,2,2};
192          int rates[13]={6000,12000,48000,16000,32000,48000,64000,512000,13000,24000,48000,64000,96000};
193          int frame[13]={960*2,960,480,960,960,960,480,960*3,960*3,960,480,240,120};
194          if(opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(rc==0))!=OPUS_OK)test_failed();
195          if(opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(MODE_SILK_ONLY+modes[j]))!=OPUS_OK)test_failed();
196          rate=rates[j]+fast_rand()%rates[j];
197          if(opus_encoder_ctl(enc, OPUS_SET_DTX(fast_rand()&1))!=OPUS_OK)test_failed();
198          if(opus_encoder_ctl(enc, OPUS_SET_BITRATE(rate))!=OPUS_OK)test_failed();
199          if(opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS((rates[j]>=64000?2:1)))!=OPUS_OK)test_failed();
200          count=i=0;
201          do {
202             int bw,len,out_samples,frame_size;
203             frame_size=frame[j];
204             if(opus_encoder_ctl(enc, OPUS_SET_COMPLEXITY((count>>2)%11))!=OPUS_OK)test_failed();
205             if(opus_encoder_ctl(enc, OPUS_SET_PACKET_LOSS_PERC((fast_rand()&15)&(fast_rand()%15)))!=OPUS_OK)test_failed();
206             bw=modes[j]==0?OPUS_BANDWIDTH_NARROWBAND+(fast_rand()%3):
207                modes[j]==1?OPUS_BANDWIDTH_SUPERWIDEBAND+(fast_rand()&1):
208                            OPUS_BANDWIDTH_NARROWBAND+(fast_rand()%5);
209             if(modes[j]==2&&bw==OPUS_BANDWIDTH_MEDIUMBAND)bw+=3;
210             if(opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(bw))!=OPUS_OK)test_failed();
211             len = opus_encode(enc, &inbuf[i<<1], frame_size, packet, MAX_PACKET);
212             if(len<0 || len>MAX_PACKET)test_failed();
213             if(opus_encoder_ctl(enc, OPUS_GET_FINAL_RANGE(&enc_final_range))!=OPUS_OK)test_failed();
214             out_samples = opus_decode(dec, packet, len, &outbuf[i<<1], MAX_FRAME_SAMP, 0);
215             if(out_samples!=frame_size)test_failed();
216             if(opus_decoder_ctl(dec, OPUS_GET_FINAL_RANGE(&dec_final_range))!=OPUS_OK)test_failed();
217             if(enc_final_range!=dec_final_range)test_failed();
218             i+=frame_size;
219             count++;
220          }while(i<(SSAMPLES-MAX_FRAME_SAMP));
221          fprintf(stdout,"    Mode %s FB encode %s, %6d bps OK.\n",mstrings[modes[j]],rc==0?" VBR":rc==1?"CVBR":" CBR",rate);
222       }
223    }
224
225    if(opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(OPUS_AUTO))!=OPUS_OK)test_failed();
226    if(opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS(OPUS_AUTO))!=OPUS_OK)test_failed();
227    if(opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(0))!=OPUS_OK)test_failed();
228    if(opus_encoder_ctl(enc, OPUS_SET_DTX(0))!=OPUS_OK)test_failed();
229
230    for(rc=0;rc<3;rc++)
231    {
232       if(opus_encoder_ctl(enc2, OPUS_SET_VBR(rc<2))!=OPUS_OK)test_failed();
233       if(opus_encoder_ctl(enc2, OPUS_SET_VBR_CONSTRAINT(rc==1))!=OPUS_OK)test_failed();
234       if(opus_encoder_ctl(enc2, OPUS_SET_VBR_CONSTRAINT(rc==1))!=OPUS_OK)test_failed();
235       if(opus_encoder_ctl(enc2, OPUS_SET_INBAND_FEC(rc==0))!=OPUS_OK)test_failed();
236       for(j=0;j<16;j++)
237       {
238          int rate;
239          int modes[16]={0,0,0,0,0,0,0,0,2,2,2,2,2,2,2,2};
240          int rates[16]={4000,12000,32000,8000,16000,32000,48000,88000,4000,12000,32000,8000,16000,32000,48000,88000};
241          int frame[16]={160*3,160,80,160,160,80,40,20,160*3,160,80,160,160,80,40,20};
242          if(opus_encoder_ctl(enc2, OPUS_SET_INBAND_FEC(rc==0&&j==1))!=OPUS_OK)test_failed();
243          if(opus_encoder_ctl(enc2, OPUS_SET_FORCE_MODE(MODE_SILK_ONLY+modes[j]))!=OPUS_OK)test_failed();
244          rate=rates[j]+fast_rand()%rates[j];
245          if(opus_encoder_ctl(enc2, OPUS_SET_DTX(fast_rand()&1))!=OPUS_OK)test_failed();
246          if(opus_encoder_ctl(enc2, OPUS_SET_BITRATE(rate))!=OPUS_OK)test_failed();
247          if(opus_encoder_ctl(enc2, OPUS_SET_FORCE_CHANNELS((rates[j]>=48000?2:1)))!=OPUS_OK)test_failed();
248          count=i=0;
249          do {
250             int len,out_samples,frame_size;
251             frame_size=frame[j];
252             if(opus_encoder_ctl(enc2, OPUS_SET_COMPLEXITY((count>>2)%11))!=OPUS_OK)test_failed();
253             if(opus_encoder_ctl(enc2, OPUS_SET_PACKET_LOSS_PERC((fast_rand()&15)&(fast_rand()%15)))!=OPUS_OK)test_failed();
254             len = opus_encode(enc2, &inbuf[i<<1], frame_size, packet, MAX_PACKET);
255             if(len<0 || len>MAX_PACKET)test_failed();
256             if(opus_encoder_ctl(enc2, OPUS_GET_FINAL_RANGE(&enc_final_range))!=OPUS_OK)test_failed();
257             out_samples = opus_decode(dec, packet, len, &outbuf[i<<1], MAX_FRAME_SAMP, 0);
258             if(out_samples!=frame_size*6)test_failed();
259             if(opus_decoder_ctl(dec, OPUS_GET_FINAL_RANGE(&dec_final_range))!=OPUS_OK)test_failed();
260             if(enc_final_range!=dec_final_range)test_failed();
261             i+=frame_size;
262             count++;
263          }while(i<(SSAMPLES/6-MAX_FRAME_SAMP));
264          fprintf(stdout,"    Mode %s NB encode %s, %6d bps OK.\n",mstrings[modes[j]],rc==0?" VBR":rc==1?"CVBR":" CBR",rate);
265       }
266    }
267
268    bitrate_bps=512000;
269    fsize=fast_rand()%31;
270    fswitch=100;
271
272    debruijn2(6,db62);
273    count=i=0;
274    do {
275       unsigned char toc;
276       const unsigned char *frames[48];
277       short size[48];
278       int payload_offset;
279       opus_uint32 dec_final_range2;
280       int jj,dec2;
281       int len,out_samples;
282       int frame_size=fsizes[db62[fsize]];
283       opus_int32 offset=i%(SAMPLES-MAX_FRAME_SAMP);
284
285       opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrate_bps));
286
287       len = opus_encode(enc, &inbuf[offset<<1], frame_size, packet, MAX_PACKET);
288       if(len<0 || len>MAX_PACKET)test_failed();
289       count++;
290
291       opus_encoder_ctl(enc, OPUS_GET_FINAL_RANGE(&enc_final_range));
292
293       out_samples = opus_decode(dec, packet, len, &outbuf[offset<<1], MAX_FRAME_SAMP, 0);
294       if(out_samples!=frame_size)test_failed();
295
296       opus_decoder_ctl(dec, OPUS_GET_FINAL_RANGE(&dec_final_range));
297
298       /* compare final range encoder rng values of encoder and decoder */
299       if(dec_final_range!=enc_final_range)test_failed();
300
301       /* We fuzz the packet, but take care not to only corrupt the payload
302          Corrupted headers are tested elsewhere and we need to actually run
303          the decoders in order to compare them. */
304       if(opus_packet_parse(packet,len,&toc,frames,size,&payload_offset)<=0)test_failed();
305       if((fast_rand()&1023)==0)len=0;
306       for(j=payload_offset;j<len;j++)for(jj=0;jj<8;jj++)packet[j]^=((fast_rand()&1023)==0)<<jj;
307       out_samples = opus_decode(dec_err[0], len>0?packet:NULL, len, out2buf, MAX_FRAME_SAMP, 0);
308       if(out_samples<0||out_samples>MAX_FRAME_SAMP)test_failed();
309       if((len>0&&out_samples!=frame_size))test_failed(); /*FIXME use lastframe*/
310
311       opus_decoder_ctl(dec_err[0], OPUS_GET_FINAL_RANGE(&dec_final_range));
312
313       /*randomly select one of the decoders to compare with*/
314       dec2=fast_rand()%9+1;
315       out_samples = opus_decode(dec_err[dec2], len>0?packet:NULL, len, out2buf, MAX_FRAME_SAMP, 0);
316       if(out_samples<0||out_samples>MAX_FRAME_SAMP)test_failed(); /*FIXME, use factor, lastframe for loss*/
317
318       opus_decoder_ctl(dec_err[dec2], OPUS_GET_FINAL_RANGE(&dec_final_range2));
319       if(len>0&&dec_final_range!=dec_final_range2)test_failed();
320
321       fswitch--;
322       if(fswitch<1)
323       {
324         int new_size;
325         fsize=(fsize+1)%36;
326         new_size=fsizes[db62[fsize]];
327         if(new_size==960||new_size==480)fswitch=2880/new_size*(fast_rand()%19+1);
328         else fswitch=(fast_rand()%(2880/new_size))+1;
329       }
330       bitrate_bps=((fast_rand()%508000+4000)+bitrate_bps)>>1;
331       i+=frame_size;
332    }while(i<SAMPLES*4);
333    fprintf(stdout,"    All framesize pairs switching encode, %d frames OK.\n",count);
334
335    opus_encoder_destroy(enc);
336    opus_encoder_destroy(enc2);
337    opus_decoder_destroy(dec);
338    for(i=0;i<10;i++)opus_decoder_destroy(dec_err[i]);
339    free(inbuf);
340    free(outbuf);
341    free(out2buf);
342    return 0;
343 }
344
345 int main(int _argc, char **_argv)
346 {
347    const char * oversion;
348    if(_argc>2)
349    {
350       fprintf(stderr,"Usage: %s [<seed>]\n",_argv[0]);
351       return 1;
352    }
353
354    if(_argc>1)iseed=atoi(_argv[1]);
355    else iseed=(opus_uint32)time(NULL)^((getpid()&65535)<<16);
356    Rw=Rz=iseed;
357
358    oversion=opus_get_version_string();
359    if(!oversion)test_failed();
360    fprintf(stderr,"Testing %s encoder. Random seed: %u (%.4X)\n", oversion, iseed, fast_rand() % 65535);
361
362    run_test1();
363
364    fprintf(stderr,"Tests completed successfully.\n");
365
366    return 0;
367 }