ee87281a0eac6a949190a4ba84bc64ac70e7f1c1
[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 "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 (5760)
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, 1, 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          rate=rates[j]+fast_rand()%rates[j];
195          count=i=0;
196          do {
197             int bw,len,out_samples,frame_size;
198             frame_size=frame[j];
199             if(fast_rand()%50==0)opus_encoder_ctl(enc, OPUS_RESET_STATE);
200             if(fast_rand()%50==0)opus_decoder_ctl(dec, OPUS_RESET_STATE);
201             if(opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(rc==0))!=OPUS_OK)test_failed();
202             if(opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(MODE_SILK_ONLY+modes[j]))!=OPUS_OK)test_failed();
203             if(opus_encoder_ctl(enc, OPUS_SET_DTX(fast_rand()&1))!=OPUS_OK)test_failed();
204             if(opus_encoder_ctl(enc, OPUS_SET_BITRATE(rate))!=OPUS_OK)test_failed();
205             if(opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS((rates[j]>=64000?2:1)))!=OPUS_OK)test_failed();
206             if(opus_encoder_ctl(enc, OPUS_SET_COMPLEXITY((count>>2)%11))!=OPUS_OK)test_failed();
207             if(opus_encoder_ctl(enc, OPUS_SET_PACKET_LOSS_PERC((fast_rand()&15)&(fast_rand()%15)))!=OPUS_OK)test_failed();
208             bw=modes[j]==0?OPUS_BANDWIDTH_NARROWBAND+(fast_rand()%3):
209                modes[j]==1?OPUS_BANDWIDTH_SUPERWIDEBAND+(fast_rand()&1):
210                            OPUS_BANDWIDTH_NARROWBAND+(fast_rand()%5);
211             if(modes[j]==2&&bw==OPUS_BANDWIDTH_MEDIUMBAND)bw+=3;
212             if(opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(bw))!=OPUS_OK)test_failed();
213             len = opus_encode(enc, &inbuf[i<<1], frame_size, packet, MAX_PACKET);
214             if(len<0 || len>MAX_PACKET)test_failed();
215             if(opus_encoder_ctl(enc, OPUS_GET_FINAL_RANGE(&enc_final_range))!=OPUS_OK)test_failed();
216             out_samples = opus_decode(dec, packet, len, &outbuf[i<<1], MAX_FRAME_SAMP, 0);
217             if(out_samples!=frame_size)test_failed();
218             if(opus_decoder_ctl(dec, OPUS_GET_FINAL_RANGE(&dec_final_range))!=OPUS_OK)test_failed();
219             if(enc_final_range!=dec_final_range)test_failed();
220             /*LBRR decode*/
221             out_samples = opus_decode(dec_err[0], packet, len, out2buf, MAX_FRAME_SAMP, (fast_rand()&3)!=0);
222             if(out_samples!=frame_size)test_failed();
223             out_samples = opus_decode(dec_err[1], packet, (fast_rand()&3)==0?0:len, out2buf, MAX_FRAME_SAMP, (fast_rand()&7)!=0);
224             if(out_samples<120)test_failed();
225             i+=frame_size;
226             count++;
227          }while(i<(SSAMPLES-MAX_FRAME_SAMP));
228          fprintf(stdout,"    Mode %s FB encode %s, %6d bps OK.\n",mstrings[modes[j]],rc==0?" VBR":rc==1?"CVBR":" CBR",rate);
229       }
230    }
231
232    if(opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(OPUS_AUTO))!=OPUS_OK)test_failed();
233    if(opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS(OPUS_AUTO))!=OPUS_OK)test_failed();
234    if(opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(0))!=OPUS_OK)test_failed();
235    if(opus_encoder_ctl(enc, OPUS_SET_DTX(0))!=OPUS_OK)test_failed();
236
237    for(rc=0;rc<3;rc++)
238    {
239       if(opus_encoder_ctl(enc2, OPUS_SET_VBR(rc<2))!=OPUS_OK)test_failed();
240       if(opus_encoder_ctl(enc2, OPUS_SET_VBR_CONSTRAINT(rc==1))!=OPUS_OK)test_failed();
241       if(opus_encoder_ctl(enc2, OPUS_SET_VBR_CONSTRAINT(rc==1))!=OPUS_OK)test_failed();
242       if(opus_encoder_ctl(enc2, OPUS_SET_INBAND_FEC(rc==0))!=OPUS_OK)test_failed();
243       for(j=0;j<16;j++)
244       {
245          int rate;
246          int modes[16]={0,0,0,0,0,0,0,0,2,2,2,2,2,2,2,2};
247          int rates[16]={4000,12000,32000,8000,16000,32000,48000,88000,4000,12000,32000,8000,16000,32000,48000,88000};
248          int frame[16]={160*3,160,80,160,160,80,40,20,160*3,160,80,160,160,80,40,20};
249          if(opus_encoder_ctl(enc2, OPUS_SET_INBAND_FEC(rc==0&&j==1))!=OPUS_OK)test_failed();
250          if(opus_encoder_ctl(enc2, OPUS_SET_FORCE_MODE(MODE_SILK_ONLY+modes[j]))!=OPUS_OK)test_failed();
251          rate=rates[j]+fast_rand()%rates[j];
252          if(opus_encoder_ctl(enc2, OPUS_SET_DTX(fast_rand()&1))!=OPUS_OK)test_failed();
253          if(opus_encoder_ctl(enc2, OPUS_SET_BITRATE(rate))!=OPUS_OK)test_failed();
254          count=i=0;
255          do {
256             int len,out_samples,frame_size;
257             frame_size=frame[j];
258             if(opus_encoder_ctl(enc2, OPUS_SET_COMPLEXITY((count>>2)%11))!=OPUS_OK)test_failed();
259             if(opus_encoder_ctl(enc2, OPUS_SET_PACKET_LOSS_PERC((fast_rand()&15)&(fast_rand()%15)))!=OPUS_OK)test_failed();
260             len = opus_encode(enc2, &inbuf[i], frame_size, packet, MAX_PACKET);
261             if(len<0 || len>MAX_PACKET)test_failed();
262             if(opus_encoder_ctl(enc2, OPUS_GET_FINAL_RANGE(&enc_final_range))!=OPUS_OK)test_failed();
263             out_samples = opus_decode(dec, packet, len, out2buf, MAX_FRAME_SAMP, 0);
264             if(out_samples!=frame_size*6)test_failed();
265             if(opus_decoder_ctl(dec, OPUS_GET_FINAL_RANGE(&dec_final_range))!=OPUS_OK)test_failed();
266             if(enc_final_range!=dec_final_range)test_failed();
267             /*LBRR decode*/
268             out_samples = opus_decode(dec_err[8], packet, len, out2buf, MAX_FRAME_SAMP, (fast_rand()&3)!=0);
269             if(out_samples!=frame_size)test_failed();
270             out_samples = opus_decode(dec_err[9], packet, (fast_rand()&3)==0?0:len, out2buf, MAX_FRAME_SAMP, (fast_rand()&7)!=0);
271             if(out_samples<20)test_failed();
272             i+=frame_size;
273             count++;
274          }while(i<(SSAMPLES/6-MAX_FRAME_SAMP));
275          fprintf(stdout,"    Mode %s NB encode %s, %6d bps OK.\n",mstrings[modes[j]],rc==0?" VBR":rc==1?"CVBR":" CBR",rate);
276       }
277    }
278
279    bitrate_bps=512000;
280    fsize=fast_rand()%31;
281    fswitch=100;
282
283    debruijn2(6,db62);
284    count=i=0;
285    do {
286       unsigned char toc;
287       const unsigned char *frames[48];
288       short size[48];
289       int payload_offset;
290       opus_uint32 dec_final_range2;
291       int jj,dec2;
292       int len,out_samples;
293       int frame_size=fsizes[db62[fsize]];
294       opus_int32 offset=i%(SAMPLES-MAX_FRAME_SAMP);
295
296       opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrate_bps));
297
298       len = opus_encode(enc, &inbuf[offset<<1], frame_size, packet, MAX_PACKET);
299       if(len<0 || len>MAX_PACKET)test_failed();
300       count++;
301
302       opus_encoder_ctl(enc, OPUS_GET_FINAL_RANGE(&enc_final_range));
303
304       out_samples = opus_decode(dec, packet, len, &outbuf[offset<<1], MAX_FRAME_SAMP, 0);
305       if(out_samples!=frame_size)test_failed();
306
307       opus_decoder_ctl(dec, OPUS_GET_FINAL_RANGE(&dec_final_range));
308
309       /* compare final range encoder rng values of encoder and decoder */
310       if(dec_final_range!=enc_final_range)test_failed();
311
312       /* We fuzz the packet, but take care not to only corrupt the payload
313          Corrupted headers are tested elsewhere and we need to actually run
314          the decoders in order to compare them. */
315       if(opus_packet_parse(packet,len,&toc,frames,size,&payload_offset)<=0)test_failed();
316       if((fast_rand()&1023)==0)len=0;
317       for(j=payload_offset;j<len;j++)for(jj=0;jj<8;jj++)packet[j]^=((fast_rand()&1023)==0)<<jj;
318       out_samples = opus_decode(dec_err[0], len>0?packet:NULL, len, out2buf, MAX_FRAME_SAMP, 0);
319       if(out_samples<0||out_samples>MAX_FRAME_SAMP)test_failed();
320       if((len>0&&out_samples!=frame_size))test_failed(); /*FIXME use lastframe*/
321
322       opus_decoder_ctl(dec_err[0], OPUS_GET_FINAL_RANGE(&dec_final_range));
323
324       /*randomly select one of the decoders to compare with*/
325       dec2=fast_rand()%9+1;
326       out_samples = opus_decode(dec_err[dec2], len>0?packet:NULL, len, out2buf, MAX_FRAME_SAMP, 0);
327       if(out_samples<0||out_samples>MAX_FRAME_SAMP)test_failed(); /*FIXME, use factor, lastframe for loss*/
328
329       opus_decoder_ctl(dec_err[dec2], OPUS_GET_FINAL_RANGE(&dec_final_range2));
330       if(len>0&&dec_final_range!=dec_final_range2)test_failed();
331
332       fswitch--;
333       if(fswitch<1)
334       {
335         int new_size;
336         fsize=(fsize+1)%36;
337         new_size=fsizes[db62[fsize]];
338         if(new_size==960||new_size==480)fswitch=2880/new_size*(fast_rand()%19+1);
339         else fswitch=(fast_rand()%(2880/new_size))+1;
340       }
341       bitrate_bps=((fast_rand()%508000+4000)+bitrate_bps)>>1;
342       i+=frame_size;
343    }while(i<SAMPLES*4);
344    fprintf(stdout,"    All framesize pairs switching encode, %d frames OK.\n",count);
345
346    opus_encoder_destroy(enc);
347    opus_encoder_destroy(enc2);
348    opus_decoder_destroy(dec);
349    for(i=0;i<10;i++)opus_decoder_destroy(dec_err[i]);
350    free(inbuf);
351    free(outbuf);
352    free(out2buf);
353    return 0;
354 }
355
356 int main(int _argc, char **_argv)
357 {
358    const char * oversion;
359    if(_argc>2)
360    {
361       fprintf(stderr,"Usage: %s [<seed>]\n",_argv[0]);
362       return 1;
363    }
364
365    if(_argc>1)iseed=atoi(_argv[1]);
366    else iseed=(opus_uint32)time(NULL)^((getpid()&65535)<<16);
367    Rw=Rz=iseed;
368
369    oversion=opus_get_version_string();
370    if(!oversion)test_failed();
371    fprintf(stderr,"Testing %s encoder. Random seed: %u (%.4X)\n", oversion, iseed, fast_rand() % 65535);
372
373    run_test1();
374
375    fprintf(stderr,"Tests completed successfully.\n");
376
377    return 0;
378 }