1 /* Copyright (c) 2007-2008 CSIRO 2 Copyright (c) 2007-2009 Xiph.Org Foundation 3 Written by Jean-Marc Valin */ 4 /* 5 Redistribution and use in source and binary forms, with or without 6 modification, are permitted provided that the following conditions 7 are met: 8 9 - Redistributions of source code must retain the above copyright 10 notice, this list of conditions and the following disclaimer. 11 12 - Redistributions in binary form must reproduce the above copyright 13 notice, this list of conditions and the following disclaimer in the 14 documentation and/or other materials provided with the distribution. 15 16 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 17 ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 18 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 19 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER 20 OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 21 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 22 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 23 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 24 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 25 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 26 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 #ifdef HAVE_CONFIG_H 30 #include "config.h" 31 #endif 32 33 #include <stdio.h> 34 #include <stdlib.h> 35 #include <math.h> 36 #include <string.h> 37 #include "opus.h" 38 #include "debug.h" 39 #include "opus_types.h" 40 #include "opus_private.h" 41 #include "opus_multistream.h" 42 43 #define MAX_PACKET 1500 44 45 void print_usage( char* argv[] ) 46 { 47 fprintf(stderr, "Usage: %s [-e] <application> <sampling rate (Hz)> <channels (1/2)> " 48 "<bits per second> [options] <input> <output>\n", argv[0]); 49 fprintf(stderr, " %s -d <sampling rate (Hz)> <channels (1/2)> " 50 "[options] <input> <output>\n\n", argv[0]); 51 fprintf(stderr, "application: voip | audio | restricted-lowdelay\n" ); 52 fprintf(stderr, "options:\n" ); 53 fprintf(stderr, "-e : only runs the encoder (output the bit-stream)\n" ); 54 fprintf(stderr, "-d : only runs the decoder (reads the bit-stream as input)\n" ); 55 fprintf(stderr, "-cbr : enable constant bitrate; default: variable bitrate\n" ); 56 fprintf(stderr, "-cvbr : enable constrained variable bitrate; default: unconstrained\n" ); 57 fprintf(stderr, "-variable-duration : enable frames of variable duration (experts only); default: disabled\n" ); 58 fprintf(stderr, "-bandwidth <NB|MB|WB|SWB|FB> : audio bandwidth (from narrowband to fullband); default: sampling rate\n" ); 59 fprintf(stderr, "-framesize <2.5|5|10|20|40|60> : frame size in ms; default: 20 \n" ); 60 fprintf(stderr, "-max_payload <bytes> : maximum payload size in bytes, default: 1024\n" ); 61 fprintf(stderr, "-complexity <comp> : complexity, 0 (lowest) ... 10 (highest); default: 10\n" ); 62 fprintf(stderr, "-inbandfec : enable SILK inband FEC\n" ); 63 fprintf(stderr, "-forcemono : force mono encoding, even for stereo input\n" ); 64 fprintf(stderr, "-dtx : enable SILK DTX\n" ); 65 fprintf(stderr, "-loss <perc> : simulate packet loss, in percent (0-100); default: 0\n" ); 66 } 67 68 static void int_to_char(opus_uint32 i, unsigned char ch[4]) 69 { 70 ch[0] = i>>24; 71 ch[1] = (i>>16)&0xFF; 72 ch[2] = (i>>8)&0xFF; 73 ch[3] = i&0xFF; 74 } 75 76 static opus_uint32 char_to_int(unsigned char ch[4]) 77 { 78 return ((opus_uint32)ch[0]<<24) | ((opus_uint32)ch[1]<<16) 79 | ((opus_uint32)ch[2]<< 8) | (opus_uint32)ch[3]; 80 } 81 82 static void check_encoder_option(int decode_only, const char *opt) 83 { 84 if (decode_only) 85 { 86 fprintf(stderr, "option %s is only for encoding\n", opt); 87 exit(EXIT_FAILURE); 88 } 89 } 90 91 static const int silk8_test[][4] = { 92 {MODE_SILK_ONLY, OPUS_BANDWIDTH_NARROWBAND, 960*3, 1}, 93 {MODE_SILK_ONLY, OPUS_BANDWIDTH_NARROWBAND, 960*2, 1}, 94 {MODE_SILK_ONLY, OPUS_BANDWIDTH_NARROWBAND, 960, 1}, 95 {MODE_SILK_ONLY, OPUS_BANDWIDTH_NARROWBAND, 480, 1}, 96 {MODE_SILK_ONLY, OPUS_BANDWIDTH_NARROWBAND, 960*3, 2}, 97 {MODE_SILK_ONLY, OPUS_BANDWIDTH_NARROWBAND, 960*2, 2}, 98 {MODE_SILK_ONLY, OPUS_BANDWIDTH_NARROWBAND, 960, 2}, 99 {MODE_SILK_ONLY, OPUS_BANDWIDTH_NARROWBAND, 480, 2} 100 }; 101 102 static const int silk12_test[][4] = { 103 {MODE_SILK_ONLY, OPUS_BANDWIDTH_MEDIUMBAND, 960*3, 1}, 104 {MODE_SILK_ONLY, OPUS_BANDWIDTH_MEDIUMBAND, 960*2, 1}, 105 {MODE_SILK_ONLY, OPUS_BANDWIDTH_MEDIUMBAND, 960, 1}, 106 {MODE_SILK_ONLY, OPUS_BANDWIDTH_MEDIUMBAND, 480, 1}, 107 {MODE_SILK_ONLY, OPUS_BANDWIDTH_MEDIUMBAND, 960*3, 2}, 108 {MODE_SILK_ONLY, OPUS_BANDWIDTH_MEDIUMBAND, 960*2, 2}, 109 {MODE_SILK_ONLY, OPUS_BANDWIDTH_MEDIUMBAND, 960, 2}, 110 {MODE_SILK_ONLY, OPUS_BANDWIDTH_MEDIUMBAND, 480, 2} 111 }; 112 113 static const int silk16_test[][4] = { 114 {MODE_SILK_ONLY, OPUS_BANDWIDTH_WIDEBAND, 960*3, 1}, 115 {MODE_SILK_ONLY, OPUS_BANDWIDTH_WIDEBAND, 960*2, 1}, 116 {MODE_SILK_ONLY, OPUS_BANDWIDTH_WIDEBAND, 960, 1}, 117 {MODE_SILK_ONLY, OPUS_BANDWIDTH_WIDEBAND, 480, 1}, 118 {MODE_SILK_ONLY, OPUS_BANDWIDTH_WIDEBAND, 960*3, 2}, 119 {MODE_SILK_ONLY, OPUS_BANDWIDTH_WIDEBAND, 960*2, 2}, 120 {MODE_SILK_ONLY, OPUS_BANDWIDTH_WIDEBAND, 960, 2}, 121 {MODE_SILK_ONLY, OPUS_BANDWIDTH_WIDEBAND, 480, 2} 122 }; 123 124 static const int hybrid24_test[][4] = { 125 {MODE_SILK_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 960, 1}, 126 {MODE_SILK_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 480, 1}, 127 {MODE_SILK_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 960, 2}, 128 {MODE_SILK_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 480, 2} 129 }; 130 131 static const int hybrid48_test[][4] = { 132 {MODE_SILK_ONLY, OPUS_BANDWIDTH_FULLBAND, 960, 1}, 133 {MODE_SILK_ONLY, OPUS_BANDWIDTH_FULLBAND, 480, 1}, 134 {MODE_SILK_ONLY, OPUS_BANDWIDTH_FULLBAND, 960, 2}, 135 {MODE_SILK_ONLY, OPUS_BANDWIDTH_FULLBAND, 480, 2} 136 }; 137 138 static const int celt_test[][4] = { 139 {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND, 960, 1}, 140 {MODE_CELT_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 960, 1}, 141 {MODE_CELT_ONLY, OPUS_BANDWIDTH_WIDEBAND, 960, 1}, 142 {MODE_CELT_ONLY, OPUS_BANDWIDTH_NARROWBAND, 960, 1}, 143 144 {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND, 480, 1}, 145 {MODE_CELT_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 480, 1}, 146 {MODE_CELT_ONLY, OPUS_BANDWIDTH_WIDEBAND, 480, 1}, 147 {MODE_CELT_ONLY, OPUS_BANDWIDTH_NARROWBAND, 480, 1}, 148 149 {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND, 240, 1}, 150 {MODE_CELT_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 240, 1}, 151 {MODE_CELT_ONLY, OPUS_BANDWIDTH_WIDEBAND, 240, 1}, 152 {MODE_CELT_ONLY, OPUS_BANDWIDTH_NARROWBAND, 240, 1}, 153 154 {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND, 120, 1}, 155 {MODE_CELT_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 120, 1}, 156 {MODE_CELT_ONLY, OPUS_BANDWIDTH_WIDEBAND, 120, 1}, 157 {MODE_CELT_ONLY, OPUS_BANDWIDTH_NARROWBAND, 120, 1}, 158 159 {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND, 960, 2}, 160 {MODE_CELT_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 960, 2}, 161 {MODE_CELT_ONLY, OPUS_BANDWIDTH_WIDEBAND, 960, 2}, 162 {MODE_CELT_ONLY, OPUS_BANDWIDTH_NARROWBAND, 960, 2}, 163 164 {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND, 480, 2}, 165 {MODE_CELT_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 480, 2}, 166 {MODE_CELT_ONLY, OPUS_BANDWIDTH_WIDEBAND, 480, 2}, 167 {MODE_CELT_ONLY, OPUS_BANDWIDTH_NARROWBAND, 480, 2}, 168 169 {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND, 240, 2}, 170 {MODE_CELT_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 240, 2}, 171 {MODE_CELT_ONLY, OPUS_BANDWIDTH_WIDEBAND, 240, 2}, 172 {MODE_CELT_ONLY, OPUS_BANDWIDTH_NARROWBAND, 240, 2}, 173 174 {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND, 120, 2}, 175 {MODE_CELT_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 120, 2}, 176 {MODE_CELT_ONLY, OPUS_BANDWIDTH_WIDEBAND, 120, 2}, 177 {MODE_CELT_ONLY, OPUS_BANDWIDTH_NARROWBAND, 120, 2}, 178 179 }; 180 181 static const int celt_hq_test[][4] = { 182 {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND, 960, 2}, 183 {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND, 480, 2}, 184 {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND, 240, 2}, 185 {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND, 120, 2}, 186 }; 187 188 #if 0 /* This is a hack that replaces the normal encoder/decoder with the multistream version */ 189 #define OpusEncoder OpusMSEncoder 190 #define OpusDecoder OpusMSDecoder 191 #define opus_encode opus_multistream_encode 192 #define opus_decode opus_multistream_decode 193 #define opus_encoder_ctl opus_multistream_encoder_ctl 194 #define opus_decoder_ctl opus_multistream_decoder_ctl 195 #define opus_encoder_create ms_opus_encoder_create 196 #define opus_decoder_create ms_opus_decoder_create 197 #define opus_encoder_destroy opus_multistream_encoder_destroy 198 #define opus_decoder_destroy opus_multistream_decoder_destroy 199 200 static OpusEncoder *ms_opus_encoder_create(opus_int32 Fs, int channels, int application, int *error) 201 { 202 int streams, coupled_streams; 203 unsigned char mapping[256]; 204 return (OpusEncoder *)opus_multistream_surround_encoder_create(Fs, channels, 1, &streams, &coupled_streams, mapping, application, error); 205 } 206 static OpusDecoder *ms_opus_decoder_create(opus_int32 Fs, int channels, int *error) 207 { 208 int streams; 209 int coupled_streams; 210 unsigned char mapping[256]={0,1}; 211 streams = 1; 212 coupled_streams = channels==2; 213 return (OpusDecoder *)opus_multistream_decoder_create(Fs, channels, streams, coupled_streams, mapping, error); 214 } 215 #endif 216 217 int main(int argc, char *argv[]) 218 { 219 int err; 220 char *inFile, *outFile; 221 FILE *fin, *fout; 222 OpusEncoder *enc=NULL; 223 OpusDecoder *dec=NULL; 224 int args; 225 int len[2]; 226 int frame_size, channels; 227 opus_int32 bitrate_bps=0; 228 unsigned char *data[2]; 229 unsigned char *fbytes; 230 opus_int32 sampling_rate; 231 int use_vbr; 232 int max_payload_bytes; 233 int complexity; 234 int use_inbandfec; 235 int use_dtx; 236 int forcechannels; 237 int cvbr = 0; 238 int packet_loss_perc; 239 opus_int32 count=0, count_act=0; 240 int k; 241 opus_int32 skip=0; 242 int stop=0; 243 short *in, *out; 244 int application=OPUS_APPLICATION_AUDIO; 245 double bits=0.0, bits_max=0.0, bits_act=0.0, bits2=0.0, nrg; 246 double tot_samples=0; 247 opus_uint64 tot_in, tot_out; 248 int bandwidth=OPUS_AUTO; 249 const char *bandwidth_string; 250 int lost = 0, lost_prev = 1; 251 int toggle = 0; 252 opus_uint32 enc_final_range[2]; 253 opus_uint32 dec_final_range; 254 int encode_only=0, decode_only=0; 255 int max_frame_size = 48000*2; 256 int curr_read=0; 257 int sweep_bps = 0; 258 int random_framesize=0, newsize=0, delayed_celt=0; 259 int sweep_max=0, sweep_min=0; 260 int random_fec=0; 261 const int (*mode_list)[4]=NULL; 262 int nb_modes_in_list=0; 263 int curr_mode=0; 264 int curr_mode_count=0; 265 int mode_switch_time = 48000; 266 int nb_encoded=0; 267 int remaining=0; 268 int variable_duration=OPUS_FRAMESIZE_ARG; 269 int delayed_decision=0; 270 271 if (argc < 5 ) 272 { 273 print_usage( argv ); 274 return EXIT_FAILURE; 275 } 276 277 tot_in=tot_out=0; 278 fprintf(stderr, "%s\n", opus_get_version_string()); 279 280 args = 1; 281 if (strcmp(argv[args], "-e")==0) 282 { 283 encode_only = 1; 284 args++; 285 } else if (strcmp(argv[args], "-d")==0) 286 { 287 decode_only = 1; 288 args++; 289 } 290 if (!decode_only && argc < 7 ) 291 { 292 print_usage( argv ); 293 return EXIT_FAILURE; 294 } 295 296 if (!decode_only) 297 { 298 if (strcmp(argv[args], "voip")==0) 299 application = OPUS_APPLICATION_VOIP; 300 else if (strcmp(argv[args], "restricted-lowdelay")==0) 301 application = OPUS_APPLICATION_RESTRICTED_LOWDELAY; 302 else if (strcmp(argv[args], "audio")!=0) { 303 fprintf(stderr, "unknown application: %s\n", argv[args]); 304 print_usage(argv); 305 return EXIT_FAILURE; 306 } 307 args++; 308 } 309 sampling_rate = (opus_int32)atol(argv[args]); 310 args++; 311 312 if (sampling_rate != 8000 && sampling_rate != 12000 313 && sampling_rate != 16000 && sampling_rate != 24000 314 && sampling_rate != 48000) 315 { 316 fprintf(stderr, "Supported sampling rates are 8000, 12000, " 317 "16000, 24000 and 48000.\n"); 318 return EXIT_FAILURE; 319 } 320 frame_size = sampling_rate/50; 321 322 channels = atoi(argv[args]); 323 args++; 324 325 if (channels < 1 || channels > 2) 326 { 327 fprintf(stderr, "Opus_demo supports only 1 or 2 channels.\n"); 328 return EXIT_FAILURE; 329 } 330 331 if (!decode_only) 332 { 333 bitrate_bps = (opus_int32)atol(argv[args]); 334 args++; 335 } 336 337 /* defaults: */ 338 use_vbr = 1; 339 max_payload_bytes = MAX_PACKET; 340 complexity = 10; 341 use_inbandfec = 0; 342 forcechannels = OPUS_AUTO; 343 use_dtx = 0; 344 packet_loss_perc = 0; 345 346 while( args < argc - 2 ) { 347 /* process command line options */ 348 if( strcmp( argv[ args ], "-cbr" ) == 0 ) { 349 check_encoder_option(decode_only, "-cbr"); 350 use_vbr = 0; 351 args++; 352 } else if( strcmp( argv[ args ], "-bandwidth" ) == 0 ) { 353 check_encoder_option(decode_only, "-bandwidth"); 354 if (strcmp(argv[ args + 1 ], "NB")==0) 355 bandwidth = OPUS_BANDWIDTH_NARROWBAND; 356 else if (strcmp(argv[ args + 1 ], "MB")==0) 357 bandwidth = OPUS_BANDWIDTH_MEDIUMBAND; 358 else if (strcmp(argv[ args + 1 ], "WB")==0) 359 bandwidth = OPUS_BANDWIDTH_WIDEBAND; 360 else if (strcmp(argv[ args + 1 ], "SWB")==0) 361 bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND; 362 else if (strcmp(argv[ args + 1 ], "FB")==0) 363 bandwidth = OPUS_BANDWIDTH_FULLBAND; 364 else { 365 fprintf(stderr, "Unknown bandwidth %s. " 366 "Supported are NB, MB, WB, SWB, FB.\n", 367 argv[ args + 1 ]); 368 return EXIT_FAILURE; 369 } 370 args += 2; 371 } else if( strcmp( argv[ args ], "-framesize" ) == 0 ) { 372 check_encoder_option(decode_only, "-framesize"); 373 if (strcmp(argv[ args + 1 ], "2.5")==0) 374 frame_size = sampling_rate/400; 375 else if (strcmp(argv[ args + 1 ], "5")==0) 376 frame_size = sampling_rate/200; 377 else if (strcmp(argv[ args + 1 ], "10")==0) 378 frame_size = sampling_rate/100; 379 else if (strcmp(argv[ args + 1 ], "20")==0) 380 frame_size = sampling_rate/50; 381 else if (strcmp(argv[ args + 1 ], "40")==0) 382 frame_size = sampling_rate/25; 383 else if (strcmp(argv[ args + 1 ], "60")==0) 384 frame_size = 3*sampling_rate/50; 385 else { 386 fprintf(stderr, "Unsupported frame size: %s ms. " 387 "Supported are 2.5, 5, 10, 20, 40, 60.\n", 388 argv[ args + 1 ]); 389 return EXIT_FAILURE; 390 } 391 args += 2; 392 } else if( strcmp( argv[ args ], "-max_payload" ) == 0 ) { 393 check_encoder_option(decode_only, "-max_payload"); 394 max_payload_bytes = atoi( argv[ args + 1 ] ); 395 args += 2; 396 } else if( strcmp( argv[ args ], "-complexity" ) == 0 ) { 397 check_encoder_option(decode_only, "-complexity"); 398 complexity = atoi( argv[ args + 1 ] ); 399 args += 2; 400 } else if( strcmp( argv[ args ], "-inbandfec" ) == 0 ) { 401 use_inbandfec = 1; 402 args++; 403 } else if( strcmp( argv[ args ], "-forcemono" ) == 0 ) { 404 check_encoder_option(decode_only, "-forcemono"); 405 forcechannels = 1; 406 args++; 407 } else if( strcmp( argv[ args ], "-cvbr" ) == 0 ) { 408 check_encoder_option(decode_only, "-cvbr"); 409 cvbr = 1; 410 args++; 411 } else if( strcmp( argv[ args ], "-variable-duration" ) == 0 ) { 412 check_encoder_option(decode_only, "-variable-duration"); 413 variable_duration = OPUS_FRAMESIZE_VARIABLE; 414 args++; 415 } else if( strcmp( argv[ args ], "-delayed-decision" ) == 0 ) { 416 check_encoder_option(decode_only, "-delayed-decision"); 417 delayed_decision = 1; 418 args++; 419 } else if( strcmp( argv[ args ], "-dtx") == 0 ) { 420 check_encoder_option(decode_only, "-dtx"); 421 use_dtx = 1; 422 args++; 423 } else if( strcmp( argv[ args ], "-loss" ) == 0 ) { 424 packet_loss_perc = atoi( argv[ args + 1 ] ); 425 args += 2; 426 } else if( strcmp( argv[ args ], "-sweep" ) == 0 ) { 427 check_encoder_option(decode_only, "-sweep"); 428 sweep_bps = atoi( argv[ args + 1 ] ); 429 args += 2; 430 } else if( strcmp( argv[ args ], "-random_framesize" ) == 0 ) { 431 check_encoder_option(decode_only, "-random_framesize"); 432 random_framesize = 1; 433 args++; 434 } else if( strcmp( argv[ args ], "-sweep_max" ) == 0 ) { 435 check_encoder_option(decode_only, "-sweep_max"); 436 sweep_max = atoi( argv[ args + 1 ] ); 437 args += 2; 438 } else if( strcmp( argv[ args ], "-random_fec" ) == 0 ) { 439 check_encoder_option(decode_only, "-random_fec"); 440 random_fec = 1; 441 args++; 442 } else if( strcmp( argv[ args ], "-silk8k_test" ) == 0 ) { 443 check_encoder_option(decode_only, "-silk8k_test"); 444 mode_list = silk8_test; 445 nb_modes_in_list = 8; 446 args++; 447 } else if( strcmp( argv[ args ], "-silk12k_test" ) == 0 ) { 448 check_encoder_option(decode_only, "-silk12k_test"); 449 mode_list = silk12_test; 450 nb_modes_in_list = 8; 451 args++; 452 } else if( strcmp( argv[ args ], "-silk16k_test" ) == 0 ) { 453 check_encoder_option(decode_only, "-silk16k_test"); 454 mode_list = silk16_test; 455 nb_modes_in_list = 8; 456 args++; 457 } else if( strcmp( argv[ args ], "-hybrid24k_test" ) == 0 ) { 458 check_encoder_option(decode_only, "-hybrid24k_test"); 459 mode_list = hybrid24_test; 460 nb_modes_in_list = 4; 461 args++; 462 } else if( strcmp( argv[ args ], "-hybrid48k_test" ) == 0 ) { 463 check_encoder_option(decode_only, "-hybrid48k_test"); 464 mode_list = hybrid48_test; 465 nb_modes_in_list = 4; 466 args++; 467 } else if( strcmp( argv[ args ], "-celt_test" ) == 0 ) { 468 check_encoder_option(decode_only, "-celt_test"); 469 mode_list = celt_test; 470 nb_modes_in_list = 32; 471 args++; 472 } else if( strcmp( argv[ args ], "-celt_hq_test" ) == 0 ) { 473 check_encoder_option(decode_only, "-celt_hq_test"); 474 mode_list = celt_hq_test; 475 nb_modes_in_list = 4; 476 args++; 477 } else { 478 printf( "Error: unrecognized setting: %s\n\n", argv[ args ] ); 479 print_usage( argv ); 480 return EXIT_FAILURE; 481 } 482 } 483 484 if (sweep_max) 485 sweep_min = bitrate_bps; 486 487 if (max_payload_bytes < 0 || max_payload_bytes > MAX_PACKET) 488 { 489 fprintf (stderr, "max_payload_bytes must be between 0 and %d\n", 490 MAX_PACKET); 491 return EXIT_FAILURE; 492 } 493 494 inFile = argv[argc-2]; 495 fin = fopen(inFile, "rb"); 496 if (!fin) 497 { 498 fprintf (stderr, "Could not open input file %s\n", argv[argc-2]); 499 return EXIT_FAILURE; 500 } 501 if (mode_list) 502 { 503 int size; 504 fseek(fin, 0, SEEK_END); 505 size = ftell(fin); 506 fprintf(stderr, "File size is %d bytes\n", size); 507 fseek(fin, 0, SEEK_SET); 508 mode_switch_time = size/sizeof(short)/channels/nb_modes_in_list; 509 fprintf(stderr, "Switching mode every %d samples\n", mode_switch_time); 510 } 511 512 outFile = argv[argc-1]; 513 fout = fopen(outFile, "wb+"); 514 if (!fout) 515 { 516 fprintf (stderr, "Could not open output file %s\n", argv[argc-1]); 517 fclose(fin); 518 return EXIT_FAILURE; 519 } 520 521 if (!decode_only) 522 { 523 enc = opus_encoder_create(sampling_rate, channels, application, &err); 524 if (err != OPUS_OK) 525 { 526 fprintf(stderr, "Cannot create encoder: %s\n", opus_strerror(err)); 527 fclose(fin); 528 fclose(fout); 529 return EXIT_FAILURE; 530 } 531 opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrate_bps)); 532 opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(bandwidth)); 533 opus_encoder_ctl(enc, OPUS_SET_VBR(use_vbr)); 534 opus_encoder_ctl(enc, OPUS_SET_VBR_CONSTRAINT(cvbr)); 535 opus_encoder_ctl(enc, OPUS_SET_COMPLEXITY(complexity)); 536 opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(use_inbandfec)); 537 opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS(forcechannels)); 538 opus_encoder_ctl(enc, OPUS_SET_DTX(use_dtx)); 539 opus_encoder_ctl(enc, OPUS_SET_PACKET_LOSS_PERC(packet_loss_perc)); 540 541 opus_encoder_ctl(enc, OPUS_GET_LOOKAHEAD(&skip)); 542 opus_encoder_ctl(enc, OPUS_SET_LSB_DEPTH(16)); 543 opus_encoder_ctl(enc, OPUS_SET_EXPERT_FRAME_DURATION(variable_duration)); 544 } 545 if (!encode_only) 546 { 547 dec = opus_decoder_create(sampling_rate, channels, &err); 548 if (err != OPUS_OK) 549 { 550 fprintf(stderr, "Cannot create decoder: %s\n", opus_strerror(err)); 551 fclose(fin); 552 fclose(fout); 553 return EXIT_FAILURE; 554 } 555 } 556 557 558 switch(bandwidth) 559 { 560 case OPUS_BANDWIDTH_NARROWBAND: 561 bandwidth_string = "narrowband"; 562 break; 563 case OPUS_BANDWIDTH_MEDIUMBAND: 564 bandwidth_string = "mediumband"; 565 break; 566 case OPUS_BANDWIDTH_WIDEBAND: 567 bandwidth_string = "wideband"; 568 break; 569 case OPUS_BANDWIDTH_SUPERWIDEBAND: 570 bandwidth_string = "superwideband"; 571 break; 572 case OPUS_BANDWIDTH_FULLBAND: 573 bandwidth_string = "fullband"; 574 break; 575 case OPUS_AUTO: 576 bandwidth_string = "auto bandwidth"; 577 break; 578 default: 579 bandwidth_string = "unknown"; 580 break; 581 } 582 583 if (decode_only) 584 fprintf(stderr, "Decoding with %ld Hz output (%d channels)\n", 585 (long)sampling_rate, channels); 586 else 587 fprintf(stderr, "Encoding %ld Hz input at %.3f kb/s " 588 "in %s with %d-sample frames.\n", 589 (long)sampling_rate, bitrate_bps*0.001, 590 bandwidth_string, frame_size); 591 592 in = (short*)malloc(max_frame_size*channels*sizeof(short)); 593 out = (short*)malloc(max_frame_size*channels*sizeof(short)); 594 /* We need to allocate for 16-bit PCM data, but we store it as unsigned char. */ 595 fbytes = (unsigned char*)malloc(max_frame_size*channels*sizeof(short)); 596 data[0] = (unsigned char*)calloc(max_payload_bytes,sizeof(unsigned char)); 597 if ( use_inbandfec ) { 598 data[1] = (unsigned char*)calloc(max_payload_bytes,sizeof(unsigned char)); 599 } 600 if(delayed_decision) 601 { 602 if (variable_duration!=OPUS_FRAMESIZE_VARIABLE) 603 { 604 if (frame_size==sampling_rate/400) 605 variable_duration = OPUS_FRAMESIZE_2_5_MS; 606 else if (frame_size==sampling_rate/200) 607 variable_duration = OPUS_FRAMESIZE_5_MS; 608 else if (frame_size==sampling_rate/100) 609 variable_duration = OPUS_FRAMESIZE_10_MS; 610 else if (frame_size==sampling_rate/50) 611 variable_duration = OPUS_FRAMESIZE_20_MS; 612 else if (frame_size==sampling_rate/25) 613 variable_duration = OPUS_FRAMESIZE_40_MS; 614 else 615 variable_duration = OPUS_FRAMESIZE_60_MS; 616 opus_encoder_ctl(enc, OPUS_SET_EXPERT_FRAME_DURATION(variable_duration)); 617 } 618 frame_size = 2*48000; 619 } 620 while (!stop) 621 { 622 if (delayed_celt) 623 { 624 frame_size = newsize; 625 delayed_celt = 0; 626 } else if (random_framesize && rand()%20==0) 627 { 628 newsize = rand()%6; 629 switch(newsize) 630 { 631 case 0: newsize=sampling_rate/400; break; 632 case 1: newsize=sampling_rate/200; break; 633 case 2: newsize=sampling_rate/100; break; 634 case 3: newsize=sampling_rate/50; break; 635 case 4: newsize=sampling_rate/25; break; 636 case 5: newsize=3*sampling_rate/50; break; 637 } 638 while (newsize < sampling_rate/25 && bitrate_bps-abs(sweep_bps) <= 3*12*sampling_rate/newsize) 639 newsize*=2; 640 if (newsize < sampling_rate/100 && frame_size >= sampling_rate/100) 641 { 642 opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(MODE_CELT_ONLY)); 643 delayed_celt=1; 644 } else { 645 frame_size = newsize; 646 } 647 } 648 if (random_fec && rand()%30==0) 649 { 650 opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(rand()%4==0)); 651 } 652 if (decode_only) 653 { 654 unsigned char ch[4]; 655 err = fread(ch, 1, 4, fin); 656 if (feof(fin)) 657 break; 658 len[toggle] = char_to_int(ch); 659 if (len[toggle]>max_payload_bytes || len[toggle]<0) 660 { 661 fprintf(stderr, "Invalid payload length: %d\n",len[toggle]); 662 break; 663 } 664 err = fread(ch, 1, 4, fin); 665 enc_final_range[toggle] = char_to_int(ch); 666 err = fread(data[toggle], 1, len[toggle], fin); 667 if (err<len[toggle]) 668 { 669 fprintf(stderr, "Ran out of input, " 670 "expecting %d bytes got %d\n", 671 len[toggle],err); 672 break; 673 } 674 } else { 675 int i; 676 if (mode_list!=NULL) 677 { 678 opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(mode_list[curr_mode][1])); 679 opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(mode_list[curr_mode][0])); 680 opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS(mode_list[curr_mode][3])); 681 frame_size = mode_list[curr_mode][2]; 682 } 683 err = fread(fbytes, sizeof(short)*channels, frame_size-remaining, fin); 684 curr_read = err; 685 tot_in += curr_read; 686 for(i=0;i<curr_read*channels;i++) 687 { 688 opus_int32 s; 689 s=fbytes[2*i+1]<<8|fbytes[2*i]; 690 s=((s&0xFFFF)^0x8000)-0x8000; 691 in[i+remaining*channels]=s; 692 } 693 if (curr_read+remaining < frame_size) 694 { 695 for (i=(curr_read+remaining)*channels;i<frame_size*channels;i++) 696 in[i] = 0; 697 if (encode_only || decode_only) 698 stop = 1; 699 } 700 len[toggle] = opus_encode(enc, in, frame_size, data[toggle], max_payload_bytes); 701 nb_encoded = opus_packet_get_samples_per_frame(data[toggle], sampling_rate)*opus_packet_get_nb_frames(data[toggle], len[toggle]); 702 remaining = frame_size-nb_encoded; 703 for(i=0;i<remaining*channels;i++) 704 in[i] = in[nb_encoded*channels+i]; 705 if (sweep_bps!=0) 706 { 707 bitrate_bps += sweep_bps; 708 if (sweep_max) 709 { 710 if (bitrate_bps > sweep_max) 711 sweep_bps = -sweep_bps; 712 else if (bitrate_bps < sweep_min) 713 sweep_bps = -sweep_bps; 714 } 715 /* safety */ 716 if (bitrate_bps<1000) 717 bitrate_bps = 1000; 718 opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrate_bps)); 719 } 720 opus_encoder_ctl(enc, OPUS_GET_FINAL_RANGE(&enc_final_range[toggle])); 721 if (len[toggle] < 0) 722 { 723 fprintf (stderr, "opus_encode() returned %d\n", len[toggle]); 724 fclose(fin); 725 fclose(fout); 726 return EXIT_FAILURE; 727 } 728 curr_mode_count += frame_size; 729 if (curr_mode_count > mode_switch_time && curr_mode < nb_modes_in_list-1) 730 { 731 curr_mode++; 732 curr_mode_count = 0; 733 } 734 } 735 736 #if 0 /* This is for testing the padding code, do not enable by default */ 737 if (len[toggle]<1275) 738 { 739 int new_len = len[toggle]+rand()%(max_payload_bytes-len[toggle]); 740 if ((err = opus_packet_pad(data[toggle], len[toggle], new_len)) != OPUS_OK) 741 { 742 fprintf(stderr, "padding failed: %s\n", opus_strerror(err)); 743 return EXIT_FAILURE; 744 } 745 len[toggle] = new_len; 746 } 747 #endif 748 if (encode_only) 749 { 750 unsigned char int_field[4]; 751 int_to_char(len[toggle], int_field); 752 if (fwrite(int_field, 1, 4, fout) != 4) { 753 fprintf(stderr, "Error writing.\n"); 754 return EXIT_FAILURE; 755 } 756 int_to_char(enc_final_range[toggle], int_field); 757 if (fwrite(int_field, 1, 4, fout) != 4) { 758 fprintf(stderr, "Error writing.\n"); 759 return EXIT_FAILURE; 760 } 761 if (fwrite(data[toggle], 1, len[toggle], fout) != (unsigned)len[toggle]) { 762 fprintf(stderr, "Error writing.\n"); 763 return EXIT_FAILURE; 764 } 765 tot_samples += nb_encoded; 766 } else { 767 int output_samples; 768 lost = len[toggle]==0 || (packet_loss_perc>0 && rand()%100 < packet_loss_perc); 769 if (lost) 770 opus_decoder_ctl(dec, OPUS_GET_LAST_PACKET_DURATION(&output_samples)); 771 else 772 output_samples = max_frame_size; 773 if( count >= use_inbandfec ) { 774 /* delay by one packet when using in-band FEC */ 775 if( use_inbandfec ) { 776 if( lost_prev ) { 777 /* attempt to decode with in-band FEC from next packet */ 778 opus_decoder_ctl(dec, OPUS_GET_LAST_PACKET_DURATION(&output_samples)); 779 output_samples = opus_decode(dec, lost ? NULL : data[toggle], len[toggle], out, output_samples, 1); 780 } else { 781 /* regular decode */ 782 output_samples = max_frame_size; 783 output_samples = opus_decode(dec, data[1-toggle], len[1-toggle], out, output_samples, 0); 784 } 785 } else { 786 output_samples = opus_decode(dec, lost ? NULL : data[toggle], len[toggle], out, output_samples, 0); 787 } 788 if (output_samples>0) 789 { 790 if (!decode_only && tot_out + output_samples > tot_in) 791 { 792 stop=1; 793 output_samples = tot_in-tot_out; 794 } 795 if (output_samples>skip) { 796 int i; 797 for(i=0;i<(output_samples-skip)*channels;i++) 798 { 799 short s; 800 s=out[i+(skip*channels)]; 801 fbytes[2*i]=s&0xFF; 802 fbytes[2*i+1]=(s>>8)&0xFF; 803 } 804 if (fwrite(fbytes, sizeof(short)*channels, output_samples-skip, fout) != (unsigned)(output_samples-skip)){ 805 fprintf(stderr, "Error writing.\n"); 806 return EXIT_FAILURE; 807 } 808 tot_out += output_samples-skip; 809 } 810 if (output_samples<skip) skip -= output_samples; 811 else skip = 0; 812 } else { 813 fprintf(stderr, "error decoding frame: %s\n", 814 opus_strerror(output_samples)); 815 } 816 tot_samples += output_samples; 817 } 818 } 819 820 if (!encode_only) 821 opus_decoder_ctl(dec, OPUS_GET_FINAL_RANGE(&dec_final_range)); 822 /* compare final range encoder rng values of encoder and decoder */ 823 if( enc_final_range[toggle^use_inbandfec]!=0 && !encode_only 824 && !lost && !lost_prev 825 && dec_final_range != enc_final_range[toggle^use_inbandfec] ) { 826 fprintf (stderr, "Error: Range coder state mismatch " 827 "between encoder and decoder " 828 "in frame %ld: 0x%8lx vs 0x%8lx\n", 829 (long)count, 830 (unsigned long)enc_final_range[toggle^use_inbandfec], 831 (unsigned long)dec_final_range); 832 fclose(fin); 833 fclose(fout); 834 return EXIT_FAILURE; 835 } 836 837 lost_prev = lost; 838 if( count >= use_inbandfec ) { 839 /* count bits */ 840 bits += len[toggle]*8; 841 bits_max = ( len[toggle]*8 > bits_max ) ? len[toggle]*8 : bits_max; 842 bits2 += len[toggle]*len[toggle]*64; 843 if (!decode_only) 844 { 845 nrg = 0.0; 846 for ( k = 0; k < frame_size * channels; k++ ) { 847 nrg += in[ k ] * (double)in[ k ]; 848 } 849 nrg /= frame_size * channels; 850 if( nrg > 1e5 ) { 851 bits_act += len[toggle]*8; 852 count_act++; 853 } 854 } 855 } 856 count++; 857 toggle = (toggle + use_inbandfec) & 1; 858 } 859 860 /* Print out bitrate statistics */ 861 if(decode_only) 862 frame_size = (int)(tot_samples / count); 863 count -= use_inbandfec; 864 fprintf (stderr, "average bitrate: %7.3f kb/s\n", 865 1e-3*bits*sampling_rate/tot_samples); 866 fprintf (stderr, "maximum bitrate: %7.3f kb/s\n", 867 1e-3*bits_max*sampling_rate/frame_size); 868 if (!decode_only) 869 fprintf (stderr, "active bitrate: %7.3f kb/s\n", 870 1e-3*bits_act*sampling_rate/(1e-15+frame_size*(double)count_act)); 871 fprintf (stderr, "bitrate standard deviation: %7.3f kb/s\n", 872 1e-3*sqrt(bits2/count - bits*bits/(count*(double)count))*sampling_rate/frame_size); 873 /* Close any files to which intermediate results were stored */ 874 SILK_DEBUG_STORE_CLOSE_FILES 875 silk_TimerSave("opus_timing.txt"); 876 opus_encoder_destroy(enc); 877 opus_decoder_destroy(dec); 878 free(data[0]); 879 if (use_inbandfec) 880 free(data[1]); 881 fclose(fin); 882 fclose(fout); 883 free(in); 884 free(out); 885 free(fbytes); 886 return EXIT_SUCCESS; 887 } 888
