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