diff options
author | William Wilgus <me.theuser@yahoo.com> | 2019-01-04 02:01:18 -0600 |
---|---|---|
committer | Solomon Peachy <pizza@shaftnet.org> | 2021-04-23 14:23:04 +0000 |
commit | 14c6bb798d6bebc80f07e863236adbaf8d156a9c (patch) | |
tree | 551a4b641906c2626af844fa3239c1b2b1ff0ad3 /lib/rbcodec/codecs/libopus/silk/control_codec.c | |
parent | 75d93937965ec4df70d37df6d4feea04577c996b (diff) | |
download | rockbox-14c6bb798d6bebc80f07e863236adbaf8d156a9c.tar.gz rockbox-14c6bb798d6bebc80f07e863236adbaf8d156a9c.zip |
Sync opus codec to upstream git
Change-Id: I0cfcc0005c4ad7bfbb1aaf454188ce70fb043dc1
Diffstat (limited to 'lib/rbcodec/codecs/libopus/silk/control_codec.c')
-rw-r--r-- | lib/rbcodec/codecs/libopus/silk/control_codec.c | 423 |
1 files changed, 423 insertions, 0 deletions
diff --git a/lib/rbcodec/codecs/libopus/silk/control_codec.c b/lib/rbcodec/codecs/libopus/silk/control_codec.c new file mode 100644 index 0000000000..52aa8fded3 --- /dev/null +++ b/lib/rbcodec/codecs/libopus/silk/control_codec.c | |||
@@ -0,0 +1,423 @@ | |||
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 | 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 | opus_int fs_kHz, ret = 0; | ||
74 | |||
75 | psEnc->sCmn.useDTX = encControl->useDTX; | ||
76 | psEnc->sCmn.useCBR = encControl->useCBR; | ||
77 | psEnc->sCmn.API_fs_Hz = encControl->API_sampleRate; | ||
78 | psEnc->sCmn.maxInternal_fs_Hz = encControl->maxInternalSampleRate; | ||
79 | psEnc->sCmn.minInternal_fs_Hz = encControl->minInternalSampleRate; | ||
80 | psEnc->sCmn.desiredInternal_fs_Hz = encControl->desiredInternalSampleRate; | ||
81 | psEnc->sCmn.useInBandFEC = encControl->useInBandFEC; | ||
82 | psEnc->sCmn.nChannelsAPI = encControl->nChannelsAPI; | ||
83 | psEnc->sCmn.nChannelsInternal = encControl->nChannelsInternal; | ||
84 | psEnc->sCmn.allow_bandwidth_switch = allow_bw_switch; | ||
85 | psEnc->sCmn.channelNb = channelNb; | ||
86 | |||
87 | if( psEnc->sCmn.controlled_since_last_payload != 0 && psEnc->sCmn.prefillFlag == 0 ) { | ||
88 | 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 | ret += silk_setup_resamplers( psEnc, psEnc->sCmn.fs_kHz ); | ||
91 | } | ||
92 | 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 | fs_kHz = silk_control_audio_bandwidth( &psEnc->sCmn, encControl ); | ||
101 | if( force_fs_kHz ) { | ||
102 | fs_kHz = force_fs_kHz; | ||
103 | } | ||
104 | /********************************************/ | ||
105 | /* Prepare resampler and buffered data */ | ||
106 | /********************************************/ | ||
107 | ret += silk_setup_resamplers( psEnc, fs_kHz ); | ||
108 | |||
109 | /********************************************/ | ||
110 | /* Set internal sampling frequency */ | ||
111 | /********************************************/ | ||
112 | ret += silk_setup_fs( psEnc, fs_kHz, encControl->payloadSize_ms ); | ||
113 | |||
114 | /********************************************/ | ||
115 | /* Set encoding complexity */ | ||
116 | /********************************************/ | ||
117 | ret += silk_setup_complexity( &psEnc->sCmn, encControl->complexity ); | ||
118 | |||
119 | /********************************************/ | ||
120 | /* Set packet loss rate measured by farend */ | ||
121 | /********************************************/ | ||
122 | psEnc->sCmn.PacketLoss_perc = encControl->packetLossPercentage; | ||
123 | |||
124 | /********************************************/ | ||
125 | /* Set LBRR usage */ | ||
126 | /********************************************/ | ||
127 | ret += silk_setup_LBRR( &psEnc->sCmn, encControl ); | ||
128 | |||
129 | psEnc->sCmn.controlled_since_last_payload = 1; | ||
130 | |||
131 | return ret; | ||
132 | } | ||
133 | |||
134 | static opus_int silk_setup_resamplers( | ||
135 | silk_encoder_state_Fxx *psEnc, /* I/O */ | ||
136 | opus_int fs_kHz /* I */ | ||
137 | ) | ||
138 | { | ||
139 | opus_int ret = SILK_NO_ERROR; | ||
140 | SAVE_STACK; | ||
141 | |||
142 | if( psEnc->sCmn.fs_kHz != fs_kHz || psEnc->sCmn.prev_API_fs_Hz != psEnc->sCmn.API_fs_Hz ) | ||
143 | { | ||
144 | if( psEnc->sCmn.fs_kHz == 0 ) { | ||
145 | /* Initialize the resampler for enc_API.c preparing resampling from API_fs_Hz to fs_kHz */ | ||
146 | 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 | buf_length_ms = silk_LSHIFT( psEnc->sCmn.nb_subfr * 5, 1 ) + LA_SHAPE_MS; | ||
161 | old_buf_samples = buf_length_ms * psEnc->sCmn.fs_kHz; | ||
162 | |||
163 | #ifndef FIXED_POINT | ||
164 | new_buf_samples = buf_length_ms * fs_kHz; | ||
165 | ALLOC( x_bufFIX, silk_max( old_buf_samples, new_buf_samples ), | ||
166 | opus_int16 ); | ||
167 | 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 | ALLOC( temp_resampler_state, 1, silk_resampler_state_struct ); | ||
172 | 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 | 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 | ALLOC( x_buf_API_fs_Hz, api_buf_samples, opus_int16 ); | ||
179 | 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 | 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 | ret += silk_resampler( &psEnc->sCmn.resampler_state, x_bufFIX, x_buf_API_fs_Hz, api_buf_samples ); | ||
186 | |||
187 | #ifndef FIXED_POINT | ||
188 | silk_short2float_array( psEnc->x_buf, x_bufFIX, new_buf_samples); | ||
189 | #endif | ||
190 | } | ||
191 | } | ||
192 | |||
193 | psEnc->sCmn.prev_API_fs_Hz = psEnc->sCmn.API_fs_Hz; | ||
194 | |||
195 | RESTORE_STACK; | ||
196 | return ret; | ||
197 | } | ||
198 | |||
199 | 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 | opus_int ret = SILK_NO_ERROR; | ||
206 | |||
207 | /* Set packet size */ | ||
208 | if( PacketSize_ms != psEnc->sCmn.PacketSize_ms ) { | ||
209 | if( ( PacketSize_ms != 10 ) && | ||
210 | ( PacketSize_ms != 20 ) && | ||
211 | ( PacketSize_ms != 40 ) && | ||
212 | ( PacketSize_ms != 60 ) ) { | ||
213 | ret = SILK_ENC_PACKET_SIZE_NOT_SUPPORTED; | ||
214 | } | ||
215 | if( PacketSize_ms <= 10 ) { | ||
216 | psEnc->sCmn.nFramesPerPacket = 1; | ||
217 | psEnc->sCmn.nb_subfr = PacketSize_ms == 10 ? 2 : 1; | ||
218 | psEnc->sCmn.frame_length = silk_SMULBB( PacketSize_ms, fs_kHz ); | ||
219 | psEnc->sCmn.pitch_LPC_win_length = silk_SMULBB( FIND_PITCH_LPC_WIN_MS_2_SF, fs_kHz ); | ||
220 | if( psEnc->sCmn.fs_kHz == 8 ) { | ||
221 | psEnc->sCmn.pitch_contour_iCDF = silk_pitch_contour_10_ms_NB_iCDF; | ||
222 | } else { | ||
223 | psEnc->sCmn.pitch_contour_iCDF = silk_pitch_contour_10_ms_iCDF; | ||
224 | } | ||
225 | } else { | ||
226 | psEnc->sCmn.nFramesPerPacket = silk_DIV32_16( PacketSize_ms, MAX_FRAME_LENGTH_MS ); | ||
227 | psEnc->sCmn.nb_subfr = MAX_NB_SUBFR; | ||
228 | psEnc->sCmn.frame_length = silk_SMULBB( 20, fs_kHz ); | ||
229 | psEnc->sCmn.pitch_LPC_win_length = silk_SMULBB( FIND_PITCH_LPC_WIN_MS, fs_kHz ); | ||
230 | if( psEnc->sCmn.fs_kHz == 8 ) { | ||
231 | psEnc->sCmn.pitch_contour_iCDF = silk_pitch_contour_NB_iCDF; | ||
232 | } else { | ||
233 | psEnc->sCmn.pitch_contour_iCDF = silk_pitch_contour_iCDF; | ||
234 | } | ||
235 | } | ||
236 | psEnc->sCmn.PacketSize_ms = PacketSize_ms; | ||
237 | psEnc->sCmn.TargetRate_bps = 0; /* trigger new SNR computation */ | ||
238 | } | ||
239 | |||
240 | /* Set internal sampling frequency */ | ||
241 | celt_assert( fs_kHz == 8 || fs_kHz == 12 || fs_kHz == 16 ); | ||
242 | celt_assert( psEnc->sCmn.nb_subfr == 2 || psEnc->sCmn.nb_subfr == 4 ); | ||
243 | if( psEnc->sCmn.fs_kHz != fs_kHz ) { | ||
244 | /* reset part of the state */ | ||
245 | silk_memset( &psEnc->sShape, 0, sizeof( psEnc->sShape ) ); | ||
246 | silk_memset( &psEnc->sCmn.sNSQ, 0, sizeof( psEnc->sCmn.sNSQ ) ); | ||
247 | silk_memset( psEnc->sCmn.prev_NLSFq_Q15, 0, sizeof( psEnc->sCmn.prev_NLSFq_Q15 ) ); | ||
248 | silk_memset( &psEnc->sCmn.sLP.In_LP_State, 0, sizeof( psEnc->sCmn.sLP.In_LP_State ) ); | ||
249 | psEnc->sCmn.inputBufIx = 0; | ||
250 | psEnc->sCmn.nFramesEncoded = 0; | ||
251 | psEnc->sCmn.TargetRate_bps = 0; /* trigger new SNR computation */ | ||
252 | |||
253 | /* Initialize non-zero parameters */ | ||
254 | psEnc->sCmn.prevLag = 100; | ||
255 | psEnc->sCmn.first_frame_after_reset = 1; | ||
256 | psEnc->sShape.LastGainIndex = 10; | ||
257 | psEnc->sCmn.sNSQ.lagPrev = 100; | ||
258 | psEnc->sCmn.sNSQ.prev_gain_Q16 = 65536; | ||
259 | psEnc->sCmn.prevSignalType = TYPE_NO_VOICE_ACTIVITY; | ||
260 | |||
261 | psEnc->sCmn.fs_kHz = fs_kHz; | ||
262 | if( psEnc->sCmn.fs_kHz == 8 ) { | ||
263 | if( psEnc->sCmn.nb_subfr == MAX_NB_SUBFR ) { | ||
264 | psEnc->sCmn.pitch_contour_iCDF = silk_pitch_contour_NB_iCDF; | ||
265 | } else { | ||
266 | psEnc->sCmn.pitch_contour_iCDF = silk_pitch_contour_10_ms_NB_iCDF; | ||
267 | } | ||
268 | } else { | ||
269 | if( psEnc->sCmn.nb_subfr == MAX_NB_SUBFR ) { | ||
270 | psEnc->sCmn.pitch_contour_iCDF = silk_pitch_contour_iCDF; | ||
271 | } else { | ||
272 | psEnc->sCmn.pitch_contour_iCDF = silk_pitch_contour_10_ms_iCDF; | ||
273 | } | ||
274 | } | ||
275 | if( psEnc->sCmn.fs_kHz == 8 || psEnc->sCmn.fs_kHz == 12 ) { | ||
276 | psEnc->sCmn.predictLPCOrder = MIN_LPC_ORDER; | ||
277 | psEnc->sCmn.psNLSF_CB = &silk_NLSF_CB_NB_MB; | ||
278 | } else { | ||
279 | psEnc->sCmn.predictLPCOrder = MAX_LPC_ORDER; | ||
280 | psEnc->sCmn.psNLSF_CB = &silk_NLSF_CB_WB; | ||
281 | } | ||
282 | psEnc->sCmn.subfr_length = SUB_FRAME_LENGTH_MS * fs_kHz; | ||
283 | psEnc->sCmn.frame_length = silk_SMULBB( psEnc->sCmn.subfr_length, psEnc->sCmn.nb_subfr ); | ||
284 | psEnc->sCmn.ltp_mem_length = silk_SMULBB( LTP_MEM_LENGTH_MS, fs_kHz ); | ||
285 | psEnc->sCmn.la_pitch = silk_SMULBB( LA_PITCH_MS, fs_kHz ); | ||
286 | psEnc->sCmn.max_pitch_lag = silk_SMULBB( 18, fs_kHz ); | ||
287 | if( psEnc->sCmn.nb_subfr == MAX_NB_SUBFR ) { | ||
288 | psEnc->sCmn.pitch_LPC_win_length = silk_SMULBB( FIND_PITCH_LPC_WIN_MS, fs_kHz ); | ||
289 | } else { | ||
290 | psEnc->sCmn.pitch_LPC_win_length = silk_SMULBB( FIND_PITCH_LPC_WIN_MS_2_SF, fs_kHz ); | ||
291 | } | ||
292 | if( psEnc->sCmn.fs_kHz == 16 ) { | ||
293 | psEnc->sCmn.pitch_lag_low_bits_iCDF = silk_uniform8_iCDF; | ||
294 | } else if( psEnc->sCmn.fs_kHz == 12 ) { | ||
295 | psEnc->sCmn.pitch_lag_low_bits_iCDF = silk_uniform6_iCDF; | ||
296 | } else { | ||
297 | psEnc->sCmn.pitch_lag_low_bits_iCDF = silk_uniform4_iCDF; | ||
298 | } | ||
299 | } | ||
300 | |||
301 | /* Check that settings are valid */ | ||
302 | celt_assert( ( psEnc->sCmn.subfr_length * psEnc->sCmn.nb_subfr ) == psEnc->sCmn.frame_length ); | ||
303 | |||
304 | return ret; | ||
305 | } | ||
306 | |||
307 | static opus_int silk_setup_complexity( | ||
308 | silk_encoder_state *psEncC, /* I/O */ | ||
309 | opus_int Complexity /* I */ | ||
310 | ) | ||
311 | { | ||
312 | opus_int ret = 0; | ||
313 | |||
314 | /* Set encoding complexity */ | ||
315 | celt_assert( Complexity >= 0 && Complexity <= 10 ); | ||
316 | if( Complexity < 1 ) { | ||
317 | psEncC->pitchEstimationComplexity = SILK_PE_MIN_COMPLEX; | ||
318 | psEncC->pitchEstimationThreshold_Q16 = SILK_FIX_CONST( 0.8, 16 ); | ||
319 | psEncC->pitchEstimationLPCOrder = 6; | ||
320 | psEncC->shapingLPCOrder = 12; | ||
321 | psEncC->la_shape = 3 * psEncC->fs_kHz; | ||
322 | psEncC->nStatesDelayedDecision = 1; | ||
323 | psEncC->useInterpolatedNLSFs = 0; | ||
324 | psEncC->NLSF_MSVQ_Survivors = 2; | ||
325 | psEncC->warping_Q16 = 0; | ||
326 | } else if( Complexity < 2 ) { | ||
327 | psEncC->pitchEstimationComplexity = SILK_PE_MID_COMPLEX; | ||
328 | psEncC->pitchEstimationThreshold_Q16 = SILK_FIX_CONST( 0.76, 16 ); | ||
329 | psEncC->pitchEstimationLPCOrder = 8; | ||
330 | psEncC->shapingLPCOrder = 14; | ||
331 | psEncC->la_shape = 5 * psEncC->fs_kHz; | ||
332 | psEncC->nStatesDelayedDecision = 1; | ||
333 | psEncC->useInterpolatedNLSFs = 0; | ||
334 | psEncC->NLSF_MSVQ_Survivors = 3; | ||
335 | psEncC->warping_Q16 = 0; | ||
336 | } else if( Complexity < 3 ) { | ||
337 | psEncC->pitchEstimationComplexity = SILK_PE_MIN_COMPLEX; | ||
338 | psEncC->pitchEstimationThreshold_Q16 = SILK_FIX_CONST( 0.8, 16 ); | ||
339 | psEncC->pitchEstimationLPCOrder = 6; | ||
340 | psEncC->shapingLPCOrder = 12; | ||
341 | psEncC->la_shape = 3 * psEncC->fs_kHz; | ||
342 | psEncC->nStatesDelayedDecision = 2; | ||
343 | psEncC->useInterpolatedNLSFs = 0; | ||
344 | psEncC->NLSF_MSVQ_Survivors = 2; | ||
345 | psEncC->warping_Q16 = 0; | ||
346 | } else if( Complexity < 4 ) { | ||
347 | psEncC->pitchEstimationComplexity = SILK_PE_MID_COMPLEX; | ||
348 | psEncC->pitchEstimationThreshold_Q16 = SILK_FIX_CONST( 0.76, 16 ); | ||
349 | psEncC->pitchEstimationLPCOrder = 8; | ||
350 | psEncC->shapingLPCOrder = 14; | ||
351 | psEncC->la_shape = 5 * psEncC->fs_kHz; | ||
352 | psEncC->nStatesDelayedDecision = 2; | ||
353 | psEncC->useInterpolatedNLSFs = 0; | ||
354 | psEncC->NLSF_MSVQ_Survivors = 4; | ||
355 | psEncC->warping_Q16 = 0; | ||
356 | } else if( Complexity < 6 ) { | ||
357 | psEncC->pitchEstimationComplexity = SILK_PE_MID_COMPLEX; | ||
358 | psEncC->pitchEstimationThreshold_Q16 = SILK_FIX_CONST( 0.74, 16 ); | ||
359 | psEncC->pitchEstimationLPCOrder = 10; | ||
360 | psEncC->shapingLPCOrder = 16; | ||
361 | psEncC->la_shape = 5 * psEncC->fs_kHz; | ||
362 | psEncC->nStatesDelayedDecision = 2; | ||
363 | psEncC->useInterpolatedNLSFs = 1; | ||
364 | psEncC->NLSF_MSVQ_Survivors = 6; | ||
365 | psEncC->warping_Q16 = psEncC->fs_kHz * SILK_FIX_CONST( WARPING_MULTIPLIER, 16 ); | ||
366 | } else if( Complexity < 8 ) { | ||
367 | psEncC->pitchEstimationComplexity = SILK_PE_MID_COMPLEX; | ||
368 | psEncC->pitchEstimationThreshold_Q16 = SILK_FIX_CONST( 0.72, 16 ); | ||
369 | psEncC->pitchEstimationLPCOrder = 12; | ||
370 | psEncC->shapingLPCOrder = 20; | ||
371 | psEncC->la_shape = 5 * psEncC->fs_kHz; | ||
372 | psEncC->nStatesDelayedDecision = 3; | ||
373 | psEncC->useInterpolatedNLSFs = 1; | ||
374 | psEncC->NLSF_MSVQ_Survivors = 8; | ||
375 | psEncC->warping_Q16 = psEncC->fs_kHz * SILK_FIX_CONST( WARPING_MULTIPLIER, 16 ); | ||
376 | } else { | ||
377 | psEncC->pitchEstimationComplexity = SILK_PE_MAX_COMPLEX; | ||
378 | psEncC->pitchEstimationThreshold_Q16 = SILK_FIX_CONST( 0.7, 16 ); | ||
379 | psEncC->pitchEstimationLPCOrder = 16; | ||
380 | psEncC->shapingLPCOrder = 24; | ||
381 | psEncC->la_shape = 5 * psEncC->fs_kHz; | ||
382 | psEncC->nStatesDelayedDecision = MAX_DEL_DEC_STATES; | ||
383 | psEncC->useInterpolatedNLSFs = 1; | ||
384 | psEncC->NLSF_MSVQ_Survivors = 16; | ||
385 | 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 | psEncC->pitchEstimationLPCOrder = silk_min_int( psEncC->pitchEstimationLPCOrder, psEncC->predictLPCOrder ); | ||
390 | psEncC->shapeWinLength = SUB_FRAME_LENGTH_MS * psEncC->fs_kHz + 2 * psEncC->la_shape; | ||
391 | psEncC->Complexity = Complexity; | ||
392 | |||
393 | celt_assert( psEncC->pitchEstimationLPCOrder <= MAX_FIND_PITCH_LPC_ORDER ); | ||
394 | celt_assert( psEncC->shapingLPCOrder <= MAX_SHAPE_LPC_ORDER ); | ||
395 | celt_assert( psEncC->nStatesDelayedDecision <= MAX_DEL_DEC_STATES ); | ||
396 | celt_assert( psEncC->warping_Q16 <= 32767 ); | ||
397 | celt_assert( psEncC->la_shape <= LA_SHAPE_MAX ); | ||
398 | celt_assert( psEncC->shapeWinLength <= SHAPE_LPC_WIN_MAX ); | ||
399 | |||
400 | return ret; | ||
401 | } | ||
402 | |||
403 | static OPUS_INLINE opus_int silk_setup_LBRR( | ||
404 | silk_encoder_state *psEncC, /* I/O */ | ||
405 | const silk_EncControlStruct *encControl /* I */ | ||
406 | ) | ||
407 | { | ||
408 | opus_int LBRR_in_previous_packet, ret = SILK_NO_ERROR; | ||
409 | |||
410 | LBRR_in_previous_packet = psEncC->LBRR_enabled; | ||
411 | psEncC->LBRR_enabled = encControl->LBRR_coded; | ||
412 | if( psEncC->LBRR_enabled ) { | ||
413 | /* Set gain increase for coding LBRR excitation */ | ||
414 | if( LBRR_in_previous_packet == 0 ) { | ||
415 | /* Previous packet did not have LBRR, and was therefore coded at a higher bitrate */ | ||
416 | psEncC->LBRR_GainIncreases = 7; | ||
417 | } else { | ||
418 | 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 | return ret; | ||
423 | } | ||