1pub mod SigProc_FLP_h {
2 #[inline]
3 pub unsafe fn silk_short2float_array(out: *mut f32, in_0: *const i16, length: i32) {
4 let mut k: i32 = 0;
5 k = length - 1;
6 while k >= 0 {
7 *out.offset(k as isize) = *in_0.offset(k as isize) as f32;
8 k -= 1;
9 }
10 }
11}
12pub use self::SigProc_FLP_h::silk_short2float_array;
13use crate::celt::entcode::{ec_ctx_saved, ec_tell};
14use crate::celt::entenc::ec_enc;
15use crate::externs::{memcpy, memmove};
16use crate::silk::define::{
17 CODE_CONDITIONALLY, LA_SHAPE_MS, MAX_CONSECUTIVE_DTX, NB_SPEECH_FRAMES_BEFORE_DTX,
18 N_LEVELS_QGAIN, TYPE_NO_VOICE_ACTIVITY, TYPE_UNVOICED, VAD_NO_ACTIVITY,
19};
20use crate::silk::encode_indices::silk_encode_indices;
21use crate::silk::encode_pulses::silk_encode_pulses;
22use crate::silk::float::find_pitch_lags_FLP::silk_find_pitch_lags_FLP;
23use crate::silk::float::find_pred_coefs_FLP::silk_find_pred_coefs_FLP;
24use crate::silk::float::noise_shape_analysis_FLP::silk_noise_shape_analysis_FLP;
25use crate::silk::float::process_gains_FLP::silk_process_gains_FLP;
26use crate::silk::float::structs_FLP::{silk_encoder_control_FLP, silk_encoder_state_FLP};
27use crate::silk::float::wrappers_FLP::silk_NSQ_wrapper_FLP;
28use crate::silk::gain_quant::{silk_gains_ID, silk_gains_dequant, silk_gains_quant};
29use crate::silk::log2lin::silk_log2lin;
30use crate::silk::structs::{silk_nsq_state, SideInfoIndices};
31use crate::silk::LP_variable_cutoff::silk_LP_variable_cutoff;
32use crate::silk::SigProc_FIX::silk_min_int;
33use crate::silk::VAD::silk_VAD_GetSA_Q8_c;
34
35pub unsafe fn silk_encode_do_VAD_FLP(psEnc: *mut silk_encoder_state_FLP, activity: i32) {
36 let activity_threshold: i32 = ((0.05f32 * ((1) << 8) as f32) as f64 + 0.5f64) as i32;
37 silk_VAD_GetSA_Q8_c(
38 &mut (*psEnc).sCmn,
39 ((*psEnc).sCmn.inputBuf).as_mut_ptr().offset(1 as isize) as *const i16,
40 );
41 if activity == VAD_NO_ACTIVITY && (*psEnc).sCmn.speech_activity_Q8 >= activity_threshold {
42 (*psEnc).sCmn.speech_activity_Q8 = activity_threshold - 1;
43 }
44 if (*psEnc).sCmn.speech_activity_Q8 < activity_threshold {
45 (*psEnc).sCmn.indices.signalType = TYPE_NO_VOICE_ACTIVITY as i8;
46 (*psEnc).sCmn.noSpeechCounter += 1;
47 if (*psEnc).sCmn.noSpeechCounter <= NB_SPEECH_FRAMES_BEFORE_DTX {
48 (*psEnc).sCmn.inDTX = 0;
49 } else if (*psEnc).sCmn.noSpeechCounter > MAX_CONSECUTIVE_DTX + NB_SPEECH_FRAMES_BEFORE_DTX
50 {
51 (*psEnc).sCmn.noSpeechCounter = NB_SPEECH_FRAMES_BEFORE_DTX;
52 (*psEnc).sCmn.inDTX = 0;
53 }
54 (*psEnc).sCmn.VAD_flags[(*psEnc).sCmn.nFramesEncoded as usize] = 0;
55 } else {
56 (*psEnc).sCmn.noSpeechCounter = 0;
57 (*psEnc).sCmn.inDTX = 0;
58 (*psEnc).sCmn.indices.signalType = TYPE_UNVOICED as i8;
59 (*psEnc).sCmn.VAD_flags[(*psEnc).sCmn.nFramesEncoded as usize] = 1;
60 };
61}
62pub unsafe fn silk_encode_frame_FLP(
63 psEnc: *mut silk_encoder_state_FLP,
64 pnBytesOut: *mut i32,
65 mut psRangeEnc: Option<&mut ec_enc>,
66 condCoding: i32,
67 maxBits: i32,
68 useCBR: i32,
69) -> i32 {
70 let mut sEncCtrl: silk_encoder_control_FLP = silk_encoder_control_FLP {
71 Gains: [0.; 4],
72 PredCoef: [[0.; 16]; 2],
73 LTPCoef: [0.; 20],
74 LTP_scale: 0.,
75 pitchL: [0; 4],
76 AR: [0.; 96],
77 LF_MA_shp: [0.; 4],
78 LF_AR_shp: [0.; 4],
79 Tilt: [0.; 4],
80 HarmShapeGain: [0.; 4],
81 Lambda: 0.,
82 input_quality: 0.,
83 coding_quality: 0.,
84 predGain: 0.,
85 LTPredCodGain: 0.,
86 ResNrg: [0.; 4],
87 GainsUnq_Q16: [0; 4],
88 lastGainIndexPrev: 0,
89 };
90 let mut i: i32 = 0;
91 let mut iter: i32 = 0;
92 let mut maxIter: i32 = 0;
93 let mut found_upper: i32 = 0;
94 let mut found_lower: i32 = 0;
95 let ret: i32 = 0;
96 let mut x_frame: *mut f32 = 0 as *mut f32;
97 let mut res_pitch_frame: *mut f32 = 0 as *mut f32;
98 let mut res_pitch: [f32; 672] = [0.; 672];
99 let mut sRangeEnc_copy = ec_ctx_saved::default();
100 let mut sRangeEnc_copy2 = ec_ctx_saved::default();
101 let mut sNSQ_copy: silk_nsq_state = silk_nsq_state {
102 xq: [0; 640],
103 sLTP_shp_Q14: [0; 640],
104 sLPC_Q14: [0; 96],
105 sAR2_Q14: [0; 24],
106 sLF_AR_shp_Q14: 0,
107 sDiff_shp_Q14: 0,
108 lagPrev: 0,
109 sLTP_buf_idx: 0,
110 sLTP_shp_buf_idx: 0,
111 rand_seed: 0,
112 prev_gain_Q16: 0,
113 rewhite_flag: 0,
114 };
115 let mut sNSQ_copy2: silk_nsq_state = silk_nsq_state {
116 xq: [0; 640],
117 sLTP_shp_Q14: [0; 640],
118 sLPC_Q14: [0; 96],
119 sAR2_Q14: [0; 24],
120 sLF_AR_shp_Q14: 0,
121 sDiff_shp_Q14: 0,
122 lagPrev: 0,
123 sLTP_buf_idx: 0,
124 sLTP_shp_buf_idx: 0,
125 rand_seed: 0,
126 prev_gain_Q16: 0,
127 rewhite_flag: 0,
128 };
129 let mut seed_copy: i32 = 0;
130 let mut nBits: i32 = 0;
131 let mut nBits_lower: i32 = 0;
132 let mut nBits_upper: i32 = 0;
133 let mut gainMult_lower: i32 = 0;
134 let mut gainMult_upper: i32 = 0;
135 let mut gainsID: i32 = 0;
136 let mut gainsID_lower: i32 = 0;
137 let mut gainsID_upper: i32 = 0;
138 let mut gainMult_Q8: i16 = 0;
139 let mut ec_prevLagIndex_copy: i16 = 0;
140 let mut ec_prevSignalType_copy: i32 = 0;
141 let mut LastGainIndex_copy2: i8 = 0;
142 let mut pGains_Q16: [i32; 4] = [0; 4];
143 let mut ec_buf_copy: [u8; 1275] = [0; 1275];
144 let mut gain_lock: [i32; 4] = [0, 0, 0, 0];
145 let mut best_gain_mult: [i16; 4] = [0; 4];
146 let mut best_sum: [i32; 4] = [0; 4];
147 gainMult_upper = 0;
148 gainMult_lower = gainMult_upper;
149 nBits_upper = gainMult_lower;
150 nBits_lower = nBits_upper;
151 LastGainIndex_copy2 = nBits_lower as i8;
152 let fresh0 = (*psEnc).sCmn.frameCounter;
153 (*psEnc).sCmn.frameCounter = (*psEnc).sCmn.frameCounter + 1;
154 (*psEnc).sCmn.indices.Seed = (fresh0 & 3) as i8;
155 x_frame = ((*psEnc).x_buf)
156 .as_mut_ptr()
157 .offset((*psEnc).sCmn.ltp_mem_length as isize);
158 res_pitch_frame = res_pitch
159 .as_mut_ptr()
160 .offset((*psEnc).sCmn.ltp_mem_length as isize);
161 silk_LP_variable_cutoff(
162 &mut (*psEnc).sCmn.sLP,
163 ((*psEnc).sCmn.inputBuf).as_mut_ptr().offset(1 as isize),
164 (*psEnc).sCmn.frame_length,
165 );
166 silk_short2float_array(
167 x_frame.offset((LA_SHAPE_MS * (*psEnc).sCmn.fs_kHz) as isize),
168 ((*psEnc).sCmn.inputBuf).as_mut_ptr().offset(1 as isize),
169 (*psEnc).sCmn.frame_length,
170 );
171 i = 0;
172 while i < 8 {
173 *x_frame.offset(
174 (LA_SHAPE_MS * (*psEnc).sCmn.fs_kHz + i * ((*psEnc).sCmn.frame_length >> 3)) as isize,
175 ) += (1 - (i & 2)) as f32 * 1e-6f32;
176 i += 1;
177 }
178 if (*psEnc).sCmn.prefillFlag == 0 {
179 let psRangeEnc = &mut **psRangeEnc.as_mut().unwrap();
180
181 silk_find_pitch_lags_FLP(
182 psEnc,
183 &mut sEncCtrl,
184 res_pitch.as_mut_ptr(),
185 x_frame as *const f32,
186 (*psEnc).sCmn.arch,
187 );
188 silk_noise_shape_analysis_FLP(psEnc, &mut sEncCtrl, res_pitch_frame, x_frame);
189 silk_find_pred_coefs_FLP(
190 psEnc,
191 &mut sEncCtrl,
192 res_pitch_frame as *const f32,
193 x_frame as *const f32,
194 condCoding,
195 );
196 silk_process_gains_FLP(psEnc, &mut sEncCtrl, condCoding);
197 silk_LBRR_encode_FLP(psEnc, &mut sEncCtrl, x_frame as *const f32, condCoding);
198 maxIter = 6;
199 gainMult_Q8 = ((1 * ((1) << 8)) as f64 + 0.5f64) as i32 as i16;
200 found_lower = 0;
201 found_upper = 0;
202 gainsID = silk_gains_ID(
203 ((*psEnc).sCmn.indices.GainsIndices).as_mut_ptr() as *const i8,
204 (*psEnc).sCmn.nb_subfr,
205 );
206 gainsID_lower = -1;
207 gainsID_upper = -1;
208 sRangeEnc_copy = psRangeEnc.save();
209 memcpy(
210 &mut sNSQ_copy as *mut silk_nsq_state as *mut core::ffi::c_void,
211 &mut (*psEnc).sCmn.sNSQ as *mut silk_nsq_state as *const core::ffi::c_void,
212 ::core::mem::size_of::<silk_nsq_state>() as u64,
213 );
214 seed_copy = (*psEnc).sCmn.indices.Seed as i32;
215 ec_prevLagIndex_copy = (*psEnc).sCmn.ec_prevLagIndex;
216 ec_prevSignalType_copy = (*psEnc).sCmn.ec_prevSignalType;
217 iter = 0;
218 loop {
219 if gainsID == gainsID_lower {
220 nBits = nBits_lower;
221 } else if gainsID == gainsID_upper {
222 nBits = nBits_upper;
223 } else {
224 if iter > 0 {
225 psRangeEnc.restore(sRangeEnc_copy);
226 memcpy(
227 &mut (*psEnc).sCmn.sNSQ as *mut silk_nsq_state as *mut core::ffi::c_void,
228 &mut sNSQ_copy as *mut silk_nsq_state as *const core::ffi::c_void,
229 ::core::mem::size_of::<silk_nsq_state>() as u64,
230 );
231 (*psEnc).sCmn.indices.Seed = seed_copy as i8;
232 (*psEnc).sCmn.ec_prevLagIndex = ec_prevLagIndex_copy;
233 (*psEnc).sCmn.ec_prevSignalType = ec_prevSignalType_copy;
234 }
235 silk_NSQ_wrapper_FLP(
236 psEnc,
237 &mut sEncCtrl,
238 &mut (*psEnc).sCmn.indices,
239 &mut (*psEnc).sCmn.sNSQ,
240 ((*psEnc).sCmn.pulses).as_mut_ptr(),
241 x_frame as *const f32,
242 );
243 if iter == maxIter && found_lower == 0 {
244 sRangeEnc_copy2 = psRangeEnc.save();
245 }
246 silk_encode_indices(
247 &mut (*psEnc).sCmn,
248 psRangeEnc,
249 (*psEnc).sCmn.nFramesEncoded,
250 0,
251 condCoding,
252 );
253 silk_encode_pulses(
254 psRangeEnc,
255 (*psEnc).sCmn.indices.signalType as i32,
256 (*psEnc).sCmn.indices.quantOffsetType as i32,
257 &mut (*psEnc).sCmn.pulses,
258 (*psEnc).sCmn.frame_length,
259 );
260 nBits = ec_tell(psRangeEnc);
261 if iter == maxIter && found_lower == 0 && nBits > maxBits {
262 psRangeEnc.restore(sRangeEnc_copy2);
263 (*psEnc).sShape.LastGainIndex = sEncCtrl.lastGainIndexPrev;
264 i = 0;
265 while i < (*psEnc).sCmn.nb_subfr {
266 (*psEnc).sCmn.indices.GainsIndices[i as usize] = 4;
267 i += 1;
268 }
269 if condCoding != CODE_CONDITIONALLY {
270 (*psEnc).sCmn.indices.GainsIndices[0 as usize] = sEncCtrl.lastGainIndexPrev;
271 }
272 (*psEnc).sCmn.ec_prevLagIndex = ec_prevLagIndex_copy;
273 (*psEnc).sCmn.ec_prevSignalType = ec_prevSignalType_copy;
274 i = 0;
275 while i < (*psEnc).sCmn.frame_length {
276 (*psEnc).sCmn.pulses[i as usize] = 0;
277 i += 1;
278 }
279 silk_encode_indices(
280 &mut (*psEnc).sCmn,
281 psRangeEnc,
282 (*psEnc).sCmn.nFramesEncoded,
283 0,
284 condCoding,
285 );
286 silk_encode_pulses(
287 psRangeEnc,
288 (*psEnc).sCmn.indices.signalType as i32,
289 (*psEnc).sCmn.indices.quantOffsetType as i32,
290 &mut (*psEnc).sCmn.pulses,
291 (*psEnc).sCmn.frame_length,
292 );
293 nBits = ec_tell(psRangeEnc);
294 }
295 if useCBR == 0 && iter == 0 && nBits <= maxBits {
296 break;
297 }
298 }
299 if iter == maxIter {
300 if found_lower != 0 && (gainsID == gainsID_lower || nBits > maxBits) {
301 psRangeEnc.restore(sRangeEnc_copy2);
302 assert!(sRangeEnc_copy2.offs <= 1275);
303 memcpy(
304 (*psRangeEnc).buf.as_mut_ptr() as *mut core::ffi::c_void,
305 ec_buf_copy.as_mut_ptr() as *const core::ffi::c_void,
306 sRangeEnc_copy2.offs as u64,
307 );
308 memcpy(
309 &mut (*psEnc).sCmn.sNSQ as *mut silk_nsq_state as *mut core::ffi::c_void,
310 &mut sNSQ_copy2 as *mut silk_nsq_state as *const core::ffi::c_void,
311 ::core::mem::size_of::<silk_nsq_state>() as u64,
312 );
313 (*psEnc).sShape.LastGainIndex = LastGainIndex_copy2;
314 }
315 break;
316 } else {
317 if nBits > maxBits {
318 if found_lower == 0 && iter >= 2 {
319 sEncCtrl.Lambda = if sEncCtrl.Lambda * 1.5f32 > 1.5f32 {
320 sEncCtrl.Lambda * 1.5f32
321 } else {
322 1.5f32
323 };
324 (*psEnc).sCmn.indices.quantOffsetType = 0;
325 found_upper = 0;
326 gainsID_upper = -1;
327 } else {
328 found_upper = 1;
329 nBits_upper = nBits;
330 gainMult_upper = gainMult_Q8 as i32;
331 gainsID_upper = gainsID;
332 }
333 } else {
334 if !(nBits < maxBits - 5) {
335 break;
336 }
337 found_lower = 1;
338 nBits_lower = nBits;
339 gainMult_lower = gainMult_Q8 as i32;
340 if gainsID != gainsID_lower {
341 gainsID_lower = gainsID;
342 sRangeEnc_copy2 = psRangeEnc.save();
343 assert!((*psRangeEnc).offs <= 1275);
344 memcpy(
345 ec_buf_copy.as_mut_ptr() as *mut core::ffi::c_void,
346 (*psRangeEnc).buf.as_mut_ptr() as *const core::ffi::c_void,
347 (*psRangeEnc).offs as u64,
348 );
349 memcpy(
350 &mut sNSQ_copy2 as *mut silk_nsq_state as *mut core::ffi::c_void,
351 &mut (*psEnc).sCmn.sNSQ as *mut silk_nsq_state
352 as *const core::ffi::c_void,
353 ::core::mem::size_of::<silk_nsq_state>() as u64,
354 );
355 LastGainIndex_copy2 = (*psEnc).sShape.LastGainIndex;
356 }
357 }
358 if found_lower == 0 && nBits > maxBits {
359 let mut j: i32 = 0;
360 i = 0;
361 while i < (*psEnc).sCmn.nb_subfr {
362 let mut sum: i32 = 0;
363 j = i * (*psEnc).sCmn.subfr_length;
364 while j < (i + 1) * (*psEnc).sCmn.subfr_length {
365 sum += ((*psEnc).sCmn.pulses[j as usize] as i32).abs();
366 j += 1;
367 }
368 if iter == 0 || sum < best_sum[i as usize] && gain_lock[i as usize] == 0 {
369 best_sum[i as usize] = sum;
370 best_gain_mult[i as usize] = gainMult_Q8;
371 } else {
372 gain_lock[i as usize] = 1;
373 }
374 i += 1;
375 }
376 }
377 if found_lower & found_upper == 0 {
378 if nBits > maxBits {
379 if (gainMult_Q8 as i32) < 16384 {
380 gainMult_Q8 = (gainMult_Q8 as i32 * 2) as i16;
381 } else {
382 gainMult_Q8 = 32767;
383 }
384 } else {
385 let mut gain_factor_Q16: i32 = 0;
386 gain_factor_Q16 = silk_log2lin(
387 (((nBits - maxBits) as u32) << 7) as i32 / (*psEnc).sCmn.frame_length
388 + ((16 * ((1) << 7)) as f64 + 0.5f64) as i32,
389 );
390 gainMult_Q8 =
391 (gain_factor_Q16 as i64 * gainMult_Q8 as i64 >> 16) as i32 as i16;
392 }
393 } else {
394 gainMult_Q8 = (gainMult_lower
395 + (gainMult_upper - gainMult_lower) * (maxBits - nBits_lower)
396 / (nBits_upper - nBits_lower)) as i16;
397 if gainMult_Q8 as i32 > gainMult_lower + (gainMult_upper - gainMult_lower >> 2)
398 {
399 gainMult_Q8 =
400 (gainMult_lower + (gainMult_upper - gainMult_lower >> 2)) as i16;
401 } else if (gainMult_Q8 as i32)
402 < gainMult_upper - (gainMult_upper - gainMult_lower >> 2)
403 {
404 gainMult_Q8 =
405 (gainMult_upper - (gainMult_upper - gainMult_lower >> 2)) as i16;
406 }
407 }
408 i = 0;
409 while i < (*psEnc).sCmn.nb_subfr {
410 let mut tmp: i16 = 0;
411 if gain_lock[i as usize] != 0 {
412 tmp = best_gain_mult[i as usize];
413 } else {
414 tmp = gainMult_Q8;
415 }
416 pGains_Q16[i as usize] = (((if 0x80000000 as u32 as i32 >> 8 > 0x7fffffff >> 8 {
417 if (sEncCtrl.GainsUnq_Q16[i as usize] as i64 * tmp as i64 >> 16) as i32
418 > 0x80000000 as u32 as i32 >> 8
419 {
420 0x80000000 as u32 as i32 >> 8
421 } else {
422 if ((sEncCtrl.GainsUnq_Q16[i as usize] as i64 * tmp as i64 >> 16)
423 as i32)
424 < 0x7fffffff >> 8
425 {
426 0x7fffffff >> 8
427 } else {
428 (sEncCtrl.GainsUnq_Q16[i as usize] as i64 * tmp as i64 >> 16) as i32
429 }
430 }
431 } else {
432 if (sEncCtrl.GainsUnq_Q16[i as usize] as i64 * tmp as i64 >> 16) as i32
433 > 0x7fffffff >> 8
434 {
435 0x7fffffff >> 8
436 } else {
437 if ((sEncCtrl.GainsUnq_Q16[i as usize] as i64 * tmp as i64 >> 16)
438 as i32)
439 < 0x80000000 as u32 as i32 >> 8
440 {
441 0x80000000 as u32 as i32 >> 8
442 } else {
443 (sEncCtrl.GainsUnq_Q16[i as usize] as i64 * tmp as i64 >> 16) as i32
444 }
445 }
446 }) as u32)
447 << 8) as i32;
448 i += 1;
449 }
450 (*psEnc).sShape.LastGainIndex = sEncCtrl.lastGainIndexPrev;
451 silk_gains_quant(
452 ((*psEnc).sCmn.indices.GainsIndices).as_mut_ptr(),
453 pGains_Q16.as_mut_ptr(),
454 &mut (*psEnc).sShape.LastGainIndex,
455 (condCoding == CODE_CONDITIONALLY) as i32,
456 (*psEnc).sCmn.nb_subfr,
457 );
458 gainsID = silk_gains_ID(
459 ((*psEnc).sCmn.indices.GainsIndices).as_mut_ptr() as *const i8,
460 (*psEnc).sCmn.nb_subfr,
461 );
462 i = 0;
463 while i < (*psEnc).sCmn.nb_subfr {
464 sEncCtrl.Gains[i as usize] = pGains_Q16[i as usize] as f32 / 65536.0f32;
465 i += 1;
466 }
467 iter += 1;
468 }
469 }
470 }
471 memmove(
472 ((*psEnc).x_buf).as_mut_ptr() as *mut core::ffi::c_void,
473 &mut *((*psEnc).x_buf)
474 .as_mut_ptr()
475 .offset((*psEnc).sCmn.frame_length as isize) as *mut f32
476 as *const core::ffi::c_void,
477 (((*psEnc).sCmn.ltp_mem_length + 5 * (*psEnc).sCmn.fs_kHz) as u64)
478 .wrapping_mul(::core::mem::size_of::<f32>() as u64),
479 );
480 if (*psEnc).sCmn.prefillFlag != 0 {
481 *pnBytesOut = 0;
482 return ret;
483 }
484 (*psEnc).sCmn.prevLag = sEncCtrl.pitchL[((*psEnc).sCmn.nb_subfr - 1) as usize];
485 (*psEnc).sCmn.prevSignalType = (*psEnc).sCmn.indices.signalType;
486 (*psEnc).sCmn.first_frame_after_reset = 0;
487 *pnBytesOut = (ec_tell(psRangeEnc.unwrap()) + 7) >> 3;
488
489 ret
490}
491#[inline]
492unsafe fn silk_LBRR_encode_FLP(
493 psEnc: *mut silk_encoder_state_FLP,
494 psEncCtrl: *mut silk_encoder_control_FLP,
495 xfw: *const f32,
496 condCoding: i32,
497) {
498 let mut k: i32 = 0;
499 let mut Gains_Q16: [i32; 4] = [0; 4];
500 let mut TempGains: [f32; 4] = [0.; 4];
501 let psIndices_LBRR: *mut SideInfoIndices = &mut *((*psEnc).sCmn.indices_LBRR)
502 .as_mut_ptr()
503 .offset((*psEnc).sCmn.nFramesEncoded as isize)
504 as *mut SideInfoIndices;
505 let mut sNSQ_LBRR: silk_nsq_state = silk_nsq_state {
506 xq: [0; 640],
507 sLTP_shp_Q14: [0; 640],
508 sLPC_Q14: [0; 96],
509 sAR2_Q14: [0; 24],
510 sLF_AR_shp_Q14: 0,
511 sDiff_shp_Q14: 0,
512 lagPrev: 0,
513 sLTP_buf_idx: 0,
514 sLTP_shp_buf_idx: 0,
515 rand_seed: 0,
516 prev_gain_Q16: 0,
517 rewhite_flag: 0,
518 };
519 if (*psEnc).sCmn.LBRR_enabled != 0
520 && (*psEnc).sCmn.speech_activity_Q8 > ((0.3f32 * ((1) << 8) as f32) as f64 + 0.5f64) as i32
521 {
522 (*psEnc).sCmn.LBRR_flags[(*psEnc).sCmn.nFramesEncoded as usize] = 1;
523 memcpy(
524 &mut sNSQ_LBRR as *mut silk_nsq_state as *mut core::ffi::c_void,
525 &mut (*psEnc).sCmn.sNSQ as *mut silk_nsq_state as *const core::ffi::c_void,
526 ::core::mem::size_of::<silk_nsq_state>() as u64,
527 );
528 memcpy(
529 psIndices_LBRR as *mut core::ffi::c_void,
530 &mut (*psEnc).sCmn.indices as *mut SideInfoIndices as *const core::ffi::c_void,
531 ::core::mem::size_of::<SideInfoIndices>() as u64,
532 );
533 memcpy(
534 TempGains.as_mut_ptr() as *mut core::ffi::c_void,
535 ((*psEncCtrl).Gains).as_mut_ptr() as *const core::ffi::c_void,
536 ((*psEnc).sCmn.nb_subfr as u64).wrapping_mul(::core::mem::size_of::<f32>() as u64),
537 );
538 if (*psEnc).sCmn.nFramesEncoded == 0
539 || (*psEnc).sCmn.LBRR_flags[((*psEnc).sCmn.nFramesEncoded - 1) as usize] == 0
540 {
541 (*psEnc).sCmn.LBRRprevLastGainIndex = (*psEnc).sShape.LastGainIndex;
542 (*psIndices_LBRR).GainsIndices[0 as usize] =
543 ((*psIndices_LBRR).GainsIndices[0 as usize] as i32
544 + (*psEnc).sCmn.LBRR_GainIncreases) as i8;
545 (*psIndices_LBRR).GainsIndices[0 as usize] = silk_min_int(
546 (*psIndices_LBRR).GainsIndices[0 as usize] as i32,
547 N_LEVELS_QGAIN - 1,
548 ) as i8;
549 }
550 silk_gains_dequant(
551 Gains_Q16.as_mut_ptr(),
552 ((*psIndices_LBRR).GainsIndices).as_mut_ptr() as *const i8,
553 &mut (*psEnc).sCmn.LBRRprevLastGainIndex,
554 (condCoding == CODE_CONDITIONALLY) as i32,
555 (*psEnc).sCmn.nb_subfr,
556 );
557 k = 0;
558 while k < (*psEnc).sCmn.nb_subfr {
559 (*psEncCtrl).Gains[k as usize] = Gains_Q16[k as usize] as f32 * (1.0f32 / 65536.0f32);
560 k += 1;
561 }
562 silk_NSQ_wrapper_FLP(
563 psEnc,
564 psEncCtrl,
565 psIndices_LBRR,
566 &mut sNSQ_LBRR,
567 ((*psEnc).sCmn.pulses_LBRR[(*psEnc).sCmn.nFramesEncoded as usize]).as_mut_ptr(),
568 xfw,
569 );
570 memcpy(
571 ((*psEncCtrl).Gains).as_mut_ptr() as *mut core::ffi::c_void,
572 TempGains.as_mut_ptr() as *const core::ffi::c_void,
573 ((*psEnc).sCmn.nb_subfr as u64).wrapping_mul(::core::mem::size_of::<f32>() as u64),
574 );
575 }
576}