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/fixed/encode_frame_FIX.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/fixed/encode_frame_FIX.c')
-rw-r--r-- | lib/rbcodec/codecs/libopus/silk/fixed/encode_frame_FIX.c | 448 |
1 files changed, 448 insertions, 0 deletions
diff --git a/lib/rbcodec/codecs/libopus/silk/fixed/encode_frame_FIX.c b/lib/rbcodec/codecs/libopus/silk/fixed/encode_frame_FIX.c new file mode 100644 index 0000000000..a02bf87dbb --- /dev/null +++ b/lib/rbcodec/codecs/libopus/silk/fixed/encode_frame_FIX.c | |||
@@ -0,0 +1,448 @@ | |||
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 | |||
32 | #include <stdlib.h> | ||
33 | #include "main_FIX.h" | ||
34 | #include "stack_alloc.h" | ||
35 | #include "tuning_parameters.h" | ||
36 | |||
37 | /* Low Bitrate Redundancy (LBRR) encoding. Reuse all parameters but encode with lower bitrate */ | ||
38 | static OPUS_INLINE void silk_LBRR_encode_FIX( | ||
39 | silk_encoder_state_FIX *psEnc, /* I/O Pointer to Silk FIX encoder state */ | ||
40 | silk_encoder_control_FIX *psEncCtrl, /* I/O Pointer to Silk FIX encoder control struct */ | ||
41 | const opus_int16 x16[], /* I Input signal */ | ||
42 | opus_int condCoding /* I The type of conditional coding used so far for this frame */ | ||
43 | ); | ||
44 | |||
45 | void silk_encode_do_VAD_FIX( | ||
46 | silk_encoder_state_FIX *psEnc, /* I/O Pointer to Silk FIX encoder state */ | ||
47 | opus_int activity /* I Decision of Opus voice activity detector */ | ||
48 | ) | ||
49 | { | ||
50 | const opus_int activity_threshold = SILK_FIX_CONST( SPEECH_ACTIVITY_DTX_THRES, 8 ); | ||
51 | |||
52 | /****************************/ | ||
53 | /* Voice Activity Detection */ | ||
54 | /****************************/ | ||
55 | silk_VAD_GetSA_Q8( &psEnc->sCmn, psEnc->sCmn.inputBuf + 1, psEnc->sCmn.arch ); | ||
56 | /* If Opus VAD is inactive and Silk VAD is active: lower Silk VAD to just under the threshold */ | ||
57 | if( activity == VAD_NO_ACTIVITY && psEnc->sCmn.speech_activity_Q8 >= activity_threshold ) { | ||
58 | psEnc->sCmn.speech_activity_Q8 = activity_threshold - 1; | ||
59 | } | ||
60 | |||
61 | /**************************************************/ | ||
62 | /* Convert speech activity into VAD and DTX flags */ | ||
63 | /**************************************************/ | ||
64 | if( psEnc->sCmn.speech_activity_Q8 < activity_threshold ) { | ||
65 | psEnc->sCmn.indices.signalType = TYPE_NO_VOICE_ACTIVITY; | ||
66 | psEnc->sCmn.noSpeechCounter++; | ||
67 | if( psEnc->sCmn.noSpeechCounter <= NB_SPEECH_FRAMES_BEFORE_DTX ) { | ||
68 | psEnc->sCmn.inDTX = 0; | ||
69 | } else if( psEnc->sCmn.noSpeechCounter > MAX_CONSECUTIVE_DTX + NB_SPEECH_FRAMES_BEFORE_DTX ) { | ||
70 | psEnc->sCmn.noSpeechCounter = NB_SPEECH_FRAMES_BEFORE_DTX; | ||
71 | psEnc->sCmn.inDTX = 0; | ||
72 | } | ||
73 | psEnc->sCmn.VAD_flags[ psEnc->sCmn.nFramesEncoded ] = 0; | ||
74 | } else { | ||
75 | psEnc->sCmn.noSpeechCounter = 0; | ||
76 | psEnc->sCmn.inDTX = 0; | ||
77 | psEnc->sCmn.indices.signalType = TYPE_UNVOICED; | ||
78 | psEnc->sCmn.VAD_flags[ psEnc->sCmn.nFramesEncoded ] = 1; | ||
79 | } | ||
80 | } | ||
81 | |||
82 | /****************/ | ||
83 | /* Encode frame */ | ||
84 | /****************/ | ||
85 | opus_int silk_encode_frame_FIX( | ||
86 | silk_encoder_state_FIX *psEnc, /* I/O Pointer to Silk FIX encoder state */ | ||
87 | opus_int32 *pnBytesOut, /* O Pointer to number of payload bytes; */ | ||
88 | ec_enc *psRangeEnc, /* I/O compressor data structure */ | ||
89 | opus_int condCoding, /* I The type of conditional coding to use */ | ||
90 | opus_int maxBits, /* I If > 0: maximum number of output bits */ | ||
91 | opus_int useCBR /* I Flag to force constant-bitrate operation */ | ||
92 | ) | ||
93 | { | ||
94 | silk_encoder_control_FIX sEncCtrl; | ||
95 | opus_int i, iter, maxIter, found_upper, found_lower, ret = 0; | ||
96 | opus_int16 *x_frame; | ||
97 | ec_enc sRangeEnc_copy, sRangeEnc_copy2; | ||
98 | silk_nsq_state sNSQ_copy, sNSQ_copy2; | ||
99 | opus_int32 seed_copy, nBits, nBits_lower, nBits_upper, gainMult_lower, gainMult_upper; | ||
100 | opus_int32 gainsID, gainsID_lower, gainsID_upper; | ||
101 | opus_int16 gainMult_Q8; | ||
102 | opus_int16 ec_prevLagIndex_copy; | ||
103 | opus_int ec_prevSignalType_copy; | ||
104 | opus_int8 LastGainIndex_copy2; | ||
105 | opus_int gain_lock[ MAX_NB_SUBFR ] = {0}; | ||
106 | opus_int16 best_gain_mult[ MAX_NB_SUBFR ]; | ||
107 | opus_int best_sum[ MAX_NB_SUBFR ]; | ||
108 | SAVE_STACK; | ||
109 | |||
110 | /* This is totally unnecessary but many compilers (including gcc) are too dumb to realise it */ | ||
111 | LastGainIndex_copy2 = nBits_lower = nBits_upper = gainMult_lower = gainMult_upper = 0; | ||
112 | |||
113 | psEnc->sCmn.indices.Seed = psEnc->sCmn.frameCounter++ & 3; | ||
114 | |||
115 | /**************************************************************/ | ||
116 | /* Set up Input Pointers, and insert frame in input buffer */ | ||
117 | /*************************************************************/ | ||
118 | /* start of frame to encode */ | ||
119 | x_frame = psEnc->x_buf + psEnc->sCmn.ltp_mem_length; | ||
120 | |||
121 | /***************************************/ | ||
122 | /* Ensure smooth bandwidth transitions */ | ||
123 | /***************************************/ | ||
124 | silk_LP_variable_cutoff( &psEnc->sCmn.sLP, psEnc->sCmn.inputBuf + 1, psEnc->sCmn.frame_length ); | ||
125 | |||
126 | /*******************************************/ | ||
127 | /* Copy new frame to front of input buffer */ | ||
128 | /*******************************************/ | ||
129 | silk_memcpy( x_frame + LA_SHAPE_MS * psEnc->sCmn.fs_kHz, psEnc->sCmn.inputBuf + 1, psEnc->sCmn.frame_length * sizeof( opus_int16 ) ); | ||
130 | |||
131 | if( !psEnc->sCmn.prefillFlag ) { | ||
132 | VARDECL( opus_int16, res_pitch ); | ||
133 | VARDECL( opus_uint8, ec_buf_copy ); | ||
134 | opus_int16 *res_pitch_frame; | ||
135 | |||
136 | ALLOC( res_pitch, | ||
137 | psEnc->sCmn.la_pitch + psEnc->sCmn.frame_length | ||
138 | + psEnc->sCmn.ltp_mem_length, opus_int16 ); | ||
139 | /* start of pitch LPC residual frame */ | ||
140 | res_pitch_frame = res_pitch + psEnc->sCmn.ltp_mem_length; | ||
141 | |||
142 | /*****************************************/ | ||
143 | /* Find pitch lags, initial LPC analysis */ | ||
144 | /*****************************************/ | ||
145 | silk_find_pitch_lags_FIX( psEnc, &sEncCtrl, res_pitch, x_frame - psEnc->sCmn.ltp_mem_length, psEnc->sCmn.arch ); | ||
146 | |||
147 | /************************/ | ||
148 | /* Noise shape analysis */ | ||
149 | /************************/ | ||
150 | silk_noise_shape_analysis_FIX( psEnc, &sEncCtrl, res_pitch_frame, x_frame, psEnc->sCmn.arch ); | ||
151 | |||
152 | /***************************************************/ | ||
153 | /* Find linear prediction coefficients (LPC + LTP) */ | ||
154 | /***************************************************/ | ||
155 | silk_find_pred_coefs_FIX( psEnc, &sEncCtrl, res_pitch_frame, x_frame, condCoding ); | ||
156 | |||
157 | /****************************************/ | ||
158 | /* Process gains */ | ||
159 | /****************************************/ | ||
160 | silk_process_gains_FIX( psEnc, &sEncCtrl, condCoding ); | ||
161 | |||
162 | /****************************************/ | ||
163 | /* Low Bitrate Redundant Encoding */ | ||
164 | /****************************************/ | ||
165 | silk_LBRR_encode_FIX( psEnc, &sEncCtrl, x_frame, condCoding ); | ||
166 | |||
167 | /* Loop over quantizer and entropy coding to control bitrate */ | ||
168 | maxIter = 6; | ||
169 | gainMult_Q8 = SILK_FIX_CONST( 1, 8 ); | ||
170 | found_lower = 0; | ||
171 | found_upper = 0; | ||
172 | gainsID = silk_gains_ID( psEnc->sCmn.indices.GainsIndices, psEnc->sCmn.nb_subfr ); | ||
173 | gainsID_lower = -1; | ||
174 | gainsID_upper = -1; | ||
175 | /* Copy part of the input state */ | ||
176 | silk_memcpy( &sRangeEnc_copy, psRangeEnc, sizeof( ec_enc ) ); | ||
177 | silk_memcpy( &sNSQ_copy, &psEnc->sCmn.sNSQ, sizeof( silk_nsq_state ) ); | ||
178 | seed_copy = psEnc->sCmn.indices.Seed; | ||
179 | ec_prevLagIndex_copy = psEnc->sCmn.ec_prevLagIndex; | ||
180 | ec_prevSignalType_copy = psEnc->sCmn.ec_prevSignalType; | ||
181 | ALLOC( ec_buf_copy, 1275, opus_uint8 ); | ||
182 | for( iter = 0; ; iter++ ) { | ||
183 | if( gainsID == gainsID_lower ) { | ||
184 | nBits = nBits_lower; | ||
185 | } else if( gainsID == gainsID_upper ) { | ||
186 | nBits = nBits_upper; | ||
187 | } else { | ||
188 | /* Restore part of the input state */ | ||
189 | if( iter > 0 ) { | ||
190 | silk_memcpy( psRangeEnc, &sRangeEnc_copy, sizeof( ec_enc ) ); | ||
191 | silk_memcpy( &psEnc->sCmn.sNSQ, &sNSQ_copy, sizeof( silk_nsq_state ) ); | ||
192 | psEnc->sCmn.indices.Seed = seed_copy; | ||
193 | psEnc->sCmn.ec_prevLagIndex = ec_prevLagIndex_copy; | ||
194 | psEnc->sCmn.ec_prevSignalType = ec_prevSignalType_copy; | ||
195 | } | ||
196 | |||
197 | /*****************************************/ | ||
198 | /* Noise shaping quantization */ | ||
199 | /*****************************************/ | ||
200 | if( psEnc->sCmn.nStatesDelayedDecision > 1 || psEnc->sCmn.warping_Q16 > 0 ) { | ||
201 | silk_NSQ_del_dec( &psEnc->sCmn, &psEnc->sCmn.sNSQ, &psEnc->sCmn.indices, x_frame, psEnc->sCmn.pulses, | ||
202 | sEncCtrl.PredCoef_Q12[ 0 ], sEncCtrl.LTPCoef_Q14, sEncCtrl.AR_Q13, sEncCtrl.HarmShapeGain_Q14, | ||
203 | sEncCtrl.Tilt_Q14, sEncCtrl.LF_shp_Q14, sEncCtrl.Gains_Q16, sEncCtrl.pitchL, sEncCtrl.Lambda_Q10, sEncCtrl.LTP_scale_Q14, | ||
204 | psEnc->sCmn.arch ); | ||
205 | } else { | ||
206 | silk_NSQ( &psEnc->sCmn, &psEnc->sCmn.sNSQ, &psEnc->sCmn.indices, x_frame, psEnc->sCmn.pulses, | ||
207 | sEncCtrl.PredCoef_Q12[ 0 ], sEncCtrl.LTPCoef_Q14, sEncCtrl.AR_Q13, sEncCtrl.HarmShapeGain_Q14, | ||
208 | sEncCtrl.Tilt_Q14, sEncCtrl.LF_shp_Q14, sEncCtrl.Gains_Q16, sEncCtrl.pitchL, sEncCtrl.Lambda_Q10, sEncCtrl.LTP_scale_Q14, | ||
209 | psEnc->sCmn.arch); | ||
210 | } | ||
211 | |||
212 | if ( iter == maxIter && !found_lower ) { | ||
213 | silk_memcpy( &sRangeEnc_copy2, psRangeEnc, sizeof( ec_enc ) ); | ||
214 | } | ||
215 | |||
216 | /****************************************/ | ||
217 | /* Encode Parameters */ | ||
218 | /****************************************/ | ||
219 | silk_encode_indices( &psEnc->sCmn, psRangeEnc, psEnc->sCmn.nFramesEncoded, 0, condCoding ); | ||
220 | |||
221 | /****************************************/ | ||
222 | /* Encode Excitation Signal */ | ||
223 | /****************************************/ | ||
224 | silk_encode_pulses( psRangeEnc, psEnc->sCmn.indices.signalType, psEnc->sCmn.indices.quantOffsetType, | ||
225 | psEnc->sCmn.pulses, psEnc->sCmn.frame_length ); | ||
226 | |||
227 | nBits = ec_tell( psRangeEnc ); | ||
228 | |||
229 | /* If we still bust after the last iteration, do some damage control. */ | ||
230 | if ( iter == maxIter && !found_lower && nBits > maxBits ) { | ||
231 | silk_memcpy( psRangeEnc, &sRangeEnc_copy2, sizeof( ec_enc ) ); | ||
232 | |||
233 | /* Keep gains the same as the last frame. */ | ||
234 | psEnc->sShape.LastGainIndex = sEncCtrl.lastGainIndexPrev; | ||
235 | for ( i = 0; i < psEnc->sCmn.nb_subfr; i++ ) { | ||
236 | psEnc->sCmn.indices.GainsIndices[ i ] = 4; | ||
237 | } | ||
238 | if (condCoding != CODE_CONDITIONALLY) { | ||
239 | psEnc->sCmn.indices.GainsIndices[ 0 ] = sEncCtrl.lastGainIndexPrev; | ||
240 | } | ||
241 | psEnc->sCmn.ec_prevLagIndex = ec_prevLagIndex_copy; | ||
242 | psEnc->sCmn.ec_prevSignalType = ec_prevSignalType_copy; | ||
243 | /* Clear all pulses. */ | ||
244 | for ( i = 0; i < psEnc->sCmn.frame_length; i++ ) { | ||
245 | psEnc->sCmn.pulses[ i ] = 0; | ||
246 | } | ||
247 | |||
248 | silk_encode_indices( &psEnc->sCmn, psRangeEnc, psEnc->sCmn.nFramesEncoded, 0, condCoding ); | ||
249 | |||
250 | silk_encode_pulses( psRangeEnc, psEnc->sCmn.indices.signalType, psEnc->sCmn.indices.quantOffsetType, | ||
251 | psEnc->sCmn.pulses, psEnc->sCmn.frame_length ); | ||
252 | |||
253 | nBits = ec_tell( psRangeEnc ); | ||
254 | } | ||
255 | |||
256 | if( useCBR == 0 && iter == 0 && nBits <= maxBits ) { | ||
257 | break; | ||
258 | } | ||
259 | } | ||
260 | |||
261 | if( iter == maxIter ) { | ||
262 | if( found_lower && ( gainsID == gainsID_lower || nBits > maxBits ) ) { | ||
263 | /* Restore output state from earlier iteration that did meet the bitrate budget */ | ||
264 | silk_memcpy( psRangeEnc, &sRangeEnc_copy2, sizeof( ec_enc ) ); | ||
265 | celt_assert( sRangeEnc_copy2.offs <= 1275 ); | ||
266 | silk_memcpy( psRangeEnc->buf, ec_buf_copy, sRangeEnc_copy2.offs ); | ||
267 | silk_memcpy( &psEnc->sCmn.sNSQ, &sNSQ_copy2, sizeof( silk_nsq_state ) ); | ||
268 | psEnc->sShape.LastGainIndex = LastGainIndex_copy2; | ||
269 | } | ||
270 | break; | ||
271 | } | ||
272 | |||
273 | if( nBits > maxBits ) { | ||
274 | if( found_lower == 0 && iter >= 2 ) { | ||
275 | /* Adjust the quantizer's rate/distortion tradeoff and discard previous "upper" results */ | ||
276 | sEncCtrl.Lambda_Q10 = silk_ADD_RSHIFT32( sEncCtrl.Lambda_Q10, sEncCtrl.Lambda_Q10, 1 ); | ||
277 | found_upper = 0; | ||
278 | gainsID_upper = -1; | ||
279 | } else { | ||
280 | found_upper = 1; | ||
281 | nBits_upper = nBits; | ||
282 | gainMult_upper = gainMult_Q8; | ||
283 | gainsID_upper = gainsID; | ||
284 | } | ||
285 | } else if( nBits < maxBits - 5 ) { | ||
286 | found_lower = 1; | ||
287 | nBits_lower = nBits; | ||
288 | gainMult_lower = gainMult_Q8; | ||
289 | if( gainsID != gainsID_lower ) { | ||
290 | gainsID_lower = gainsID; | ||
291 | /* Copy part of the output state */ | ||
292 | silk_memcpy( &sRangeEnc_copy2, psRangeEnc, sizeof( ec_enc ) ); | ||
293 | celt_assert( psRangeEnc->offs <= 1275 ); | ||
294 | silk_memcpy( ec_buf_copy, psRangeEnc->buf, psRangeEnc->offs ); | ||
295 | silk_memcpy( &sNSQ_copy2, &psEnc->sCmn.sNSQ, sizeof( silk_nsq_state ) ); | ||
296 | LastGainIndex_copy2 = psEnc->sShape.LastGainIndex; | ||
297 | } | ||
298 | } else { | ||
299 | /* Within 5 bits of budget: close enough */ | ||
300 | break; | ||
301 | } | ||
302 | |||
303 | if ( !found_lower && nBits > maxBits ) { | ||
304 | int j; | ||
305 | for ( i = 0; i < psEnc->sCmn.nb_subfr; i++ ) { | ||
306 | int sum=0; | ||
307 | for ( j = i*psEnc->sCmn.subfr_length; j < (i+1)*psEnc->sCmn.subfr_length; j++ ) { | ||
308 | sum += abs( psEnc->sCmn.pulses[j] ); | ||
309 | } | ||
310 | if ( iter == 0 || (sum < best_sum[i] && !gain_lock[i]) ) { | ||
311 | best_sum[i] = sum; | ||
312 | best_gain_mult[i] = gainMult_Q8; | ||
313 | } else { | ||
314 | gain_lock[i] = 1; | ||
315 | } | ||
316 | } | ||
317 | } | ||
318 | if( ( found_lower & found_upper ) == 0 ) { | ||
319 | /* Adjust gain according to high-rate rate/distortion curve */ | ||
320 | if( nBits > maxBits ) { | ||
321 | if (gainMult_Q8 < 16384) { | ||
322 | gainMult_Q8 *= 2; | ||
323 | } else { | ||
324 | gainMult_Q8 = 32767; | ||
325 | } | ||
326 | } else { | ||
327 | opus_int32 gain_factor_Q16; | ||
328 | gain_factor_Q16 = silk_log2lin( silk_LSHIFT( nBits - maxBits, 7 ) / psEnc->sCmn.frame_length + SILK_FIX_CONST( 16, 7 ) ); | ||
329 | gainMult_Q8 = silk_SMULWB( gain_factor_Q16, gainMult_Q8 ); | ||
330 | } | ||
331 | |||
332 | } else { | ||
333 | /* Adjust gain by interpolating */ | ||
334 | gainMult_Q8 = gainMult_lower + silk_DIV32_16( silk_MUL( gainMult_upper - gainMult_lower, maxBits - nBits_lower ), nBits_upper - nBits_lower ); | ||
335 | /* New gain multplier must be between 25% and 75% of old range (note that gainMult_upper < gainMult_lower) */ | ||
336 | if( gainMult_Q8 > silk_ADD_RSHIFT32( gainMult_lower, gainMult_upper - gainMult_lower, 2 ) ) { | ||
337 | gainMult_Q8 = silk_ADD_RSHIFT32( gainMult_lower, gainMult_upper - gainMult_lower, 2 ); | ||
338 | } else | ||
339 | if( gainMult_Q8 < silk_SUB_RSHIFT32( gainMult_upper, gainMult_upper - gainMult_lower, 2 ) ) { | ||
340 | gainMult_Q8 = silk_SUB_RSHIFT32( gainMult_upper, gainMult_upper - gainMult_lower, 2 ); | ||
341 | } | ||
342 | } | ||
343 | |||
344 | for( i = 0; i < psEnc->sCmn.nb_subfr; i++ ) { | ||
345 | opus_int16 tmp; | ||
346 | if ( gain_lock[i] ) { | ||
347 | tmp = best_gain_mult[i]; | ||
348 | } else { | ||
349 | tmp = gainMult_Q8; | ||
350 | } | ||
351 | sEncCtrl.Gains_Q16[ i ] = silk_LSHIFT_SAT32( silk_SMULWB( sEncCtrl.GainsUnq_Q16[ i ], tmp ), 8 ); | ||
352 | } | ||
353 | |||
354 | /* Quantize gains */ | ||
355 | psEnc->sShape.LastGainIndex = sEncCtrl.lastGainIndexPrev; | ||
356 | silk_gains_quant( psEnc->sCmn.indices.GainsIndices, sEncCtrl.Gains_Q16, | ||
357 | &psEnc->sShape.LastGainIndex, condCoding == CODE_CONDITIONALLY, psEnc->sCmn.nb_subfr ); | ||
358 | |||
359 | /* Unique identifier of gains vector */ | ||
360 | gainsID = silk_gains_ID( psEnc->sCmn.indices.GainsIndices, psEnc->sCmn.nb_subfr ); | ||
361 | } | ||
362 | } | ||
363 | |||
364 | /* Update input buffer */ | ||
365 | silk_memmove( psEnc->x_buf, &psEnc->x_buf[ psEnc->sCmn.frame_length ], | ||
366 | ( psEnc->sCmn.ltp_mem_length + LA_SHAPE_MS * psEnc->sCmn.fs_kHz ) * sizeof( opus_int16 ) ); | ||
367 | |||
368 | /* Exit without entropy coding */ | ||
369 | if( psEnc->sCmn.prefillFlag ) { | ||
370 | /* No payload */ | ||
371 | *pnBytesOut = 0; | ||
372 | RESTORE_STACK; | ||
373 | return ret; | ||
374 | } | ||
375 | |||
376 | /* Parameters needed for next frame */ | ||
377 | psEnc->sCmn.prevLag = sEncCtrl.pitchL[ psEnc->sCmn.nb_subfr - 1 ]; | ||
378 | psEnc->sCmn.prevSignalType = psEnc->sCmn.indices.signalType; | ||
379 | |||
380 | /****************************************/ | ||
381 | /* Finalize payload */ | ||
382 | /****************************************/ | ||
383 | psEnc->sCmn.first_frame_after_reset = 0; | ||
384 | /* Payload size */ | ||
385 | *pnBytesOut = silk_RSHIFT( ec_tell( psRangeEnc ) + 7, 3 ); | ||
386 | |||
387 | RESTORE_STACK; | ||
388 | return ret; | ||
389 | } | ||
390 | |||
391 | /* Low-Bitrate Redundancy (LBRR) encoding. Reuse all parameters but encode excitation at lower bitrate */ | ||
392 | static OPUS_INLINE void silk_LBRR_encode_FIX( | ||
393 | silk_encoder_state_FIX *psEnc, /* I/O Pointer to Silk FIX encoder state */ | ||
394 | silk_encoder_control_FIX *psEncCtrl, /* I/O Pointer to Silk FIX encoder control struct */ | ||
395 | const opus_int16 x16[], /* I Input signal */ | ||
396 | opus_int condCoding /* I The type of conditional coding used so far for this frame */ | ||
397 | ) | ||
398 | { | ||
399 | opus_int32 TempGains_Q16[ MAX_NB_SUBFR ]; | ||
400 | SideInfoIndices *psIndices_LBRR = &psEnc->sCmn.indices_LBRR[ psEnc->sCmn.nFramesEncoded ]; | ||
401 | silk_nsq_state sNSQ_LBRR; | ||
402 | |||
403 | /*******************************************/ | ||
404 | /* Control use of inband LBRR */ | ||
405 | /*******************************************/ | ||
406 | if( psEnc->sCmn.LBRR_enabled && psEnc->sCmn.speech_activity_Q8 > SILK_FIX_CONST( LBRR_SPEECH_ACTIVITY_THRES, 8 ) ) { | ||
407 | psEnc->sCmn.LBRR_flags[ psEnc->sCmn.nFramesEncoded ] = 1; | ||
408 | |||
409 | /* Copy noise shaping quantizer state and quantization indices from regular encoding */ | ||
410 | silk_memcpy( &sNSQ_LBRR, &psEnc->sCmn.sNSQ, sizeof( silk_nsq_state ) ); | ||
411 | silk_memcpy( psIndices_LBRR, &psEnc->sCmn.indices, sizeof( SideInfoIndices ) ); | ||
412 | |||
413 | /* Save original gains */ | ||
414 | silk_memcpy( TempGains_Q16, psEncCtrl->Gains_Q16, psEnc->sCmn.nb_subfr * sizeof( opus_int32 ) ); | ||
415 | |||
416 | if( psEnc->sCmn.nFramesEncoded == 0 || psEnc->sCmn.LBRR_flags[ psEnc->sCmn.nFramesEncoded - 1 ] == 0 ) { | ||
417 | /* First frame in packet or previous frame not LBRR coded */ | ||
418 | psEnc->sCmn.LBRRprevLastGainIndex = psEnc->sShape.LastGainIndex; | ||
419 | |||
420 | /* Increase Gains to get target LBRR rate */ | ||
421 | psIndices_LBRR->GainsIndices[ 0 ] = psIndices_LBRR->GainsIndices[ 0 ] + psEnc->sCmn.LBRR_GainIncreases; | ||
422 | psIndices_LBRR->GainsIndices[ 0 ] = silk_min_int( psIndices_LBRR->GainsIndices[ 0 ], N_LEVELS_QGAIN - 1 ); | ||
423 | } | ||
424 | |||
425 | /* Decode to get gains in sync with decoder */ | ||
426 | /* Overwrite unquantized gains with quantized gains */ | ||
427 | silk_gains_dequant( psEncCtrl->Gains_Q16, psIndices_LBRR->GainsIndices, | ||
428 | &psEnc->sCmn.LBRRprevLastGainIndex, condCoding == CODE_CONDITIONALLY, psEnc->sCmn.nb_subfr ); | ||
429 | |||
430 | /*****************************************/ | ||
431 | /* Noise shaping quantization */ | ||
432 | /*****************************************/ | ||
433 | if( psEnc->sCmn.nStatesDelayedDecision > 1 || psEnc->sCmn.warping_Q16 > 0 ) { | ||
434 | silk_NSQ_del_dec( &psEnc->sCmn, &sNSQ_LBRR, psIndices_LBRR, x16, | ||
435 | psEnc->sCmn.pulses_LBRR[ psEnc->sCmn.nFramesEncoded ], psEncCtrl->PredCoef_Q12[ 0 ], psEncCtrl->LTPCoef_Q14, | ||
436 | psEncCtrl->AR_Q13, psEncCtrl->HarmShapeGain_Q14, psEncCtrl->Tilt_Q14, psEncCtrl->LF_shp_Q14, | ||
437 | psEncCtrl->Gains_Q16, psEncCtrl->pitchL, psEncCtrl->Lambda_Q10, psEncCtrl->LTP_scale_Q14, psEnc->sCmn.arch ); | ||
438 | } else { | ||
439 | silk_NSQ( &psEnc->sCmn, &sNSQ_LBRR, psIndices_LBRR, x16, | ||
440 | psEnc->sCmn.pulses_LBRR[ psEnc->sCmn.nFramesEncoded ], psEncCtrl->PredCoef_Q12[ 0 ], psEncCtrl->LTPCoef_Q14, | ||
441 | psEncCtrl->AR_Q13, psEncCtrl->HarmShapeGain_Q14, psEncCtrl->Tilt_Q14, psEncCtrl->LF_shp_Q14, | ||
442 | psEncCtrl->Gains_Q16, psEncCtrl->pitchL, psEncCtrl->Lambda_Q10, psEncCtrl->LTP_scale_Q14, psEnc->sCmn.arch ); | ||
443 | } | ||
444 | |||
445 | /* Restore original gains */ | ||
446 | silk_memcpy( psEncCtrl->Gains_Q16, TempGains_Q16, psEnc->sCmn.nb_subfr * sizeof( opus_int32 ) ); | ||
447 | } | ||
448 | } | ||