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