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 42#define MAX_PACKET 1500 43 44void print_usage( char* argv[] ) 45{ 46 fprintf(stderr, "Usage: %s [-e] <application> <sampling rate (Hz)> <channels (1/2)> " 47 "<bits per second> [options] <input> <output>\n", argv[0]); 48 fprintf(stderr, " %s -d <sampling rate (Hz)> <channels (1/2)> " 49 "[options] <input> <output>\n\n", argv[0]); 50 fprintf(stderr, "mode: voip | audio | restricted-lowdelay\n" ); 51 fprintf(stderr, "options:\n" ); 52 fprintf(stderr, "-e : only runs the encoder (output the bit-stream)\n" ); 53 fprintf(stderr, "-d : only runs the decoder (reads the bit-stream as input)\n" ); 54 fprintf(stderr, "-cbr : enable constant bitrate; default: variable bitrate\n" ); 55 fprintf(stderr, "-cvbr : enable constrained variable bitrate; default: unconstrained\n" ); 56 fprintf(stderr, "-bandwidth <NB|MB|WB|SWB|FB> : audio bandwidth (from narrowband to fullband); default: sampling rate\n" ); 57 fprintf(stderr, "-framesize <2.5|5|10|20|40|60> : frame size in ms; default: 20 \n" ); 58 fprintf(stderr, "-max_payload <bytes> : maximum payload size in bytes, default: 1024\n" ); 59 fprintf(stderr, "-complexity <comp> : complexity, 0 (lowest) ... 10 (highest); default: 10\n" ); 60 fprintf(stderr, "-inbandfec : enable SILK inband FEC\n" ); 61 fprintf(stderr, "-forcemono : force mono encoding, even for stereo input\n" ); 62 fprintf(stderr, "-dtx : enable SILK DTX\n" ); 63 fprintf(stderr, "-loss <perc> : simulate packet loss, in percent (0-100); default: 0\n" ); 64} 65 66static void int_to_char(opus_uint32 i, unsigned char ch[4]) 67{ 68 ch[0] = i>>24; 69 ch[1] = (i>>16)&0xFF; 70 ch[2] = (i>>8)&0xFF; 71 ch[3] = i&0xFF; 72} 73 74static opus_uint32 char_to_int(unsigned char ch[4]) 75{ 76 return ((opus_uint32)ch[0]<<24) | ((opus_uint32)ch[1]<<16) 77 | ((opus_uint32)ch[2]<< 8) | (opus_uint32)ch[3]; 78} 79 80static void check_decoder_option(int encode_only, const char *opt) 81{ 82 if (encode_only) 83 { 84 fprintf(stderr, "option %s is only for decoding\n", opt); 85 exit(EXIT_FAILURE); 86 } 87} 88 89static void check_encoder_option(int decode_only, const char *opt) 90{ 91 if (decode_only) 92 { 93 fprintf(stderr, "option %s is only for encoding\n", opt); 94 exit(EXIT_FAILURE); 95 } 96} 97 98static const int silk8_test[][4] = { 99 {MODE_SILK_ONLY, OPUS_BANDWIDTH_NARROWBAND, 960*3, 1}, 100 {MODE_SILK_ONLY, OPUS_BANDWIDTH_NARROWBAND, 960*2, 1}, 101 {MODE_SILK_ONLY, OPUS_BANDWIDTH_NARROWBAND, 960, 1}, 102 {MODE_SILK_ONLY, OPUS_BANDWIDTH_NARROWBAND, 480, 1}, 103 {MODE_SILK_ONLY, OPUS_BANDWIDTH_NARROWBAND, 960*3, 2}, 104 {MODE_SILK_ONLY, OPUS_BANDWIDTH_NARROWBAND, 960*2, 2}, 105 {MODE_SILK_ONLY, OPUS_BANDWIDTH_NARROWBAND, 960, 2}, 106 {MODE_SILK_ONLY, OPUS_BANDWIDTH_NARROWBAND, 480, 2} 107}; 108 109static const int silk12_test[][4] = { 110 {MODE_SILK_ONLY, OPUS_BANDWIDTH_MEDIUMBAND, 960*3, 1}, 111 {MODE_SILK_ONLY, OPUS_BANDWIDTH_MEDIUMBAND, 960*2, 1}, 112 {MODE_SILK_ONLY, OPUS_BANDWIDTH_MEDIUMBAND, 960, 1}, 113 {MODE_SILK_ONLY, OPUS_BANDWIDTH_MEDIUMBAND, 480, 1}, 114 {MODE_SILK_ONLY, OPUS_BANDWIDTH_MEDIUMBAND, 960*3, 2}, 115 {MODE_SILK_ONLY, OPUS_BANDWIDTH_MEDIUMBAND, 960*2, 2}, 116 {MODE_SILK_ONLY, OPUS_BANDWIDTH_MEDIUMBAND, 960, 2}, 117 {MODE_SILK_ONLY, OPUS_BANDWIDTH_MEDIUMBAND, 480, 2} 118}; 119 120static const int silk16_test[][4] = { 121 {MODE_SILK_ONLY, OPUS_BANDWIDTH_WIDEBAND, 960*3, 1}, 122 {MODE_SILK_ONLY, OPUS_BANDWIDTH_WIDEBAND, 960*2, 1}, 123 {MODE_SILK_ONLY, OPUS_BANDWIDTH_WIDEBAND, 960, 1}, 124 {MODE_SILK_ONLY, OPUS_BANDWIDTH_WIDEBAND, 480, 1}, 125 {MODE_SILK_ONLY, OPUS_BANDWIDTH_WIDEBAND, 960*3, 2}, 126 {MODE_SILK_ONLY, OPUS_BANDWIDTH_WIDEBAND, 960*2, 2}, 127 {MODE_SILK_ONLY, OPUS_BANDWIDTH_WIDEBAND, 960, 2}, 128 {MODE_SILK_ONLY, OPUS_BANDWIDTH_WIDEBAND, 480, 2} 129}; 130 131static const int hybrid24_test[][4] = { 132 {MODE_SILK_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 960, 1}, 133 {MODE_SILK_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 480, 1}, 134 {MODE_SILK_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 960, 2}, 135 {MODE_SILK_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 480, 2} 136}; 137 138static const int hybrid48_test[][4] = { 139 {MODE_SILK_ONLY, OPUS_BANDWIDTH_FULLBAND, 960, 1}, 140 {MODE_SILK_ONLY, OPUS_BANDWIDTH_FULLBAND, 480, 1}, 141 {MODE_SILK_ONLY, OPUS_BANDWIDTH_FULLBAND, 960, 2}, 142 {MODE_SILK_ONLY, OPUS_BANDWIDTH_FULLBAND, 480, 2} 143}; 144 145static const int celt_test[][4] = { 146 {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND, 960, 1}, 147 {MODE_CELT_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 960, 1}, 148 {MODE_CELT_ONLY, OPUS_BANDWIDTH_WIDEBAND, 960, 1}, 149 {MODE_CELT_ONLY, OPUS_BANDWIDTH_NARROWBAND, 960, 1}, 150 151 {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND, 480, 1}, 152 {MODE_CELT_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 480, 1}, 153 {MODE_CELT_ONLY, OPUS_BANDWIDTH_WIDEBAND, 480, 1}, 154 {MODE_CELT_ONLY, OPUS_BANDWIDTH_NARROWBAND, 480, 1}, 155 156 {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND, 240, 1}, 157 {MODE_CELT_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 240, 1}, 158 {MODE_CELT_ONLY, OPUS_BANDWIDTH_WIDEBAND, 240, 1}, 159 {MODE_CELT_ONLY, OPUS_BANDWIDTH_NARROWBAND, 240, 1}, 160 161 {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND, 120, 1}, 162 {MODE_CELT_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 120, 1}, 163 {MODE_CELT_ONLY, OPUS_BANDWIDTH_WIDEBAND, 120, 1}, 164 {MODE_CELT_ONLY, OPUS_BANDWIDTH_NARROWBAND, 120, 1}, 165 166 {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND, 960, 2}, 167 {MODE_CELT_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 960, 2}, 168 {MODE_CELT_ONLY, OPUS_BANDWIDTH_WIDEBAND, 960, 2}, 169 {MODE_CELT_ONLY, OPUS_BANDWIDTH_NARROWBAND, 960, 2}, 170 171 {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND, 480, 2}, 172 {MODE_CELT_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 480, 2}, 173 {MODE_CELT_ONLY, OPUS_BANDWIDTH_WIDEBAND, 480, 2}, 174 {MODE_CELT_ONLY, OPUS_BANDWIDTH_NARROWBAND, 480, 2}, 175 176 {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND, 240, 2}, 177 {MODE_CELT_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 240, 2}, 178 {MODE_CELT_ONLY, OPUS_BANDWIDTH_WIDEBAND, 240, 2}, 179 {MODE_CELT_ONLY, OPUS_BANDWIDTH_NARROWBAND, 240, 2}, 180 181 {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND, 120, 2}, 182 {MODE_CELT_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 120, 2}, 183 {MODE_CELT_ONLY, OPUS_BANDWIDTH_WIDEBAND, 120, 2}, 184 {MODE_CELT_ONLY, OPUS_BANDWIDTH_NARROWBAND, 120, 2}, 185 186}; 187 188static const int celt_hq_test[][4] = { 189 {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND, 960, 2}, 190 {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND, 480, 2}, 191 {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND, 240, 2}, 192 {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND, 120, 2}, 193}; 194 195int main(int argc, char *argv[]) 196{ 197 int err; 198 char *inFile, *outFile; 199 FILE *fin, *fout; 200 OpusEncoder *enc=NULL; 201 OpusDecoder *dec=NULL; 202 int args; 203 int len[2]; 204 int frame_size, channels; 205 opus_int32 bitrate_bps=0; 206 unsigned char *data[2]; 207 unsigned char *fbytes; 208 opus_int32 sampling_rate; 209 int use_vbr; 210 int max_payload_bytes; 211 int complexity; 212 int use_inbandfec; 213 int use_dtx; 214 int forcechannels; 215 int cvbr = 0; 216 int packet_loss_perc; 217 opus_int32 count=0, count_act=0; 218 int k; 219 opus_int32 skip=0; 220 int stop=0; 221 short *in, *out; 222 int application=OPUS_APPLICATION_AUDIO; 223 double bits=0.0, bits_max=0.0, bits_act=0.0, bits2=0.0, nrg; 224 int bandwidth=-1; 225 const char *bandwidth_string; 226 int lost = 0, lost_prev = 1; 227 int toggle = 0; 228 opus_uint32 enc_final_range[2]; 229 opus_uint32 dec_final_range; 230 int encode_only=0, decode_only=0; 231 int max_frame_size = 960*6; 232 int curr_read=0; 233 int sweep_bps = 0; 234 int random_framesize=0, newsize=0, delayed_celt=0; 235 int sweep_max=0, sweep_min=0; 236 int random_fec=0; 237 const int (*mode_list)[4]=NULL; 238 int nb_modes_in_list=0; 239 int curr_mode=0; 240 int curr_mode_count=0; 241 int mode_switch_time = 48000; 242 243 if (argc < 5 ) 244 { 245 print_usage( argv ); 246 return EXIT_FAILURE; 247 } 248 249 fprintf(stderr, "%s\n", opus_get_version_string()); 250 251 args = 1; 252 if (strcmp(argv[args], "-e")==0) 253 { 254 encode_only = 1; 255 args++; 256 } else if (strcmp(argv[args], "-d")==0) 257 { 258 decode_only = 1; 259 args++; 260 } 261 if (!decode_only && argc < 7 ) 262 { 263 print_usage( argv ); 264 return EXIT_FAILURE; 265 } 266 267 if (!decode_only) 268 { 269 if (strcmp(argv[args], "voip")==0) 270 application = OPUS_APPLICATION_VOIP; 271 else if (strcmp(argv[args], "restricted-lowdelay")==0) 272 application = OPUS_APPLICATION_RESTRICTED_LOWDELAY; 273 else if (strcmp(argv[args], "audio")!=0) { 274 fprintf(stderr, "unknown application: %s\n", argv[args]); 275 print_usage(argv); 276 return EXIT_FAILURE; 277 } 278 args++; 279 } 280 sampling_rate = (opus_int32)atol(argv[args]); 281 args++; 282 channels = atoi(argv[args]); 283 args++; 284 if (!decode_only) 285 { 286 bitrate_bps = (opus_int32)atol(argv[args]); 287 args++; 288 } 289 290 if (sampling_rate != 8000 && sampling_rate != 12000 291 && sampling_rate != 16000 && sampling_rate != 24000 292 && sampling_rate != 48000) 293 { 294 fprintf(stderr, "Supported sampling rates are 8000, 12000, " 295 "16000, 24000 and 48000.\n"); 296 return EXIT_FAILURE; 297 } 298 frame_size = sampling_rate/50; 299 300 /* defaults: */ 301 use_vbr = 1; 302 bandwidth = OPUS_AUTO; 303 max_payload_bytes = MAX_PACKET; 304 complexity = 10; 305 use_inbandfec = 0; 306 forcechannels = OPUS_AUTO; 307 use_dtx = 0; 308 packet_loss_perc = 0; 309 max_frame_size = 960*6; 310 curr_read=0; 311 312 while( args < argc - 2 ) { 313 /* process command line options */ 314 if( strcmp( argv[ args ], "-cbr" ) == 0 ) { 315 check_encoder_option(decode_only, "-cbr"); 316 use_vbr = 0; 317 args++; 318 } else if( strcmp( argv[ args ], "-bandwidth" ) == 0 ) { 319 check_encoder_option(decode_only, "-bandwidth"); 320 if (strcmp(argv[ args + 1 ], "NB")==0) 321 bandwidth = OPUS_BANDWIDTH_NARROWBAND; 322 else if (strcmp(argv[ args + 1 ], "MB")==0) 323 bandwidth = OPUS_BANDWIDTH_MEDIUMBAND; 324 else if (strcmp(argv[ args + 1 ], "WB")==0) 325 bandwidth = OPUS_BANDWIDTH_WIDEBAND; 326 else if (strcmp(argv[ args + 1 ], "SWB")==0) 327 bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND; 328 else if (strcmp(argv[ args + 1 ], "FB")==0) 329 bandwidth = OPUS_BANDWIDTH_FULLBAND; 330 else { 331 fprintf(stderr, "Unknown bandwidth %s. " 332 "Supported are NB, MB, WB, SWB, FB.\n", 333 argv[ args + 1 ]); 334 return EXIT_FAILURE; 335 } 336 args += 2; 337 } else if( strcmp( argv[ args ], "-framesize" ) == 0 ) { 338 check_encoder_option(decode_only, "-framesize"); 339 if (strcmp(argv[ args + 1 ], "2.5")==0) 340 frame_size = sampling_rate/400; 341 else if (strcmp(argv[ args + 1 ], "5")==0) 342 frame_size = sampling_rate/200; 343 else if (strcmp(argv[ args + 1 ], "10")==0) 344 frame_size = sampling_rate/100; 345 else if (strcmp(argv[ args + 1 ], "20")==0) 346 frame_size = sampling_rate/50; 347 else if (strcmp(argv[ args + 1 ], "40")==0) 348 frame_size = sampling_rate/25; 349 else if (strcmp(argv[ args + 1 ], "60")==0) 350 frame_size = 3*sampling_rate/50; 351 else { 352 fprintf(stderr, "Unsupported frame size: %s ms. " 353 "Supported are 2.5, 5, 10, 20, 40, 60.\n", 354 argv[ args + 1 ]); 355 return EXIT_FAILURE; 356 } 357 args += 2; 358 } else if( strcmp( argv[ args ], "-max_payload" ) == 0 ) { 359 check_encoder_option(decode_only, "-max_payload"); 360 max_payload_bytes = atoi( argv[ args + 1 ] ); 361 args += 2; 362 } else if( strcmp( argv[ args ], "-complexity" ) == 0 ) { 363 check_encoder_option(decode_only, "-complexity"); 364 complexity = atoi( argv[ args + 1 ] ); 365 args += 2; 366 } else if( strcmp( argv[ args ], "-inbandfec" ) == 0 ) { 367 use_inbandfec = 1; 368 args++; 369 } else if( strcmp( argv[ args ], "-forcemono" ) == 0 ) { 370 check_encoder_option(decode_only, "-forcemono"); 371 forcechannels = 1; 372 args++; 373 } else if( strcmp( argv[ args ], "-cvbr" ) == 0 ) { 374 check_encoder_option(decode_only, "-cvbr"); 375 cvbr = 1; 376 args++; 377 } else if( strcmp( argv[ args ], "-dtx") == 0 ) { 378 check_encoder_option(decode_only, "-dtx"); 379 use_dtx = 1; 380 args++; 381 } else if( strcmp( argv[ args ], "-loss" ) == 0 ) { 382 check_decoder_option(encode_only, "-loss"); 383 packet_loss_perc = atoi( argv[ args + 1 ] ); 384 args += 2; 385 } else if( strcmp( argv[ args ], "-sweep" ) == 0 ) { 386 check_encoder_option(decode_only, "-sweep"); 387 sweep_bps = atoi( argv[ args + 1 ] ); 388 args += 2; 389 } else if( strcmp( argv[ args ], "-random_framesize" ) == 0 ) { 390 check_encoder_option(decode_only, "-random_framesize"); 391 random_framesize = 1; 392 args++; 393 } else if( strcmp( argv[ args ], "-sweep_max" ) == 0 ) { 394 check_encoder_option(decode_only, "-sweep_max"); 395 sweep_max = atoi( argv[ args + 1 ] ); 396 args += 2; 397 } else if( strcmp( argv[ args ], "-random_fec" ) == 0 ) { 398 check_encoder_option(decode_only, "-random_fec"); 399 random_fec = 1; 400 args++; 401 } else if( strcmp( argv[ args ], "-silk8k_test" ) == 0 ) { 402 check_encoder_option(decode_only, "-silk8k_test"); 403 mode_list = silk8_test; 404 nb_modes_in_list = 8; 405 args++; 406 } else if( strcmp( argv[ args ], "-silk12k_test" ) == 0 ) { 407 check_encoder_option(decode_only, "-silk12k_test"); 408 mode_list = silk12_test; 409 nb_modes_in_list = 8; 410 args++; 411 } else if( strcmp( argv[ args ], "-silk16k_test" ) == 0 ) { 412 check_encoder_option(decode_only, "-silk16k_test"); 413 mode_list = silk16_test; 414 nb_modes_in_list = 8; 415 args++; 416 } else if( strcmp( argv[ args ], "-hybrid24k_test" ) == 0 ) { 417 check_encoder_option(decode_only, "-hybrid24k_test"); 418 mode_list = hybrid24_test; 419 nb_modes_in_list = 4; 420 args++; 421 } else if( strcmp( argv[ args ], "-hybrid48k_test" ) == 0 ) { 422 check_encoder_option(decode_only, "-hybrid48k_test"); 423 mode_list = hybrid48_test; 424 nb_modes_in_list = 4; 425 args++; 426 } else if( strcmp( argv[ args ], "-celt_test" ) == 0 ) { 427 check_encoder_option(decode_only, "-celt_test"); 428 mode_list = celt_test; 429 nb_modes_in_list = 32; 430 args++; 431 } else if( strcmp( argv[ args ], "-celt_hq_test" ) == 0 ) { 432 check_encoder_option(decode_only, "-celt_hq_test"); 433 mode_list = celt_hq_test; 434 nb_modes_in_list = 4; 435 args++; 436 } else { 437 printf( "Error: unrecognized setting: %s\n\n", argv[ args ] ); 438 print_usage( argv ); 439 return EXIT_FAILURE; 440 } 441 } 442 443 if (sweep_max) 444 sweep_min = bitrate_bps; 445 446 if (max_payload_bytes < 0 || max_payload_bytes > MAX_PACKET) 447 { 448 fprintf (stderr, "max_payload_bytes must be between 0 and %d\n", 449 MAX_PACKET); 450 return EXIT_FAILURE; 451 } 452 453 inFile = argv[argc-2]; 454 fin = fopen(inFile, "rb"); 455 if (!fin) 456 { 457 fprintf (stderr, "Could not open input file %s\n", argv[argc-2]); 458 return EXIT_FAILURE; 459 } 460 if (mode_list) 461 { 462 int size; 463 fseek(fin, 0, SEEK_END); 464 size = ftell(fin); 465 fprintf(stderr, "File size is %d bytes\n", size); 466 fseek(fin, 0, SEEK_SET); 467 mode_switch_time = size/sizeof(short)/channels/nb_modes_in_list; 468 fprintf(stderr, "Switching mode every %d samples\n", mode_switch_time); 469 } 470 471 outFile = argv[argc-1]; 472 fout = fopen(outFile, "wb+"); 473 if (!fout) 474 { 475 fprintf (stderr, "Could not open output file %s\n", argv[argc-1]); 476 fclose(fin); 477 return EXIT_FAILURE; 478 } 479 480 if (!decode_only) 481 { 482 enc = opus_encoder_create(sampling_rate, channels, application, &err); 483 if (err != OPUS_OK) 484 { 485 fprintf(stderr, "Cannot create encoder: %s\n", opus_strerror(err)); 486 fclose(fin); 487 fclose(fout); 488 return EXIT_FAILURE; 489 } 490 opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrate_bps)); 491 opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(bandwidth)); 492 opus_encoder_ctl(enc, OPUS_SET_VBR(use_vbr)); 493 opus_encoder_ctl(enc, OPUS_SET_VBR_CONSTRAINT(cvbr)); 494 opus_encoder_ctl(enc, OPUS_SET_COMPLEXITY(complexity)); 495 opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(use_inbandfec)); 496 opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS(forcechannels)); 497 opus_encoder_ctl(enc, OPUS_SET_DTX(use_dtx)); 498 opus_encoder_ctl(enc, OPUS_SET_PACKET_LOSS_PERC(packet_loss_perc)); 499 500 opus_encoder_ctl(enc, OPUS_GET_LOOKAHEAD(&skip)); 501 opus_encoder_ctl(enc, OPUS_SET_LSB_DEPTH(16)); 502 } 503 if (!encode_only) 504 { 505 dec = opus_decoder_create(sampling_rate, channels, &err); 506 if (err != OPUS_OK) 507 { 508 fprintf(stderr, "Cannot create decoder: %s\n", opus_strerror(err)); 509 fclose(fin); 510 fclose(fout); 511 return EXIT_FAILURE; 512 } 513 } 514 515 516 switch(bandwidth) 517 { 518 case OPUS_BANDWIDTH_NARROWBAND: 519 bandwidth_string = "narrowband"; 520 break; 521 case OPUS_BANDWIDTH_MEDIUMBAND: 522 bandwidth_string = "mediumband"; 523 break; 524 case OPUS_BANDWIDTH_WIDEBAND: 525 bandwidth_string = "wideband"; 526 break; 527 case OPUS_BANDWIDTH_SUPERWIDEBAND: 528 bandwidth_string = "superwideband"; 529 break; 530 case OPUS_BANDWIDTH_FULLBAND: 531 bandwidth_string = "fullband"; 532 break; 533 case OPUS_AUTO: 534 bandwidth_string = "auto"; 535 break; 536 default: 537 bandwidth_string = "unknown"; 538 break; 539 } 540 541 if (decode_only) 542 fprintf(stderr, "Decoding with %ld Hz output (%d channels)\n", 543 (long)sampling_rate, channels); 544 else 545 fprintf(stderr, "Encoding %ld Hz input at %.3f kb/s " 546 "in %s mode with %d-sample frames.\n", 547 (long)sampling_rate, bitrate_bps*0.001, 548 bandwidth_string, frame_size); 549 550 in = (short*)malloc(max_frame_size*channels*sizeof(short)); 551 out = (short*)malloc(max_frame_size*channels*sizeof(short)); 552 fbytes = (unsigned char*)malloc(max_frame_size*channels*sizeof(short)); 553 data[0] = (unsigned char*)calloc(max_payload_bytes,sizeof(char)); 554 if ( use_inbandfec ) { 555 data[1] = (unsigned char*)calloc(max_payload_bytes,sizeof(char)); 556 } 557 while (!stop) 558 { 559 if (delayed_celt) 560 { 561 frame_size = newsize; 562 delayed_celt = 0; 563 } else if (random_framesize && rand()%20==0) 564 { 565 newsize = rand()%6; 566 switch(newsize) 567 { 568 case 0: newsize=sampling_rate/400; break; 569 case 1: newsize=sampling_rate/200; break; 570 case 2: newsize=sampling_rate/100; break; 571 case 3: newsize=sampling_rate/50; break; 572 case 4: newsize=sampling_rate/25; break; 573 case 5: newsize=3*sampling_rate/50; break; 574 } 575 while (newsize < sampling_rate/25 && bitrate_bps-fabs(sweep_bps) <= 3*12*sampling_rate/newsize) 576 newsize*=2; 577 if (newsize < sampling_rate/100 && frame_size >= sampling_rate/100) 578 { 579 opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(MODE_CELT_ONLY)); 580 delayed_celt=1; 581 } else { 582 frame_size = newsize; 583 } 584 } 585 if (random_fec && rand()%30==0) 586 { 587 opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(rand()%4==0)); 588 } 589 if (decode_only) 590 { 591 unsigned char ch[4]; 592 err = fread(ch, 1, 4, fin); 593 if (feof(fin)) 594 break; 595 len[toggle] = char_to_int(ch); 596 if (len[toggle]>max_payload_bytes || len[toggle]<0) 597 { 598 fprintf(stderr, "Invalid payload length: %d\n",len[toggle]); 599 break; 600 } 601 err = fread(ch, 1, 4, fin); 602 enc_final_range[toggle] = char_to_int(ch); 603 err = fread(data[toggle], 1, len[toggle], fin); 604 if (err<len[toggle]) 605 { 606 fprintf(stderr, "Ran out of input, " 607 "expecting %d bytes got %d\n", 608 len[toggle],err); 609 break; 610 } 611 } else { 612 int i; 613 if (mode_list!=NULL) 614 { 615 opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(mode_list[curr_mode][1])); 616 opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(mode_list[curr_mode][0])); 617 opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS(mode_list[curr_mode][3])); 618 frame_size = mode_list[curr_mode][2]; 619 } 620 err = fread(fbytes, sizeof(short)*channels, frame_size, fin); 621 curr_read = err; 622 for(i=0;i<curr_read*channels;i++) 623 { 624 opus_int32 s; 625 s=fbytes[2*i+1]<<8|fbytes[2*i]; 626 s=((s&0xFFFF)^0x8000)-0x8000; 627 in[i]=s; 628 } 629 if (curr_read < frame_size) 630 { 631 for (i=curr_read*channels;i<frame_size*channels;i++) 632 in[i] = 0; 633 stop = 1; 634 } 635 len[toggle] = opus_encode(enc, in, frame_size, data[toggle], max_payload_bytes); 636 if (sweep_bps!=0) 637 { 638 bitrate_bps += sweep_bps; 639 if (sweep_max) 640 { 641 if (bitrate_bps > sweep_max) 642 sweep_bps = -sweep_bps; 643 else if (bitrate_bps < sweep_min) 644 sweep_bps = -sweep_bps; 645 } 646 /* safety */ 647 if (bitrate_bps<1000) 648 bitrate_bps = 1000; 649 opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrate_bps)); 650 } 651 opus_encoder_ctl(enc, OPUS_GET_FINAL_RANGE(&enc_final_range[toggle])); 652 if (len[toggle] < 0) 653 { 654 fprintf (stderr, "opus_encode() returned %d\n", len[toggle]); 655 fclose(fin); 656 fclose(fout); 657 return EXIT_FAILURE; 658 } 659 curr_mode_count += frame_size; 660 if (curr_mode_count > mode_switch_time && curr_mode < nb_modes_in_list-1) 661 { 662 curr_mode++; 663 curr_mode_count = 0; 664 } 665 } 666 667 if (encode_only) 668 { 669 unsigned char int_field[4]; 670 int_to_char(len[toggle], int_field); 671 if (fwrite(int_field, 1, 4, fout) != 4) { 672 fprintf(stderr, "Error writing.\n"); 673 return EXIT_FAILURE; 674 } 675 int_to_char(enc_final_range[toggle], int_field); 676 if (fwrite(int_field, 1, 4, fout) != 4) { 677 fprintf(stderr, "Error writing.\n"); 678 return EXIT_FAILURE; 679 } 680 if (fwrite(data[toggle], 1, len[toggle], fout) != (unsigned)len[toggle]) { 681 fprintf(stderr, "Error writing.\n"); 682 return EXIT_FAILURE; 683 } 684 } else { 685 int output_samples; 686 lost = len[toggle]==0 || (packet_loss_perc>0 && rand()%100 < packet_loss_perc); 687 if (lost) 688 opus_decoder_ctl(dec, OPUS_GET_LAST_PACKET_DURATION(&output_samples)); 689 else 690 output_samples = max_frame_size; 691 if( count >= use_inbandfec ) { 692 /* delay by one packet when using in-band FEC */ 693 if( use_inbandfec ) { 694 if( lost_prev ) { 695 /* attempt to decode with in-band FEC from next packet */ 696 output_samples = opus_decode(dec, lost ? NULL : data[toggle], len[toggle], out, output_samples, 1); 697 } else { 698 /* regular decode */ 699 output_samples = opus_decode(dec, data[1-toggle], len[1-toggle], out, output_samples, 0); 700 } 701 } else { 702 output_samples = opus_decode(dec, lost ? NULL : data[toggle], len[toggle], out, output_samples, 0); 703 } 704 if (output_samples>0) 705 { 706 if (output_samples>skip) { 707 int i; 708 for(i=0;i<(output_samples-skip)*channels;i++) 709 { 710 short s; 711 s=out[i+(skip*channels)]; 712 fbytes[2*i]=s&0xFF; 713 fbytes[2*i+1]=(s>>8)&0xFF; 714 } 715 if (fwrite(fbytes, sizeof(short)*channels, output_samples-skip, fout) != (unsigned)(output_samples-skip)){ 716 fprintf(stderr, "Error writing.\n"); 717 return EXIT_FAILURE; 718 } 719 } 720 if (output_samples<skip) skip -= output_samples; 721 else skip = 0; 722 } else { 723 fprintf(stderr, "error decoding frame: %s\n", 724 opus_strerror(output_samples)); 725 } 726 } 727 } 728 729 if (!encode_only) 730 opus_decoder_ctl(dec, OPUS_GET_FINAL_RANGE(&dec_final_range)); 731 /* compare final range encoder rng values of encoder and decoder */ 732 if( enc_final_range[toggle^use_inbandfec]!=0 && !encode_only 733 && !lost && !lost_prev 734 && dec_final_range != enc_final_range[toggle^use_inbandfec] ) { 735 fprintf (stderr, "Error: Range coder state mismatch " 736 "between encoder and decoder " 737 "in frame %ld: 0x%8lx vs 0x%8lx\n", 738 (long)count, 739 (unsigned long)enc_final_range[toggle^use_inbandfec], 740 (unsigned long)dec_final_range); 741 fclose(fin); 742 fclose(fout); 743 return EXIT_FAILURE; 744 } 745 746 lost_prev = lost; 747 748 /* count bits */ 749 bits += len[toggle]*8; 750 bits_max = ( len[toggle]*8 > bits_max ) ? len[toggle]*8 : bits_max; 751 if( count >= use_inbandfec ) { 752 nrg = 0.0; 753 if (!decode_only) 754 { 755 for ( k = 0; k < frame_size * channels; k++ ) { 756 nrg += in[ k ] * (double)in[ k ]; 757 } 758 } 759 if ( ( nrg / ( frame_size * channels ) ) > 1e5 ) { 760 bits_act += len[toggle]*8; 761 count_act++; 762 } 763 /* Variance */ 764 bits2 += len[toggle]*len[toggle]*64; 765 } 766 count++; 767 toggle = (toggle + use_inbandfec) & 1; 768 } 769 fprintf (stderr, "average bitrate: %7.3f kb/s\n", 770 1e-3*bits*sampling_rate/(frame_size*(double)count)); 771 fprintf (stderr, "maximum bitrate: %7.3f kb/s\n", 772 1e-3*bits_max*sampling_rate/frame_size); 773 if (!decode_only) 774 fprintf (stderr, "active bitrate: %7.3f kb/s\n", 775 1e-3*bits_act*sampling_rate/(frame_size*(double)count_act)); 776 fprintf (stderr, "bitrate standard deviation: %7.3f kb/s\n", 777 1e-3*sqrt(bits2/count - bits*bits/(count*(double)count))*sampling_rate/frame_size); 778 /* Close any files to which intermediate results were stored */ 779 SILK_DEBUG_STORE_CLOSE_FILES 780 silk_TimerSave("opus_timing.txt"); 781 opus_encoder_destroy(enc); 782 opus_decoder_destroy(dec); 783 free(data[0]); 784 if (use_inbandfec) 785 free(data[1]); 786 fclose(fin); 787 fclose(fout); 788 free(in); 789 free(out); 790 free(fbytes); 791 return EXIT_SUCCESS; 792} 793