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