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 45void 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, "mode: 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 68static 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 76static 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 82static 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 91static 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 102static 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 113static 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 124static 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 131static 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 138static 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 181static 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 200static 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} 206static 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 217int 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=-1; 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 = 960*6; 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 bandwidth = OPUS_AUTO; 340 max_payload_bytes = MAX_PACKET; 341 complexity = 10; 342 use_inbandfec = 0; 343 forcechannels = OPUS_AUTO; 344 use_dtx = 0; 345 packet_loss_perc = 0; 346 max_frame_size = 2*48000; 347 curr_read=0; 348 349 while( args < argc - 2 ) { 350 /* process command line options */ 351 if( strcmp( argv[ args ], "-cbr" ) == 0 ) { 352 check_encoder_option(decode_only, "-cbr"); 353 use_vbr = 0; 354 args++; 355 } else if( strcmp( argv[ args ], "-bandwidth" ) == 0 ) { 356 check_encoder_option(decode_only, "-bandwidth"); 357 if (strcmp(argv[ args + 1 ], "NB")==0) 358 bandwidth = OPUS_BANDWIDTH_NARROWBAND; 359 else if (strcmp(argv[ args + 1 ], "MB")==0) 360 bandwidth = OPUS_BANDWIDTH_MEDIUMBAND; 361 else if (strcmp(argv[ args + 1 ], "WB")==0) 362 bandwidth = OPUS_BANDWIDTH_WIDEBAND; 363 else if (strcmp(argv[ args + 1 ], "SWB")==0) 364 bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND; 365 else if (strcmp(argv[ args + 1 ], "FB")==0) 366 bandwidth = OPUS_BANDWIDTH_FULLBAND; 367 else { 368 fprintf(stderr, "Unknown bandwidth %s. " 369 "Supported are NB, MB, WB, SWB, FB.\n", 370 argv[ args + 1 ]); 371 return EXIT_FAILURE; 372 } 373 args += 2; 374 } else if( strcmp( argv[ args ], "-framesize" ) == 0 ) { 375 check_encoder_option(decode_only, "-framesize"); 376 if (strcmp(argv[ args + 1 ], "2.5")==0) 377 frame_size = sampling_rate/400; 378 else if (strcmp(argv[ args + 1 ], "5")==0) 379 frame_size = sampling_rate/200; 380 else if (strcmp(argv[ args + 1 ], "10")==0) 381 frame_size = sampling_rate/100; 382 else if (strcmp(argv[ args + 1 ], "20")==0) 383 frame_size = sampling_rate/50; 384 else if (strcmp(argv[ args + 1 ], "40")==0) 385 frame_size = sampling_rate/25; 386 else if (strcmp(argv[ args + 1 ], "60")==0) 387 frame_size = 3*sampling_rate/50; 388 else { 389 fprintf(stderr, "Unsupported frame size: %s ms. " 390 "Supported are 2.5, 5, 10, 20, 40, 60.\n", 391 argv[ args + 1 ]); 392 return EXIT_FAILURE; 393 } 394 args += 2; 395 } else if( strcmp( argv[ args ], "-max_payload" ) == 0 ) { 396 check_encoder_option(decode_only, "-max_payload"); 397 max_payload_bytes = atoi( argv[ args + 1 ] ); 398 args += 2; 399 } else if( strcmp( argv[ args ], "-complexity" ) == 0 ) { 400 check_encoder_option(decode_only, "-complexity"); 401 complexity = atoi( argv[ args + 1 ] ); 402 args += 2; 403 } else if( strcmp( argv[ args ], "-inbandfec" ) == 0 ) { 404 use_inbandfec = 1; 405 args++; 406 } else if( strcmp( argv[ args ], "-forcemono" ) == 0 ) { 407 check_encoder_option(decode_only, "-forcemono"); 408 forcechannels = 1; 409 args++; 410 } else if( strcmp( argv[ args ], "-cvbr" ) == 0 ) { 411 check_encoder_option(decode_only, "-cvbr"); 412 cvbr = 1; 413 args++; 414 } else if( strcmp( argv[ args ], "-variable-duration" ) == 0 ) { 415 check_encoder_option(decode_only, "-variable-duration"); 416 variable_duration = OPUS_FRAMESIZE_VARIABLE; 417 args++; 418 } else if( strcmp( argv[ args ], "-delayed-decision" ) == 0 ) { 419 check_encoder_option(decode_only, "-delayed-decision"); 420 delayed_decision = 1; 421 args++; 422 } else if( strcmp( argv[ args ], "-dtx") == 0 ) { 423 check_encoder_option(decode_only, "-dtx"); 424 use_dtx = 1; 425 args++; 426 } else if( strcmp( argv[ args ], "-loss" ) == 0 ) { 427 packet_loss_perc = atoi( argv[ args + 1 ] ); 428 args += 2; 429 } else if( strcmp( argv[ args ], "-sweep" ) == 0 ) { 430 check_encoder_option(decode_only, "-sweep"); 431 sweep_bps = atoi( argv[ args + 1 ] ); 432 args += 2; 433 } else if( strcmp( argv[ args ], "-random_framesize" ) == 0 ) { 434 check_encoder_option(decode_only, "-random_framesize"); 435 random_framesize = 1; 436 args++; 437 } else if( strcmp( argv[ args ], "-sweep_max" ) == 0 ) { 438 check_encoder_option(decode_only, "-sweep_max"); 439 sweep_max = atoi( argv[ args + 1 ] ); 440 args += 2; 441 } else if( strcmp( argv[ args ], "-random_fec" ) == 0 ) { 442 check_encoder_option(decode_only, "-random_fec"); 443 random_fec = 1; 444 args++; 445 } else if( strcmp( argv[ args ], "-silk8k_test" ) == 0 ) { 446 check_encoder_option(decode_only, "-silk8k_test"); 447 mode_list = silk8_test; 448 nb_modes_in_list = 8; 449 args++; 450 } else if( strcmp( argv[ args ], "-silk12k_test" ) == 0 ) { 451 check_encoder_option(decode_only, "-silk12k_test"); 452 mode_list = silk12_test; 453 nb_modes_in_list = 8; 454 args++; 455 } else if( strcmp( argv[ args ], "-silk16k_test" ) == 0 ) { 456 check_encoder_option(decode_only, "-silk16k_test"); 457 mode_list = silk16_test; 458 nb_modes_in_list = 8; 459 args++; 460 } else if( strcmp( argv[ args ], "-hybrid24k_test" ) == 0 ) { 461 check_encoder_option(decode_only, "-hybrid24k_test"); 462 mode_list = hybrid24_test; 463 nb_modes_in_list = 4; 464 args++; 465 } else if( strcmp( argv[ args ], "-hybrid48k_test" ) == 0 ) { 466 check_encoder_option(decode_only, "-hybrid48k_test"); 467 mode_list = hybrid48_test; 468 nb_modes_in_list = 4; 469 args++; 470 } else if( strcmp( argv[ args ], "-celt_test" ) == 0 ) { 471 check_encoder_option(decode_only, "-celt_test"); 472 mode_list = celt_test; 473 nb_modes_in_list = 32; 474 args++; 475 } else if( strcmp( argv[ args ], "-celt_hq_test" ) == 0 ) { 476 check_encoder_option(decode_only, "-celt_hq_test"); 477 mode_list = celt_hq_test; 478 nb_modes_in_list = 4; 479 args++; 480 } else { 481 printf( "Error: unrecognized setting: %s\n\n", argv[ args ] ); 482 print_usage( argv ); 483 return EXIT_FAILURE; 484 } 485 } 486 487 if (sweep_max) 488 sweep_min = bitrate_bps; 489 490 if (max_payload_bytes < 0 || max_payload_bytes > MAX_PACKET) 491 { 492 fprintf (stderr, "max_payload_bytes must be between 0 and %d\n", 493 MAX_PACKET); 494 return EXIT_FAILURE; 495 } 496 497 inFile = argv[argc-2]; 498 fin = fopen(inFile, "rb"); 499 if (!fin) 500 { 501 fprintf (stderr, "Could not open input file %s\n", argv[argc-2]); 502 return EXIT_FAILURE; 503 } 504 if (mode_list) 505 { 506 int size; 507 fseek(fin, 0, SEEK_END); 508 size = ftell(fin); 509 fprintf(stderr, "File size is %d bytes\n", size); 510 fseek(fin, 0, SEEK_SET); 511 mode_switch_time = size/sizeof(short)/channels/nb_modes_in_list; 512 fprintf(stderr, "Switching mode every %d samples\n", mode_switch_time); 513 } 514 515 outFile = argv[argc-1]; 516 fout = fopen(outFile, "wb+"); 517 if (!fout) 518 { 519 fprintf (stderr, "Could not open output file %s\n", argv[argc-1]); 520 fclose(fin); 521 return EXIT_FAILURE; 522 } 523 524 if (!decode_only) 525 { 526 enc = opus_encoder_create(sampling_rate, channels, application, &err); 527 if (err != OPUS_OK) 528 { 529 fprintf(stderr, "Cannot create encoder: %s\n", opus_strerror(err)); 530 fclose(fin); 531 fclose(fout); 532 return EXIT_FAILURE; 533 } 534 opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrate_bps)); 535 opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(bandwidth)); 536 opus_encoder_ctl(enc, OPUS_SET_VBR(use_vbr)); 537 opus_encoder_ctl(enc, OPUS_SET_VBR_CONSTRAINT(cvbr)); 538 opus_encoder_ctl(enc, OPUS_SET_COMPLEXITY(complexity)); 539 opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(use_inbandfec)); 540 opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS(forcechannels)); 541 opus_encoder_ctl(enc, OPUS_SET_DTX(use_dtx)); 542 opus_encoder_ctl(enc, OPUS_SET_PACKET_LOSS_PERC(packet_loss_perc)); 543 544 opus_encoder_ctl(enc, OPUS_GET_LOOKAHEAD(&skip)); 545 opus_encoder_ctl(enc, OPUS_SET_LSB_DEPTH(16)); 546 opus_encoder_ctl(enc, OPUS_SET_EXPERT_FRAME_DURATION(variable_duration)); 547 } 548 if (!encode_only) 549 { 550 dec = opus_decoder_create(sampling_rate, channels, &err); 551 if (err != OPUS_OK) 552 { 553 fprintf(stderr, "Cannot create decoder: %s\n", opus_strerror(err)); 554 fclose(fin); 555 fclose(fout); 556 return EXIT_FAILURE; 557 } 558 } 559 560 561 switch(bandwidth) 562 { 563 case OPUS_BANDWIDTH_NARROWBAND: 564 bandwidth_string = "narrowband"; 565 break; 566 case OPUS_BANDWIDTH_MEDIUMBAND: 567 bandwidth_string = "mediumband"; 568 break; 569 case OPUS_BANDWIDTH_WIDEBAND: 570 bandwidth_string = "wideband"; 571 break; 572 case OPUS_BANDWIDTH_SUPERWIDEBAND: 573 bandwidth_string = "superwideband"; 574 break; 575 case OPUS_BANDWIDTH_FULLBAND: 576 bandwidth_string = "fullband"; 577 break; 578 case OPUS_AUTO: 579 bandwidth_string = "auto"; 580 break; 581 default: 582 bandwidth_string = "unknown"; 583 break; 584 } 585 586 if (decode_only) 587 fprintf(stderr, "Decoding with %ld Hz output (%d channels)\n", 588 (long)sampling_rate, channels); 589 else 590 fprintf(stderr, "Encoding %ld Hz input at %.3f kb/s " 591 "in %s mode with %d-sample frames.\n", 592 (long)sampling_rate, bitrate_bps*0.001, 593 bandwidth_string, frame_size); 594 595 in = (short*)malloc(max_frame_size*channels*sizeof(short)); 596 out = (short*)malloc(max_frame_size*channels*sizeof(short)); 597 fbytes = (unsigned char*)malloc(max_frame_size*channels*sizeof(short)); 598 data[0] = (unsigned char*)calloc(max_payload_bytes,sizeof(char)); 599 if ( use_inbandfec ) { 600 data[1] = (unsigned char*)calloc(max_payload_bytes,sizeof(char)); 601 } 602 if(delayed_decision) 603 { 604 if (variable_duration!=OPUS_FRAMESIZE_VARIABLE) 605 { 606 if (frame_size==sampling_rate/400) 607 variable_duration = OPUS_FRAMESIZE_2_5_MS; 608 else if (frame_size==sampling_rate/200) 609 variable_duration = OPUS_FRAMESIZE_5_MS; 610 else if (frame_size==sampling_rate/100) 611 variable_duration = OPUS_FRAMESIZE_10_MS; 612 else if (frame_size==sampling_rate/50) 613 variable_duration = OPUS_FRAMESIZE_20_MS; 614 else if (frame_size==sampling_rate/25) 615 variable_duration = OPUS_FRAMESIZE_40_MS; 616 else 617 variable_duration = OPUS_FRAMESIZE_60_MS; 618 opus_encoder_ctl(enc, OPUS_SET_EXPERT_FRAME_DURATION(variable_duration)); 619 } 620 frame_size = 2*48000; 621 } 622 while (!stop) 623 { 624 if (delayed_celt) 625 { 626 frame_size = newsize; 627 delayed_celt = 0; 628 } else if (random_framesize && rand()%20==0) 629 { 630 newsize = rand()%6; 631 switch(newsize) 632 { 633 case 0: newsize=sampling_rate/400; break; 634 case 1: newsize=sampling_rate/200; break; 635 case 2: newsize=sampling_rate/100; break; 636 case 3: newsize=sampling_rate/50; break; 637 case 4: newsize=sampling_rate/25; break; 638 case 5: newsize=3*sampling_rate/50; break; 639 } 640 while (newsize < sampling_rate/25 && bitrate_bps-fabs(sweep_bps) <= 3*12*sampling_rate/newsize) 641 newsize*=2; 642 if (newsize < sampling_rate/100 && frame_size >= sampling_rate/100) 643 { 644 opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(MODE_CELT_ONLY)); 645 delayed_celt=1; 646 } else { 647 frame_size = newsize; 648 } 649 } 650 if (random_fec && rand()%30==0) 651 { 652 opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(rand()%4==0)); 653 } 654 if (decode_only) 655 { 656 unsigned char ch[4]; 657 err = fread(ch, 1, 4, fin); 658 if (feof(fin)) 659 break; 660 len[toggle] = char_to_int(ch); 661 if (len[toggle]>max_payload_bytes || len[toggle]<0) 662 { 663 fprintf(stderr, "Invalid payload length: %d\n",len[toggle]); 664 break; 665 } 666 err = fread(ch, 1, 4, fin); 667 enc_final_range[toggle] = char_to_int(ch); 668 err = fread(data[toggle], 1, len[toggle], fin); 669 if (err<len[toggle]) 670 { 671 fprintf(stderr, "Ran out of input, " 672 "expecting %d bytes got %d\n", 673 len[toggle],err); 674 break; 675 } 676 } else { 677 int i; 678 if (mode_list!=NULL) 679 { 680 opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(mode_list[curr_mode][1])); 681 opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(mode_list[curr_mode][0])); 682 opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS(mode_list[curr_mode][3])); 683 frame_size = mode_list[curr_mode][2]; 684 } 685 err = fread(fbytes, sizeof(short)*channels, frame_size-remaining, fin); 686 curr_read = err; 687 tot_in += curr_read; 688 for(i=0;i<curr_read*channels;i++) 689 { 690 opus_int32 s; 691 s=fbytes[2*i+1]<<8|fbytes[2*i]; 692 s=((s&0xFFFF)^0x8000)-0x8000; 693 in[i+remaining*channels]=s; 694 } 695 if (curr_read+remaining < frame_size) 696 { 697 for (i=(curr_read+remaining)*channels;i<frame_size*channels;i++) 698 in[i] = 0; 699 if (encode_only || decode_only) 700 stop = 1; 701 } 702 len[toggle] = opus_encode(enc, in, frame_size, data[toggle], max_payload_bytes); 703 nb_encoded = opus_packet_get_samples_per_frame(data[toggle], sampling_rate)*opus_packet_get_nb_frames(data[toggle], len[toggle]); 704 remaining = frame_size-nb_encoded; 705 for(i=0;i<remaining*channels;i++) 706 in[i] = in[nb_encoded*channels+i]; 707 if (sweep_bps!=0) 708 { 709 bitrate_bps += sweep_bps; 710 if (sweep_max) 711 { 712 if (bitrate_bps > sweep_max) 713 sweep_bps = -sweep_bps; 714 else if (bitrate_bps < sweep_min) 715 sweep_bps = -sweep_bps; 716 } 717 /* safety */ 718 if (bitrate_bps<1000) 719 bitrate_bps = 1000; 720 opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrate_bps)); 721 } 722 opus_encoder_ctl(enc, OPUS_GET_FINAL_RANGE(&enc_final_range[toggle])); 723 if (len[toggle] < 0) 724 { 725 fprintf (stderr, "opus_encode() returned %d\n", len[toggle]); 726 fclose(fin); 727 fclose(fout); 728 return EXIT_FAILURE; 729 } 730 curr_mode_count += frame_size; 731 if (curr_mode_count > mode_switch_time && curr_mode < nb_modes_in_list-1) 732 { 733 curr_mode++; 734 curr_mode_count = 0; 735 } 736 } 737 738#if 0 /* This is for testing the padding code, do not enable by default */ 739 if (len[toggle]<1275) 740 { 741 int new_len = len[toggle]+rand()%(max_payload_bytes-len[toggle]); 742 if ((err = opus_packet_pad(data[toggle], len[toggle], new_len)) != OPUS_OK) 743 { 744 fprintf(stderr, "padding failed: %s\n", opus_strerror(err)); 745 return EXIT_FAILURE; 746 } 747 len[toggle] = new_len; 748 } 749#endif 750 if (encode_only) 751 { 752 unsigned char int_field[4]; 753 int_to_char(len[toggle], int_field); 754 if (fwrite(int_field, 1, 4, fout) != 4) { 755 fprintf(stderr, "Error writing.\n"); 756 return EXIT_FAILURE; 757 } 758 int_to_char(enc_final_range[toggle], int_field); 759 if (fwrite(int_field, 1, 4, fout) != 4) { 760 fprintf(stderr, "Error writing.\n"); 761 return EXIT_FAILURE; 762 } 763 if (fwrite(data[toggle], 1, len[toggle], fout) != (unsigned)len[toggle]) { 764 fprintf(stderr, "Error writing.\n"); 765 return EXIT_FAILURE; 766 } 767 tot_samples += nb_encoded; 768 } else { 769 int output_samples; 770 lost = len[toggle]==0 || (packet_loss_perc>0 && rand()%100 < packet_loss_perc); 771 if (lost) 772 opus_decoder_ctl(dec, OPUS_GET_LAST_PACKET_DURATION(&output_samples)); 773 else 774 output_samples = max_frame_size; 775 if( count >= use_inbandfec ) { 776 /* delay by one packet when using in-band FEC */ 777 if( use_inbandfec ) { 778 if( lost_prev ) { 779 /* attempt to decode with in-band FEC from next packet */ 780 opus_decoder_ctl(dec, OPUS_GET_LAST_PACKET_DURATION(&output_samples)); 781 output_samples = opus_decode(dec, lost ? NULL : data[toggle], len[toggle], out, output_samples, 1); 782 } else { 783 /* regular decode */ 784 output_samples = max_frame_size; 785 output_samples = opus_decode(dec, data[1-toggle], len[1-toggle], out, output_samples, 0); 786 } 787 } else { 788 output_samples = opus_decode(dec, lost ? NULL : data[toggle], len[toggle], out, output_samples, 0); 789 } 790 if (output_samples>0) 791 { 792 if (!decode_only && tot_out + output_samples > tot_in) 793 { 794 stop=1; 795 output_samples = tot_in-tot_out; 796 } 797 if (output_samples>skip) { 798 int i; 799 for(i=0;i<(output_samples-skip)*channels;i++) 800 { 801 short s; 802 s=out[i+(skip*channels)]; 803 fbytes[2*i]=s&0xFF; 804 fbytes[2*i+1]=(s>>8)&0xFF; 805 } 806 if (fwrite(fbytes, sizeof(short)*channels, output_samples-skip, fout) != (unsigned)(output_samples-skip)){ 807 fprintf(stderr, "Error writing.\n"); 808 return EXIT_FAILURE; 809 } 810 tot_out += output_samples-skip; 811 } 812 if (output_samples<skip) skip -= output_samples; 813 else skip = 0; 814 } else { 815 fprintf(stderr, "error decoding frame: %s\n", 816 opus_strerror(output_samples)); 817 } 818 tot_samples += output_samples; 819 } 820 } 821 822 if (!encode_only) 823 opus_decoder_ctl(dec, OPUS_GET_FINAL_RANGE(&dec_final_range)); 824 /* compare final range encoder rng values of encoder and decoder */ 825 if( enc_final_range[toggle^use_inbandfec]!=0 && !encode_only 826 && !lost && !lost_prev 827 && dec_final_range != enc_final_range[toggle^use_inbandfec] ) { 828 fprintf (stderr, "Error: Range coder state mismatch " 829 "between encoder and decoder " 830 "in frame %ld: 0x%8lx vs 0x%8lx\n", 831 (long)count, 832 (unsigned long)enc_final_range[toggle^use_inbandfec], 833 (unsigned long)dec_final_range); 834 fclose(fin); 835 fclose(fout); 836 return EXIT_FAILURE; 837 } 838 839 lost_prev = lost; 840 841 /* count bits */ 842 bits += len[toggle]*8; 843 bits_max = ( len[toggle]*8 > bits_max ) ? len[toggle]*8 : bits_max; 844 if( count >= use_inbandfec ) { 845 nrg = 0.0; 846 if (!decode_only) 847 { 848 for ( k = 0; k < frame_size * channels; k++ ) { 849 nrg += in[ k ] * (double)in[ k ]; 850 } 851 } 852 if ( ( nrg / ( frame_size * channels ) ) > 1e5 ) { 853 bits_act += len[toggle]*8; 854 count_act++; 855 } 856 /* Variance */ 857 bits2 += len[toggle]*len[toggle]*64; 858 } 859 count++; 860 toggle = (toggle + use_inbandfec) & 1; 861 } 862 fprintf (stderr, "average bitrate: %7.3f kb/s\n", 863 1e-3*bits*sampling_rate/tot_samples); 864 fprintf (stderr, "maximum bitrate: %7.3f kb/s\n", 865 1e-3*bits_max*sampling_rate/frame_size); 866 if (!decode_only) 867 fprintf (stderr, "active bitrate: %7.3f kb/s\n", 868 1e-3*bits_act*sampling_rate/(frame_size*(double)count_act)); 869 fprintf (stderr, "bitrate standard deviation: %7.3f kb/s\n", 870 1e-3*sqrt(bits2/count - bits*bits/(count*(double)count))*sampling_rate/frame_size); 871 /* Close any files to which intermediate results were stored */ 872 SILK_DEBUG_STORE_CLOSE_FILES 873 silk_TimerSave("opus_timing.txt"); 874 opus_encoder_destroy(enc); 875 opus_decoder_destroy(dec); 876 free(data[0]); 877 if (use_inbandfec) 878 free(data[1]); 879 fclose(fin); 880 fclose(fout); 881 free(in); 882 free(out); 883 free(fbytes); 884 return EXIT_SUCCESS; 885} 886