1 /* Copyright (c) 2010-2011 Xiph.Org Foundation, Skype Limited 2 Written by Jean-Marc Valin and Koen Vos */ 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 <stdarg.h> 33 #include "celt.h" 34 #include "entenc.h" 35 #include "modes.h" 36 #include "API.h" 37 #include "stack_alloc.h" 38 #include "float_cast.h" 39 #include "opus.h" 40 #include "arch.h" 41 #include "opus_private.h" 42 #include "os_support.h" 43 44 #include "tuning_parameters.h" 45 #ifdef FIXED_POINT 46 #include "fixed/structs_FIX.h" 47 #else 48 #include "float/structs_FLP.h" 49 #endif 50 51 #define MAX_ENCODER_BUFFER 480 52 53 struct OpusEncoder { 54 int celt_enc_offset; 55 int silk_enc_offset; 56 silk_EncControlStruct silk_mode; 57 int application; 58 int channels; 59 int delay_compensation; 60 int force_channels; 61 int signal_type; 62 int user_bandwidth; 63 int max_bandwidth; 64 int user_forced_mode; 65 int voice_ratio; 66 opus_int32 Fs; 67 int use_vbr; 68 int vbr_constraint; 69 opus_int32 bitrate_bps; 70 opus_int32 user_bitrate_bps; 71 int encoder_buffer; 72 73 #define OPUS_ENCODER_RESET_START stream_channels 74 int stream_channels; 75 opus_int16 hybrid_stereo_width_Q14; 76 opus_int32 variable_HP_smth2_Q15; 77 opus_val32 hp_mem[4]; 78 int mode; 79 int prev_mode; 80 int prev_channels; 81 int prev_framesize; 82 int bandwidth; 83 int silk_bw_switch; 84 /* Sampling rate (at the API level) */ 85 int first; 86 opus_val16 delay_buffer[MAX_ENCODER_BUFFER*2]; 87 88 opus_uint32 rangeFinal; 89 }; 90 91 /* Transition tables for the voice and music. First column is the 92 middle (memoriless) threshold. The second column is the hysteresis 93 (difference with the middle) */ 94 static const opus_int32 mono_voice_bandwidth_thresholds[8] = { 95 11000, 1000, /* NB<->MB */ 96 14000, 1000, /* MB<->WB */ 97 21000, 2000, /* WB<->SWB */ 98 29000, 2000, /* SWB<->FB */ 99 }; 100 static const opus_int32 mono_music_bandwidth_thresholds[8] = { 101 14000, 1000, /* MB not allowed */ 102 18000, 2000, /* MB<->WB */ 103 24000, 2000, /* WB<->SWB */ 104 33000, 2000, /* SWB<->FB */ 105 }; 106 static const opus_int32 stereo_voice_bandwidth_thresholds[8] = { 107 11000, 1000, /* NB<->MB */ 108 14000, 1000, /* MB<->WB */ 109 21000, 2000, /* WB<->SWB */ 110 32000, 2000, /* SWB<->FB */ 111 }; 112 static const opus_int32 stereo_music_bandwidth_thresholds[8] = { 113 14000, 1000, /* MB not allowed */ 114 18000, 2000, /* MB<->WB */ 115 24000, 2000, /* WB<->SWB */ 116 48000, 2000, /* SWB<->FB */ 117 }; 118 /* Threshold bit-rates for switching between mono and stereo */ 119 static const opus_int32 stereo_voice_threshold = 26000; 120 static const opus_int32 stereo_music_threshold = 36000; 121 122 /* Threshold bit-rate for switching between SILK/hybrid and CELT-only */ 123 static const opus_int32 mode_thresholds[2][2] = { 124 /* voice */ /* music */ 125 { 48000, 24000}, /* mono */ 126 { 48000, 24000}, /* stereo */ 127 }; 128 129 int opus_encoder_get_size(int channels) 130 { 131 int silkEncSizeBytes, celtEncSizeBytes; 132 int ret; 133 if (channels<1 || channels > 2) 134 return 0; 135 ret = silk_Get_Encoder_Size( &silkEncSizeBytes ); 136 if (ret) 137 return 0; 138 silkEncSizeBytes = align(silkEncSizeBytes); 139 celtEncSizeBytes = celt_encoder_get_size(channels); 140 return align(sizeof(OpusEncoder))+silkEncSizeBytes+celtEncSizeBytes; 141 } 142 143 int opus_encoder_init(OpusEncoder* st, opus_int32 Fs, int channels, int application) 144 { 145 void *silk_enc; 146 CELTEncoder *celt_enc; 147 int err; 148 int ret, silkEncSizeBytes; 149 150 if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2)|| 151 (application != OPUS_APPLICATION_VOIP && application != OPUS_APPLICATION_AUDIO 152 && application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)) 153 return OPUS_BAD_ARG; 154 155 OPUS_CLEAR((char*)st, opus_encoder_get_size(channels)); 156 /* Create SILK encoder */ 157 ret = silk_Get_Encoder_Size( &silkEncSizeBytes ); 158 if (ret) 159 return OPUS_BAD_ARG; 160 silkEncSizeBytes = align(silkEncSizeBytes); 161 st->silk_enc_offset = align(sizeof(OpusEncoder)); 162 st->celt_enc_offset = st->silk_enc_offset+silkEncSizeBytes; 163 silk_enc = (char*)st+st->silk_enc_offset; 164 celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset); 165 166 st->stream_channels = st->channels = channels; 167 168 st->Fs = Fs; 169 170 ret = silk_InitEncoder( silk_enc, &st->silk_mode ); 171 if(ret)return OPUS_INTERNAL_ERROR; 172 173 /* default SILK parameters */ 174 st->silk_mode.nChannelsAPI = channels; 175 st->silk_mode.nChannelsInternal = channels; 176 st->silk_mode.API_sampleRate = st->Fs; 177 st->silk_mode.maxInternalSampleRate = 16000; 178 st->silk_mode.minInternalSampleRate = 8000; 179 st->silk_mode.desiredInternalSampleRate = 16000; 180 st->silk_mode.payloadSize_ms = 20; 181 st->silk_mode.bitRate = 25000; 182 st->silk_mode.packetLossPercentage = 0; 183 st->silk_mode.complexity = 10; 184 st->silk_mode.useInBandFEC = 0; 185 st->silk_mode.useDTX = 0; 186 st->silk_mode.useCBR = 0; 187 188 /* Create CELT encoder */ 189 /* Initialize CELT encoder */ 190 err = celt_encoder_init(celt_enc, Fs, channels); 191 if(err!=OPUS_OK)return OPUS_INTERNAL_ERROR; 192 193 celt_encoder_ctl(celt_enc, CELT_SET_SIGNALLING(0)); 194 celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(10)); 195 196 st->use_vbr = 1; 197 /* Makes constrained VBR the default (safer for real-time use) */ 198 st->vbr_constraint = 1; 199 st->user_bitrate_bps = OPUS_AUTO; 200 st->bitrate_bps = 3000+Fs*channels; 201 st->application = application; 202 st->signal_type = OPUS_AUTO; 203 st->user_bandwidth = OPUS_AUTO; 204 st->max_bandwidth = OPUS_BANDWIDTH_FULLBAND; 205 st->force_channels = OPUS_AUTO; 206 st->user_forced_mode = OPUS_AUTO; 207 st->voice_ratio = -1; 208 st->encoder_buffer = st->Fs/100; 209 210 /* Delay compensation of 4 ms (2.5 ms for SILK's extra look-ahead 211 + 1.5 ms for SILK resamplers and stereo prediction) */ 212 st->delay_compensation = st->Fs/250; 213 214 st->hybrid_stereo_width_Q14 = 1 << 14; 215 st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 ); 216 st->first = 1; 217 st->mode = MODE_HYBRID; 218 st->bandwidth = OPUS_BANDWIDTH_FULLBAND; 219 220 return OPUS_OK; 221 } 222 223 static int pad_frame(unsigned char *data, opus_int32 len, opus_int32 new_len) 224 { 225 if (len == new_len) 226 return 0; 227 if (len > new_len) 228 return 1; 229 230 if ((data[0]&0x3)==0) 231 { 232 int i; 233 int padding, nb_255s; 234 235 padding = new_len - len; 236 if (padding >= 2) 237 { 238 nb_255s = (padding-2)/255; 239 240 for (i=len-1;i>=1;i--) 241 data[i+nb_255s+2] = data[i]; 242 data[0] |= 0x3; 243 data[1] = 0x41; 244 for (i=0;i<nb_255s;i++) 245 data[i+2] = 255; 246 data[nb_255s+2] = padding-255*nb_255s-2; 247 for (i=len+3+nb_255s;i<new_len;i++) 248 data[i] = 0; 249 } else { 250 for (i=len-1;i>=1;i--) 251 data[i+1] = data[i]; 252 data[0] |= 0x3; 253 data[1] = 1; 254 } 255 return 0; 256 } else { 257 return 1; 258 } 259 } 260 261 static unsigned char gen_toc(int mode, int framerate, int bandwidth, int channels) 262 { 263 int period; 264 unsigned char toc; 265 period = 0; 266 while (framerate < 400) 267 { 268 framerate <<= 1; 269 period++; 270 } 271 if (mode == MODE_SILK_ONLY) 272 { 273 toc = (bandwidth-OPUS_BANDWIDTH_NARROWBAND)<<5; 274 toc |= (period-2)<<3; 275 } else if (mode == MODE_CELT_ONLY) 276 { 277 int tmp = bandwidth-OPUS_BANDWIDTH_MEDIUMBAND; 278 if (tmp < 0) 279 tmp = 0; 280 toc = 0x80; 281 toc |= tmp << 5; 282 toc |= period<<3; 283 } else /* Hybrid */ 284 { 285 toc = 0x60; 286 toc |= (bandwidth-OPUS_BANDWIDTH_SUPERWIDEBAND)<<4; 287 toc |= (period-2)<<3; 288 } 289 toc |= (channels==2)<<2; 290 return toc; 291 } 292 293 #ifndef FIXED_POINT 294 static void silk_biquad_float( 295 const opus_val16 *in, /* I: Input signal */ 296 const opus_int32 *B_Q28, /* I: MA coefficients [3] */ 297 const opus_int32 *A_Q28, /* I: AR coefficients [2] */ 298 opus_val32 *S, /* I/O: State vector [2] */ 299 opus_val16 *out, /* O: Output signal */ 300 const opus_int32 len, /* I: Signal length (must be even) */ 301 int stride 302 ) 303 { 304 /* DIRECT FORM II TRANSPOSED (uses 2 element state vector) */ 305 opus_int k; 306 opus_val32 vout; 307 opus_val32 inval; 308 opus_val32 A[2], B[3]; 309 310 A[0] = (opus_val32)(A_Q28[0] * (1.f/((opus_int32)1<<28))); 311 A[1] = (opus_val32)(A_Q28[1] * (1.f/((opus_int32)1<<28))); 312 B[0] = (opus_val32)(B_Q28[0] * (1.f/((opus_int32)1<<28))); 313 B[1] = (opus_val32)(B_Q28[1] * (1.f/((opus_int32)1<<28))); 314 B[2] = (opus_val32)(B_Q28[2] * (1.f/((opus_int32)1<<28))); 315 316 /* Negate A_Q28 values and split in two parts */ 317 318 for( k = 0; k < len; k++ ) { 319 /* S[ 0 ], S[ 1 ]: Q12 */ 320 inval = in[ k*stride ]; 321 vout = S[ 0 ] + B[0]*inval; 322 323 S[ 0 ] = S[1] - vout*A[0] + B[1]*inval; 324 325 S[ 1 ] = - vout*A[1] + B[2]*inval; 326 327 /* Scale back to Q0 and saturate */ 328 out[ k*stride ] = vout; 329 } 330 } 331 #endif 332 333 static void hp_cutoff(const opus_val16 *in, opus_int32 cutoff_Hz, opus_val16 *out, opus_val32 *hp_mem, int len, int channels, opus_int32 Fs) 334 { 335 opus_int32 B_Q28[ 3 ], A_Q28[ 2 ]; 336 opus_int32 Fc_Q19, r_Q28, r_Q22; 337 338 silk_assert( cutoff_Hz <= silk_int32_MAX / SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ) ); 339 Fc_Q19 = silk_DIV32_16( silk_SMULBB( SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ), cutoff_Hz ), Fs/1000 ); 340 silk_assert( Fc_Q19 > 0 && Fc_Q19 < 32768 ); 341 342 r_Q28 = SILK_FIX_CONST( 1.0, 28 ) - silk_MUL( SILK_FIX_CONST( 0.92, 9 ), Fc_Q19 ); 343 344 /* b = r * [ 1; -2; 1 ]; */ 345 /* a = [ 1; -2 * r * ( 1 - 0.5 * Fc^2 ); r^2 ]; */ 346 B_Q28[ 0 ] = r_Q28; 347 B_Q28[ 1 ] = silk_LSHIFT( -r_Q28, 1 ); 348 B_Q28[ 2 ] = r_Q28; 349 350 /* -r * ( 2 - Fc * Fc ); */ 351 r_Q22 = silk_RSHIFT( r_Q28, 6 ); 352 A_Q28[ 0 ] = silk_SMULWW( r_Q22, silk_SMULWW( Fc_Q19, Fc_Q19 ) - SILK_FIX_CONST( 2.0, 22 ) ); 353 A_Q28[ 1 ] = silk_SMULWW( r_Q22, r_Q22 ); 354 355 #ifdef FIXED_POINT 356 silk_biquad_alt( in, B_Q28, A_Q28, hp_mem, out, len, channels ); 357 if( channels == 2 ) { 358 silk_biquad_alt( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels ); 359 } 360 #else 361 silk_biquad_float( in, B_Q28, A_Q28, hp_mem, out, len, channels ); 362 if( channels == 2 ) { 363 silk_biquad_float( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels ); 364 } 365 #endif 366 } 367 368 static void stereo_fade(const opus_val16 *in, opus_val16 *out, opus_val16 g1, opus_val16 g2, 369 int overlap48, int frame_size, int channels, const opus_val16 *window, opus_int32 Fs) 370 { 371 int i; 372 int overlap; 373 int inc; 374 inc = 48000/Fs; 375 overlap=overlap48/inc; 376 g1 = Q15ONE-g1; 377 g2 = Q15ONE-g2; 378 for (i=0;i<overlap;i++) 379 { 380 opus_val32 diff; 381 opus_val16 g, w; 382 w = MULT16_16_Q15(window[i*inc], window[i*inc]); 383 g = SHR32(MAC16_16(MULT16_16(w,g2), 384 Q15ONE-w, g1), 15); 385 diff = EXTRACT16(HALF32((opus_val32)in[i*channels] - (opus_val32)in[i*channels+1])); 386 diff = MULT16_16_Q15(g, diff); 387 out[i*channels] = out[i*channels] - diff; 388 out[i*channels+1] = out[i*channels+1] + diff; 389 } 390 for (;i<frame_size;i++) 391 { 392 opus_val32 diff; 393 diff = EXTRACT16(HALF32((opus_val32)in[i*channels] - (opus_val32)in[i*channels+1])); 394 diff = MULT16_16_Q15(g2, diff); 395 out[i*channels] = out[i*channels] - diff; 396 out[i*channels+1] = out[i*channels+1] + diff; 397 } 398 } 399 400 OpusEncoder *opus_encoder_create(opus_int32 Fs, int channels, int application, int *error) 401 { 402 int ret; 403 OpusEncoder *st; 404 if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2)|| 405 (application != OPUS_APPLICATION_VOIP && application != OPUS_APPLICATION_AUDIO 406 && application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)) 407 { 408 if (error) 409 *error = OPUS_BAD_ARG; 410 return NULL; 411 } 412 st = (OpusEncoder *)opus_alloc(opus_encoder_get_size(channels)); 413 if (st == NULL) 414 { 415 if (error) 416 *error = OPUS_ALLOC_FAIL; 417 return NULL; 418 } 419 ret = opus_encoder_init(st, Fs, channels, application); 420 if (error) 421 *error = ret; 422 if (ret != OPUS_OK) 423 { 424 opus_free(st); 425 st = NULL; 426 } 427 return st; 428 } 429 430 static opus_int32 user_bitrate_to_bitrate(OpusEncoder *st, int frame_size, int max_data_bytes) 431 { 432 if(!frame_size)frame_size=st->Fs/400; 433 if (st->user_bitrate_bps==OPUS_AUTO) 434 return 60*st->Fs/frame_size + st->Fs*st->channels; 435 else if (st->user_bitrate_bps==OPUS_BITRATE_MAX) 436 return max_data_bytes*8*st->Fs/frame_size; 437 else 438 return st->user_bitrate_bps; 439 } 440 441 #ifdef FIXED_POINT 442 #define opus_encode_native opus_encode 443 opus_int32 opus_encode(OpusEncoder *st, const opus_val16 *pcm, int frame_size, 444 unsigned char *data, opus_int32 out_data_bytes) 445 #else 446 #define opus_encode_native opus_encode_float 447 opus_int32 opus_encode_float(OpusEncoder *st, const opus_val16 *pcm, int frame_size, 448 unsigned char *data, opus_int32 out_data_bytes) 449 #endif 450 { 451 void *silk_enc; 452 CELTEncoder *celt_enc; 453 int i; 454 int ret=0; 455 opus_int32 nBytes; 456 ec_enc enc; 457 int bytes_target; 458 int prefill=0; 459 int start_band = 0; 460 int redundancy = 0; 461 int redundancy_bytes = 0; /* Number of bytes to use for redundancy frame */ 462 int celt_to_silk = 0; 463 VARDECL(opus_val16, pcm_buf); 464 int nb_compr_bytes; 465 int to_celt = 0; 466 opus_uint32 redundant_rng = 0; 467 int cutoff_Hz, hp_freq_smth1; 468 int voice_est; /* Probability of voice in Q7 */ 469 opus_int32 equiv_rate; 470 int delay_compensation; 471 int frame_rate; 472 opus_int32 max_rate; /* Max bitrate we're allowed to use */ 473 int curr_bandwidth; 474 opus_int32 max_data_bytes; /* Max number of bytes we're allowed to use */ 475 VARDECL(opus_val16, tmp_prefill); 476 477 ALLOC_STACK; 478 479 max_data_bytes = IMIN(1276, out_data_bytes); 480 481 st->rangeFinal = 0; 482 if (400*frame_size != st->Fs && 200*frame_size != st->Fs && 100*frame_size != st->Fs && 483 50*frame_size != st->Fs && 25*frame_size != st->Fs && 50*frame_size != 3*st->Fs) 484 { 485 RESTORE_STACK; 486 return OPUS_BAD_ARG; 487 } 488 if (max_data_bytes<=0) 489 { 490 RESTORE_STACK; 491 return OPUS_BAD_ARG; 492 } 493 silk_enc = (char*)st+st->silk_enc_offset; 494 celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset); 495 496 if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY) 497 delay_compensation = 0; 498 else 499 delay_compensation = st->delay_compensation; 500 501 st->bitrate_bps = user_bitrate_to_bitrate(st, frame_size, max_data_bytes); 502 503 frame_rate = st->Fs/frame_size; 504 if (max_data_bytes<3 || st->bitrate_bps < 3*frame_rate*8 505 || (frame_rate<50 && (max_data_bytes*frame_rate<300 || st->bitrate_bps < 2400))) 506 { 507 /*If the space is too low to do something useful, emit 'PLC' frames.*/ 508 int tocmode = st->mode; 509 int bw = st->bandwidth == 0 ? OPUS_BANDWIDTH_NARROWBAND : st->bandwidth; 510 if (tocmode==0) 511 tocmode = MODE_SILK_ONLY; 512 if (frame_rate>100) 513 tocmode = MODE_CELT_ONLY; 514 if (frame_rate < 50) 515 tocmode = MODE_SILK_ONLY; 516 if(tocmode==MODE_SILK_ONLY&&bw>OPUS_BANDWIDTH_WIDEBAND) 517 bw=OPUS_BANDWIDTH_WIDEBAND; 518 else if (tocmode==MODE_CELT_ONLY&&bw==OPUS_BANDWIDTH_MEDIUMBAND) 519 bw=OPUS_BANDWIDTH_NARROWBAND; 520 else if (bw<=OPUS_BANDWIDTH_SUPERWIDEBAND) 521 bw=OPUS_BANDWIDTH_SUPERWIDEBAND; 522 data[0] = gen_toc(tocmode, frame_rate, bw, st->stream_channels); 523 RESTORE_STACK; 524 return 1; 525 } 526 if (!st->use_vbr) 527 { 528 int cbrBytes; 529 cbrBytes = IMIN( (st->bitrate_bps + 4*frame_rate)/(8*frame_rate) , max_data_bytes); 530 st->bitrate_bps = cbrBytes * (8*frame_rate); 531 max_data_bytes = cbrBytes; 532 } 533 max_rate = frame_rate*max_data_bytes*8; 534 535 /* Equivalent 20-ms rate for mode/channel/bandwidth decisions */ 536 equiv_rate = st->bitrate_bps - 60*(st->Fs/frame_size - 50); 537 538 if (st->signal_type == OPUS_SIGNAL_VOICE) 539 voice_est = 127; 540 else if (st->signal_type == OPUS_SIGNAL_MUSIC) 541 voice_est = 0; 542 else if (st->voice_ratio >= 0) 543 voice_est = st->voice_ratio*327>>8; 544 else if (st->application == OPUS_APPLICATION_VOIP) 545 voice_est = 115; 546 else 547 voice_est = 48; 548 549 if (st->force_channels!=OPUS_AUTO && st->channels == 2) 550 { 551 st->stream_channels = st->force_channels; 552 } else { 553 #ifdef FUZZING 554 /* Random mono/stereo decision */ 555 if (st->channels == 2 && (rand()&0x1F)==0) 556 st->stream_channels = 3-st->stream_channels; 557 #else 558 /* Rate-dependent mono-stereo decision */ 559 if (st->channels == 2) 560 { 561 opus_int32 stereo_threshold; 562 stereo_threshold = stereo_music_threshold + ((voice_est*voice_est*(stereo_voice_threshold-stereo_music_threshold))>>14); 563 if (st->stream_channels == 2) 564 stereo_threshold -= 4000; 565 else 566 stereo_threshold += 4000; 567 st->stream_channels = (equiv_rate > stereo_threshold) ? 2 : 1; 568 } else { 569 st->stream_channels = st->channels; 570 } 571 #endif 572 } 573 574 /* Mode selection depending on application and signal type */ 575 if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY) 576 { 577 st->mode = MODE_CELT_ONLY; 578 } else if (st->user_forced_mode == OPUS_AUTO) 579 { 580 #ifdef FUZZING 581 /* Random mode switching */ 582 if ((rand()&0xF)==0) 583 { 584 if ((rand()&0x1)==0) 585 st->mode = MODE_CELT_ONLY; 586 else 587 st->mode = MODE_SILK_ONLY; 588 } else { 589 if (st->prev_mode==MODE_CELT_ONLY) 590 st->mode = MODE_CELT_ONLY; 591 else 592 st->mode = MODE_SILK_ONLY; 593 } 594 #else 595 int chan; 596 opus_int32 mode_voice, mode_music; 597 opus_int32 threshold; 598 599 chan = (st->channels==2) && st->force_channels!=1; 600 mode_voice = mode_thresholds[chan][0]; 601 mode_music = mode_thresholds[chan][1]; 602 threshold = mode_music + ((voice_est*voice_est*(mode_voice-mode_music))>>14); 603 604 /* Hysteresis */ 605 if (st->prev_mode == MODE_CELT_ONLY) 606 threshold -= 4000; 607 else if (st->prev_mode>0) 608 threshold += 4000; 609 610 st->mode = (equiv_rate >= threshold) ? MODE_CELT_ONLY: MODE_SILK_ONLY; 611 612 /* When FEC is enabled and there's enough packet loss, use SILK */ 613 if (st->silk_mode.useInBandFEC && st->silk_mode.packetLossPercentage > (128-voice_est)>>4) 614 st->mode = MODE_SILK_ONLY; 615 /* When encoding voice and DTX is enabled, set the encoder to SILK mode (at least for now) */ 616 if (st->silk_mode.useDTX && voice_est > 100) 617 st->mode = MODE_SILK_ONLY; 618 #endif 619 } else { 620 st->mode = st->user_forced_mode; 621 } 622 623 /* Override the chosen mode to make sure we meet the requested frame size */ 624 if (st->mode != MODE_CELT_ONLY && frame_size < st->Fs/100) 625 st->mode = MODE_CELT_ONLY; 626 627 if (st->stream_channels == 1 && st->prev_channels ==2 && st->silk_mode.toMono==0 628 && st->mode != MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY) 629 { 630 /* Delay stereo->mono transition by two frames so that SILK can do a smooth downmix */ 631 st->silk_mode.toMono = 1; 632 st->stream_channels = 2; 633 } else { 634 st->silk_mode.toMono = 0; 635 } 636 637 if (st->prev_mode > 0 && 638 ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) || 639 (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY))) 640 { 641 redundancy = 1; 642 celt_to_silk = (st->mode != MODE_CELT_ONLY); 643 if (!celt_to_silk) 644 { 645 /* Switch to SILK/hybrid if frame size is 10 ms or more*/ 646 if (frame_size >= st->Fs/100) 647 { 648 st->mode = st->prev_mode; 649 to_celt = 1; 650 } else { 651 redundancy=0; 652 } 653 } 654 } 655 /* For the first frame at a new SILK bandwidth */ 656 if (st->silk_bw_switch) 657 { 658 redundancy = 1; 659 celt_to_silk = 1; 660 st->silk_bw_switch = 0; 661 } 662 663 if (redundancy) 664 { 665 /* Fair share of the max size allowed */ 666 redundancy_bytes = IMIN(257, max_data_bytes*(opus_int32)(st->Fs/200)/(frame_size+st->Fs/200)); 667 /* For VBR, target the actual bitrate (subject to the limit above) */ 668 if (st->use_vbr) 669 redundancy_bytes = IMIN(redundancy_bytes, st->bitrate_bps/1600); 670 } 671 672 if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) 673 { 674 silk_EncControlStruct dummy; 675 silk_InitEncoder( silk_enc, &dummy); 676 prefill=1; 677 } 678 679 /* Automatic (rate-dependent) bandwidth selection */ 680 if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch) 681 { 682 const opus_int32 *voice_bandwidth_thresholds, *music_bandwidth_thresholds; 683 opus_int32 bandwidth_thresholds[8]; 684 int bandwidth = OPUS_BANDWIDTH_FULLBAND; 685 opus_int32 equiv_rate2; 686 687 equiv_rate2 = equiv_rate; 688 if (st->mode != MODE_CELT_ONLY) 689 { 690 /* Adjust the threshold +/- 10% depending on complexity */ 691 equiv_rate2 = equiv_rate2 * (45+st->silk_mode.complexity)/50; 692 /* CBR is less efficient by ~1 kb/s */ 693 if (!st->use_vbr) 694 equiv_rate2 -= 1000; 695 } 696 if (st->channels==2 && st->force_channels!=1) 697 { 698 voice_bandwidth_thresholds = stereo_voice_bandwidth_thresholds; 699 music_bandwidth_thresholds = stereo_music_bandwidth_thresholds; 700 } else { 701 voice_bandwidth_thresholds = mono_voice_bandwidth_thresholds; 702 music_bandwidth_thresholds = mono_music_bandwidth_thresholds; 703 } 704 /* Interpolate bandwidth thresholds depending on voice estimation */ 705 for (i=0;i<8;i++) 706 { 707 bandwidth_thresholds[i] = music_bandwidth_thresholds[i] 708 + ((voice_est*voice_est*(voice_bandwidth_thresholds[i]-music_bandwidth_thresholds[i]))>>14); 709 } 710 do { 711 int threshold, hysteresis; 712 threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)]; 713 hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)+1]; 714 if (!st->first) 715 { 716 if (st->bandwidth >= bandwidth) 717 threshold -= hysteresis; 718 else 719 threshold += hysteresis; 720 } 721 if (equiv_rate2 >= threshold) 722 break; 723 } while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND); 724 st->bandwidth = bandwidth; 725 /* Prevents any transition to SWB/FB until the SILK layer has fully 726 switched to WB mode and turned the variable LP filter off */ 727 if (!st->first && st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND) 728 st->bandwidth = OPUS_BANDWIDTH_WIDEBAND; 729 } 730 731 if (st->bandwidth>st->max_bandwidth) 732 st->bandwidth = st->max_bandwidth; 733 734 if (st->user_bandwidth != OPUS_AUTO) 735 st->bandwidth = st->user_bandwidth; 736 737 /* This prevents us from using hybrid at unsafe CBR/max rates */ 738 if (st->mode != MODE_CELT_ONLY && max_rate < 15000) 739 { 740 st->bandwidth = IMIN(st->bandwidth, OPUS_BANDWIDTH_WIDEBAND); 741 } 742 743 /* Prevents Opus from wasting bits on frequencies that are above 744 the Nyquist rate of the input signal */ 745 if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND) 746 st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND; 747 if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND) 748 st->bandwidth = OPUS_BANDWIDTH_WIDEBAND; 749 if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND) 750 st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND; 751 if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND) 752 st->bandwidth = OPUS_BANDWIDTH_NARROWBAND; 753 754 /* If max_data_bytes represents less than 8 kb/s, switch to CELT-only mode */ 755 if (max_data_bytes < (frame_rate > 50 ? 12000 : 8000)*frame_size / (st->Fs * 8)) 756 st->mode = MODE_CELT_ONLY; 757 758 /* CELT mode doesn't support mediumband, use wideband instead */ 759 if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) 760 st->bandwidth = OPUS_BANDWIDTH_WIDEBAND; 761 762 /* Can't support higher than wideband for >20 ms frames */ 763 if (frame_size > st->Fs/50 && (st->mode == MODE_CELT_ONLY || st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)) 764 { 765 VARDECL(unsigned char, tmp_data); 766 int nb_frames; 767 int bak_mode, bak_bandwidth, bak_channels, bak_to_mono; 768 OpusRepacketizer rp; 769 opus_int32 bytes_per_frame; 770 771 772 nb_frames = frame_size > st->Fs/25 ? 3 : 2; 773 bytes_per_frame = IMIN(1276,(out_data_bytes-3)/nb_frames); 774 775 ALLOC(tmp_data, nb_frames*bytes_per_frame, unsigned char); 776 777 opus_repacketizer_init(&rp); 778 779 bak_mode = st->user_forced_mode; 780 bak_bandwidth = st->user_bandwidth; 781 bak_channels = st->force_channels; 782 783 st->user_forced_mode = st->mode; 784 st->user_bandwidth = st->bandwidth; 785 st->force_channels = st->stream_channels; 786 bak_to_mono = st->silk_mode.toMono; 787 788 if (bak_to_mono) 789 st->force_channels = 1; 790 else 791 st->prev_channels = st->stream_channels; 792 for (i=0;i<nb_frames;i++) 793 { 794 int tmp_len; 795 st->silk_mode.toMono = 0; 796 /* When switching from SILK/Hybrid to CELT, only ask for a switch at the last frame */ 797 if (to_celt && i==nb_frames-1) 798 st->user_forced_mode = MODE_CELT_ONLY; 799 tmp_len = opus_encode_native(st, pcm+i*(st->channels*st->Fs/50), st->Fs/50, tmp_data+i*bytes_per_frame, bytes_per_frame); 800 if (tmp_len<0) 801 { 802 RESTORE_STACK; 803 return OPUS_INTERNAL_ERROR; 804 } 805 ret = opus_repacketizer_cat(&rp, tmp_data+i*bytes_per_frame, tmp_len); 806 if (ret<0) 807 { 808 RESTORE_STACK; 809 return OPUS_INTERNAL_ERROR; 810 } 811 } 812 ret = opus_repacketizer_out(&rp, data, out_data_bytes); 813 if (ret<0) 814 { 815 RESTORE_STACK; 816 return OPUS_INTERNAL_ERROR; 817 } 818 st->user_forced_mode = bak_mode; 819 st->user_bandwidth = bak_bandwidth; 820 st->force_channels = bak_channels; 821 st->silk_mode.toMono = bak_to_mono; 822 RESTORE_STACK; 823 return ret; 824 } 825 826 curr_bandwidth = st->bandwidth; 827 828 /* Chooses the appropriate mode for speech 829 *NEVER* switch to/from CELT-only mode here as this will invalidate some assumptions */ 830 if (st->mode == MODE_SILK_ONLY && curr_bandwidth > OPUS_BANDWIDTH_WIDEBAND) 831 st->mode = MODE_HYBRID; 832 if (st->mode == MODE_HYBRID && curr_bandwidth <= OPUS_BANDWIDTH_WIDEBAND) 833 st->mode = MODE_SILK_ONLY; 834 835 /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, curr_bandwidth); */ 836 bytes_target = IMIN(max_data_bytes-redundancy_bytes, st->bitrate_bps * frame_size / (st->Fs * 8)) - 1; 837 838 data += 1; 839 840 ec_enc_init(&enc, data, max_data_bytes-1); 841 842 ALLOC(pcm_buf, (delay_compensation+frame_size)*st->channels, opus_val16); 843 for (i=0;i<delay_compensation*st->channels;i++) 844 pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-delay_compensation)*st->channels+i]; 845 846 if (st->mode == MODE_CELT_ONLY) 847 hp_freq_smth1 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 ); 848 else 849 hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15; 850 851 st->variable_HP_smth2_Q15 = silk_SMLAWB( st->variable_HP_smth2_Q15, 852 hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) ); 853 854 /* convert from log scale to Hertz */ 855 cutoff_Hz = silk_log2lin( silk_RSHIFT( st->variable_HP_smth2_Q15, 8 ) ); 856 857 if (st->application == OPUS_APPLICATION_VOIP) 858 { 859 hp_cutoff(pcm, cutoff_Hz, &pcm_buf[delay_compensation*st->channels], st->hp_mem, frame_size, st->channels, st->Fs); 860 } else { 861 for (i=0;i<frame_size*st->channels;i++) 862 pcm_buf[delay_compensation*st->channels + i] = pcm[i]; 863 } 864 865 /* SILK processing */ 866 if (st->mode != MODE_CELT_ONLY) 867 { 868 #ifdef FIXED_POINT 869 const opus_int16 *pcm_silk; 870 #else 871 VARDECL(opus_int16, pcm_silk); 872 ALLOC(pcm_silk, st->channels*frame_size, opus_int16); 873 #endif 874 st->silk_mode.bitRate = 8*bytes_target*frame_rate; 875 if( st->mode == MODE_HYBRID ) { 876 st->silk_mode.bitRate /= st->stream_channels; 877 if( curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) { 878 if( st->Fs == 100 * frame_size ) { 879 /* 24 kHz, 10 ms */ 880 st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 2000 + st->use_vbr * 1000 ) * 2 ) / 3; 881 } else { 882 /* 24 kHz, 20 ms */ 883 st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 1000 + st->use_vbr * 1000 ) * 2 ) / 3; 884 } 885 } else { 886 if( st->Fs == 100 * frame_size ) { 887 /* 48 kHz, 10 ms */ 888 st->silk_mode.bitRate = ( st->silk_mode.bitRate + 8000 + st->use_vbr * 3000 ) / 2; 889 } else { 890 /* 48 kHz, 20 ms */ 891 st->silk_mode.bitRate = ( st->silk_mode.bitRate + 9000 + st->use_vbr * 1000 ) / 2; 892 } 893 } 894 st->silk_mode.bitRate *= st->stream_channels; 895 /* don't let SILK use more than 80% */ 896 if( st->silk_mode.bitRate > ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5 ) { 897 st->silk_mode.bitRate = ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5; 898 } 899 } 900 901 st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs; 902 st->silk_mode.nChannelsAPI = st->channels; 903 st->silk_mode.nChannelsInternal = st->stream_channels; 904 if (curr_bandwidth == OPUS_BANDWIDTH_NARROWBAND) { 905 st->silk_mode.desiredInternalSampleRate = 8000; 906 } else if (curr_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) { 907 st->silk_mode.desiredInternalSampleRate = 12000; 908 } else { 909 silk_assert( st->mode == MODE_HYBRID || curr_bandwidth == OPUS_BANDWIDTH_WIDEBAND ); 910 st->silk_mode.desiredInternalSampleRate = 16000; 911 } 912 if( st->mode == MODE_HYBRID ) { 913 /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */ 914 st->silk_mode.minInternalSampleRate = 16000; 915 } else { 916 st->silk_mode.minInternalSampleRate = 8000; 917 } 918 919 if (st->mode == MODE_SILK_ONLY) 920 { 921 opus_int32 effective_max_rate = max_rate; 922 st->silk_mode.maxInternalSampleRate = 16000; 923 if (frame_rate > 50) 924 effective_max_rate = effective_max_rate*2/3; 925 if (effective_max_rate < 13000) 926 { 927 st->silk_mode.maxInternalSampleRate = 12000; 928 st->silk_mode.desiredInternalSampleRate = IMIN(12000, st->silk_mode.desiredInternalSampleRate); 929 } 930 if (effective_max_rate < 9600) 931 { 932 st->silk_mode.maxInternalSampleRate = 8000; 933 st->silk_mode.desiredInternalSampleRate = IMIN(8000, st->silk_mode.desiredInternalSampleRate); 934 } 935 } else { 936 st->silk_mode.maxInternalSampleRate = 16000; 937 } 938 939 st->silk_mode.useCBR = !st->use_vbr; 940 941 /* Call SILK encoder for the low band */ 942 nBytes = IMIN(1275, max_data_bytes-1-redundancy_bytes); 943 944 st->silk_mode.maxBits = nBytes*8; 945 /* Only allow up to 90% of the bits for hybrid mode*/ 946 if (st->mode == MODE_HYBRID) 947 st->silk_mode.maxBits = (opus_int32)st->silk_mode.maxBits*9/10; 948 if (st->silk_mode.useCBR) 949 { 950 st->silk_mode.maxBits = (st->silk_mode.bitRate * frame_size / (st->Fs * 8))*8; 951 /* Reduce the initial target to make it easier to reach the CBR rate */ 952 st->silk_mode.bitRate = IMAX(1, st->silk_mode.bitRate-2000); 953 } 954 955 if (prefill) 956 { 957 opus_int32 zero=0; 958 #ifdef FIXED_POINT 959 pcm_silk = st->delay_buffer; 960 #else 961 for (i=0;i<st->encoder_buffer*st->channels;i++) 962 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]); 963 #endif 964 silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 ); 965 } 966 967 #ifdef FIXED_POINT 968 pcm_silk = pcm_buf+delay_compensation*st->channels; 969 #else 970 for (i=0;i<frame_size*st->channels;i++) 971 pcm_silk[i] = FLOAT2INT16(pcm_buf[delay_compensation*st->channels + i]); 972 #endif 973 ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 ); 974 if( ret ) { 975 /*fprintf (stderr, "SILK encode error: %d\n", ret);*/ 976 /* Handle error */ 977 RESTORE_STACK; 978 return OPUS_INTERNAL_ERROR; 979 } 980 if (nBytes==0) 981 { 982 st->rangeFinal = 0; 983 data[-1] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels); 984 RESTORE_STACK; 985 return 1; 986 } 987 /* Extract SILK internal bandwidth for signaling in first byte */ 988 if( st->mode == MODE_SILK_ONLY ) { 989 if( st->silk_mode.internalSampleRate == 8000 ) { 990 curr_bandwidth = OPUS_BANDWIDTH_NARROWBAND; 991 } else if( st->silk_mode.internalSampleRate == 12000 ) { 992 curr_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND; 993 } else if( st->silk_mode.internalSampleRate == 16000 ) { 994 curr_bandwidth = OPUS_BANDWIDTH_WIDEBAND; 995 } 996 } else { 997 silk_assert( st->silk_mode.internalSampleRate == 16000 ); 998 } 999 1000 st->silk_mode.opusCanSwitch = st->silk_mode.switchReady; 1001 /* FIXME: How do we allocate the redundancy for CBR? */ 1002 if (st->silk_mode.opusCanSwitch) 1003 { 1004 redundancy = 1; 1005 celt_to_silk = 0; 1006 st->silk_bw_switch = 1; 1007 } 1008 } 1009 1010 /* CELT processing */ 1011 { 1012 int endband=21; 1013 1014 switch(curr_bandwidth) 1015 { 1016 case OPUS_BANDWIDTH_NARROWBAND: 1017 endband = 13; 1018 break; 1019 case OPUS_BANDWIDTH_MEDIUMBAND: 1020 case OPUS_BANDWIDTH_WIDEBAND: 1021 endband = 17; 1022 break; 1023 case OPUS_BANDWIDTH_SUPERWIDEBAND: 1024 endband = 19; 1025 break; 1026 case OPUS_BANDWIDTH_FULLBAND: 1027 endband = 21; 1028 break; 1029 } 1030 celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband)); 1031 celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels)); 1032 } 1033 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX)); 1034 if (st->mode != MODE_SILK_ONLY) 1035 { 1036 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0)); 1037 /* Allow prediction unless we decide to disable it later */ 1038 celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2)); 1039 1040 if (st->mode == MODE_HYBRID) 1041 { 1042 int len; 1043 1044 len = (ec_tell(&enc)+7)>>3; 1045 if (redundancy) 1046 len += st->mode == MODE_HYBRID ? 3 : 1; 1047 if( st->use_vbr ) { 1048 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs); 1049 } else { 1050 /* check if SILK used up too much */ 1051 nb_compr_bytes = len > bytes_target ? len : bytes_target; 1052 } 1053 } else { 1054 if (st->use_vbr) 1055 { 1056 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1)); 1057 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint)); 1058 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps)); 1059 nb_compr_bytes = max_data_bytes-1-redundancy_bytes; 1060 } else { 1061 nb_compr_bytes = bytes_target; 1062 } 1063 } 1064 1065 } else { 1066 nb_compr_bytes = 0; 1067 } 1068 1069 ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16); 1070 if (st->mode != MODE_SILK_ONLY && st->mode != st->prev_mode && st->prev_mode > 0) 1071 { 1072 for (i=0;i<st->channels*st->Fs/400;i++) 1073 tmp_prefill[i] = st->delay_buffer[(st->encoder_buffer-st->delay_compensation-st->Fs/400)*st->channels + i]; 1074 } 1075 1076 for (i=0;i<st->channels*(st->encoder_buffer-(frame_size+delay_compensation));i++) 1077 st->delay_buffer[i] = st->delay_buffer[i+st->channels*frame_size]; 1078 for (;i<st->encoder_buffer*st->channels;i++) 1079 st->delay_buffer[i] = pcm_buf[(frame_size+delay_compensation-st->encoder_buffer)*st->channels+i]; 1080 1081 1082 if (st->mode != MODE_HYBRID || st->stream_channels==1) 1083 st->silk_mode.stereoWidth_Q14 = 1<<14; 1084 if( st->channels == 2 ) { 1085 /* Apply stereo width reduction (at low bitrates) */ 1086 if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) { 1087 opus_val16 g1, g2; 1088 const CELTMode *celt_mode; 1089 1090 celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode)); 1091 g1 = st->hybrid_stereo_width_Q14; 1092 g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14); 1093 #ifdef FIXED_POINT 1094 g1 = g1==16384 ? Q15ONE : SHL16(g1,1); 1095 g2 = g2==16384 ? Q15ONE : SHL16(g2,1); 1096 #else 1097 g1 *= (1.f/16384); 1098 g2 *= (1.f/16384); 1099 #endif 1100 stereo_fade(pcm_buf, pcm_buf, g1, g2, celt_mode->overlap, 1101 frame_size, st->channels, celt_mode->window, st->Fs); 1102 st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14; 1103 } 1104 } 1105 1106 if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1)) 1107 { 1108 /* For SILK mode, the redundancy is inferred from the length */ 1109 if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 <= 8*nb_compr_bytes)) 1110 ec_enc_bit_logp(&enc, redundancy, 12); 1111 if (redundancy) 1112 { 1113 int max_redundancy; 1114 ec_enc_bit_logp(&enc, celt_to_silk, 1); 1115 if (st->mode == MODE_HYBRID) 1116 max_redundancy = (max_data_bytes-1)-nb_compr_bytes-1; 1117 else 1118 max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3); 1119 /* Target the same bit-rate for redundancy as for the rest, 1120 up to a max of 257 bytes */ 1121 redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600); 1122 redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes)); 1123 if (st->mode == MODE_HYBRID) 1124 ec_enc_uint(&enc, redundancy_bytes-2, 256); 1125 } 1126 } else { 1127 redundancy = 0; 1128 } 1129 1130 if (!redundancy) 1131 { 1132 st->silk_bw_switch = 0; 1133 redundancy_bytes = 0; 1134 } 1135 if (st->mode != MODE_CELT_ONLY)start_band=17; 1136 1137 if (st->mode == MODE_SILK_ONLY) 1138 { 1139 ret = (ec_tell(&enc)+7)>>3; 1140 ec_enc_done(&enc); 1141 nb_compr_bytes = ret; 1142 } else { 1143 nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes); 1144 ec_enc_shrink(&enc, nb_compr_bytes); 1145 } 1146 1147 1148 /* 5 ms redundant frame for CELT->SILK */ 1149 if (redundancy && celt_to_silk) 1150 { 1151 int err; 1152 celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0)); 1153 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0)); 1154 err = celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL); 1155 if (err < 0) 1156 { 1157 RESTORE_STACK; 1158 return OPUS_INTERNAL_ERROR; 1159 } 1160 celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng)); 1161 celt_encoder_ctl(celt_enc, OPUS_RESET_STATE); 1162 } 1163 1164 celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band)); 1165 1166 if (st->mode != MODE_SILK_ONLY) 1167 { 1168 if (st->mode != st->prev_mode && st->prev_mode > 0) 1169 { 1170 unsigned char dummy[2]; 1171 celt_encoder_ctl(celt_enc, OPUS_RESET_STATE); 1172 1173 /* Prefilling */ 1174 celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL); 1175 celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0)); 1176 } 1177 /* If false, we already busted the budget and we'll end up with a "PLC packet" */ 1178 if (ec_tell(&enc) <= 8*nb_compr_bytes) 1179 { 1180 ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc); 1181 if (ret < 0) 1182 { 1183 RESTORE_STACK; 1184 return OPUS_INTERNAL_ERROR; 1185 } 1186 } 1187 } 1188 1189 /* 5 ms redundant frame for SILK->CELT */ 1190 if (redundancy && !celt_to_silk) 1191 { 1192 int err; 1193 unsigned char dummy[2]; 1194 int N2, N4; 1195 N2 = st->Fs/200; 1196 N4 = st->Fs/400; 1197 1198 celt_encoder_ctl(celt_enc, OPUS_RESET_STATE); 1199 celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0)); 1200 celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0)); 1201 1202 /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */ 1203 celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, dummy, 2, NULL); 1204 1205 err = celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL); 1206 if (err < 0) 1207 { 1208 RESTORE_STACK; 1209 return OPUS_INTERNAL_ERROR; 1210 } 1211 celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng)); 1212 } 1213 1214 1215 1216 /* Signalling the mode in the first byte */ 1217 data--; 1218 data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels); 1219 1220 st->rangeFinal = enc.rng ^ redundant_rng; 1221 1222 if (to_celt) 1223 st->prev_mode = MODE_CELT_ONLY; 1224 else 1225 st->prev_mode = st->mode; 1226 st->prev_channels = st->stream_channels; 1227 st->prev_framesize = frame_size; 1228 1229 st->first = 0; 1230 1231 /* In the unlikely case that the SILK encoder busted its target, tell 1232 the decoder to call the PLC */ 1233 if (ec_tell(&enc) > (max_data_bytes-1)*8) 1234 { 1235 if (max_data_bytes < 2) 1236 { 1237 RESTORE_STACK; 1238 return OPUS_BUFFER_TOO_SMALL; 1239 } 1240 data[1] = 0; 1241 ret = 1; 1242 st->rangeFinal = 0; 1243 } else if (st->mode==MODE_SILK_ONLY&&!redundancy) 1244 { 1245 /*When in LPC only mode it's perfectly 1246 reasonable to strip off trailing zero bytes as 1247 the required range decoder behavior is to 1248 fill these in. This can't be done when the MDCT 1249 modes are used because the decoder needs to know 1250 the actual length for allocation purposes.*/ 1251 while(ret>2&&data[ret]==0)ret--; 1252 } 1253 /* Count ToC and redundancy */ 1254 ret += 1+redundancy_bytes; 1255 if (!st->use_vbr && ret >= 3) 1256 { 1257 if (pad_frame(data, ret, max_data_bytes)) 1258 { 1259 RESTORE_STACK; 1260 return OPUS_INTERNAL_ERROR; 1261 } 1262 ret = max_data_bytes; 1263 } 1264 RESTORE_STACK; 1265 return ret; 1266 } 1267 1268 #ifdef FIXED_POINT 1269 1270 #ifndef DISABLE_FLOAT_API 1271 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size, 1272 unsigned char *data, opus_int32 max_data_bytes) 1273 { 1274 int i, ret; 1275 VARDECL(opus_int16, in); 1276 ALLOC_STACK; 1277 1278 if(frame_size<0) 1279 { 1280 RESTORE_STACK; 1281 return OPUS_BAD_ARG; 1282 } 1283 1284 ALLOC(in, frame_size*st->channels, opus_int16); 1285 1286 for (i=0;i<frame_size*st->channels;i++) 1287 in[i] = FLOAT2INT16(pcm[i]); 1288 ret = opus_encode(st, in, frame_size, data, max_data_bytes); 1289 RESTORE_STACK; 1290 return ret; 1291 } 1292 #endif 1293 1294 #else 1295 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size, 1296 unsigned char *data, opus_int32 max_data_bytes) 1297 { 1298 int i, ret; 1299 VARDECL(float, in); 1300 ALLOC_STACK; 1301 1302 ALLOC(in, frame_size*st->channels, float); 1303 1304 for (i=0;i<frame_size*st->channels;i++) 1305 in[i] = (1.0f/32768)*pcm[i]; 1306 ret = opus_encode_float(st, in, frame_size, data, max_data_bytes); 1307 RESTORE_STACK; 1308 return ret; 1309 } 1310 #endif 1311 1312 1313 int opus_encoder_ctl(OpusEncoder *st, int request, ...) 1314 { 1315 int ret; 1316 CELTEncoder *celt_enc; 1317 va_list ap; 1318 1319 ret = OPUS_OK; 1320 va_start(ap, request); 1321 1322 celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset); 1323 1324 switch (request) 1325 { 1326 case OPUS_SET_APPLICATION_REQUEST: 1327 { 1328 opus_int32 value = va_arg(ap, opus_int32); 1329 if ( (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO 1330 && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY) 1331 || (!st->first && st->application != value)) 1332 { 1333 ret = OPUS_BAD_ARG; 1334 break; 1335 } 1336 st->application = value; 1337 } 1338 break; 1339 case OPUS_GET_APPLICATION_REQUEST: 1340 { 1341 opus_int32 *value = va_arg(ap, opus_int32*); 1342 *value = st->application; 1343 } 1344 break; 1345 case OPUS_SET_BITRATE_REQUEST: 1346 { 1347 opus_int32 value = va_arg(ap, opus_int32); 1348 if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX) 1349 { 1350 if (value <= 0) 1351 goto bad_arg; 1352 else if (value <= 500) 1353 value = 500; 1354 else if (value > (opus_int32)300000*st->channels) 1355 value = (opus_int32)300000*st->channels; 1356 } 1357 st->user_bitrate_bps = value; 1358 } 1359 break; 1360 case OPUS_GET_BITRATE_REQUEST: 1361 { 1362 opus_int32 *value = va_arg(ap, opus_int32*); 1363 *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276); 1364 } 1365 break; 1366 case OPUS_SET_FORCE_CHANNELS_REQUEST: 1367 { 1368 opus_int32 value = va_arg(ap, opus_int32); 1369 if((value<1 || value>st->channels) && value != OPUS_AUTO) 1370 return OPUS_BAD_ARG; 1371 st->force_channels = value; 1372 } 1373 break; 1374 case OPUS_GET_FORCE_CHANNELS_REQUEST: 1375 { 1376 opus_int32 *value = va_arg(ap, opus_int32*); 1377 *value = st->force_channels; 1378 } 1379 break; 1380 case OPUS_SET_MAX_BANDWIDTH_REQUEST: 1381 { 1382 opus_int32 value = va_arg(ap, opus_int32); 1383 if (value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) 1384 return OPUS_BAD_ARG; 1385 st->max_bandwidth = value; 1386 if (st->max_bandwidth == OPUS_BANDWIDTH_NARROWBAND) { 1387 st->silk_mode.maxInternalSampleRate = 8000; 1388 } else if (st->max_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) { 1389 st->silk_mode.maxInternalSampleRate = 12000; 1390 } else { 1391 st->silk_mode.maxInternalSampleRate = 16000; 1392 } 1393 } 1394 break; 1395 case OPUS_GET_MAX_BANDWIDTH_REQUEST: 1396 { 1397 opus_int32 *value = va_arg(ap, opus_int32*); 1398 *value = st->max_bandwidth; 1399 } 1400 break; 1401 case OPUS_SET_BANDWIDTH_REQUEST: 1402 { 1403 opus_int32 value = va_arg(ap, opus_int32); 1404 if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO) 1405 return OPUS_BAD_ARG; 1406 st->user_bandwidth = value; 1407 if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) { 1408 st->silk_mode.maxInternalSampleRate = 8000; 1409 } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) { 1410 st->silk_mode.maxInternalSampleRate = 12000; 1411 } else { 1412 st->silk_mode.maxInternalSampleRate = 16000; 1413 } 1414 } 1415 break; 1416 case OPUS_GET_BANDWIDTH_REQUEST: 1417 { 1418 opus_int32 *value = va_arg(ap, opus_int32*); 1419 *value = st->bandwidth; 1420 } 1421 break; 1422 case OPUS_SET_DTX_REQUEST: 1423 { 1424 opus_int32 value = va_arg(ap, opus_int32); 1425 if(value<0 || value>1) 1426 return OPUS_BAD_ARG; 1427 st->silk_mode.useDTX = value; 1428 } 1429 break; 1430 case OPUS_GET_DTX_REQUEST: 1431 { 1432 opus_int32 *value = va_arg(ap, opus_int32*); 1433 *value = st->silk_mode.useDTX; 1434 } 1435 break; 1436 case OPUS_SET_COMPLEXITY_REQUEST: 1437 { 1438 opus_int32 value = va_arg(ap, opus_int32); 1439 if(value<0 || value>10) 1440 return OPUS_BAD_ARG; 1441 st->silk_mode.complexity = value; 1442 celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value)); 1443 } 1444 break; 1445 case OPUS_GET_COMPLEXITY_REQUEST: 1446 { 1447 opus_int32 *value = va_arg(ap, opus_int32*); 1448 *value = st->silk_mode.complexity; 1449 } 1450 break; 1451 case OPUS_SET_INBAND_FEC_REQUEST: 1452 { 1453 opus_int32 value = va_arg(ap, opus_int32); 1454 if(value<0 || value>1) 1455 return OPUS_BAD_ARG; 1456 st->silk_mode.useInBandFEC = value; 1457 } 1458 break; 1459 case OPUS_GET_INBAND_FEC_REQUEST: 1460 { 1461 opus_int32 *value = va_arg(ap, opus_int32*); 1462 *value = st->silk_mode.useInBandFEC; 1463 } 1464 break; 1465 case OPUS_SET_PACKET_LOSS_PERC_REQUEST: 1466 { 1467 opus_int32 value = va_arg(ap, opus_int32); 1468 if (value < 0 || value > 100) 1469 return OPUS_BAD_ARG; 1470 st->silk_mode.packetLossPercentage = value; 1471 celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value)); 1472 } 1473 break; 1474 case OPUS_GET_PACKET_LOSS_PERC_REQUEST: 1475 { 1476 opus_int32 *value = va_arg(ap, opus_int32*); 1477 *value = st->silk_mode.packetLossPercentage; 1478 } 1479 break; 1480 case OPUS_SET_VBR_REQUEST: 1481 { 1482 opus_int32 value = va_arg(ap, opus_int32); 1483 if(value<0 || value>1) 1484 return OPUS_BAD_ARG; 1485 st->use_vbr = value; 1486 st->silk_mode.useCBR = 1-value; 1487 } 1488 break; 1489 case OPUS_GET_VBR_REQUEST: 1490 { 1491 opus_int32 *value = va_arg(ap, opus_int32*); 1492 *value = st->use_vbr; 1493 } 1494 break; 1495 case OPUS_SET_VOICE_RATIO_REQUEST: 1496 { 1497 opus_int32 value = va_arg(ap, opus_int32); 1498 if (value>100 || value<-1) 1499 goto bad_arg; 1500 st->voice_ratio = value; 1501 } 1502 break; 1503 case OPUS_GET_VOICE_RATIO_REQUEST: 1504 { 1505 opus_int32 *value = va_arg(ap, opus_int32*); 1506 *value = st->voice_ratio; 1507 } 1508 break; 1509 case OPUS_SET_VBR_CONSTRAINT_REQUEST: 1510 { 1511 opus_int32 value = va_arg(ap, opus_int32); 1512 if(value<0 || value>1) 1513 return OPUS_BAD_ARG; 1514 st->vbr_constraint = value; 1515 } 1516 break; 1517 case OPUS_GET_VBR_CONSTRAINT_REQUEST: 1518 { 1519 opus_int32 *value = va_arg(ap, opus_int32*); 1520 *value = st->vbr_constraint; 1521 } 1522 break; 1523 case OPUS_SET_SIGNAL_REQUEST: 1524 { 1525 opus_int32 value = va_arg(ap, opus_int32); 1526 if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC) 1527 return OPUS_BAD_ARG; 1528 st->signal_type = value; 1529 } 1530 break; 1531 case OPUS_GET_SIGNAL_REQUEST: 1532 { 1533 opus_int32 *value = va_arg(ap, opus_int32*); 1534 *value = st->signal_type; 1535 } 1536 break; 1537 case OPUS_GET_LOOKAHEAD_REQUEST: 1538 { 1539 opus_int32 *value = va_arg(ap, opus_int32*); 1540 *value = st->Fs/400; 1541 if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY) 1542 *value += st->delay_compensation; 1543 } 1544 break; 1545 case OPUS_GET_SAMPLE_RATE_REQUEST: 1546 { 1547 opus_int32 *value = va_arg(ap, opus_int32*); 1548 if (value==NULL) 1549 { 1550 ret = OPUS_BAD_ARG; 1551 break; 1552 } 1553 *value = st->Fs; 1554 } 1555 break; 1556 case OPUS_GET_FINAL_RANGE_REQUEST: 1557 { 1558 opus_uint32 *value = va_arg(ap, opus_uint32*); 1559 *value = st->rangeFinal; 1560 } 1561 break; 1562 case OPUS_SET_LSB_DEPTH_REQUEST: 1563 { 1564 opus_int32 value = va_arg(ap, opus_int32); 1565 ret = celt_encoder_ctl(celt_enc, OPUS_SET_LSB_DEPTH(value)); 1566 } 1567 break; 1568 case OPUS_GET_LSB_DEPTH_REQUEST: 1569 { 1570 opus_int32 *value = va_arg(ap, opus_int32*); 1571 celt_encoder_ctl(celt_enc, OPUS_GET_LSB_DEPTH(value)); 1572 } 1573 break; 1574 case OPUS_RESET_STATE: 1575 { 1576 void *silk_enc; 1577 silk_EncControlStruct dummy; 1578 silk_enc = (char*)st+st->silk_enc_offset; 1579 1580 OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START, 1581 sizeof(OpusEncoder)- 1582 ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st)); 1583 1584 celt_encoder_ctl(celt_enc, OPUS_RESET_STATE); 1585 silk_InitEncoder( silk_enc, &dummy ); 1586 st->stream_channels = st->channels; 1587 st->hybrid_stereo_width_Q14 = 1 << 14; 1588 st->first = 1; 1589 st->mode = MODE_HYBRID; 1590 st->bandwidth = OPUS_BANDWIDTH_FULLBAND; 1591 st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 ); 1592 } 1593 break; 1594 case OPUS_SET_FORCE_MODE_REQUEST: 1595 { 1596 opus_int32 value = va_arg(ap, opus_int32); 1597 if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO) 1598 goto bad_arg; 1599 st->user_forced_mode = value; 1600 } 1601 break; 1602 default: 1603 /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/ 1604 ret = OPUS_UNIMPLEMENTED; 1605 break; 1606 } 1607 va_end(ap); 1608 return ret; 1609 bad_arg: 1610 va_end(ap); 1611 return OPUS_BAD_ARG; 1612 } 1613 1614 void opus_encoder_destroy(OpusEncoder *st) 1615 { 1616 opus_free(st); 1617 } 1618
