Line data Source code
1 : /***********************************************************************
2 : Copyright (c) 2006-2011, Skype Limited. All rights reserved.
3 : Redistribution and use in source and binary forms, with or without
4 : modification, are permitted provided that the following conditions
5 : are met:
6 : - Redistributions of source code must retain the above copyright notice,
7 : this list of conditions and the following disclaimer.
8 : - Redistributions in binary form must reproduce the above copyright
9 : notice, this list of conditions and the following disclaimer in the
10 : documentation and/or other materials provided with the distribution.
11 : - Neither the name of Internet Society, IETF or IETF Trust, nor the
12 : names of specific contributors, may be used to endorse or promote
13 : products derived from this software without specific prior written
14 : permission.
15 : THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
16 : AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 : IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 : ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
19 : LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
20 : CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
21 : SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
22 : INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
23 : CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
24 : ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
25 : POSSIBILITY OF SUCH DAMAGE.
26 : ***********************************************************************/
27 :
28 : #ifdef HAVE_CONFIG_H
29 : #include "config.h"
30 : #endif
31 : #ifdef FIXED_POINT
32 : #include "main_FIX.h"
33 : #define silk_encoder_state_Fxx silk_encoder_state_FIX
34 : #else
35 : #include "main_FLP.h"
36 : #define silk_encoder_state_Fxx silk_encoder_state_FLP
37 : #endif
38 : #include "stack_alloc.h"
39 : #include "tuning_parameters.h"
40 : #include "pitch_est_defines.h"
41 :
42 : static opus_int silk_setup_resamplers(
43 : silk_encoder_state_Fxx *psEnc, /* I/O */
44 : opus_int fs_kHz /* I */
45 : );
46 :
47 : static opus_int silk_setup_fs(
48 : silk_encoder_state_Fxx *psEnc, /* I/O */
49 : opus_int fs_kHz, /* I */
50 : opus_int PacketSize_ms /* I */
51 : );
52 :
53 : static opus_int silk_setup_complexity(
54 : silk_encoder_state *psEncC, /* I/O */
55 : opus_int Complexity /* I */
56 : );
57 :
58 : static OPUS_INLINE opus_int silk_setup_LBRR(
59 : silk_encoder_state *psEncC, /* I/O */
60 : const silk_EncControlStruct *encControl /* I */
61 : );
62 :
63 :
64 : /* Control encoder */
65 0 : opus_int silk_control_encoder(
66 : silk_encoder_state_Fxx *psEnc, /* I/O Pointer to Silk encoder state */
67 : silk_EncControlStruct *encControl, /* I Control structure */
68 : const opus_int allow_bw_switch, /* I Flag to allow switching audio bandwidth */
69 : const opus_int channelNb, /* I Channel number */
70 : const opus_int force_fs_kHz
71 : )
72 : {
73 0 : opus_int fs_kHz, ret = 0;
74 :
75 0 : psEnc->sCmn.useDTX = encControl->useDTX;
76 0 : psEnc->sCmn.useCBR = encControl->useCBR;
77 0 : psEnc->sCmn.API_fs_Hz = encControl->API_sampleRate;
78 0 : psEnc->sCmn.maxInternal_fs_Hz = encControl->maxInternalSampleRate;
79 0 : psEnc->sCmn.minInternal_fs_Hz = encControl->minInternalSampleRate;
80 0 : psEnc->sCmn.desiredInternal_fs_Hz = encControl->desiredInternalSampleRate;
81 0 : psEnc->sCmn.useInBandFEC = encControl->useInBandFEC;
82 0 : psEnc->sCmn.nChannelsAPI = encControl->nChannelsAPI;
83 0 : psEnc->sCmn.nChannelsInternal = encControl->nChannelsInternal;
84 0 : psEnc->sCmn.allow_bandwidth_switch = allow_bw_switch;
85 0 : psEnc->sCmn.channelNb = channelNb;
86 :
87 0 : if( psEnc->sCmn.controlled_since_last_payload != 0 && psEnc->sCmn.prefillFlag == 0 ) {
88 0 : if( psEnc->sCmn.API_fs_Hz != psEnc->sCmn.prev_API_fs_Hz && psEnc->sCmn.fs_kHz > 0 ) {
89 : /* Change in API sampling rate in the middle of encoding a packet */
90 0 : ret += silk_setup_resamplers( psEnc, psEnc->sCmn.fs_kHz );
91 : }
92 0 : return ret;
93 : }
94 :
95 : /* Beyond this point we know that there are no previously coded frames in the payload buffer */
96 :
97 : /********************************************/
98 : /* Determine internal sampling rate */
99 : /********************************************/
100 0 : fs_kHz = silk_control_audio_bandwidth( &psEnc->sCmn, encControl );
101 0 : if( force_fs_kHz ) {
102 0 : fs_kHz = force_fs_kHz;
103 : }
104 : /********************************************/
105 : /* Prepare resampler and buffered data */
106 : /********************************************/
107 0 : ret += silk_setup_resamplers( psEnc, fs_kHz );
108 :
109 : /********************************************/
110 : /* Set internal sampling frequency */
111 : /********************************************/
112 0 : ret += silk_setup_fs( psEnc, fs_kHz, encControl->payloadSize_ms );
113 :
114 : /********************************************/
115 : /* Set encoding complexity */
116 : /********************************************/
117 0 : ret += silk_setup_complexity( &psEnc->sCmn, encControl->complexity );
118 :
119 : /********************************************/
120 : /* Set packet loss rate measured by farend */
121 : /********************************************/
122 0 : psEnc->sCmn.PacketLoss_perc = encControl->packetLossPercentage;
123 :
124 : /********************************************/
125 : /* Set LBRR usage */
126 : /********************************************/
127 0 : ret += silk_setup_LBRR( &psEnc->sCmn, encControl );
128 :
129 0 : psEnc->sCmn.controlled_since_last_payload = 1;
130 :
131 0 : return ret;
132 : }
133 :
134 0 : static opus_int silk_setup_resamplers(
135 : silk_encoder_state_Fxx *psEnc, /* I/O */
136 : opus_int fs_kHz /* I */
137 : )
138 : {
139 0 : opus_int ret = SILK_NO_ERROR;
140 : SAVE_STACK;
141 :
142 0 : if( psEnc->sCmn.fs_kHz != fs_kHz || psEnc->sCmn.prev_API_fs_Hz != psEnc->sCmn.API_fs_Hz )
143 : {
144 0 : if( psEnc->sCmn.fs_kHz == 0 ) {
145 : /* Initialize the resampler for enc_API.c preparing resampling from API_fs_Hz to fs_kHz */
146 0 : ret += silk_resampler_init( &psEnc->sCmn.resampler_state, psEnc->sCmn.API_fs_Hz, fs_kHz * 1000, 1 );
147 : } else {
148 : VARDECL( opus_int16, x_buf_API_fs_Hz );
149 : VARDECL( silk_resampler_state_struct, temp_resampler_state );
150 : #ifdef FIXED_POINT
151 : opus_int16 *x_bufFIX = psEnc->x_buf;
152 : #else
153 : VARDECL( opus_int16, x_bufFIX );
154 : opus_int32 new_buf_samples;
155 : #endif
156 : opus_int32 api_buf_samples;
157 : opus_int32 old_buf_samples;
158 : opus_int32 buf_length_ms;
159 :
160 0 : buf_length_ms = silk_LSHIFT( psEnc->sCmn.nb_subfr * 5, 1 ) + LA_SHAPE_MS;
161 0 : old_buf_samples = buf_length_ms * psEnc->sCmn.fs_kHz;
162 :
163 : #ifndef FIXED_POINT
164 0 : new_buf_samples = buf_length_ms * fs_kHz;
165 0 : ALLOC( x_bufFIX, silk_max( old_buf_samples, new_buf_samples ),
166 : opus_int16 );
167 0 : silk_float2short_array( x_bufFIX, psEnc->x_buf, old_buf_samples );
168 : #endif
169 :
170 : /* Initialize resampler for temporary resampling of x_buf data to API_fs_Hz */
171 0 : ALLOC( temp_resampler_state, 1, silk_resampler_state_struct );
172 0 : ret += silk_resampler_init( temp_resampler_state, silk_SMULBB( psEnc->sCmn.fs_kHz, 1000 ), psEnc->sCmn.API_fs_Hz, 0 );
173 :
174 : /* Calculate number of samples to temporarily upsample */
175 0 : api_buf_samples = buf_length_ms * silk_DIV32_16( psEnc->sCmn.API_fs_Hz, 1000 );
176 :
177 : /* Temporary resampling of x_buf data to API_fs_Hz */
178 0 : ALLOC( x_buf_API_fs_Hz, api_buf_samples, opus_int16 );
179 0 : ret += silk_resampler( temp_resampler_state, x_buf_API_fs_Hz, x_bufFIX, old_buf_samples );
180 :
181 : /* Initialize the resampler for enc_API.c preparing resampling from API_fs_Hz to fs_kHz */
182 0 : ret += silk_resampler_init( &psEnc->sCmn.resampler_state, psEnc->sCmn.API_fs_Hz, silk_SMULBB( fs_kHz, 1000 ), 1 );
183 :
184 : /* Correct resampler state by resampling buffered data from API_fs_Hz to fs_kHz */
185 0 : ret += silk_resampler( &psEnc->sCmn.resampler_state, x_bufFIX, x_buf_API_fs_Hz, api_buf_samples );
186 :
187 : #ifndef FIXED_POINT
188 0 : silk_short2float_array( psEnc->x_buf, x_bufFIX, new_buf_samples);
189 : #endif
190 : }
191 : }
192 :
193 0 : psEnc->sCmn.prev_API_fs_Hz = psEnc->sCmn.API_fs_Hz;
194 :
195 : RESTORE_STACK;
196 0 : return ret;
197 : }
198 :
199 0 : static opus_int silk_setup_fs(
200 : silk_encoder_state_Fxx *psEnc, /* I/O */
201 : opus_int fs_kHz, /* I */
202 : opus_int PacketSize_ms /* I */
203 : )
204 : {
205 0 : opus_int ret = SILK_NO_ERROR;
206 :
207 : /* Set packet size */
208 0 : if( PacketSize_ms != psEnc->sCmn.PacketSize_ms ) {
209 0 : if( ( PacketSize_ms != 10 ) &&
210 0 : ( PacketSize_ms != 20 ) &&
211 0 : ( PacketSize_ms != 40 ) &&
212 : ( PacketSize_ms != 60 ) ) {
213 0 : ret = SILK_ENC_PACKET_SIZE_NOT_SUPPORTED;
214 : }
215 0 : if( PacketSize_ms <= 10 ) {
216 0 : psEnc->sCmn.nFramesPerPacket = 1;
217 0 : psEnc->sCmn.nb_subfr = PacketSize_ms == 10 ? 2 : 1;
218 0 : psEnc->sCmn.frame_length = silk_SMULBB( PacketSize_ms, fs_kHz );
219 0 : psEnc->sCmn.pitch_LPC_win_length = silk_SMULBB( FIND_PITCH_LPC_WIN_MS_2_SF, fs_kHz );
220 0 : if( psEnc->sCmn.fs_kHz == 8 ) {
221 0 : psEnc->sCmn.pitch_contour_iCDF = silk_pitch_contour_10_ms_NB_iCDF;
222 : } else {
223 0 : psEnc->sCmn.pitch_contour_iCDF = silk_pitch_contour_10_ms_iCDF;
224 : }
225 : } else {
226 0 : psEnc->sCmn.nFramesPerPacket = silk_DIV32_16( PacketSize_ms, MAX_FRAME_LENGTH_MS );
227 0 : psEnc->sCmn.nb_subfr = MAX_NB_SUBFR;
228 0 : psEnc->sCmn.frame_length = silk_SMULBB( 20, fs_kHz );
229 0 : psEnc->sCmn.pitch_LPC_win_length = silk_SMULBB( FIND_PITCH_LPC_WIN_MS, fs_kHz );
230 0 : if( psEnc->sCmn.fs_kHz == 8 ) {
231 0 : psEnc->sCmn.pitch_contour_iCDF = silk_pitch_contour_NB_iCDF;
232 : } else {
233 0 : psEnc->sCmn.pitch_contour_iCDF = silk_pitch_contour_iCDF;
234 : }
235 : }
236 0 : psEnc->sCmn.PacketSize_ms = PacketSize_ms;
237 0 : psEnc->sCmn.TargetRate_bps = 0; /* trigger new SNR computation */
238 : }
239 :
240 : /* Set internal sampling frequency */
241 0 : silk_assert( fs_kHz == 8 || fs_kHz == 12 || fs_kHz == 16 );
242 0 : silk_assert( psEnc->sCmn.nb_subfr == 2 || psEnc->sCmn.nb_subfr == 4 );
243 0 : if( psEnc->sCmn.fs_kHz != fs_kHz ) {
244 : /* reset part of the state */
245 0 : silk_memset( &psEnc->sShape, 0, sizeof( psEnc->sShape ) );
246 0 : silk_memset( &psEnc->sCmn.sNSQ, 0, sizeof( psEnc->sCmn.sNSQ ) );
247 0 : silk_memset( psEnc->sCmn.prev_NLSFq_Q15, 0, sizeof( psEnc->sCmn.prev_NLSFq_Q15 ) );
248 0 : silk_memset( &psEnc->sCmn.sLP.In_LP_State, 0, sizeof( psEnc->sCmn.sLP.In_LP_State ) );
249 0 : psEnc->sCmn.inputBufIx = 0;
250 0 : psEnc->sCmn.nFramesEncoded = 0;
251 0 : psEnc->sCmn.TargetRate_bps = 0; /* trigger new SNR computation */
252 :
253 : /* Initialize non-zero parameters */
254 0 : psEnc->sCmn.prevLag = 100;
255 0 : psEnc->sCmn.first_frame_after_reset = 1;
256 0 : psEnc->sShape.LastGainIndex = 10;
257 0 : psEnc->sCmn.sNSQ.lagPrev = 100;
258 0 : psEnc->sCmn.sNSQ.prev_gain_Q16 = 65536;
259 0 : psEnc->sCmn.prevSignalType = TYPE_NO_VOICE_ACTIVITY;
260 :
261 0 : psEnc->sCmn.fs_kHz = fs_kHz;
262 0 : if( psEnc->sCmn.fs_kHz == 8 ) {
263 0 : if( psEnc->sCmn.nb_subfr == MAX_NB_SUBFR ) {
264 0 : psEnc->sCmn.pitch_contour_iCDF = silk_pitch_contour_NB_iCDF;
265 : } else {
266 0 : psEnc->sCmn.pitch_contour_iCDF = silk_pitch_contour_10_ms_NB_iCDF;
267 : }
268 : } else {
269 0 : if( psEnc->sCmn.nb_subfr == MAX_NB_SUBFR ) {
270 0 : psEnc->sCmn.pitch_contour_iCDF = silk_pitch_contour_iCDF;
271 : } else {
272 0 : psEnc->sCmn.pitch_contour_iCDF = silk_pitch_contour_10_ms_iCDF;
273 : }
274 : }
275 0 : if( psEnc->sCmn.fs_kHz == 8 || psEnc->sCmn.fs_kHz == 12 ) {
276 0 : psEnc->sCmn.predictLPCOrder = MIN_LPC_ORDER;
277 0 : psEnc->sCmn.psNLSF_CB = &silk_NLSF_CB_NB_MB;
278 : } else {
279 0 : psEnc->sCmn.predictLPCOrder = MAX_LPC_ORDER;
280 0 : psEnc->sCmn.psNLSF_CB = &silk_NLSF_CB_WB;
281 : }
282 0 : psEnc->sCmn.subfr_length = SUB_FRAME_LENGTH_MS * fs_kHz;
283 0 : psEnc->sCmn.frame_length = silk_SMULBB( psEnc->sCmn.subfr_length, psEnc->sCmn.nb_subfr );
284 0 : psEnc->sCmn.ltp_mem_length = silk_SMULBB( LTP_MEM_LENGTH_MS, fs_kHz );
285 0 : psEnc->sCmn.la_pitch = silk_SMULBB( LA_PITCH_MS, fs_kHz );
286 0 : psEnc->sCmn.max_pitch_lag = silk_SMULBB( 18, fs_kHz );
287 0 : if( psEnc->sCmn.nb_subfr == MAX_NB_SUBFR ) {
288 0 : psEnc->sCmn.pitch_LPC_win_length = silk_SMULBB( FIND_PITCH_LPC_WIN_MS, fs_kHz );
289 : } else {
290 0 : psEnc->sCmn.pitch_LPC_win_length = silk_SMULBB( FIND_PITCH_LPC_WIN_MS_2_SF, fs_kHz );
291 : }
292 0 : if( psEnc->sCmn.fs_kHz == 16 ) {
293 0 : psEnc->sCmn.pitch_lag_low_bits_iCDF = silk_uniform8_iCDF;
294 0 : } else if( psEnc->sCmn.fs_kHz == 12 ) {
295 0 : psEnc->sCmn.pitch_lag_low_bits_iCDF = silk_uniform6_iCDF;
296 : } else {
297 0 : psEnc->sCmn.pitch_lag_low_bits_iCDF = silk_uniform4_iCDF;
298 : }
299 : }
300 :
301 : /* Check that settings are valid */
302 0 : silk_assert( ( psEnc->sCmn.subfr_length * psEnc->sCmn.nb_subfr ) == psEnc->sCmn.frame_length );
303 :
304 0 : return ret;
305 : }
306 :
307 0 : static opus_int silk_setup_complexity(
308 : silk_encoder_state *psEncC, /* I/O */
309 : opus_int Complexity /* I */
310 : )
311 : {
312 0 : opus_int ret = 0;
313 :
314 : /* Set encoding complexity */
315 0 : silk_assert( Complexity >= 0 && Complexity <= 10 );
316 0 : if( Complexity < 1 ) {
317 0 : psEncC->pitchEstimationComplexity = SILK_PE_MIN_COMPLEX;
318 0 : psEncC->pitchEstimationThreshold_Q16 = SILK_FIX_CONST( 0.8, 16 );
319 0 : psEncC->pitchEstimationLPCOrder = 6;
320 0 : psEncC->shapingLPCOrder = 12;
321 0 : psEncC->la_shape = 3 * psEncC->fs_kHz;
322 0 : psEncC->nStatesDelayedDecision = 1;
323 0 : psEncC->useInterpolatedNLSFs = 0;
324 0 : psEncC->NLSF_MSVQ_Survivors = 2;
325 0 : psEncC->warping_Q16 = 0;
326 0 : } else if( Complexity < 2 ) {
327 0 : psEncC->pitchEstimationComplexity = SILK_PE_MID_COMPLEX;
328 0 : psEncC->pitchEstimationThreshold_Q16 = SILK_FIX_CONST( 0.76, 16 );
329 0 : psEncC->pitchEstimationLPCOrder = 8;
330 0 : psEncC->shapingLPCOrder = 14;
331 0 : psEncC->la_shape = 5 * psEncC->fs_kHz;
332 0 : psEncC->nStatesDelayedDecision = 1;
333 0 : psEncC->useInterpolatedNLSFs = 0;
334 0 : psEncC->NLSF_MSVQ_Survivors = 3;
335 0 : psEncC->warping_Q16 = 0;
336 0 : } else if( Complexity < 3 ) {
337 0 : psEncC->pitchEstimationComplexity = SILK_PE_MIN_COMPLEX;
338 0 : psEncC->pitchEstimationThreshold_Q16 = SILK_FIX_CONST( 0.8, 16 );
339 0 : psEncC->pitchEstimationLPCOrder = 6;
340 0 : psEncC->shapingLPCOrder = 12;
341 0 : psEncC->la_shape = 3 * psEncC->fs_kHz;
342 0 : psEncC->nStatesDelayedDecision = 2;
343 0 : psEncC->useInterpolatedNLSFs = 0;
344 0 : psEncC->NLSF_MSVQ_Survivors = 2;
345 0 : psEncC->warping_Q16 = 0;
346 0 : } else if( Complexity < 4 ) {
347 0 : psEncC->pitchEstimationComplexity = SILK_PE_MID_COMPLEX;
348 0 : psEncC->pitchEstimationThreshold_Q16 = SILK_FIX_CONST( 0.76, 16 );
349 0 : psEncC->pitchEstimationLPCOrder = 8;
350 0 : psEncC->shapingLPCOrder = 14;
351 0 : psEncC->la_shape = 5 * psEncC->fs_kHz;
352 0 : psEncC->nStatesDelayedDecision = 2;
353 0 : psEncC->useInterpolatedNLSFs = 0;
354 0 : psEncC->NLSF_MSVQ_Survivors = 4;
355 0 : psEncC->warping_Q16 = 0;
356 0 : } else if( Complexity < 6 ) {
357 0 : psEncC->pitchEstimationComplexity = SILK_PE_MID_COMPLEX;
358 0 : psEncC->pitchEstimationThreshold_Q16 = SILK_FIX_CONST( 0.74, 16 );
359 0 : psEncC->pitchEstimationLPCOrder = 10;
360 0 : psEncC->shapingLPCOrder = 16;
361 0 : psEncC->la_shape = 5 * psEncC->fs_kHz;
362 0 : psEncC->nStatesDelayedDecision = 2;
363 0 : psEncC->useInterpolatedNLSFs = 1;
364 0 : psEncC->NLSF_MSVQ_Survivors = 6;
365 0 : psEncC->warping_Q16 = psEncC->fs_kHz * SILK_FIX_CONST( WARPING_MULTIPLIER, 16 );
366 0 : } else if( Complexity < 8 ) {
367 0 : psEncC->pitchEstimationComplexity = SILK_PE_MID_COMPLEX;
368 0 : psEncC->pitchEstimationThreshold_Q16 = SILK_FIX_CONST( 0.72, 16 );
369 0 : psEncC->pitchEstimationLPCOrder = 12;
370 0 : psEncC->shapingLPCOrder = 20;
371 0 : psEncC->la_shape = 5 * psEncC->fs_kHz;
372 0 : psEncC->nStatesDelayedDecision = 3;
373 0 : psEncC->useInterpolatedNLSFs = 1;
374 0 : psEncC->NLSF_MSVQ_Survivors = 8;
375 0 : psEncC->warping_Q16 = psEncC->fs_kHz * SILK_FIX_CONST( WARPING_MULTIPLIER, 16 );
376 : } else {
377 0 : psEncC->pitchEstimationComplexity = SILK_PE_MAX_COMPLEX;
378 0 : psEncC->pitchEstimationThreshold_Q16 = SILK_FIX_CONST( 0.7, 16 );
379 0 : psEncC->pitchEstimationLPCOrder = 16;
380 0 : psEncC->shapingLPCOrder = 24;
381 0 : psEncC->la_shape = 5 * psEncC->fs_kHz;
382 0 : psEncC->nStatesDelayedDecision = MAX_DEL_DEC_STATES;
383 0 : psEncC->useInterpolatedNLSFs = 1;
384 0 : psEncC->NLSF_MSVQ_Survivors = 16;
385 0 : psEncC->warping_Q16 = psEncC->fs_kHz * SILK_FIX_CONST( WARPING_MULTIPLIER, 16 );
386 : }
387 :
388 : /* Do not allow higher pitch estimation LPC order than predict LPC order */
389 0 : psEncC->pitchEstimationLPCOrder = silk_min_int( psEncC->pitchEstimationLPCOrder, psEncC->predictLPCOrder );
390 0 : psEncC->shapeWinLength = SUB_FRAME_LENGTH_MS * psEncC->fs_kHz + 2 * psEncC->la_shape;
391 0 : psEncC->Complexity = Complexity;
392 :
393 0 : silk_assert( psEncC->pitchEstimationLPCOrder <= MAX_FIND_PITCH_LPC_ORDER );
394 0 : silk_assert( psEncC->shapingLPCOrder <= MAX_SHAPE_LPC_ORDER );
395 0 : silk_assert( psEncC->nStatesDelayedDecision <= MAX_DEL_DEC_STATES );
396 0 : silk_assert( psEncC->warping_Q16 <= 32767 );
397 0 : silk_assert( psEncC->la_shape <= LA_SHAPE_MAX );
398 0 : silk_assert( psEncC->shapeWinLength <= SHAPE_LPC_WIN_MAX );
399 :
400 0 : return ret;
401 : }
402 :
403 0 : static OPUS_INLINE opus_int silk_setup_LBRR(
404 : silk_encoder_state *psEncC, /* I/O */
405 : const silk_EncControlStruct *encControl /* I */
406 : )
407 : {
408 0 : opus_int LBRR_in_previous_packet, ret = SILK_NO_ERROR;
409 :
410 0 : LBRR_in_previous_packet = psEncC->LBRR_enabled;
411 0 : psEncC->LBRR_enabled = encControl->LBRR_coded;
412 0 : if( psEncC->LBRR_enabled ) {
413 : /* Set gain increase for coding LBRR excitation */
414 0 : if( LBRR_in_previous_packet == 0 ) {
415 : /* Previous packet did not have LBRR, and was therefore coded at a higher bitrate */
416 0 : psEncC->LBRR_GainIncreases = 7;
417 : } else {
418 0 : psEncC->LBRR_GainIncreases = silk_max_int( 7 - silk_SMULWB( (opus_int32)psEncC->PacketLoss_perc, SILK_FIX_CONST( 0.4, 16 ) ), 2 );
419 : }
420 : }
421 :
422 0 : return ret;
423 : }
|
