Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 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" |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 43 | #include "cpu_support.h" |
| 44 | #include "analysis.h" |
| 45 | #include "mathops.h" |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 46 | #include "tuning_parameters.h" |
| 47 | #ifdef FIXED_POINT |
| 48 | #include "fixed/structs_FIX.h" |
| 49 | #else |
| 50 | #include "float/structs_FLP.h" |
| 51 | #endif |
| 52 | |
| 53 | #define MAX_ENCODER_BUFFER 480 |
| 54 | |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 55 | typedef struct { |
| 56 | opus_val32 XX, XY, YY; |
| 57 | opus_val16 smoothed_width; |
| 58 | opus_val16 max_follower; |
| 59 | } StereoWidthState; |
| 60 | |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 61 | struct OpusEncoder { |
| 62 | int celt_enc_offset; |
| 63 | int silk_enc_offset; |
| 64 | silk_EncControlStruct silk_mode; |
| 65 | int application; |
| 66 | int channels; |
| 67 | int delay_compensation; |
| 68 | int force_channels; |
| 69 | int signal_type; |
| 70 | int user_bandwidth; |
| 71 | int max_bandwidth; |
| 72 | int user_forced_mode; |
| 73 | int voice_ratio; |
| 74 | opus_int32 Fs; |
| 75 | int use_vbr; |
| 76 | int vbr_constraint; |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 77 | int variable_duration; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 78 | opus_int32 bitrate_bps; |
| 79 | opus_int32 user_bitrate_bps; |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 80 | int lsb_depth; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 81 | int encoder_buffer; |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 82 | int lfe; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 83 | |
| 84 | #define OPUS_ENCODER_RESET_START stream_channels |
| 85 | int stream_channels; |
| 86 | opus_int16 hybrid_stereo_width_Q14; |
| 87 | opus_int32 variable_HP_smth2_Q15; |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 88 | opus_val16 prev_HB_gain; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 89 | opus_val32 hp_mem[4]; |
| 90 | int mode; |
| 91 | int prev_mode; |
| 92 | int prev_channels; |
| 93 | int prev_framesize; |
| 94 | int bandwidth; |
| 95 | int silk_bw_switch; |
| 96 | /* Sampling rate (at the API level) */ |
| 97 | int first; |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 98 | opus_val16 * energy_masking; |
| 99 | StereoWidthState width_mem; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 100 | opus_val16 delay_buffer[MAX_ENCODER_BUFFER*2]; |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 101 | #ifndef DISABLE_FLOAT_API |
| 102 | TonalityAnalysisState analysis; |
| 103 | int detected_bandwidth; |
| 104 | int analysis_offset; |
| 105 | #endif |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 106 | opus_uint32 rangeFinal; |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 107 | int arch; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 108 | }; |
| 109 | |
| 110 | /* Transition tables for the voice and music. First column is the |
| 111 | middle (memoriless) threshold. The second column is the hysteresis |
| 112 | (difference with the middle) */ |
| 113 | static const opus_int32 mono_voice_bandwidth_thresholds[8] = { |
| 114 | 11000, 1000, /* NB<->MB */ |
| 115 | 14000, 1000, /* MB<->WB */ |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 116 | 17000, 1000, /* WB<->SWB */ |
| 117 | 21000, 2000, /* SWB<->FB */ |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 118 | }; |
| 119 | static const opus_int32 mono_music_bandwidth_thresholds[8] = { |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 120 | 12000, 1000, /* NB<->MB */ |
| 121 | 15000, 1000, /* MB<->WB */ |
| 122 | 18000, 2000, /* WB<->SWB */ |
| 123 | 22000, 2000, /* SWB<->FB */ |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 124 | }; |
| 125 | static const opus_int32 stereo_voice_bandwidth_thresholds[8] = { |
| 126 | 11000, 1000, /* NB<->MB */ |
| 127 | 14000, 1000, /* MB<->WB */ |
| 128 | 21000, 2000, /* WB<->SWB */ |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 129 | 28000, 2000, /* SWB<->FB */ |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 130 | }; |
| 131 | static const opus_int32 stereo_music_bandwidth_thresholds[8] = { |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 132 | 12000, 1000, /* NB<->MB */ |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 133 | 18000, 2000, /* MB<->WB */ |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 134 | 21000, 2000, /* WB<->SWB */ |
| 135 | 30000, 2000, /* SWB<->FB */ |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 136 | }; |
| 137 | /* Threshold bit-rates for switching between mono and stereo */ |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 138 | static const opus_int32 stereo_voice_threshold = 30000; |
| 139 | static const opus_int32 stereo_music_threshold = 30000; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 140 | |
| 141 | /* Threshold bit-rate for switching between SILK/hybrid and CELT-only */ |
| 142 | static const opus_int32 mode_thresholds[2][2] = { |
| 143 | /* voice */ /* music */ |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 144 | { 64000, 16000}, /* mono */ |
| 145 | { 36000, 16000}, /* stereo */ |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 146 | }; |
| 147 | |
| 148 | int opus_encoder_get_size(int channels) |
| 149 | { |
| 150 | int silkEncSizeBytes, celtEncSizeBytes; |
| 151 | int ret; |
| 152 | if (channels<1 || channels > 2) |
| 153 | return 0; |
| 154 | ret = silk_Get_Encoder_Size( &silkEncSizeBytes ); |
| 155 | if (ret) |
| 156 | return 0; |
| 157 | silkEncSizeBytes = align(silkEncSizeBytes); |
| 158 | celtEncSizeBytes = celt_encoder_get_size(channels); |
| 159 | return align(sizeof(OpusEncoder))+silkEncSizeBytes+celtEncSizeBytes; |
| 160 | } |
| 161 | |
| 162 | int opus_encoder_init(OpusEncoder* st, opus_int32 Fs, int channels, int application) |
| 163 | { |
| 164 | void *silk_enc; |
| 165 | CELTEncoder *celt_enc; |
| 166 | int err; |
| 167 | int ret, silkEncSizeBytes; |
| 168 | |
| 169 | if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2)|| |
| 170 | (application != OPUS_APPLICATION_VOIP && application != OPUS_APPLICATION_AUDIO |
| 171 | && application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)) |
| 172 | return OPUS_BAD_ARG; |
| 173 | |
| 174 | OPUS_CLEAR((char*)st, opus_encoder_get_size(channels)); |
| 175 | /* Create SILK encoder */ |
| 176 | ret = silk_Get_Encoder_Size( &silkEncSizeBytes ); |
| 177 | if (ret) |
| 178 | return OPUS_BAD_ARG; |
| 179 | silkEncSizeBytes = align(silkEncSizeBytes); |
| 180 | st->silk_enc_offset = align(sizeof(OpusEncoder)); |
| 181 | st->celt_enc_offset = st->silk_enc_offset+silkEncSizeBytes; |
| 182 | silk_enc = (char*)st+st->silk_enc_offset; |
| 183 | celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset); |
| 184 | |
| 185 | st->stream_channels = st->channels = channels; |
| 186 | |
| 187 | st->Fs = Fs; |
| 188 | |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 189 | st->arch = opus_select_arch(); |
| 190 | |
| 191 | ret = silk_InitEncoder( silk_enc, st->arch, &st->silk_mode ); |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 192 | if(ret)return OPUS_INTERNAL_ERROR; |
| 193 | |
| 194 | /* default SILK parameters */ |
| 195 | st->silk_mode.nChannelsAPI = channels; |
| 196 | st->silk_mode.nChannelsInternal = channels; |
| 197 | st->silk_mode.API_sampleRate = st->Fs; |
| 198 | st->silk_mode.maxInternalSampleRate = 16000; |
| 199 | st->silk_mode.minInternalSampleRate = 8000; |
| 200 | st->silk_mode.desiredInternalSampleRate = 16000; |
| 201 | st->silk_mode.payloadSize_ms = 20; |
| 202 | st->silk_mode.bitRate = 25000; |
| 203 | st->silk_mode.packetLossPercentage = 0; |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 204 | st->silk_mode.complexity = 9; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 205 | st->silk_mode.useInBandFEC = 0; |
| 206 | st->silk_mode.useDTX = 0; |
| 207 | st->silk_mode.useCBR = 0; |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 208 | st->silk_mode.reducedDependency = 0; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 209 | |
| 210 | /* Create CELT encoder */ |
| 211 | /* Initialize CELT encoder */ |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 212 | err = celt_encoder_init(celt_enc, Fs, channels, st->arch); |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 213 | if(err!=OPUS_OK)return OPUS_INTERNAL_ERROR; |
| 214 | |
| 215 | celt_encoder_ctl(celt_enc, CELT_SET_SIGNALLING(0)); |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 216 | celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(st->silk_mode.complexity)); |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 217 | |
| 218 | st->use_vbr = 1; |
| 219 | /* Makes constrained VBR the default (safer for real-time use) */ |
| 220 | st->vbr_constraint = 1; |
| 221 | st->user_bitrate_bps = OPUS_AUTO; |
| 222 | st->bitrate_bps = 3000+Fs*channels; |
| 223 | st->application = application; |
| 224 | st->signal_type = OPUS_AUTO; |
| 225 | st->user_bandwidth = OPUS_AUTO; |
| 226 | st->max_bandwidth = OPUS_BANDWIDTH_FULLBAND; |
| 227 | st->force_channels = OPUS_AUTO; |
| 228 | st->user_forced_mode = OPUS_AUTO; |
| 229 | st->voice_ratio = -1; |
| 230 | st->encoder_buffer = st->Fs/100; |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 231 | st->lsb_depth = 24; |
| 232 | st->variable_duration = OPUS_FRAMESIZE_ARG; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 233 | |
| 234 | /* Delay compensation of 4 ms (2.5 ms for SILK's extra look-ahead |
| 235 | + 1.5 ms for SILK resamplers and stereo prediction) */ |
| 236 | st->delay_compensation = st->Fs/250; |
| 237 | |
| 238 | st->hybrid_stereo_width_Q14 = 1 << 14; |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 239 | st->prev_HB_gain = Q15ONE; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 240 | st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 ); |
| 241 | st->first = 1; |
| 242 | st->mode = MODE_HYBRID; |
| 243 | st->bandwidth = OPUS_BANDWIDTH_FULLBAND; |
| 244 | |
| 245 | return OPUS_OK; |
| 246 | } |
| 247 | |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 248 | static unsigned char gen_toc(int mode, int framerate, int bandwidth, int channels) |
| 249 | { |
| 250 | int period; |
| 251 | unsigned char toc; |
| 252 | period = 0; |
| 253 | while (framerate < 400) |
| 254 | { |
| 255 | framerate <<= 1; |
| 256 | period++; |
| 257 | } |
| 258 | if (mode == MODE_SILK_ONLY) |
| 259 | { |
| 260 | toc = (bandwidth-OPUS_BANDWIDTH_NARROWBAND)<<5; |
| 261 | toc |= (period-2)<<3; |
| 262 | } else if (mode == MODE_CELT_ONLY) |
| 263 | { |
| 264 | int tmp = bandwidth-OPUS_BANDWIDTH_MEDIUMBAND; |
| 265 | if (tmp < 0) |
| 266 | tmp = 0; |
| 267 | toc = 0x80; |
| 268 | toc |= tmp << 5; |
| 269 | toc |= period<<3; |
| 270 | } else /* Hybrid */ |
| 271 | { |
| 272 | toc = 0x60; |
| 273 | toc |= (bandwidth-OPUS_BANDWIDTH_SUPERWIDEBAND)<<4; |
| 274 | toc |= (period-2)<<3; |
| 275 | } |
| 276 | toc |= (channels==2)<<2; |
| 277 | return toc; |
| 278 | } |
| 279 | |
| 280 | #ifndef FIXED_POINT |
| 281 | static void silk_biquad_float( |
| 282 | const opus_val16 *in, /* I: Input signal */ |
| 283 | const opus_int32 *B_Q28, /* I: MA coefficients [3] */ |
| 284 | const opus_int32 *A_Q28, /* I: AR coefficients [2] */ |
| 285 | opus_val32 *S, /* I/O: State vector [2] */ |
| 286 | opus_val16 *out, /* O: Output signal */ |
| 287 | const opus_int32 len, /* I: Signal length (must be even) */ |
| 288 | int stride |
| 289 | ) |
| 290 | { |
| 291 | /* DIRECT FORM II TRANSPOSED (uses 2 element state vector) */ |
| 292 | opus_int k; |
| 293 | opus_val32 vout; |
| 294 | opus_val32 inval; |
| 295 | opus_val32 A[2], B[3]; |
| 296 | |
| 297 | A[0] = (opus_val32)(A_Q28[0] * (1.f/((opus_int32)1<<28))); |
| 298 | A[1] = (opus_val32)(A_Q28[1] * (1.f/((opus_int32)1<<28))); |
| 299 | B[0] = (opus_val32)(B_Q28[0] * (1.f/((opus_int32)1<<28))); |
| 300 | B[1] = (opus_val32)(B_Q28[1] * (1.f/((opus_int32)1<<28))); |
| 301 | B[2] = (opus_val32)(B_Q28[2] * (1.f/((opus_int32)1<<28))); |
| 302 | |
| 303 | /* Negate A_Q28 values and split in two parts */ |
| 304 | |
| 305 | for( k = 0; k < len; k++ ) { |
| 306 | /* S[ 0 ], S[ 1 ]: Q12 */ |
| 307 | inval = in[ k*stride ]; |
| 308 | vout = S[ 0 ] + B[0]*inval; |
| 309 | |
| 310 | S[ 0 ] = S[1] - vout*A[0] + B[1]*inval; |
| 311 | |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 312 | S[ 1 ] = - vout*A[1] + B[2]*inval + VERY_SMALL; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 313 | |
| 314 | /* Scale back to Q0 and saturate */ |
| 315 | out[ k*stride ] = vout; |
| 316 | } |
| 317 | } |
| 318 | #endif |
| 319 | |
| 320 | 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) |
| 321 | { |
| 322 | opus_int32 B_Q28[ 3 ], A_Q28[ 2 ]; |
| 323 | opus_int32 Fc_Q19, r_Q28, r_Q22; |
| 324 | |
| 325 | silk_assert( cutoff_Hz <= silk_int32_MAX / SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ) ); |
| 326 | Fc_Q19 = silk_DIV32_16( silk_SMULBB( SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ), cutoff_Hz ), Fs/1000 ); |
| 327 | silk_assert( Fc_Q19 > 0 && Fc_Q19 < 32768 ); |
| 328 | |
| 329 | r_Q28 = SILK_FIX_CONST( 1.0, 28 ) - silk_MUL( SILK_FIX_CONST( 0.92, 9 ), Fc_Q19 ); |
| 330 | |
| 331 | /* b = r * [ 1; -2; 1 ]; */ |
| 332 | /* a = [ 1; -2 * r * ( 1 - 0.5 * Fc^2 ); r^2 ]; */ |
| 333 | B_Q28[ 0 ] = r_Q28; |
| 334 | B_Q28[ 1 ] = silk_LSHIFT( -r_Q28, 1 ); |
| 335 | B_Q28[ 2 ] = r_Q28; |
| 336 | |
| 337 | /* -r * ( 2 - Fc * Fc ); */ |
| 338 | r_Q22 = silk_RSHIFT( r_Q28, 6 ); |
| 339 | A_Q28[ 0 ] = silk_SMULWW( r_Q22, silk_SMULWW( Fc_Q19, Fc_Q19 ) - SILK_FIX_CONST( 2.0, 22 ) ); |
| 340 | A_Q28[ 1 ] = silk_SMULWW( r_Q22, r_Q22 ); |
| 341 | |
| 342 | #ifdef FIXED_POINT |
| 343 | silk_biquad_alt( in, B_Q28, A_Q28, hp_mem, out, len, channels ); |
| 344 | if( channels == 2 ) { |
| 345 | silk_biquad_alt( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels ); |
| 346 | } |
| 347 | #else |
| 348 | silk_biquad_float( in, B_Q28, A_Q28, hp_mem, out, len, channels ); |
| 349 | if( channels == 2 ) { |
| 350 | silk_biquad_float( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels ); |
| 351 | } |
| 352 | #endif |
| 353 | } |
| 354 | |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 355 | #ifdef FIXED_POINT |
| 356 | static void dc_reject(const opus_val16 *in, opus_int32 cutoff_Hz, opus_val16 *out, opus_val32 *hp_mem, int len, int channels, opus_int32 Fs) |
| 357 | { |
| 358 | int c, i; |
| 359 | int shift; |
| 360 | |
| 361 | /* Approximates -round(log2(4.*cutoff_Hz/Fs)) */ |
| 362 | shift=celt_ilog2(Fs/(cutoff_Hz*3)); |
| 363 | for (c=0;c<channels;c++) |
| 364 | { |
| 365 | for (i=0;i<len;i++) |
| 366 | { |
| 367 | opus_val32 x, tmp, y; |
| 368 | x = SHL32(EXTEND32(in[channels*i+c]), 15); |
| 369 | /* First stage */ |
| 370 | tmp = x-hp_mem[2*c]; |
| 371 | hp_mem[2*c] = hp_mem[2*c] + PSHR32(x - hp_mem[2*c], shift); |
| 372 | /* Second stage */ |
| 373 | y = tmp - hp_mem[2*c+1]; |
| 374 | hp_mem[2*c+1] = hp_mem[2*c+1] + PSHR32(tmp - hp_mem[2*c+1], shift); |
| 375 | out[channels*i+c] = EXTRACT16(SATURATE(PSHR32(y, 15), 32767)); |
| 376 | } |
| 377 | } |
| 378 | } |
| 379 | |
| 380 | #else |
| 381 | static void dc_reject(const opus_val16 *in, opus_int32 cutoff_Hz, opus_val16 *out, opus_val32 *hp_mem, int len, int channels, opus_int32 Fs) |
| 382 | { |
| 383 | int c, i; |
| 384 | float coef; |
| 385 | |
| 386 | coef = 4.0f*cutoff_Hz/Fs; |
| 387 | for (c=0;c<channels;c++) |
| 388 | { |
| 389 | for (i=0;i<len;i++) |
| 390 | { |
| 391 | opus_val32 x, tmp, y; |
| 392 | x = in[channels*i+c]; |
| 393 | /* First stage */ |
| 394 | tmp = x-hp_mem[2*c]; |
| 395 | hp_mem[2*c] = hp_mem[2*c] + coef*(x - hp_mem[2*c]) + VERY_SMALL; |
| 396 | /* Second stage */ |
| 397 | y = tmp - hp_mem[2*c+1]; |
| 398 | hp_mem[2*c+1] = hp_mem[2*c+1] + coef*(tmp - hp_mem[2*c+1]) + VERY_SMALL; |
| 399 | out[channels*i+c] = y; |
| 400 | } |
| 401 | } |
| 402 | } |
| 403 | #endif |
| 404 | |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 405 | static void stereo_fade(const opus_val16 *in, opus_val16 *out, opus_val16 g1, opus_val16 g2, |
| 406 | int overlap48, int frame_size, int channels, const opus_val16 *window, opus_int32 Fs) |
| 407 | { |
| 408 | int i; |
| 409 | int overlap; |
| 410 | int inc; |
| 411 | inc = 48000/Fs; |
| 412 | overlap=overlap48/inc; |
| 413 | g1 = Q15ONE-g1; |
| 414 | g2 = Q15ONE-g2; |
| 415 | for (i=0;i<overlap;i++) |
| 416 | { |
| 417 | opus_val32 diff; |
| 418 | opus_val16 g, w; |
| 419 | w = MULT16_16_Q15(window[i*inc], window[i*inc]); |
| 420 | g = SHR32(MAC16_16(MULT16_16(w,g2), |
| 421 | Q15ONE-w, g1), 15); |
| 422 | diff = EXTRACT16(HALF32((opus_val32)in[i*channels] - (opus_val32)in[i*channels+1])); |
| 423 | diff = MULT16_16_Q15(g, diff); |
| 424 | out[i*channels] = out[i*channels] - diff; |
| 425 | out[i*channels+1] = out[i*channels+1] + diff; |
| 426 | } |
| 427 | for (;i<frame_size;i++) |
| 428 | { |
| 429 | opus_val32 diff; |
| 430 | diff = EXTRACT16(HALF32((opus_val32)in[i*channels] - (opus_val32)in[i*channels+1])); |
| 431 | diff = MULT16_16_Q15(g2, diff); |
| 432 | out[i*channels] = out[i*channels] - diff; |
| 433 | out[i*channels+1] = out[i*channels+1] + diff; |
| 434 | } |
| 435 | } |
| 436 | |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 437 | static void gain_fade(const opus_val16 *in, opus_val16 *out, opus_val16 g1, opus_val16 g2, |
| 438 | int overlap48, int frame_size, int channels, const opus_val16 *window, opus_int32 Fs) |
| 439 | { |
| 440 | int i; |
| 441 | int inc; |
| 442 | int overlap; |
| 443 | int c; |
| 444 | inc = 48000/Fs; |
| 445 | overlap=overlap48/inc; |
| 446 | if (channels==1) |
| 447 | { |
| 448 | for (i=0;i<overlap;i++) |
| 449 | { |
| 450 | opus_val16 g, w; |
| 451 | w = MULT16_16_Q15(window[i*inc], window[i*inc]); |
| 452 | g = SHR32(MAC16_16(MULT16_16(w,g2), |
| 453 | Q15ONE-w, g1), 15); |
| 454 | out[i] = MULT16_16_Q15(g, in[i]); |
| 455 | } |
| 456 | } else { |
| 457 | for (i=0;i<overlap;i++) |
| 458 | { |
| 459 | opus_val16 g, w; |
| 460 | w = MULT16_16_Q15(window[i*inc], window[i*inc]); |
| 461 | g = SHR32(MAC16_16(MULT16_16(w,g2), |
| 462 | Q15ONE-w, g1), 15); |
| 463 | out[i*2] = MULT16_16_Q15(g, in[i*2]); |
| 464 | out[i*2+1] = MULT16_16_Q15(g, in[i*2+1]); |
| 465 | } |
| 466 | } |
| 467 | c=0;do { |
| 468 | for (i=overlap;i<frame_size;i++) |
| 469 | { |
| 470 | out[i*channels+c] = MULT16_16_Q15(g2, in[i*channels+c]); |
| 471 | } |
| 472 | } |
| 473 | while (++c<channels); |
| 474 | } |
| 475 | |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 476 | OpusEncoder *opus_encoder_create(opus_int32 Fs, int channels, int application, int *error) |
| 477 | { |
| 478 | int ret; |
| 479 | OpusEncoder *st; |
| 480 | if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2)|| |
| 481 | (application != OPUS_APPLICATION_VOIP && application != OPUS_APPLICATION_AUDIO |
| 482 | && application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)) |
| 483 | { |
| 484 | if (error) |
| 485 | *error = OPUS_BAD_ARG; |
| 486 | return NULL; |
| 487 | } |
| 488 | st = (OpusEncoder *)opus_alloc(opus_encoder_get_size(channels)); |
| 489 | if (st == NULL) |
| 490 | { |
| 491 | if (error) |
| 492 | *error = OPUS_ALLOC_FAIL; |
| 493 | return NULL; |
| 494 | } |
| 495 | ret = opus_encoder_init(st, Fs, channels, application); |
| 496 | if (error) |
| 497 | *error = ret; |
| 498 | if (ret != OPUS_OK) |
| 499 | { |
| 500 | opus_free(st); |
| 501 | st = NULL; |
| 502 | } |
| 503 | return st; |
| 504 | } |
| 505 | |
| 506 | static opus_int32 user_bitrate_to_bitrate(OpusEncoder *st, int frame_size, int max_data_bytes) |
| 507 | { |
| 508 | if(!frame_size)frame_size=st->Fs/400; |
| 509 | if (st->user_bitrate_bps==OPUS_AUTO) |
| 510 | return 60*st->Fs/frame_size + st->Fs*st->channels; |
| 511 | else if (st->user_bitrate_bps==OPUS_BITRATE_MAX) |
| 512 | return max_data_bytes*8*st->Fs/frame_size; |
| 513 | else |
| 514 | return st->user_bitrate_bps; |
| 515 | } |
| 516 | |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 517 | #ifndef DISABLE_FLOAT_API |
| 518 | /* Don't use more than 60 ms for the frame size analysis */ |
| 519 | #define MAX_DYNAMIC_FRAMESIZE 24 |
| 520 | /* Estimates how much the bitrate will be boosted based on the sub-frame energy */ |
| 521 | static float transient_boost(const float *E, const float *E_1, int LM, int maxM) |
| 522 | { |
| 523 | int i; |
| 524 | int M; |
| 525 | float sumE=0, sumE_1=0; |
| 526 | float metric; |
| 527 | |
| 528 | M = IMIN(maxM, (1<<LM)+1); |
| 529 | for (i=0;i<M;i++) |
| 530 | { |
| 531 | sumE += E[i]; |
| 532 | sumE_1 += E_1[i]; |
| 533 | } |
| 534 | metric = sumE*sumE_1/(M*M); |
| 535 | /*if (LM==3) |
| 536 | printf("%f\n", metric);*/ |
| 537 | /*return metric>10 ? 1 : 0;*/ |
| 538 | /*return MAX16(0,1-exp(-.25*(metric-2.)));*/ |
| 539 | return MIN16(1,(float)sqrt(MAX16(0,.05f*(metric-2)))); |
| 540 | } |
| 541 | |
| 542 | /* Viterbi decoding trying to find the best frame size combination using look-ahead |
| 543 | |
| 544 | State numbering: |
| 545 | 0: unused |
| 546 | 1: 2.5 ms |
| 547 | 2: 5 ms (#1) |
| 548 | 3: 5 ms (#2) |
| 549 | 4: 10 ms (#1) |
| 550 | 5: 10 ms (#2) |
| 551 | 6: 10 ms (#3) |
| 552 | 7: 10 ms (#4) |
| 553 | 8: 20 ms (#1) |
| 554 | 9: 20 ms (#2) |
| 555 | 10: 20 ms (#3) |
| 556 | 11: 20 ms (#4) |
| 557 | 12: 20 ms (#5) |
| 558 | 13: 20 ms (#6) |
| 559 | 14: 20 ms (#7) |
| 560 | 15: 20 ms (#8) |
| 561 | */ |
| 562 | static int transient_viterbi(const float *E, const float *E_1, int N, int frame_cost, int rate) |
| 563 | { |
| 564 | int i; |
| 565 | float cost[MAX_DYNAMIC_FRAMESIZE][16]; |
| 566 | int states[MAX_DYNAMIC_FRAMESIZE][16]; |
| 567 | float best_cost; |
| 568 | int best_state; |
| 569 | float factor; |
| 570 | /* Take into account that we damp VBR in the 32 kb/s to 64 kb/s range. */ |
| 571 | if (rate<80) |
| 572 | factor=0; |
| 573 | else if (rate>160) |
| 574 | factor=1; |
| 575 | else |
| 576 | factor = (rate-80.f)/80.f; |
| 577 | /* Makes variable framesize less aggressive at lower bitrates, but I can't |
| 578 | find any valid theoretical justification for this (other than it seems |
| 579 | to help) */ |
| 580 | for (i=0;i<16;i++) |
| 581 | { |
| 582 | /* Impossible state */ |
| 583 | states[0][i] = -1; |
| 584 | cost[0][i] = 1e10; |
| 585 | } |
| 586 | for (i=0;i<4;i++) |
| 587 | { |
| 588 | cost[0][1<<i] = (frame_cost + rate*(1<<i))*(1+factor*transient_boost(E, E_1, i, N+1)); |
| 589 | states[0][1<<i] = i; |
| 590 | } |
| 591 | for (i=1;i<N;i++) |
| 592 | { |
| 593 | int j; |
| 594 | |
| 595 | /* Follow continuations */ |
| 596 | for (j=2;j<16;j++) |
| 597 | { |
| 598 | cost[i][j] = cost[i-1][j-1]; |
| 599 | states[i][j] = j-1; |
| 600 | } |
| 601 | |
| 602 | /* New frames */ |
| 603 | for(j=0;j<4;j++) |
| 604 | { |
| 605 | int k; |
| 606 | float min_cost; |
| 607 | float curr_cost; |
| 608 | states[i][1<<j] = 1; |
| 609 | min_cost = cost[i-1][1]; |
| 610 | for(k=1;k<4;k++) |
| 611 | { |
| 612 | float tmp = cost[i-1][(1<<(k+1))-1]; |
| 613 | if (tmp < min_cost) |
| 614 | { |
| 615 | states[i][1<<j] = (1<<(k+1))-1; |
| 616 | min_cost = tmp; |
| 617 | } |
| 618 | } |
| 619 | curr_cost = (frame_cost + rate*(1<<j))*(1+factor*transient_boost(E+i, E_1+i, j, N-i+1)); |
| 620 | cost[i][1<<j] = min_cost; |
| 621 | /* If part of the frame is outside the analysis window, only count part of the cost */ |
| 622 | if (N-i < (1<<j)) |
| 623 | cost[i][1<<j] += curr_cost*(float)(N-i)/(1<<j); |
| 624 | else |
| 625 | cost[i][1<<j] += curr_cost; |
| 626 | } |
| 627 | } |
| 628 | |
| 629 | best_state=1; |
| 630 | best_cost = cost[N-1][1]; |
| 631 | /* Find best end state (doesn't force a frame to end at N-1) */ |
| 632 | for (i=2;i<16;i++) |
| 633 | { |
| 634 | if (cost[N-1][i]<best_cost) |
| 635 | { |
| 636 | best_cost = cost[N-1][i]; |
| 637 | best_state = i; |
| 638 | } |
| 639 | } |
| 640 | |
| 641 | /* Follow transitions back */ |
| 642 | for (i=N-1;i>=0;i--) |
| 643 | { |
| 644 | /*printf("%d ", best_state);*/ |
| 645 | best_state = states[i][best_state]; |
| 646 | } |
| 647 | /*printf("%d\n", best_state);*/ |
| 648 | return best_state; |
| 649 | } |
| 650 | |
| 651 | int optimize_framesize(const opus_val16 *x, int len, int C, opus_int32 Fs, |
| 652 | int bitrate, opus_val16 tonality, float *mem, int buffering, |
| 653 | downmix_func downmix) |
| 654 | { |
| 655 | int N; |
| 656 | int i; |
| 657 | float e[MAX_DYNAMIC_FRAMESIZE+4]; |
| 658 | float e_1[MAX_DYNAMIC_FRAMESIZE+3]; |
| 659 | opus_val32 memx; |
| 660 | int bestLM=0; |
| 661 | int subframe; |
| 662 | int pos; |
| 663 | VARDECL(opus_val32, sub); |
| 664 | |
| 665 | subframe = Fs/400; |
| 666 | ALLOC(sub, subframe, opus_val32); |
| 667 | e[0]=mem[0]; |
| 668 | e_1[0]=1.f/(EPSILON+mem[0]); |
| 669 | if (buffering) |
| 670 | { |
| 671 | /* Consider the CELT delay when not in restricted-lowdelay */ |
| 672 | /* We assume the buffering is between 2.5 and 5 ms */ |
| 673 | int offset = 2*subframe - buffering; |
| 674 | celt_assert(offset>=0 && offset <= subframe); |
| 675 | x += C*offset; |
| 676 | len -= offset; |
| 677 | e[1]=mem[1]; |
| 678 | e_1[1]=1.f/(EPSILON+mem[1]); |
| 679 | e[2]=mem[2]; |
| 680 | e_1[2]=1.f/(EPSILON+mem[2]); |
| 681 | pos = 3; |
| 682 | } else { |
| 683 | pos=1; |
| 684 | } |
| 685 | N=IMIN(len/subframe, MAX_DYNAMIC_FRAMESIZE); |
| 686 | /* Just silencing a warning, it's really initialized later */ |
| 687 | memx = 0; |
| 688 | for (i=0;i<N;i++) |
| 689 | { |
| 690 | float tmp; |
| 691 | opus_val32 tmpx; |
| 692 | int j; |
| 693 | tmp=EPSILON; |
| 694 | |
| 695 | downmix(x, sub, subframe, i*subframe, 0, -2, C); |
| 696 | if (i==0) |
| 697 | memx = sub[0]; |
| 698 | for (j=0;j<subframe;j++) |
| 699 | { |
| 700 | tmpx = sub[j]; |
| 701 | tmp += (tmpx-memx)*(float)(tmpx-memx); |
| 702 | memx = tmpx; |
| 703 | } |
| 704 | e[i+pos] = tmp; |
| 705 | e_1[i+pos] = 1.f/tmp; |
| 706 | } |
| 707 | /* Hack to get 20 ms working with APPLICATION_AUDIO |
| 708 | The real problem is that the corresponding memory needs to use 1.5 ms |
| 709 | from this frame and 1 ms from the next frame */ |
| 710 | e[i+pos] = e[i+pos-1]; |
| 711 | if (buffering) |
| 712 | N=IMIN(MAX_DYNAMIC_FRAMESIZE, N+2); |
| 713 | bestLM = transient_viterbi(e, e_1, N, (int)((1.f+.5f*tonality)*(60*C+40)), bitrate/400); |
| 714 | mem[0] = e[1<<bestLM]; |
| 715 | if (buffering) |
| 716 | { |
| 717 | mem[1] = e[(1<<bestLM)+1]; |
| 718 | mem[2] = e[(1<<bestLM)+2]; |
| 719 | } |
| 720 | return bestLM; |
| 721 | } |
| 722 | |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 723 | #endif |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 724 | |
| 725 | #ifndef DISABLE_FLOAT_API |
| 726 | #ifdef FIXED_POINT |
| 727 | #define PCM2VAL(x) FLOAT2INT16(x) |
| 728 | #else |
| 729 | #define PCM2VAL(x) SCALEIN(x) |
| 730 | #endif |
| 731 | void downmix_float(const void *_x, opus_val32 *sub, int subframe, int offset, int c1, int c2, int C) |
| 732 | { |
| 733 | const float *x; |
| 734 | opus_val32 scale; |
| 735 | int j; |
| 736 | x = (const float *)_x; |
| 737 | for (j=0;j<subframe;j++) |
| 738 | sub[j] = PCM2VAL(x[(j+offset)*C+c1]); |
| 739 | if (c2>-1) |
| 740 | { |
| 741 | for (j=0;j<subframe;j++) |
| 742 | sub[j] += PCM2VAL(x[(j+offset)*C+c2]); |
| 743 | } else if (c2==-2) |
| 744 | { |
| 745 | int c; |
| 746 | for (c=1;c<C;c++) |
| 747 | { |
| 748 | for (j=0;j<subframe;j++) |
| 749 | sub[j] += PCM2VAL(x[(j+offset)*C+c]); |
| 750 | } |
| 751 | } |
| 752 | #ifdef FIXED_POINT |
| 753 | scale = (1<<SIG_SHIFT); |
| 754 | #else |
| 755 | scale = 1.f; |
| 756 | #endif |
| 757 | if (C==-2) |
| 758 | scale /= C; |
| 759 | else |
| 760 | scale /= 2; |
| 761 | for (j=0;j<subframe;j++) |
| 762 | sub[j] *= scale; |
| 763 | } |
| 764 | #endif |
| 765 | |
| 766 | void downmix_int(const void *_x, opus_val32 *sub, int subframe, int offset, int c1, int c2, int C) |
| 767 | { |
| 768 | const opus_int16 *x; |
| 769 | opus_val32 scale; |
| 770 | int j; |
| 771 | x = (const opus_int16 *)_x; |
| 772 | for (j=0;j<subframe;j++) |
| 773 | sub[j] = x[(j+offset)*C+c1]; |
| 774 | if (c2>-1) |
| 775 | { |
| 776 | for (j=0;j<subframe;j++) |
| 777 | sub[j] += x[(j+offset)*C+c2]; |
| 778 | } else if (c2==-2) |
| 779 | { |
| 780 | int c; |
| 781 | for (c=1;c<C;c++) |
| 782 | { |
| 783 | for (j=0;j<subframe;j++) |
| 784 | sub[j] += x[(j+offset)*C+c]; |
| 785 | } |
| 786 | } |
| 787 | #ifdef FIXED_POINT |
| 788 | scale = (1<<SIG_SHIFT); |
| 789 | #else |
| 790 | scale = 1.f/32768; |
| 791 | #endif |
| 792 | if (C==-2) |
| 793 | scale /= C; |
| 794 | else |
| 795 | scale /= 2; |
| 796 | for (j=0;j<subframe;j++) |
| 797 | sub[j] *= scale; |
| 798 | } |
| 799 | |
| 800 | opus_int32 frame_size_select(opus_int32 frame_size, int variable_duration, opus_int32 Fs) |
| 801 | { |
| 802 | int new_size; |
| 803 | if (frame_size<Fs/400) |
| 804 | return -1; |
| 805 | if (variable_duration == OPUS_FRAMESIZE_ARG) |
| 806 | new_size = frame_size; |
| 807 | else if (variable_duration == OPUS_FRAMESIZE_VARIABLE) |
| 808 | new_size = Fs/50; |
| 809 | else if (variable_duration >= OPUS_FRAMESIZE_2_5_MS && variable_duration <= OPUS_FRAMESIZE_60_MS) |
| 810 | new_size = IMIN(3*Fs/50, (Fs/400)<<(variable_duration-OPUS_FRAMESIZE_2_5_MS)); |
| 811 | else |
| 812 | return -1; |
| 813 | if (new_size>frame_size) |
| 814 | return -1; |
| 815 | if (400*new_size!=Fs && 200*new_size!=Fs && 100*new_size!=Fs && |
| 816 | 50*new_size!=Fs && 25*new_size!=Fs && 50*new_size!=3*Fs) |
| 817 | return -1; |
| 818 | return new_size; |
| 819 | } |
| 820 | |
| 821 | opus_int32 compute_frame_size(const void *analysis_pcm, int frame_size, |
| 822 | int variable_duration, int C, opus_int32 Fs, int bitrate_bps, |
| 823 | int delay_compensation, downmix_func downmix |
| 824 | #ifndef DISABLE_FLOAT_API |
| 825 | , float *subframe_mem |
| 826 | #endif |
| 827 | ) |
| 828 | { |
| 829 | #ifndef DISABLE_FLOAT_API |
| 830 | if (variable_duration == OPUS_FRAMESIZE_VARIABLE && frame_size >= Fs/200) |
| 831 | { |
| 832 | int LM = 3; |
| 833 | LM = optimize_framesize(analysis_pcm, frame_size, C, Fs, bitrate_bps, |
| 834 | 0, subframe_mem, delay_compensation, downmix); |
| 835 | while ((Fs/400<<LM)>frame_size) |
| 836 | LM--; |
| 837 | frame_size = (Fs/400<<LM); |
| 838 | } else |
| 839 | #endif |
| 840 | { |
| 841 | frame_size = frame_size_select(frame_size, variable_duration, Fs); |
| 842 | } |
| 843 | if (frame_size<0) |
| 844 | return -1; |
| 845 | return frame_size; |
| 846 | } |
| 847 | |
| 848 | opus_val16 compute_stereo_width(const opus_val16 *pcm, int frame_size, opus_int32 Fs, StereoWidthState *mem) |
| 849 | { |
| 850 | opus_val16 corr; |
| 851 | opus_val16 ldiff; |
| 852 | opus_val16 width; |
| 853 | opus_val32 xx, xy, yy; |
| 854 | opus_val16 sqrt_xx, sqrt_yy; |
| 855 | opus_val16 qrrt_xx, qrrt_yy; |
| 856 | int frame_rate; |
| 857 | int i; |
| 858 | opus_val16 short_alpha; |
| 859 | |
| 860 | frame_rate = Fs/frame_size; |
| 861 | short_alpha = Q15ONE - 25*Q15ONE/IMAX(50,frame_rate); |
| 862 | xx=xy=yy=0; |
| 863 | for (i=0;i<frame_size;i+=4) |
| 864 | { |
| 865 | opus_val32 pxx=0; |
| 866 | opus_val32 pxy=0; |
| 867 | opus_val32 pyy=0; |
| 868 | opus_val16 x, y; |
| 869 | x = pcm[2*i]; |
| 870 | y = pcm[2*i+1]; |
| 871 | pxx = SHR32(MULT16_16(x,x),2); |
| 872 | pxy = SHR32(MULT16_16(x,y),2); |
| 873 | pyy = SHR32(MULT16_16(y,y),2); |
| 874 | x = pcm[2*i+2]; |
| 875 | y = pcm[2*i+3]; |
| 876 | pxx += SHR32(MULT16_16(x,x),2); |
| 877 | pxy += SHR32(MULT16_16(x,y),2); |
| 878 | pyy += SHR32(MULT16_16(y,y),2); |
| 879 | x = pcm[2*i+4]; |
| 880 | y = pcm[2*i+5]; |
| 881 | pxx += SHR32(MULT16_16(x,x),2); |
| 882 | pxy += SHR32(MULT16_16(x,y),2); |
| 883 | pyy += SHR32(MULT16_16(y,y),2); |
| 884 | x = pcm[2*i+6]; |
| 885 | y = pcm[2*i+7]; |
| 886 | pxx += SHR32(MULT16_16(x,x),2); |
| 887 | pxy += SHR32(MULT16_16(x,y),2); |
| 888 | pyy += SHR32(MULT16_16(y,y),2); |
| 889 | |
| 890 | xx += SHR32(pxx, 10); |
| 891 | xy += SHR32(pxy, 10); |
| 892 | yy += SHR32(pyy, 10); |
| 893 | } |
| 894 | mem->XX += MULT16_32_Q15(short_alpha, xx-mem->XX); |
| 895 | mem->XY += MULT16_32_Q15(short_alpha, xy-mem->XY); |
| 896 | mem->YY += MULT16_32_Q15(short_alpha, yy-mem->YY); |
| 897 | mem->XX = MAX32(0, mem->XX); |
| 898 | mem->XY = MAX32(0, mem->XY); |
| 899 | mem->YY = MAX32(0, mem->YY); |
| 900 | if (MAX32(mem->XX, mem->YY)>QCONST16(8e-4f, 18)) |
| 901 | { |
| 902 | sqrt_xx = celt_sqrt(mem->XX); |
| 903 | sqrt_yy = celt_sqrt(mem->YY); |
| 904 | qrrt_xx = celt_sqrt(sqrt_xx); |
| 905 | qrrt_yy = celt_sqrt(sqrt_yy); |
| 906 | /* Inter-channel correlation */ |
| 907 | mem->XY = MIN32(mem->XY, sqrt_xx*sqrt_yy); |
| 908 | corr = SHR32(frac_div32(mem->XY,EPSILON+MULT16_16(sqrt_xx,sqrt_yy)),16); |
| 909 | /* Approximate loudness difference */ |
| 910 | ldiff = Q15ONE*ABS16(qrrt_xx-qrrt_yy)/(EPSILON+qrrt_xx+qrrt_yy); |
| 911 | width = MULT16_16_Q15(celt_sqrt(QCONST32(1.f,30)-MULT16_16(corr,corr)), ldiff); |
| 912 | /* Smoothing over one second */ |
| 913 | mem->smoothed_width += (width-mem->smoothed_width)/frame_rate; |
| 914 | /* Peak follower */ |
| 915 | mem->max_follower = MAX16(mem->max_follower-QCONST16(.02f,15)/frame_rate, mem->smoothed_width); |
| 916 | } else { |
| 917 | width = 0; |
| 918 | corr=Q15ONE; |
| 919 | ldiff=0; |
| 920 | } |
| 921 | /*printf("%f %f %f %f %f ", corr/(float)Q15ONE, ldiff/(float)Q15ONE, width/(float)Q15ONE, mem->smoothed_width/(float)Q15ONE, mem->max_follower/(float)Q15ONE);*/ |
| 922 | return EXTRACT16(MIN32(Q15ONE,20*mem->max_follower)); |
| 923 | } |
| 924 | |
| 925 | opus_int32 opus_encode_native(OpusEncoder *st, const opus_val16 *pcm, int frame_size, |
| 926 | unsigned char *data, opus_int32 out_data_bytes, int lsb_depth, |
| 927 | const void *analysis_pcm, opus_int32 analysis_size, int c1, int c2, int analysis_channels, downmix_func downmix) |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 928 | { |
| 929 | void *silk_enc; |
| 930 | CELTEncoder *celt_enc; |
| 931 | int i; |
| 932 | int ret=0; |
| 933 | opus_int32 nBytes; |
| 934 | ec_enc enc; |
| 935 | int bytes_target; |
| 936 | int prefill=0; |
| 937 | int start_band = 0; |
| 938 | int redundancy = 0; |
| 939 | int redundancy_bytes = 0; /* Number of bytes to use for redundancy frame */ |
| 940 | int celt_to_silk = 0; |
| 941 | VARDECL(opus_val16, pcm_buf); |
| 942 | int nb_compr_bytes; |
| 943 | int to_celt = 0; |
| 944 | opus_uint32 redundant_rng = 0; |
| 945 | int cutoff_Hz, hp_freq_smth1; |
| 946 | int voice_est; /* Probability of voice in Q7 */ |
| 947 | opus_int32 equiv_rate; |
| 948 | int delay_compensation; |
| 949 | int frame_rate; |
| 950 | opus_int32 max_rate; /* Max bitrate we're allowed to use */ |
| 951 | int curr_bandwidth; |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 952 | opus_val16 HB_gain; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 953 | opus_int32 max_data_bytes; /* Max number of bytes we're allowed to use */ |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 954 | int total_buffer; |
| 955 | opus_val16 stereo_width; |
| 956 | const CELTMode *celt_mode; |
| 957 | AnalysisInfo analysis_info; |
| 958 | int analysis_read_pos_bak=-1; |
| 959 | int analysis_read_subframe_bak=-1; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 960 | VARDECL(opus_val16, tmp_prefill); |
| 961 | |
| 962 | ALLOC_STACK; |
| 963 | |
| 964 | max_data_bytes = IMIN(1276, out_data_bytes); |
| 965 | |
| 966 | st->rangeFinal = 0; |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 967 | if ((!st->variable_duration && 400*frame_size != st->Fs && 200*frame_size != st->Fs && 100*frame_size != st->Fs && |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 968 | 50*frame_size != st->Fs && 25*frame_size != st->Fs && 50*frame_size != 3*st->Fs) |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 969 | || (400*frame_size < st->Fs) |
| 970 | || max_data_bytes<=0 |
| 971 | ) |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 972 | { |
| 973 | RESTORE_STACK; |
| 974 | return OPUS_BAD_ARG; |
| 975 | } |
| 976 | silk_enc = (char*)st+st->silk_enc_offset; |
| 977 | celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset); |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 978 | if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY) |
| 979 | delay_compensation = 0; |
| 980 | else |
| 981 | delay_compensation = st->delay_compensation; |
| 982 | |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 983 | lsb_depth = IMIN(lsb_depth, st->lsb_depth); |
| 984 | |
| 985 | analysis_info.valid = 0; |
| 986 | celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode)); |
| 987 | #ifndef DISABLE_FLOAT_API |
| 988 | #ifdef FIXED_POINT |
| 989 | if (st->silk_mode.complexity >= 10 && st->Fs==48000) |
| 990 | #else |
| 991 | if (st->silk_mode.complexity >= 7 && st->Fs==48000) |
| 992 | #endif |
| 993 | { |
| 994 | analysis_read_pos_bak = st->analysis.read_pos; |
| 995 | analysis_read_subframe_bak = st->analysis.read_subframe; |
| 996 | run_analysis(&st->analysis, celt_mode, analysis_pcm, analysis_size, frame_size, |
| 997 | c1, c2, analysis_channels, st->Fs, |
| 998 | lsb_depth, downmix, &analysis_info); |
| 999 | } |
| 1000 | #endif |
| 1001 | |
| 1002 | st->voice_ratio = -1; |
| 1003 | |
| 1004 | #ifndef DISABLE_FLOAT_API |
| 1005 | st->detected_bandwidth = 0; |
| 1006 | if (analysis_info.valid) |
| 1007 | { |
| 1008 | int analysis_bandwidth; |
| 1009 | if (st->signal_type == OPUS_AUTO) |
| 1010 | st->voice_ratio = (int)floor(.5+100*(1-analysis_info.music_prob)); |
| 1011 | |
| 1012 | analysis_bandwidth = analysis_info.bandwidth; |
| 1013 | if (analysis_bandwidth<=12) |
| 1014 | st->detected_bandwidth = OPUS_BANDWIDTH_NARROWBAND; |
| 1015 | else if (analysis_bandwidth<=14) |
| 1016 | st->detected_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND; |
| 1017 | else if (analysis_bandwidth<=16) |
| 1018 | st->detected_bandwidth = OPUS_BANDWIDTH_WIDEBAND; |
| 1019 | else if (analysis_bandwidth<=18) |
| 1020 | st->detected_bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND; |
| 1021 | else |
| 1022 | st->detected_bandwidth = OPUS_BANDWIDTH_FULLBAND; |
| 1023 | } |
| 1024 | #endif |
| 1025 | |
| 1026 | if (st->channels==2 && st->force_channels!=1) |
| 1027 | stereo_width = compute_stereo_width(pcm, frame_size, st->Fs, &st->width_mem); |
| 1028 | else |
| 1029 | stereo_width = 0; |
| 1030 | total_buffer = delay_compensation; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1031 | st->bitrate_bps = user_bitrate_to_bitrate(st, frame_size, max_data_bytes); |
| 1032 | |
| 1033 | frame_rate = st->Fs/frame_size; |
| 1034 | if (max_data_bytes<3 || st->bitrate_bps < 3*frame_rate*8 |
| 1035 | || (frame_rate<50 && (max_data_bytes*frame_rate<300 || st->bitrate_bps < 2400))) |
| 1036 | { |
| 1037 | /*If the space is too low to do something useful, emit 'PLC' frames.*/ |
| 1038 | int tocmode = st->mode; |
| 1039 | int bw = st->bandwidth == 0 ? OPUS_BANDWIDTH_NARROWBAND : st->bandwidth; |
| 1040 | if (tocmode==0) |
| 1041 | tocmode = MODE_SILK_ONLY; |
| 1042 | if (frame_rate>100) |
| 1043 | tocmode = MODE_CELT_ONLY; |
| 1044 | if (frame_rate < 50) |
| 1045 | tocmode = MODE_SILK_ONLY; |
| 1046 | if(tocmode==MODE_SILK_ONLY&&bw>OPUS_BANDWIDTH_WIDEBAND) |
| 1047 | bw=OPUS_BANDWIDTH_WIDEBAND; |
| 1048 | else if (tocmode==MODE_CELT_ONLY&&bw==OPUS_BANDWIDTH_MEDIUMBAND) |
| 1049 | bw=OPUS_BANDWIDTH_NARROWBAND; |
| 1050 | else if (bw<=OPUS_BANDWIDTH_SUPERWIDEBAND) |
| 1051 | bw=OPUS_BANDWIDTH_SUPERWIDEBAND; |
| 1052 | data[0] = gen_toc(tocmode, frame_rate, bw, st->stream_channels); |
| 1053 | RESTORE_STACK; |
| 1054 | return 1; |
| 1055 | } |
| 1056 | if (!st->use_vbr) |
| 1057 | { |
| 1058 | int cbrBytes; |
| 1059 | cbrBytes = IMIN( (st->bitrate_bps + 4*frame_rate)/(8*frame_rate) , max_data_bytes); |
| 1060 | st->bitrate_bps = cbrBytes * (8*frame_rate); |
| 1061 | max_data_bytes = cbrBytes; |
| 1062 | } |
| 1063 | max_rate = frame_rate*max_data_bytes*8; |
| 1064 | |
| 1065 | /* Equivalent 20-ms rate for mode/channel/bandwidth decisions */ |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1066 | equiv_rate = st->bitrate_bps - (40*st->channels+20)*(st->Fs/frame_size - 50); |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1067 | |
| 1068 | if (st->signal_type == OPUS_SIGNAL_VOICE) |
| 1069 | voice_est = 127; |
| 1070 | else if (st->signal_type == OPUS_SIGNAL_MUSIC) |
| 1071 | voice_est = 0; |
| 1072 | else if (st->voice_ratio >= 0) |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1073 | { |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1074 | voice_est = st->voice_ratio*327>>8; |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1075 | /* For AUDIO, never be more than 90% confident of having speech */ |
| 1076 | if (st->application == OPUS_APPLICATION_AUDIO) |
| 1077 | voice_est = IMIN(voice_est, 115); |
| 1078 | } else if (st->application == OPUS_APPLICATION_VOIP) |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1079 | voice_est = 115; |
| 1080 | else |
| 1081 | voice_est = 48; |
| 1082 | |
| 1083 | if (st->force_channels!=OPUS_AUTO && st->channels == 2) |
| 1084 | { |
| 1085 | st->stream_channels = st->force_channels; |
| 1086 | } else { |
| 1087 | #ifdef FUZZING |
| 1088 | /* Random mono/stereo decision */ |
| 1089 | if (st->channels == 2 && (rand()&0x1F)==0) |
| 1090 | st->stream_channels = 3-st->stream_channels; |
| 1091 | #else |
| 1092 | /* Rate-dependent mono-stereo decision */ |
| 1093 | if (st->channels == 2) |
| 1094 | { |
| 1095 | opus_int32 stereo_threshold; |
| 1096 | stereo_threshold = stereo_music_threshold + ((voice_est*voice_est*(stereo_voice_threshold-stereo_music_threshold))>>14); |
| 1097 | if (st->stream_channels == 2) |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1098 | stereo_threshold -= 1000; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1099 | else |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1100 | stereo_threshold += 1000; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1101 | st->stream_channels = (equiv_rate > stereo_threshold) ? 2 : 1; |
| 1102 | } else { |
| 1103 | st->stream_channels = st->channels; |
| 1104 | } |
| 1105 | #endif |
| 1106 | } |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1107 | equiv_rate = st->bitrate_bps - (40*st->stream_channels+20)*(st->Fs/frame_size - 50); |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1108 | |
| 1109 | /* Mode selection depending on application and signal type */ |
| 1110 | if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY) |
| 1111 | { |
| 1112 | st->mode = MODE_CELT_ONLY; |
| 1113 | } else if (st->user_forced_mode == OPUS_AUTO) |
| 1114 | { |
| 1115 | #ifdef FUZZING |
| 1116 | /* Random mode switching */ |
| 1117 | if ((rand()&0xF)==0) |
| 1118 | { |
| 1119 | if ((rand()&0x1)==0) |
| 1120 | st->mode = MODE_CELT_ONLY; |
| 1121 | else |
| 1122 | st->mode = MODE_SILK_ONLY; |
| 1123 | } else { |
| 1124 | if (st->prev_mode==MODE_CELT_ONLY) |
| 1125 | st->mode = MODE_CELT_ONLY; |
| 1126 | else |
| 1127 | st->mode = MODE_SILK_ONLY; |
| 1128 | } |
| 1129 | #else |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1130 | opus_int32 mode_voice, mode_music; |
| 1131 | opus_int32 threshold; |
| 1132 | |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1133 | /* Interpolate based on stereo width */ |
| 1134 | mode_voice = (opus_int32)(MULT16_32_Q15(Q15ONE-stereo_width,mode_thresholds[0][0]) |
| 1135 | + MULT16_32_Q15(stereo_width,mode_thresholds[1][0])); |
| 1136 | mode_music = (opus_int32)(MULT16_32_Q15(Q15ONE-stereo_width,mode_thresholds[1][1]) |
| 1137 | + MULT16_32_Q15(stereo_width,mode_thresholds[1][1])); |
| 1138 | /* Interpolate based on speech/music probability */ |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1139 | threshold = mode_music + ((voice_est*voice_est*(mode_voice-mode_music))>>14); |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1140 | /* Bias towards SILK for VoIP because of some useful features */ |
| 1141 | if (st->application == OPUS_APPLICATION_VOIP) |
| 1142 | threshold += 8000; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1143 | |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1144 | /*printf("%f %d\n", stereo_width/(float)Q15ONE, threshold);*/ |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1145 | /* Hysteresis */ |
| 1146 | if (st->prev_mode == MODE_CELT_ONLY) |
| 1147 | threshold -= 4000; |
| 1148 | else if (st->prev_mode>0) |
| 1149 | threshold += 4000; |
| 1150 | |
| 1151 | st->mode = (equiv_rate >= threshold) ? MODE_CELT_ONLY: MODE_SILK_ONLY; |
| 1152 | |
| 1153 | /* When FEC is enabled and there's enough packet loss, use SILK */ |
| 1154 | if (st->silk_mode.useInBandFEC && st->silk_mode.packetLossPercentage > (128-voice_est)>>4) |
| 1155 | st->mode = MODE_SILK_ONLY; |
| 1156 | /* When encoding voice and DTX is enabled, set the encoder to SILK mode (at least for now) */ |
| 1157 | if (st->silk_mode.useDTX && voice_est > 100) |
| 1158 | st->mode = MODE_SILK_ONLY; |
| 1159 | #endif |
| 1160 | } else { |
| 1161 | st->mode = st->user_forced_mode; |
| 1162 | } |
| 1163 | |
| 1164 | /* Override the chosen mode to make sure we meet the requested frame size */ |
| 1165 | if (st->mode != MODE_CELT_ONLY && frame_size < st->Fs/100) |
| 1166 | st->mode = MODE_CELT_ONLY; |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1167 | if (st->lfe) |
| 1168 | st->mode = MODE_CELT_ONLY; |
| 1169 | /* If max_data_bytes represents less than 8 kb/s, switch to CELT-only mode */ |
| 1170 | if (max_data_bytes < (frame_rate > 50 ? 12000 : 8000)*frame_size / (st->Fs * 8)) |
| 1171 | st->mode = MODE_CELT_ONLY; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1172 | |
| 1173 | if (st->stream_channels == 1 && st->prev_channels ==2 && st->silk_mode.toMono==0 |
| 1174 | && st->mode != MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY) |
| 1175 | { |
| 1176 | /* Delay stereo->mono transition by two frames so that SILK can do a smooth downmix */ |
| 1177 | st->silk_mode.toMono = 1; |
| 1178 | st->stream_channels = 2; |
| 1179 | } else { |
| 1180 | st->silk_mode.toMono = 0; |
| 1181 | } |
| 1182 | |
| 1183 | if (st->prev_mode > 0 && |
| 1184 | ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) || |
| 1185 | (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY))) |
| 1186 | { |
| 1187 | redundancy = 1; |
| 1188 | celt_to_silk = (st->mode != MODE_CELT_ONLY); |
| 1189 | if (!celt_to_silk) |
| 1190 | { |
| 1191 | /* Switch to SILK/hybrid if frame size is 10 ms or more*/ |
| 1192 | if (frame_size >= st->Fs/100) |
| 1193 | { |
| 1194 | st->mode = st->prev_mode; |
| 1195 | to_celt = 1; |
| 1196 | } else { |
| 1197 | redundancy=0; |
| 1198 | } |
| 1199 | } |
| 1200 | } |
| 1201 | /* For the first frame at a new SILK bandwidth */ |
| 1202 | if (st->silk_bw_switch) |
| 1203 | { |
| 1204 | redundancy = 1; |
| 1205 | celt_to_silk = 1; |
| 1206 | st->silk_bw_switch = 0; |
| 1207 | prefill=1; |
| 1208 | } |
| 1209 | |
| 1210 | if (redundancy) |
| 1211 | { |
| 1212 | /* Fair share of the max size allowed */ |
| 1213 | redundancy_bytes = IMIN(257, max_data_bytes*(opus_int32)(st->Fs/200)/(frame_size+st->Fs/200)); |
| 1214 | /* For VBR, target the actual bitrate (subject to the limit above) */ |
| 1215 | if (st->use_vbr) |
| 1216 | redundancy_bytes = IMIN(redundancy_bytes, st->bitrate_bps/1600); |
| 1217 | } |
| 1218 | |
| 1219 | if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) |
| 1220 | { |
| 1221 | silk_EncControlStruct dummy; |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1222 | silk_InitEncoder( silk_enc, st->arch, &dummy); |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1223 | prefill=1; |
| 1224 | } |
| 1225 | |
| 1226 | /* Automatic (rate-dependent) bandwidth selection */ |
| 1227 | if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch) |
| 1228 | { |
| 1229 | const opus_int32 *voice_bandwidth_thresholds, *music_bandwidth_thresholds; |
| 1230 | opus_int32 bandwidth_thresholds[8]; |
| 1231 | int bandwidth = OPUS_BANDWIDTH_FULLBAND; |
| 1232 | opus_int32 equiv_rate2; |
| 1233 | |
| 1234 | equiv_rate2 = equiv_rate; |
| 1235 | if (st->mode != MODE_CELT_ONLY) |
| 1236 | { |
| 1237 | /* Adjust the threshold +/- 10% depending on complexity */ |
| 1238 | equiv_rate2 = equiv_rate2 * (45+st->silk_mode.complexity)/50; |
| 1239 | /* CBR is less efficient by ~1 kb/s */ |
| 1240 | if (!st->use_vbr) |
| 1241 | equiv_rate2 -= 1000; |
| 1242 | } |
| 1243 | if (st->channels==2 && st->force_channels!=1) |
| 1244 | { |
| 1245 | voice_bandwidth_thresholds = stereo_voice_bandwidth_thresholds; |
| 1246 | music_bandwidth_thresholds = stereo_music_bandwidth_thresholds; |
| 1247 | } else { |
| 1248 | voice_bandwidth_thresholds = mono_voice_bandwidth_thresholds; |
| 1249 | music_bandwidth_thresholds = mono_music_bandwidth_thresholds; |
| 1250 | } |
| 1251 | /* Interpolate bandwidth thresholds depending on voice estimation */ |
| 1252 | for (i=0;i<8;i++) |
| 1253 | { |
| 1254 | bandwidth_thresholds[i] = music_bandwidth_thresholds[i] |
| 1255 | + ((voice_est*voice_est*(voice_bandwidth_thresholds[i]-music_bandwidth_thresholds[i]))>>14); |
| 1256 | } |
| 1257 | do { |
| 1258 | int threshold, hysteresis; |
| 1259 | threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)]; |
| 1260 | hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)+1]; |
| 1261 | if (!st->first) |
| 1262 | { |
| 1263 | if (st->bandwidth >= bandwidth) |
| 1264 | threshold -= hysteresis; |
| 1265 | else |
| 1266 | threshold += hysteresis; |
| 1267 | } |
| 1268 | if (equiv_rate2 >= threshold) |
| 1269 | break; |
| 1270 | } while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND); |
| 1271 | st->bandwidth = bandwidth; |
| 1272 | /* Prevents any transition to SWB/FB until the SILK layer has fully |
| 1273 | switched to WB mode and turned the variable LP filter off */ |
| 1274 | if (!st->first && st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND) |
| 1275 | st->bandwidth = OPUS_BANDWIDTH_WIDEBAND; |
| 1276 | } |
| 1277 | |
| 1278 | if (st->bandwidth>st->max_bandwidth) |
| 1279 | st->bandwidth = st->max_bandwidth; |
| 1280 | |
| 1281 | if (st->user_bandwidth != OPUS_AUTO) |
| 1282 | st->bandwidth = st->user_bandwidth; |
| 1283 | |
| 1284 | /* This prevents us from using hybrid at unsafe CBR/max rates */ |
| 1285 | if (st->mode != MODE_CELT_ONLY && max_rate < 15000) |
| 1286 | { |
| 1287 | st->bandwidth = IMIN(st->bandwidth, OPUS_BANDWIDTH_WIDEBAND); |
| 1288 | } |
| 1289 | |
| 1290 | /* Prevents Opus from wasting bits on frequencies that are above |
| 1291 | the Nyquist rate of the input signal */ |
| 1292 | if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND) |
| 1293 | st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND; |
| 1294 | if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND) |
| 1295 | st->bandwidth = OPUS_BANDWIDTH_WIDEBAND; |
| 1296 | if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND) |
| 1297 | st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND; |
| 1298 | if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND) |
| 1299 | st->bandwidth = OPUS_BANDWIDTH_NARROWBAND; |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1300 | #ifndef DISABLE_FLOAT_API |
| 1301 | /* Use detected bandwidth to reduce the encoded bandwidth. */ |
| 1302 | if (st->detected_bandwidth && st->user_bandwidth == OPUS_AUTO) |
| 1303 | { |
| 1304 | int min_detected_bandwidth; |
| 1305 | /* Makes bandwidth detection more conservative just in case the detector |
| 1306 | gets it wrong when we could have coded a high bandwidth transparently. |
| 1307 | When operating in SILK/hybrid mode, we don't go below wideband to avoid |
| 1308 | more complicated switches that require redundancy. */ |
| 1309 | if (equiv_rate <= 18000*st->stream_channels && st->mode == MODE_CELT_ONLY) |
| 1310 | min_detected_bandwidth = OPUS_BANDWIDTH_NARROWBAND; |
| 1311 | else if (equiv_rate <= 24000*st->stream_channels && st->mode == MODE_CELT_ONLY) |
| 1312 | min_detected_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND; |
| 1313 | else if (equiv_rate <= 30000*st->stream_channels) |
| 1314 | min_detected_bandwidth = OPUS_BANDWIDTH_WIDEBAND; |
| 1315 | else if (equiv_rate <= 44000*st->stream_channels) |
| 1316 | min_detected_bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND; |
| 1317 | else |
| 1318 | min_detected_bandwidth = OPUS_BANDWIDTH_FULLBAND; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1319 | |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1320 | st->detected_bandwidth = IMAX(st->detected_bandwidth, min_detected_bandwidth); |
| 1321 | st->bandwidth = IMIN(st->bandwidth, st->detected_bandwidth); |
| 1322 | } |
| 1323 | #endif |
| 1324 | celt_encoder_ctl(celt_enc, OPUS_SET_LSB_DEPTH(lsb_depth)); |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1325 | |
| 1326 | /* CELT mode doesn't support mediumband, use wideband instead */ |
| 1327 | if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) |
| 1328 | st->bandwidth = OPUS_BANDWIDTH_WIDEBAND; |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1329 | if (st->lfe) |
| 1330 | st->bandwidth = OPUS_BANDWIDTH_NARROWBAND; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1331 | |
| 1332 | /* Can't support higher than wideband for >20 ms frames */ |
| 1333 | if (frame_size > st->Fs/50 && (st->mode == MODE_CELT_ONLY || st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)) |
| 1334 | { |
| 1335 | VARDECL(unsigned char, tmp_data); |
| 1336 | int nb_frames; |
| 1337 | int bak_mode, bak_bandwidth, bak_channels, bak_to_mono; |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1338 | VARDECL(OpusRepacketizer, rp); |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1339 | opus_int32 bytes_per_frame; |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1340 | opus_int32 repacketize_len; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1341 | |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1342 | #ifndef DISABLE_FLOAT_API |
| 1343 | if (analysis_read_pos_bak!= -1) |
| 1344 | { |
| 1345 | st->analysis.read_pos = analysis_read_pos_bak; |
| 1346 | st->analysis.read_subframe = analysis_read_subframe_bak; |
| 1347 | } |
| 1348 | #endif |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1349 | |
| 1350 | nb_frames = frame_size > st->Fs/25 ? 3 : 2; |
| 1351 | bytes_per_frame = IMIN(1276,(out_data_bytes-3)/nb_frames); |
| 1352 | |
| 1353 | ALLOC(tmp_data, nb_frames*bytes_per_frame, unsigned char); |
| 1354 | |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1355 | ALLOC(rp, 1, OpusRepacketizer); |
| 1356 | opus_repacketizer_init(rp); |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1357 | |
| 1358 | bak_mode = st->user_forced_mode; |
| 1359 | bak_bandwidth = st->user_bandwidth; |
| 1360 | bak_channels = st->force_channels; |
| 1361 | |
| 1362 | st->user_forced_mode = st->mode; |
| 1363 | st->user_bandwidth = st->bandwidth; |
| 1364 | st->force_channels = st->stream_channels; |
| 1365 | bak_to_mono = st->silk_mode.toMono; |
| 1366 | |
| 1367 | if (bak_to_mono) |
| 1368 | st->force_channels = 1; |
| 1369 | else |
| 1370 | st->prev_channels = st->stream_channels; |
| 1371 | for (i=0;i<nb_frames;i++) |
| 1372 | { |
| 1373 | int tmp_len; |
| 1374 | st->silk_mode.toMono = 0; |
| 1375 | /* When switching from SILK/Hybrid to CELT, only ask for a switch at the last frame */ |
| 1376 | if (to_celt && i==nb_frames-1) |
| 1377 | st->user_forced_mode = MODE_CELT_ONLY; |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1378 | tmp_len = opus_encode_native(st, pcm+i*(st->channels*st->Fs/50), st->Fs/50, |
| 1379 | tmp_data+i*bytes_per_frame, bytes_per_frame, lsb_depth, |
| 1380 | NULL, 0, c1, c2, analysis_channels, downmix); |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1381 | if (tmp_len<0) |
| 1382 | { |
| 1383 | RESTORE_STACK; |
| 1384 | return OPUS_INTERNAL_ERROR; |
| 1385 | } |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1386 | ret = opus_repacketizer_cat(rp, tmp_data+i*bytes_per_frame, tmp_len); |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1387 | if (ret<0) |
| 1388 | { |
| 1389 | RESTORE_STACK; |
| 1390 | return OPUS_INTERNAL_ERROR; |
| 1391 | } |
| 1392 | } |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1393 | if (st->use_vbr) |
| 1394 | repacketize_len = out_data_bytes; |
| 1395 | else |
| 1396 | repacketize_len = IMIN(3*st->bitrate_bps/(3*8*50/nb_frames), out_data_bytes); |
| 1397 | ret = opus_repacketizer_out_range_impl(rp, 0, nb_frames, data, repacketize_len, 0, !st->use_vbr); |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1398 | if (ret<0) |
| 1399 | { |
| 1400 | RESTORE_STACK; |
| 1401 | return OPUS_INTERNAL_ERROR; |
| 1402 | } |
| 1403 | st->user_forced_mode = bak_mode; |
| 1404 | st->user_bandwidth = bak_bandwidth; |
| 1405 | st->force_channels = bak_channels; |
| 1406 | st->silk_mode.toMono = bak_to_mono; |
| 1407 | RESTORE_STACK; |
| 1408 | return ret; |
| 1409 | } |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1410 | curr_bandwidth = st->bandwidth; |
| 1411 | |
| 1412 | /* Chooses the appropriate mode for speech |
| 1413 | *NEVER* switch to/from CELT-only mode here as this will invalidate some assumptions */ |
| 1414 | if (st->mode == MODE_SILK_ONLY && curr_bandwidth > OPUS_BANDWIDTH_WIDEBAND) |
| 1415 | st->mode = MODE_HYBRID; |
| 1416 | if (st->mode == MODE_HYBRID && curr_bandwidth <= OPUS_BANDWIDTH_WIDEBAND) |
| 1417 | st->mode = MODE_SILK_ONLY; |
| 1418 | |
| 1419 | /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, curr_bandwidth); */ |
| 1420 | bytes_target = IMIN(max_data_bytes-redundancy_bytes, st->bitrate_bps * frame_size / (st->Fs * 8)) - 1; |
| 1421 | |
| 1422 | data += 1; |
| 1423 | |
| 1424 | ec_enc_init(&enc, data, max_data_bytes-1); |
| 1425 | |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1426 | ALLOC(pcm_buf, (total_buffer+frame_size)*st->channels, opus_val16); |
| 1427 | for (i=0;i<total_buffer*st->channels;i++) |
| 1428 | pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-total_buffer)*st->channels+i]; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1429 | |
| 1430 | if (st->mode == MODE_CELT_ONLY) |
| 1431 | hp_freq_smth1 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 ); |
| 1432 | else |
| 1433 | hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15; |
| 1434 | |
| 1435 | st->variable_HP_smth2_Q15 = silk_SMLAWB( st->variable_HP_smth2_Q15, |
| 1436 | hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) ); |
| 1437 | |
| 1438 | /* convert from log scale to Hertz */ |
| 1439 | cutoff_Hz = silk_log2lin( silk_RSHIFT( st->variable_HP_smth2_Q15, 8 ) ); |
| 1440 | |
| 1441 | if (st->application == OPUS_APPLICATION_VOIP) |
| 1442 | { |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1443 | hp_cutoff(pcm, cutoff_Hz, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs); |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1444 | } else { |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1445 | dc_reject(pcm, 3, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs); |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1446 | } |
| 1447 | |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1448 | |
| 1449 | |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1450 | /* SILK processing */ |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1451 | HB_gain = Q15ONE; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1452 | if (st->mode != MODE_CELT_ONLY) |
| 1453 | { |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1454 | opus_int32 total_bitRate, celt_rate; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1455 | #ifdef FIXED_POINT |
| 1456 | const opus_int16 *pcm_silk; |
| 1457 | #else |
| 1458 | VARDECL(opus_int16, pcm_silk); |
| 1459 | ALLOC(pcm_silk, st->channels*frame_size, opus_int16); |
| 1460 | #endif |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1461 | |
| 1462 | /* Distribute bits between SILK and CELT */ |
| 1463 | total_bitRate = 8 * bytes_target * frame_rate; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1464 | if( st->mode == MODE_HYBRID ) { |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1465 | int HB_gain_ref; |
| 1466 | /* Base rate for SILK */ |
| 1467 | st->silk_mode.bitRate = st->stream_channels * ( 5000 + 1000 * ( st->Fs == 100 * frame_size ) ); |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1468 | if( curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) { |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1469 | /* SILK gets 2/3 of the remaining bits */ |
| 1470 | st->silk_mode.bitRate += ( total_bitRate - st->silk_mode.bitRate ) * 2 / 3; |
| 1471 | } else { /* FULLBAND */ |
| 1472 | /* SILK gets 3/5 of the remaining bits */ |
| 1473 | st->silk_mode.bitRate += ( total_bitRate - st->silk_mode.bitRate ) * 3 / 5; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1474 | } |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1475 | /* Don't let SILK use more than 80% */ |
| 1476 | if( st->silk_mode.bitRate > total_bitRate * 4/5 ) { |
| 1477 | st->silk_mode.bitRate = total_bitRate * 4/5; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1478 | } |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1479 | if (!st->energy_masking) |
| 1480 | { |
| 1481 | /* Increasingly attenuate high band when it gets allocated fewer bits */ |
| 1482 | celt_rate = total_bitRate - st->silk_mode.bitRate; |
| 1483 | HB_gain_ref = (curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND) ? 3000 : 3600; |
| 1484 | HB_gain = SHL32((opus_val32)celt_rate, 9) / SHR32((opus_val32)celt_rate + st->stream_channels * HB_gain_ref, 6); |
| 1485 | HB_gain = HB_gain < Q15ONE*6/7 ? HB_gain + Q15ONE/7 : Q15ONE; |
| 1486 | } |
| 1487 | } else { |
| 1488 | /* SILK gets all bits */ |
| 1489 | st->silk_mode.bitRate = total_bitRate; |
| 1490 | } |
| 1491 | |
| 1492 | /* Surround masking for SILK */ |
| 1493 | if (st->energy_masking && st->use_vbr && !st->lfe) |
| 1494 | { |
| 1495 | opus_val32 mask_sum=0; |
| 1496 | opus_val16 masking_depth; |
| 1497 | opus_int32 rate_offset; |
| 1498 | int c; |
| 1499 | int end = 17; |
| 1500 | opus_int16 srate = 16000; |
| 1501 | if (st->bandwidth == OPUS_BANDWIDTH_NARROWBAND) |
| 1502 | { |
| 1503 | end = 13; |
| 1504 | srate = 8000; |
| 1505 | } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) |
| 1506 | { |
| 1507 | end = 15; |
| 1508 | srate = 12000; |
| 1509 | } |
| 1510 | for (c=0;c<st->channels;c++) |
| 1511 | { |
| 1512 | for(i=0;i<end;i++) |
| 1513 | { |
| 1514 | opus_val16 mask; |
| 1515 | mask = MAX16(MIN16(st->energy_masking[21*c+i], |
| 1516 | QCONST16(.5f, DB_SHIFT)), -QCONST16(2.0f, DB_SHIFT)); |
| 1517 | if (mask > 0) |
| 1518 | mask = HALF16(mask); |
| 1519 | mask_sum += mask; |
| 1520 | } |
| 1521 | } |
| 1522 | /* Conservative rate reduction, we cut the masking in half */ |
| 1523 | masking_depth = mask_sum / end*st->channels; |
| 1524 | masking_depth += QCONST16(.2f, DB_SHIFT); |
| 1525 | rate_offset = (opus_int32)PSHR32(MULT16_16(srate, masking_depth), DB_SHIFT); |
| 1526 | rate_offset = MAX32(rate_offset, -2*st->silk_mode.bitRate/3); |
| 1527 | /* Split the rate change between the SILK and CELT part for hybrid. */ |
| 1528 | if (st->bandwidth==OPUS_BANDWIDTH_SUPERWIDEBAND || st->bandwidth==OPUS_BANDWIDTH_FULLBAND) |
| 1529 | st->silk_mode.bitRate += 3*rate_offset/5; |
| 1530 | else |
| 1531 | st->silk_mode.bitRate += rate_offset; |
| 1532 | bytes_target += rate_offset * frame_size / (8 * st->Fs); |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1533 | } |
| 1534 | |
| 1535 | st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs; |
| 1536 | st->silk_mode.nChannelsAPI = st->channels; |
| 1537 | st->silk_mode.nChannelsInternal = st->stream_channels; |
| 1538 | if (curr_bandwidth == OPUS_BANDWIDTH_NARROWBAND) { |
| 1539 | st->silk_mode.desiredInternalSampleRate = 8000; |
| 1540 | } else if (curr_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) { |
| 1541 | st->silk_mode.desiredInternalSampleRate = 12000; |
| 1542 | } else { |
| 1543 | silk_assert( st->mode == MODE_HYBRID || curr_bandwidth == OPUS_BANDWIDTH_WIDEBAND ); |
| 1544 | st->silk_mode.desiredInternalSampleRate = 16000; |
| 1545 | } |
| 1546 | if( st->mode == MODE_HYBRID ) { |
| 1547 | /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */ |
| 1548 | st->silk_mode.minInternalSampleRate = 16000; |
| 1549 | } else { |
| 1550 | st->silk_mode.minInternalSampleRate = 8000; |
| 1551 | } |
| 1552 | |
| 1553 | if (st->mode == MODE_SILK_ONLY) |
| 1554 | { |
| 1555 | opus_int32 effective_max_rate = max_rate; |
| 1556 | st->silk_mode.maxInternalSampleRate = 16000; |
| 1557 | if (frame_rate > 50) |
| 1558 | effective_max_rate = effective_max_rate*2/3; |
| 1559 | if (effective_max_rate < 13000) |
| 1560 | { |
| 1561 | st->silk_mode.maxInternalSampleRate = 12000; |
| 1562 | st->silk_mode.desiredInternalSampleRate = IMIN(12000, st->silk_mode.desiredInternalSampleRate); |
| 1563 | } |
| 1564 | if (effective_max_rate < 9600) |
| 1565 | { |
| 1566 | st->silk_mode.maxInternalSampleRate = 8000; |
| 1567 | st->silk_mode.desiredInternalSampleRate = IMIN(8000, st->silk_mode.desiredInternalSampleRate); |
| 1568 | } |
| 1569 | } else { |
| 1570 | st->silk_mode.maxInternalSampleRate = 16000; |
| 1571 | } |
| 1572 | |
| 1573 | st->silk_mode.useCBR = !st->use_vbr; |
| 1574 | |
| 1575 | /* Call SILK encoder for the low band */ |
| 1576 | nBytes = IMIN(1275, max_data_bytes-1-redundancy_bytes); |
| 1577 | |
| 1578 | st->silk_mode.maxBits = nBytes*8; |
| 1579 | /* Only allow up to 90% of the bits for hybrid mode*/ |
| 1580 | if (st->mode == MODE_HYBRID) |
| 1581 | st->silk_mode.maxBits = (opus_int32)st->silk_mode.maxBits*9/10; |
| 1582 | if (st->silk_mode.useCBR) |
| 1583 | { |
| 1584 | st->silk_mode.maxBits = (st->silk_mode.bitRate * frame_size / (st->Fs * 8))*8; |
| 1585 | /* Reduce the initial target to make it easier to reach the CBR rate */ |
| 1586 | st->silk_mode.bitRate = IMAX(1, st->silk_mode.bitRate-2000); |
| 1587 | } |
| 1588 | |
| 1589 | if (prefill) |
| 1590 | { |
| 1591 | opus_int32 zero=0; |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1592 | int prefill_offset; |
| 1593 | /* Use a smooth onset for the SILK prefill to avoid the encoder trying to encode |
| 1594 | a discontinuity. The exact location is what we need to avoid leaving any "gap" |
| 1595 | in the audio when mixing with the redundant CELT frame. Here we can afford to |
| 1596 | overwrite st->delay_buffer because the only thing that uses it before it gets |
| 1597 | rewritten is tmp_prefill[] and even then only the part after the ramp really |
| 1598 | gets used (rather than sent to the encoder and discarded) */ |
| 1599 | prefill_offset = st->channels*(st->encoder_buffer-st->delay_compensation-st->Fs/400); |
| 1600 | gain_fade(st->delay_buffer+prefill_offset, st->delay_buffer+prefill_offset, |
| 1601 | 0, Q15ONE, celt_mode->overlap, st->Fs/400, st->channels, celt_mode->window, st->Fs); |
| 1602 | for(i=0;i<prefill_offset;i++) |
| 1603 | st->delay_buffer[i]=0; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1604 | #ifdef FIXED_POINT |
| 1605 | pcm_silk = st->delay_buffer; |
| 1606 | #else |
| 1607 | for (i=0;i<st->encoder_buffer*st->channels;i++) |
| 1608 | pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]); |
| 1609 | #endif |
| 1610 | silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 ); |
| 1611 | } |
| 1612 | |
| 1613 | #ifdef FIXED_POINT |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1614 | pcm_silk = pcm_buf+total_buffer*st->channels; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1615 | #else |
| 1616 | for (i=0;i<frame_size*st->channels;i++) |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1617 | pcm_silk[i] = FLOAT2INT16(pcm_buf[total_buffer*st->channels + i]); |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1618 | #endif |
| 1619 | ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 ); |
| 1620 | if( ret ) { |
| 1621 | /*fprintf (stderr, "SILK encode error: %d\n", ret);*/ |
| 1622 | /* Handle error */ |
| 1623 | RESTORE_STACK; |
| 1624 | return OPUS_INTERNAL_ERROR; |
| 1625 | } |
| 1626 | if (nBytes==0) |
| 1627 | { |
| 1628 | st->rangeFinal = 0; |
| 1629 | data[-1] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels); |
| 1630 | RESTORE_STACK; |
| 1631 | return 1; |
| 1632 | } |
| 1633 | /* Extract SILK internal bandwidth for signaling in first byte */ |
| 1634 | if( st->mode == MODE_SILK_ONLY ) { |
| 1635 | if( st->silk_mode.internalSampleRate == 8000 ) { |
| 1636 | curr_bandwidth = OPUS_BANDWIDTH_NARROWBAND; |
| 1637 | } else if( st->silk_mode.internalSampleRate == 12000 ) { |
| 1638 | curr_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND; |
| 1639 | } else if( st->silk_mode.internalSampleRate == 16000 ) { |
| 1640 | curr_bandwidth = OPUS_BANDWIDTH_WIDEBAND; |
| 1641 | } |
| 1642 | } else { |
| 1643 | silk_assert( st->silk_mode.internalSampleRate == 16000 ); |
| 1644 | } |
| 1645 | |
| 1646 | st->silk_mode.opusCanSwitch = st->silk_mode.switchReady; |
| 1647 | /* FIXME: How do we allocate the redundancy for CBR? */ |
| 1648 | if (st->silk_mode.opusCanSwitch) |
| 1649 | { |
| 1650 | redundancy = 1; |
| 1651 | celt_to_silk = 0; |
| 1652 | st->silk_bw_switch = 1; |
| 1653 | } |
| 1654 | } |
| 1655 | |
| 1656 | /* CELT processing */ |
| 1657 | { |
| 1658 | int endband=21; |
| 1659 | |
| 1660 | switch(curr_bandwidth) |
| 1661 | { |
| 1662 | case OPUS_BANDWIDTH_NARROWBAND: |
| 1663 | endband = 13; |
| 1664 | break; |
| 1665 | case OPUS_BANDWIDTH_MEDIUMBAND: |
| 1666 | case OPUS_BANDWIDTH_WIDEBAND: |
| 1667 | endband = 17; |
| 1668 | break; |
| 1669 | case OPUS_BANDWIDTH_SUPERWIDEBAND: |
| 1670 | endband = 19; |
| 1671 | break; |
| 1672 | case OPUS_BANDWIDTH_FULLBAND: |
| 1673 | endband = 21; |
| 1674 | break; |
| 1675 | } |
| 1676 | celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband)); |
| 1677 | celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels)); |
| 1678 | } |
| 1679 | celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX)); |
| 1680 | if (st->mode != MODE_SILK_ONLY) |
| 1681 | { |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1682 | opus_val32 celt_pred=2; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1683 | celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0)); |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1684 | /* We may still decide to disable prediction later */ |
| 1685 | if (st->silk_mode.reducedDependency) |
| 1686 | celt_pred = 0; |
| 1687 | celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(celt_pred)); |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1688 | |
| 1689 | if (st->mode == MODE_HYBRID) |
| 1690 | { |
| 1691 | int len; |
| 1692 | |
| 1693 | len = (ec_tell(&enc)+7)>>3; |
| 1694 | if (redundancy) |
| 1695 | len += st->mode == MODE_HYBRID ? 3 : 1; |
| 1696 | if( st->use_vbr ) { |
| 1697 | nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs); |
| 1698 | } else { |
| 1699 | /* check if SILK used up too much */ |
| 1700 | nb_compr_bytes = len > bytes_target ? len : bytes_target; |
| 1701 | } |
| 1702 | } else { |
| 1703 | if (st->use_vbr) |
| 1704 | { |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1705 | opus_int32 bonus=0; |
| 1706 | #ifndef DISABLE_FLOAT_API |
| 1707 | if (st->variable_duration==OPUS_FRAMESIZE_VARIABLE && frame_size != st->Fs/50) |
| 1708 | { |
| 1709 | bonus = (60*st->stream_channels+40)*(st->Fs/frame_size-50); |
| 1710 | if (analysis_info.valid) |
| 1711 | bonus = (opus_int32)(bonus*(1.f+.5f*analysis_info.tonality)); |
| 1712 | } |
| 1713 | #endif |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1714 | celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1)); |
| 1715 | celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint)); |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1716 | celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps+bonus)); |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1717 | nb_compr_bytes = max_data_bytes-1-redundancy_bytes; |
| 1718 | } else { |
| 1719 | nb_compr_bytes = bytes_target; |
| 1720 | } |
| 1721 | } |
| 1722 | |
| 1723 | } else { |
| 1724 | nb_compr_bytes = 0; |
| 1725 | } |
| 1726 | |
| 1727 | ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16); |
| 1728 | if (st->mode != MODE_SILK_ONLY && st->mode != st->prev_mode && st->prev_mode > 0) |
| 1729 | { |
| 1730 | for (i=0;i<st->channels*st->Fs/400;i++) |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1731 | tmp_prefill[i] = st->delay_buffer[(st->encoder_buffer-total_buffer-st->Fs/400)*st->channels + i]; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1732 | } |
| 1733 | |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1734 | for (i=0;i<st->channels*(st->encoder_buffer-(frame_size+total_buffer));i++) |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1735 | st->delay_buffer[i] = st->delay_buffer[i+st->channels*frame_size]; |
| 1736 | for (;i<st->encoder_buffer*st->channels;i++) |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1737 | st->delay_buffer[i] = pcm_buf[(frame_size+total_buffer-st->encoder_buffer)*st->channels+i]; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1738 | |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1739 | /* gain_fade() and stereo_fade() need to be after the buffer copying |
| 1740 | because we don't want any of this to affect the SILK part */ |
| 1741 | if( st->prev_HB_gain < Q15ONE || HB_gain < Q15ONE ) { |
| 1742 | gain_fade(pcm_buf, pcm_buf, |
| 1743 | st->prev_HB_gain, HB_gain, celt_mode->overlap, frame_size, st->channels, celt_mode->window, st->Fs); |
| 1744 | } |
| 1745 | st->prev_HB_gain = HB_gain; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1746 | if (st->mode != MODE_HYBRID || st->stream_channels==1) |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1747 | st->silk_mode.stereoWidth_Q14 = IMIN((1<<14),2*IMAX(0,equiv_rate-30000)); |
| 1748 | if( !st->energy_masking && st->channels == 2 ) { |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1749 | /* Apply stereo width reduction (at low bitrates) */ |
| 1750 | if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) { |
| 1751 | opus_val16 g1, g2; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1752 | g1 = st->hybrid_stereo_width_Q14; |
| 1753 | g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14); |
| 1754 | #ifdef FIXED_POINT |
| 1755 | g1 = g1==16384 ? Q15ONE : SHL16(g1,1); |
| 1756 | g2 = g2==16384 ? Q15ONE : SHL16(g2,1); |
| 1757 | #else |
| 1758 | g1 *= (1.f/16384); |
| 1759 | g2 *= (1.f/16384); |
| 1760 | #endif |
| 1761 | stereo_fade(pcm_buf, pcm_buf, g1, g2, celt_mode->overlap, |
| 1762 | frame_size, st->channels, celt_mode->window, st->Fs); |
| 1763 | st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14; |
| 1764 | } |
| 1765 | } |
| 1766 | |
| 1767 | if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1)) |
| 1768 | { |
| 1769 | /* For SILK mode, the redundancy is inferred from the length */ |
| 1770 | if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 <= 8*nb_compr_bytes)) |
| 1771 | ec_enc_bit_logp(&enc, redundancy, 12); |
| 1772 | if (redundancy) |
| 1773 | { |
| 1774 | int max_redundancy; |
| 1775 | ec_enc_bit_logp(&enc, celt_to_silk, 1); |
| 1776 | if (st->mode == MODE_HYBRID) |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1777 | max_redundancy = (max_data_bytes-1)-nb_compr_bytes; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1778 | else |
| 1779 | max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3); |
| 1780 | /* Target the same bit-rate for redundancy as for the rest, |
| 1781 | up to a max of 257 bytes */ |
| 1782 | redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600); |
| 1783 | redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes)); |
| 1784 | if (st->mode == MODE_HYBRID) |
| 1785 | ec_enc_uint(&enc, redundancy_bytes-2, 256); |
| 1786 | } |
| 1787 | } else { |
| 1788 | redundancy = 0; |
| 1789 | } |
| 1790 | |
| 1791 | if (!redundancy) |
| 1792 | { |
| 1793 | st->silk_bw_switch = 0; |
| 1794 | redundancy_bytes = 0; |
| 1795 | } |
| 1796 | if (st->mode != MODE_CELT_ONLY)start_band=17; |
| 1797 | |
| 1798 | if (st->mode == MODE_SILK_ONLY) |
| 1799 | { |
| 1800 | ret = (ec_tell(&enc)+7)>>3; |
| 1801 | ec_enc_done(&enc); |
| 1802 | nb_compr_bytes = ret; |
| 1803 | } else { |
| 1804 | nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes); |
| 1805 | ec_enc_shrink(&enc, nb_compr_bytes); |
| 1806 | } |
| 1807 | |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1808 | #ifndef DISABLE_FLOAT_API |
| 1809 | if (redundancy || st->mode != MODE_SILK_ONLY) |
| 1810 | celt_encoder_ctl(celt_enc, CELT_SET_ANALYSIS(&analysis_info)); |
| 1811 | #endif |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1812 | |
| 1813 | /* 5 ms redundant frame for CELT->SILK */ |
| 1814 | if (redundancy && celt_to_silk) |
| 1815 | { |
| 1816 | int err; |
| 1817 | celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0)); |
| 1818 | celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0)); |
| 1819 | err = celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL); |
| 1820 | if (err < 0) |
| 1821 | { |
| 1822 | RESTORE_STACK; |
| 1823 | return OPUS_INTERNAL_ERROR; |
| 1824 | } |
| 1825 | celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng)); |
| 1826 | celt_encoder_ctl(celt_enc, OPUS_RESET_STATE); |
| 1827 | } |
| 1828 | |
| 1829 | celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band)); |
| 1830 | |
| 1831 | if (st->mode != MODE_SILK_ONLY) |
| 1832 | { |
| 1833 | if (st->mode != st->prev_mode && st->prev_mode > 0) |
| 1834 | { |
| 1835 | unsigned char dummy[2]; |
| 1836 | celt_encoder_ctl(celt_enc, OPUS_RESET_STATE); |
| 1837 | |
| 1838 | /* Prefilling */ |
| 1839 | celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL); |
| 1840 | celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0)); |
| 1841 | } |
| 1842 | /* If false, we already busted the budget and we'll end up with a "PLC packet" */ |
| 1843 | if (ec_tell(&enc) <= 8*nb_compr_bytes) |
| 1844 | { |
| 1845 | ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc); |
| 1846 | if (ret < 0) |
| 1847 | { |
| 1848 | RESTORE_STACK; |
| 1849 | return OPUS_INTERNAL_ERROR; |
| 1850 | } |
| 1851 | } |
| 1852 | } |
| 1853 | |
| 1854 | /* 5 ms redundant frame for SILK->CELT */ |
| 1855 | if (redundancy && !celt_to_silk) |
| 1856 | { |
| 1857 | int err; |
| 1858 | unsigned char dummy[2]; |
| 1859 | int N2, N4; |
| 1860 | N2 = st->Fs/200; |
| 1861 | N4 = st->Fs/400; |
| 1862 | |
| 1863 | celt_encoder_ctl(celt_enc, OPUS_RESET_STATE); |
| 1864 | celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0)); |
| 1865 | celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0)); |
| 1866 | |
| 1867 | /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */ |
| 1868 | celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, dummy, 2, NULL); |
| 1869 | |
| 1870 | err = celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL); |
| 1871 | if (err < 0) |
| 1872 | { |
| 1873 | RESTORE_STACK; |
| 1874 | return OPUS_INTERNAL_ERROR; |
| 1875 | } |
| 1876 | celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng)); |
| 1877 | } |
| 1878 | |
| 1879 | |
| 1880 | |
| 1881 | /* Signalling the mode in the first byte */ |
| 1882 | data--; |
| 1883 | data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels); |
| 1884 | |
| 1885 | st->rangeFinal = enc.rng ^ redundant_rng; |
| 1886 | |
| 1887 | if (to_celt) |
| 1888 | st->prev_mode = MODE_CELT_ONLY; |
| 1889 | else |
| 1890 | st->prev_mode = st->mode; |
| 1891 | st->prev_channels = st->stream_channels; |
| 1892 | st->prev_framesize = frame_size; |
| 1893 | |
| 1894 | st->first = 0; |
| 1895 | |
| 1896 | /* In the unlikely case that the SILK encoder busted its target, tell |
| 1897 | the decoder to call the PLC */ |
| 1898 | if (ec_tell(&enc) > (max_data_bytes-1)*8) |
| 1899 | { |
| 1900 | if (max_data_bytes < 2) |
| 1901 | { |
| 1902 | RESTORE_STACK; |
| 1903 | return OPUS_BUFFER_TOO_SMALL; |
| 1904 | } |
| 1905 | data[1] = 0; |
| 1906 | ret = 1; |
| 1907 | st->rangeFinal = 0; |
| 1908 | } else if (st->mode==MODE_SILK_ONLY&&!redundancy) |
| 1909 | { |
| 1910 | /*When in LPC only mode it's perfectly |
| 1911 | reasonable to strip off trailing zero bytes as |
| 1912 | the required range decoder behavior is to |
| 1913 | fill these in. This can't be done when the MDCT |
| 1914 | modes are used because the decoder needs to know |
| 1915 | the actual length for allocation purposes.*/ |
| 1916 | while(ret>2&&data[ret]==0)ret--; |
| 1917 | } |
| 1918 | /* Count ToC and redundancy */ |
| 1919 | ret += 1+redundancy_bytes; |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1920 | if (!st->use_vbr) |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1921 | { |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1922 | if (opus_packet_pad(data, ret, max_data_bytes) != OPUS_OK) |
| 1923 | |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1924 | { |
| 1925 | RESTORE_STACK; |
| 1926 | return OPUS_INTERNAL_ERROR; |
| 1927 | } |
| 1928 | ret = max_data_bytes; |
| 1929 | } |
| 1930 | RESTORE_STACK; |
| 1931 | return ret; |
| 1932 | } |
| 1933 | |
| 1934 | #ifdef FIXED_POINT |
| 1935 | |
| 1936 | #ifndef DISABLE_FLOAT_API |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1937 | opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int analysis_frame_size, |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1938 | unsigned char *data, opus_int32 max_data_bytes) |
| 1939 | { |
| 1940 | int i, ret; |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1941 | int frame_size; |
| 1942 | int delay_compensation; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1943 | VARDECL(opus_int16, in); |
| 1944 | ALLOC_STACK; |
| 1945 | |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1946 | if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY) |
| 1947 | delay_compensation = 0; |
| 1948 | else |
| 1949 | delay_compensation = st->delay_compensation; |
| 1950 | frame_size = compute_frame_size(pcm, analysis_frame_size, |
| 1951 | st->variable_duration, st->channels, st->Fs, st->bitrate_bps, |
| 1952 | delay_compensation, downmix_float, st->analysis.subframe_mem); |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1953 | |
| 1954 | ALLOC(in, frame_size*st->channels, opus_int16); |
| 1955 | |
| 1956 | for (i=0;i<frame_size*st->channels;i++) |
| 1957 | in[i] = FLOAT2INT16(pcm[i]); |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1958 | ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16, pcm, analysis_frame_size, 0, -2, st->channels, downmix_float); |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1959 | RESTORE_STACK; |
| 1960 | return ret; |
| 1961 | } |
| 1962 | #endif |
| 1963 | |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1964 | opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int analysis_frame_size, |
| 1965 | unsigned char *data, opus_int32 out_data_bytes) |
| 1966 | { |
| 1967 | int frame_size; |
| 1968 | int delay_compensation; |
| 1969 | if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY) |
| 1970 | delay_compensation = 0; |
| 1971 | else |
| 1972 | delay_compensation = st->delay_compensation; |
| 1973 | frame_size = compute_frame_size(pcm, analysis_frame_size, |
| 1974 | st->variable_duration, st->channels, st->Fs, st->bitrate_bps, |
| 1975 | delay_compensation, downmix_int |
| 1976 | #ifndef DISABLE_FLOAT_API |
| 1977 | , st->analysis.subframe_mem |
| 1978 | #endif |
| 1979 | ); |
| 1980 | return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 16, pcm, analysis_frame_size, 0, -2, st->channels, downmix_int); |
| 1981 | } |
| 1982 | |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1983 | #else |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1984 | opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int analysis_frame_size, |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1985 | unsigned char *data, opus_int32 max_data_bytes) |
| 1986 | { |
| 1987 | int i, ret; |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1988 | int frame_size; |
| 1989 | int delay_compensation; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1990 | VARDECL(float, in); |
| 1991 | ALLOC_STACK; |
| 1992 | |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 1993 | if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY) |
| 1994 | delay_compensation = 0; |
| 1995 | else |
| 1996 | delay_compensation = st->delay_compensation; |
| 1997 | frame_size = compute_frame_size(pcm, analysis_frame_size, |
| 1998 | st->variable_duration, st->channels, st->Fs, st->bitrate_bps, |
| 1999 | delay_compensation, downmix_int, st->analysis.subframe_mem); |
| 2000 | |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2001 | ALLOC(in, frame_size*st->channels, float); |
| 2002 | |
| 2003 | for (i=0;i<frame_size*st->channels;i++) |
| 2004 | in[i] = (1.0f/32768)*pcm[i]; |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2005 | ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16, pcm, analysis_frame_size, 0, -2, st->channels, downmix_int); |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2006 | RESTORE_STACK; |
| 2007 | return ret; |
| 2008 | } |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2009 | opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int analysis_frame_size, |
| 2010 | unsigned char *data, opus_int32 out_data_bytes) |
| 2011 | { |
| 2012 | int frame_size; |
| 2013 | int delay_compensation; |
| 2014 | if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY) |
| 2015 | delay_compensation = 0; |
| 2016 | else |
| 2017 | delay_compensation = st->delay_compensation; |
| 2018 | frame_size = compute_frame_size(pcm, analysis_frame_size, |
| 2019 | st->variable_duration, st->channels, st->Fs, st->bitrate_bps, |
| 2020 | delay_compensation, downmix_float, st->analysis.subframe_mem); |
| 2021 | return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 24, |
| 2022 | pcm, analysis_frame_size, 0, -2, st->channels, downmix_float); |
| 2023 | } |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2024 | #endif |
| 2025 | |
| 2026 | |
| 2027 | int opus_encoder_ctl(OpusEncoder *st, int request, ...) |
| 2028 | { |
| 2029 | int ret; |
| 2030 | CELTEncoder *celt_enc; |
| 2031 | va_list ap; |
| 2032 | |
| 2033 | ret = OPUS_OK; |
| 2034 | va_start(ap, request); |
| 2035 | |
| 2036 | celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset); |
| 2037 | |
| 2038 | switch (request) |
| 2039 | { |
| 2040 | case OPUS_SET_APPLICATION_REQUEST: |
| 2041 | { |
| 2042 | opus_int32 value = va_arg(ap, opus_int32); |
| 2043 | if ( (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO |
| 2044 | && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY) |
| 2045 | || (!st->first && st->application != value)) |
| 2046 | { |
| 2047 | ret = OPUS_BAD_ARG; |
| 2048 | break; |
| 2049 | } |
| 2050 | st->application = value; |
| 2051 | } |
| 2052 | break; |
| 2053 | case OPUS_GET_APPLICATION_REQUEST: |
| 2054 | { |
| 2055 | opus_int32 *value = va_arg(ap, opus_int32*); |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2056 | if (!value) |
| 2057 | { |
| 2058 | goto bad_arg; |
| 2059 | } |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2060 | *value = st->application; |
| 2061 | } |
| 2062 | break; |
| 2063 | case OPUS_SET_BITRATE_REQUEST: |
| 2064 | { |
| 2065 | opus_int32 value = va_arg(ap, opus_int32); |
| 2066 | if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX) |
| 2067 | { |
| 2068 | if (value <= 0) |
| 2069 | goto bad_arg; |
| 2070 | else if (value <= 500) |
| 2071 | value = 500; |
| 2072 | else if (value > (opus_int32)300000*st->channels) |
| 2073 | value = (opus_int32)300000*st->channels; |
| 2074 | } |
| 2075 | st->user_bitrate_bps = value; |
| 2076 | } |
| 2077 | break; |
| 2078 | case OPUS_GET_BITRATE_REQUEST: |
| 2079 | { |
| 2080 | opus_int32 *value = va_arg(ap, opus_int32*); |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2081 | if (!value) |
| 2082 | { |
| 2083 | goto bad_arg; |
| 2084 | } |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2085 | *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276); |
| 2086 | } |
| 2087 | break; |
| 2088 | case OPUS_SET_FORCE_CHANNELS_REQUEST: |
| 2089 | { |
| 2090 | opus_int32 value = va_arg(ap, opus_int32); |
| 2091 | if((value<1 || value>st->channels) && value != OPUS_AUTO) |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2092 | { |
| 2093 | goto bad_arg; |
| 2094 | } |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2095 | st->force_channels = value; |
| 2096 | } |
| 2097 | break; |
| 2098 | case OPUS_GET_FORCE_CHANNELS_REQUEST: |
| 2099 | { |
| 2100 | opus_int32 *value = va_arg(ap, opus_int32*); |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2101 | if (!value) |
| 2102 | { |
| 2103 | goto bad_arg; |
| 2104 | } |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2105 | *value = st->force_channels; |
| 2106 | } |
| 2107 | break; |
| 2108 | case OPUS_SET_MAX_BANDWIDTH_REQUEST: |
| 2109 | { |
| 2110 | opus_int32 value = va_arg(ap, opus_int32); |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2111 | if (value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) |
| 2112 | { |
| 2113 | goto bad_arg; |
| 2114 | } |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2115 | st->max_bandwidth = value; |
| 2116 | if (st->max_bandwidth == OPUS_BANDWIDTH_NARROWBAND) { |
| 2117 | st->silk_mode.maxInternalSampleRate = 8000; |
| 2118 | } else if (st->max_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) { |
| 2119 | st->silk_mode.maxInternalSampleRate = 12000; |
| 2120 | } else { |
| 2121 | st->silk_mode.maxInternalSampleRate = 16000; |
| 2122 | } |
| 2123 | } |
| 2124 | break; |
| 2125 | case OPUS_GET_MAX_BANDWIDTH_REQUEST: |
| 2126 | { |
| 2127 | opus_int32 *value = va_arg(ap, opus_int32*); |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2128 | if (!value) |
| 2129 | { |
| 2130 | goto bad_arg; |
| 2131 | } |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2132 | *value = st->max_bandwidth; |
| 2133 | } |
| 2134 | break; |
| 2135 | case OPUS_SET_BANDWIDTH_REQUEST: |
| 2136 | { |
| 2137 | opus_int32 value = va_arg(ap, opus_int32); |
| 2138 | if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO) |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2139 | { |
| 2140 | goto bad_arg; |
| 2141 | } |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2142 | st->user_bandwidth = value; |
| 2143 | if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) { |
| 2144 | st->silk_mode.maxInternalSampleRate = 8000; |
| 2145 | } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) { |
| 2146 | st->silk_mode.maxInternalSampleRate = 12000; |
| 2147 | } else { |
| 2148 | st->silk_mode.maxInternalSampleRate = 16000; |
| 2149 | } |
| 2150 | } |
| 2151 | break; |
| 2152 | case OPUS_GET_BANDWIDTH_REQUEST: |
| 2153 | { |
| 2154 | opus_int32 *value = va_arg(ap, opus_int32*); |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2155 | if (!value) |
| 2156 | { |
| 2157 | goto bad_arg; |
| 2158 | } |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2159 | *value = st->bandwidth; |
| 2160 | } |
| 2161 | break; |
| 2162 | case OPUS_SET_DTX_REQUEST: |
| 2163 | { |
| 2164 | opus_int32 value = va_arg(ap, opus_int32); |
| 2165 | if(value<0 || value>1) |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2166 | { |
| 2167 | goto bad_arg; |
| 2168 | } |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2169 | st->silk_mode.useDTX = value; |
| 2170 | } |
| 2171 | break; |
| 2172 | case OPUS_GET_DTX_REQUEST: |
| 2173 | { |
| 2174 | opus_int32 *value = va_arg(ap, opus_int32*); |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2175 | if (!value) |
| 2176 | { |
| 2177 | goto bad_arg; |
| 2178 | } |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2179 | *value = st->silk_mode.useDTX; |
| 2180 | } |
| 2181 | break; |
| 2182 | case OPUS_SET_COMPLEXITY_REQUEST: |
| 2183 | { |
| 2184 | opus_int32 value = va_arg(ap, opus_int32); |
| 2185 | if(value<0 || value>10) |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2186 | { |
| 2187 | goto bad_arg; |
| 2188 | } |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2189 | st->silk_mode.complexity = value; |
| 2190 | celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value)); |
| 2191 | } |
| 2192 | break; |
| 2193 | case OPUS_GET_COMPLEXITY_REQUEST: |
| 2194 | { |
| 2195 | opus_int32 *value = va_arg(ap, opus_int32*); |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2196 | if (!value) |
| 2197 | { |
| 2198 | goto bad_arg; |
| 2199 | } |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2200 | *value = st->silk_mode.complexity; |
| 2201 | } |
| 2202 | break; |
| 2203 | case OPUS_SET_INBAND_FEC_REQUEST: |
| 2204 | { |
| 2205 | opus_int32 value = va_arg(ap, opus_int32); |
| 2206 | if(value<0 || value>1) |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2207 | { |
| 2208 | goto bad_arg; |
| 2209 | } |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2210 | st->silk_mode.useInBandFEC = value; |
| 2211 | } |
| 2212 | break; |
| 2213 | case OPUS_GET_INBAND_FEC_REQUEST: |
| 2214 | { |
| 2215 | opus_int32 *value = va_arg(ap, opus_int32*); |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2216 | if (!value) |
| 2217 | { |
| 2218 | goto bad_arg; |
| 2219 | } |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2220 | *value = st->silk_mode.useInBandFEC; |
| 2221 | } |
| 2222 | break; |
| 2223 | case OPUS_SET_PACKET_LOSS_PERC_REQUEST: |
| 2224 | { |
| 2225 | opus_int32 value = va_arg(ap, opus_int32); |
| 2226 | if (value < 0 || value > 100) |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2227 | { |
| 2228 | goto bad_arg; |
| 2229 | } |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2230 | st->silk_mode.packetLossPercentage = value; |
| 2231 | celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value)); |
| 2232 | } |
| 2233 | break; |
| 2234 | case OPUS_GET_PACKET_LOSS_PERC_REQUEST: |
| 2235 | { |
| 2236 | opus_int32 *value = va_arg(ap, opus_int32*); |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2237 | if (!value) |
| 2238 | { |
| 2239 | goto bad_arg; |
| 2240 | } |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2241 | *value = st->silk_mode.packetLossPercentage; |
| 2242 | } |
| 2243 | break; |
| 2244 | case OPUS_SET_VBR_REQUEST: |
| 2245 | { |
| 2246 | opus_int32 value = va_arg(ap, opus_int32); |
| 2247 | if(value<0 || value>1) |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2248 | { |
| 2249 | goto bad_arg; |
| 2250 | } |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2251 | st->use_vbr = value; |
| 2252 | st->silk_mode.useCBR = 1-value; |
| 2253 | } |
| 2254 | break; |
| 2255 | case OPUS_GET_VBR_REQUEST: |
| 2256 | { |
| 2257 | opus_int32 *value = va_arg(ap, opus_int32*); |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2258 | if (!value) |
| 2259 | { |
| 2260 | goto bad_arg; |
| 2261 | } |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2262 | *value = st->use_vbr; |
| 2263 | } |
| 2264 | break; |
| 2265 | case OPUS_SET_VOICE_RATIO_REQUEST: |
| 2266 | { |
| 2267 | opus_int32 value = va_arg(ap, opus_int32); |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2268 | if (value<-1 || value>100) |
| 2269 | { |
| 2270 | goto bad_arg; |
| 2271 | } |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2272 | st->voice_ratio = value; |
| 2273 | } |
| 2274 | break; |
| 2275 | case OPUS_GET_VOICE_RATIO_REQUEST: |
| 2276 | { |
| 2277 | opus_int32 *value = va_arg(ap, opus_int32*); |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2278 | if (!value) |
| 2279 | { |
| 2280 | goto bad_arg; |
| 2281 | } |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2282 | *value = st->voice_ratio; |
| 2283 | } |
| 2284 | break; |
| 2285 | case OPUS_SET_VBR_CONSTRAINT_REQUEST: |
| 2286 | { |
| 2287 | opus_int32 value = va_arg(ap, opus_int32); |
| 2288 | if(value<0 || value>1) |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2289 | { |
| 2290 | goto bad_arg; |
| 2291 | } |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2292 | st->vbr_constraint = value; |
| 2293 | } |
| 2294 | break; |
| 2295 | case OPUS_GET_VBR_CONSTRAINT_REQUEST: |
| 2296 | { |
| 2297 | opus_int32 *value = va_arg(ap, opus_int32*); |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2298 | if (!value) |
| 2299 | { |
| 2300 | goto bad_arg; |
| 2301 | } |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2302 | *value = st->vbr_constraint; |
| 2303 | } |
| 2304 | break; |
| 2305 | case OPUS_SET_SIGNAL_REQUEST: |
| 2306 | { |
| 2307 | opus_int32 value = va_arg(ap, opus_int32); |
| 2308 | if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC) |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2309 | { |
| 2310 | goto bad_arg; |
| 2311 | } |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2312 | st->signal_type = value; |
| 2313 | } |
| 2314 | break; |
| 2315 | case OPUS_GET_SIGNAL_REQUEST: |
| 2316 | { |
| 2317 | opus_int32 *value = va_arg(ap, opus_int32*); |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2318 | if (!value) |
| 2319 | { |
| 2320 | goto bad_arg; |
| 2321 | } |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2322 | *value = st->signal_type; |
| 2323 | } |
| 2324 | break; |
| 2325 | case OPUS_GET_LOOKAHEAD_REQUEST: |
| 2326 | { |
| 2327 | opus_int32 *value = va_arg(ap, opus_int32*); |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2328 | if (!value) |
| 2329 | { |
| 2330 | goto bad_arg; |
| 2331 | } |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2332 | *value = st->Fs/400; |
| 2333 | if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY) |
| 2334 | *value += st->delay_compensation; |
| 2335 | } |
| 2336 | break; |
| 2337 | case OPUS_GET_SAMPLE_RATE_REQUEST: |
| 2338 | { |
| 2339 | opus_int32 *value = va_arg(ap, opus_int32*); |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2340 | if (!value) |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2341 | { |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2342 | goto bad_arg; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2343 | } |
| 2344 | *value = st->Fs; |
| 2345 | } |
| 2346 | break; |
| 2347 | case OPUS_GET_FINAL_RANGE_REQUEST: |
| 2348 | { |
| 2349 | opus_uint32 *value = va_arg(ap, opus_uint32*); |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2350 | if (!value) |
| 2351 | { |
| 2352 | goto bad_arg; |
| 2353 | } |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2354 | *value = st->rangeFinal; |
| 2355 | } |
| 2356 | break; |
| 2357 | case OPUS_SET_LSB_DEPTH_REQUEST: |
| 2358 | { |
| 2359 | opus_int32 value = va_arg(ap, opus_int32); |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2360 | if (value<8 || value>24) |
| 2361 | { |
| 2362 | goto bad_arg; |
| 2363 | } |
| 2364 | st->lsb_depth=value; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2365 | } |
| 2366 | break; |
| 2367 | case OPUS_GET_LSB_DEPTH_REQUEST: |
| 2368 | { |
| 2369 | opus_int32 *value = va_arg(ap, opus_int32*); |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2370 | if (!value) |
| 2371 | { |
| 2372 | goto bad_arg; |
| 2373 | } |
| 2374 | *value = st->lsb_depth; |
| 2375 | } |
| 2376 | break; |
| 2377 | case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST: |
| 2378 | { |
| 2379 | opus_int32 value = va_arg(ap, opus_int32); |
| 2380 | if (value != OPUS_FRAMESIZE_ARG && value != OPUS_FRAMESIZE_2_5_MS && |
| 2381 | value != OPUS_FRAMESIZE_5_MS && value != OPUS_FRAMESIZE_10_MS && |
| 2382 | value != OPUS_FRAMESIZE_20_MS && value != OPUS_FRAMESIZE_40_MS && |
| 2383 | value != OPUS_FRAMESIZE_60_MS && value != OPUS_FRAMESIZE_VARIABLE) |
| 2384 | { |
| 2385 | goto bad_arg; |
| 2386 | } |
| 2387 | st->variable_duration = value; |
| 2388 | celt_encoder_ctl(celt_enc, OPUS_SET_EXPERT_FRAME_DURATION(value)); |
| 2389 | } |
| 2390 | break; |
| 2391 | case OPUS_GET_EXPERT_FRAME_DURATION_REQUEST: |
| 2392 | { |
| 2393 | opus_int32 *value = va_arg(ap, opus_int32*); |
| 2394 | if (!value) |
| 2395 | { |
| 2396 | goto bad_arg; |
| 2397 | } |
| 2398 | *value = st->variable_duration; |
| 2399 | } |
| 2400 | break; |
| 2401 | case OPUS_SET_PREDICTION_DISABLED_REQUEST: |
| 2402 | { |
| 2403 | opus_int32 value = va_arg(ap, opus_int32); |
| 2404 | if (value > 1 || value < 0) |
| 2405 | goto bad_arg; |
| 2406 | st->silk_mode.reducedDependency = value; |
| 2407 | } |
| 2408 | break; |
| 2409 | case OPUS_GET_PREDICTION_DISABLED_REQUEST: |
| 2410 | { |
| 2411 | opus_int32 *value = va_arg(ap, opus_int32*); |
| 2412 | if (!value) |
| 2413 | goto bad_arg; |
| 2414 | *value = st->silk_mode.reducedDependency; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2415 | } |
| 2416 | break; |
| 2417 | case OPUS_RESET_STATE: |
| 2418 | { |
| 2419 | void *silk_enc; |
| 2420 | silk_EncControlStruct dummy; |
| 2421 | silk_enc = (char*)st+st->silk_enc_offset; |
| 2422 | |
| 2423 | OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START, |
| 2424 | sizeof(OpusEncoder)- |
| 2425 | ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st)); |
| 2426 | |
| 2427 | celt_encoder_ctl(celt_enc, OPUS_RESET_STATE); |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2428 | silk_InitEncoder( silk_enc, st->arch, &dummy ); |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2429 | st->stream_channels = st->channels; |
| 2430 | st->hybrid_stereo_width_Q14 = 1 << 14; |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2431 | st->prev_HB_gain = Q15ONE; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2432 | st->first = 1; |
| 2433 | st->mode = MODE_HYBRID; |
| 2434 | st->bandwidth = OPUS_BANDWIDTH_FULLBAND; |
| 2435 | st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 ); |
| 2436 | } |
| 2437 | break; |
| 2438 | case OPUS_SET_FORCE_MODE_REQUEST: |
| 2439 | { |
| 2440 | opus_int32 value = va_arg(ap, opus_int32); |
| 2441 | if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO) |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2442 | { |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2443 | goto bad_arg; |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2444 | } |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2445 | st->user_forced_mode = value; |
| 2446 | } |
| 2447 | break; |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 2448 | case OPUS_SET_LFE_REQUEST: |
| 2449 | { |
| 2450 | opus_int32 value = va_arg(ap, opus_int32); |
| 2451 | st->lfe = value; |
| 2452 | ret = celt_encoder_ctl(celt_enc, OPUS_SET_LFE(value)); |
| 2453 | } |
| 2454 | break; |
| 2455 | case OPUS_SET_ENERGY_MASK_REQUEST: |
| 2456 | { |
| 2457 | opus_val16 *value = va_arg(ap, opus_val16*); |
| 2458 | st->energy_masking = value; |
| 2459 | ret = celt_encoder_ctl(celt_enc, OPUS_SET_ENERGY_MASK(value)); |
| 2460 | } |
| 2461 | break; |
| 2462 | |
| 2463 | case CELT_GET_MODE_REQUEST: |
| 2464 | { |
| 2465 | const CELTMode ** value = va_arg(ap, const CELTMode**); |
| 2466 | if (!value) |
| 2467 | { |
| 2468 | goto bad_arg; |
| 2469 | } |
| 2470 | ret = celt_encoder_ctl(celt_enc, CELT_GET_MODE(value)); |
| 2471 | } |
| 2472 | break; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 2473 | default: |
| 2474 | /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/ |
| 2475 | ret = OPUS_UNIMPLEMENTED; |
| 2476 | break; |
| 2477 | } |
| 2478 | va_end(ap); |
| 2479 | return ret; |
| 2480 | bad_arg: |
| 2481 | va_end(ap); |
| 2482 | return OPUS_BAD_ARG; |
| 2483 | } |
| 2484 | |
| 2485 | void opus_encoder_destroy(OpusEncoder *st) |
| 2486 | { |
| 2487 | opus_free(st); |
| 2488 | } |