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/mips/NSQ_del_dec_mipsr1.h | |
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/mips/NSQ_del_dec_mipsr1.h')
-rw-r--r-- | lib/rbcodec/codecs/libopus/silk/mips/NSQ_del_dec_mipsr1.h | 410 |
1 files changed, 410 insertions, 0 deletions
diff --git a/lib/rbcodec/codecs/libopus/silk/mips/NSQ_del_dec_mipsr1.h b/lib/rbcodec/codecs/libopus/silk/mips/NSQ_del_dec_mipsr1.h new file mode 100644 index 0000000000..cd70713a8f --- /dev/null +++ b/lib/rbcodec/codecs/libopus/silk/mips/NSQ_del_dec_mipsr1.h | |||
@@ -0,0 +1,410 @@ | |||
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 | #ifndef __NSQ_DEL_DEC_MIPSR1_H__ | ||
29 | #define __NSQ_DEL_DEC_MIPSR1_H__ | ||
30 | |||
31 | #ifdef HAVE_CONFIG_H | ||
32 | #include "config.h" | ||
33 | #endif | ||
34 | |||
35 | #include "main.h" | ||
36 | #include "stack_alloc.h" | ||
37 | |||
38 | #define OVERRIDE_silk_noise_shape_quantizer_del_dec | ||
39 | static inline void silk_noise_shape_quantizer_del_dec( | ||
40 | silk_nsq_state *NSQ, /* I/O NSQ state */ | ||
41 | NSQ_del_dec_struct psDelDec[], /* I/O Delayed decision states */ | ||
42 | opus_int signalType, /* I Signal type */ | ||
43 | const opus_int32 x_Q10[], /* I */ | ||
44 | opus_int8 pulses[], /* O */ | ||
45 | opus_int16 xq[], /* O */ | ||
46 | opus_int32 sLTP_Q15[], /* I/O LTP filter state */ | ||
47 | opus_int32 delayedGain_Q10[], /* I/O Gain delay buffer */ | ||
48 | const opus_int16 a_Q12[], /* I Short term prediction coefs */ | ||
49 | const opus_int16 b_Q14[], /* I Long term prediction coefs */ | ||
50 | const opus_int16 AR_shp_Q13[], /* I Noise shaping coefs */ | ||
51 | opus_int lag, /* I Pitch lag */ | ||
52 | opus_int32 HarmShapeFIRPacked_Q14, /* I */ | ||
53 | opus_int Tilt_Q14, /* I Spectral tilt */ | ||
54 | opus_int32 LF_shp_Q14, /* I */ | ||
55 | opus_int32 Gain_Q16, /* I */ | ||
56 | opus_int Lambda_Q10, /* I */ | ||
57 | opus_int offset_Q10, /* I */ | ||
58 | opus_int length, /* I Input length */ | ||
59 | opus_int subfr, /* I Subframe number */ | ||
60 | opus_int shapingLPCOrder, /* I Shaping LPC filter order */ | ||
61 | opus_int predictLPCOrder, /* I Prediction filter order */ | ||
62 | opus_int warping_Q16, /* I */ | ||
63 | opus_int nStatesDelayedDecision, /* I Number of states in decision tree */ | ||
64 | opus_int *smpl_buf_idx, /* I/O Index to newest samples in buffers */ | ||
65 | opus_int decisionDelay, /* I */ | ||
66 | int arch /* I */ | ||
67 | ) | ||
68 | { | ||
69 | opus_int i, j, k, Winner_ind, RDmin_ind, RDmax_ind, last_smple_idx; | ||
70 | opus_int32 Winner_rand_state; | ||
71 | opus_int32 LTP_pred_Q14, LPC_pred_Q14, n_AR_Q14, n_LTP_Q14; | ||
72 | opus_int32 n_LF_Q14, r_Q10, rr_Q10, rd1_Q10, rd2_Q10, RDmin_Q10, RDmax_Q10; | ||
73 | opus_int32 q1_Q0, q1_Q10, q2_Q10, exc_Q14, LPC_exc_Q14, xq_Q14, Gain_Q10; | ||
74 | opus_int32 tmp1, tmp2, sLF_AR_shp_Q14; | ||
75 | opus_int32 *pred_lag_ptr, *shp_lag_ptr, *psLPC_Q14; | ||
76 | NSQ_sample_struct psSampleState[ MAX_DEL_DEC_STATES ][ 2 ]; | ||
77 | NSQ_del_dec_struct *psDD; | ||
78 | NSQ_sample_struct *psSS; | ||
79 | opus_int16 b_Q14_0, b_Q14_1, b_Q14_2, b_Q14_3, b_Q14_4; | ||
80 | opus_int16 a_Q12_0, a_Q12_1, a_Q12_2, a_Q12_3, a_Q12_4, a_Q12_5, a_Q12_6; | ||
81 | opus_int16 a_Q12_7, a_Q12_8, a_Q12_9, a_Q12_10, a_Q12_11, a_Q12_12, a_Q12_13; | ||
82 | opus_int16 a_Q12_14, a_Q12_15; | ||
83 | |||
84 | opus_int32 cur, prev, next; | ||
85 | |||
86 | /*Unused.*/ | ||
87 | (void)arch; | ||
88 | |||
89 | //Intialize b_Q14 variables | ||
90 | b_Q14_0 = b_Q14[ 0 ]; | ||
91 | b_Q14_1 = b_Q14[ 1 ]; | ||
92 | b_Q14_2 = b_Q14[ 2 ]; | ||
93 | b_Q14_3 = b_Q14[ 3 ]; | ||
94 | b_Q14_4 = b_Q14[ 4 ]; | ||
95 | |||
96 | //Intialize a_Q12 variables | ||
97 | a_Q12_0 = a_Q12[0]; | ||
98 | a_Q12_1 = a_Q12[1]; | ||
99 | a_Q12_2 = a_Q12[2]; | ||
100 | a_Q12_3 = a_Q12[3]; | ||
101 | a_Q12_4 = a_Q12[4]; | ||
102 | a_Q12_5 = a_Q12[5]; | ||
103 | a_Q12_6 = a_Q12[6]; | ||
104 | a_Q12_7 = a_Q12[7]; | ||
105 | a_Q12_8 = a_Q12[8]; | ||
106 | a_Q12_9 = a_Q12[9]; | ||
107 | a_Q12_10 = a_Q12[10]; | ||
108 | a_Q12_11 = a_Q12[11]; | ||
109 | a_Q12_12 = a_Q12[12]; | ||
110 | a_Q12_13 = a_Q12[13]; | ||
111 | a_Q12_14 = a_Q12[14]; | ||
112 | a_Q12_15 = a_Q12[15]; | ||
113 | |||
114 | long long temp64; | ||
115 | |||
116 | silk_assert( nStatesDelayedDecision > 0 ); | ||
117 | |||
118 | shp_lag_ptr = &NSQ->sLTP_shp_Q14[ NSQ->sLTP_shp_buf_idx - lag + HARM_SHAPE_FIR_TAPS / 2 ]; | ||
119 | pred_lag_ptr = &sLTP_Q15[ NSQ->sLTP_buf_idx - lag + LTP_ORDER / 2 ]; | ||
120 | Gain_Q10 = silk_RSHIFT( Gain_Q16, 6 ); | ||
121 | |||
122 | for( i = 0; i < length; i++ ) { | ||
123 | /* Perform common calculations used in all states */ | ||
124 | |||
125 | /* Long-term prediction */ | ||
126 | if( signalType == TYPE_VOICED ) { | ||
127 | /* Unrolled loop */ | ||
128 | /* Avoids introducing a bias because silk_SMLAWB() always rounds to -inf */ | ||
129 | temp64 = __builtin_mips_mult(pred_lag_ptr[ 0 ], b_Q14_0 ); | ||
130 | temp64 = __builtin_mips_madd( temp64, pred_lag_ptr[ -1 ], b_Q14_1 ); | ||
131 | temp64 = __builtin_mips_madd( temp64, pred_lag_ptr[ -2 ], b_Q14_2 ); | ||
132 | temp64 = __builtin_mips_madd( temp64, pred_lag_ptr[ -3 ], b_Q14_3 ); | ||
133 | temp64 = __builtin_mips_madd( temp64, pred_lag_ptr[ -4 ], b_Q14_4 ); | ||
134 | temp64 += 32768; | ||
135 | LTP_pred_Q14 = __builtin_mips_extr_w(temp64, 16); | ||
136 | LTP_pred_Q14 = silk_LSHIFT( LTP_pred_Q14, 1 ); /* Q13 -> Q14 */ | ||
137 | pred_lag_ptr++; | ||
138 | } else { | ||
139 | LTP_pred_Q14 = 0; | ||
140 | } | ||
141 | |||
142 | /* Long-term shaping */ | ||
143 | if( lag > 0 ) { | ||
144 | /* Symmetric, packed FIR coefficients */ | ||
145 | n_LTP_Q14 = silk_SMULWB( silk_ADD32( shp_lag_ptr[ 0 ], shp_lag_ptr[ -2 ] ), HarmShapeFIRPacked_Q14 ); | ||
146 | n_LTP_Q14 = silk_SMLAWT( n_LTP_Q14, shp_lag_ptr[ -1 ], HarmShapeFIRPacked_Q14 ); | ||
147 | n_LTP_Q14 = silk_SUB_LSHIFT32( LTP_pred_Q14, n_LTP_Q14, 2 ); /* Q12 -> Q14 */ | ||
148 | shp_lag_ptr++; | ||
149 | } else { | ||
150 | n_LTP_Q14 = 0; | ||
151 | } | ||
152 | |||
153 | for( k = 0; k < nStatesDelayedDecision; k++ ) { | ||
154 | /* Delayed decision state */ | ||
155 | psDD = &psDelDec[ k ]; | ||
156 | |||
157 | /* Sample state */ | ||
158 | psSS = psSampleState[ k ]; | ||
159 | |||
160 | /* Generate dither */ | ||
161 | psDD->Seed = silk_RAND( psDD->Seed ); | ||
162 | |||
163 | /* Pointer used in short term prediction and shaping */ | ||
164 | psLPC_Q14 = &psDD->sLPC_Q14[ NSQ_LPC_BUF_LENGTH - 1 + i ]; | ||
165 | /* Short-term prediction */ | ||
166 | silk_assert( predictLPCOrder == 10 || predictLPCOrder == 16 ); | ||
167 | temp64 = __builtin_mips_mult(psLPC_Q14[ 0 ], a_Q12_0 ); | ||
168 | temp64 = __builtin_mips_madd( temp64, psLPC_Q14[ -1 ], a_Q12_1 ); | ||
169 | temp64 = __builtin_mips_madd( temp64, psLPC_Q14[ -2 ], a_Q12_2 ); | ||
170 | temp64 = __builtin_mips_madd( temp64, psLPC_Q14[ -3 ], a_Q12_3 ); | ||
171 | temp64 = __builtin_mips_madd( temp64, psLPC_Q14[ -4 ], a_Q12_4 ); | ||
172 | temp64 = __builtin_mips_madd( temp64, psLPC_Q14[ -5 ], a_Q12_5 ); | ||
173 | temp64 = __builtin_mips_madd( temp64, psLPC_Q14[ -6 ], a_Q12_6 ); | ||
174 | temp64 = __builtin_mips_madd( temp64, psLPC_Q14[ -7 ], a_Q12_7 ); | ||
175 | temp64 = __builtin_mips_madd( temp64, psLPC_Q14[ -8 ], a_Q12_8 ); | ||
176 | temp64 = __builtin_mips_madd( temp64, psLPC_Q14[ -9 ], a_Q12_9 ); | ||
177 | if( predictLPCOrder == 16 ) { | ||
178 | temp64 = __builtin_mips_madd( temp64, psLPC_Q14[ -10 ], a_Q12_10 ); | ||
179 | temp64 = __builtin_mips_madd( temp64, psLPC_Q14[ -11 ], a_Q12_11 ); | ||
180 | temp64 = __builtin_mips_madd( temp64, psLPC_Q14[ -12 ], a_Q12_12 ); | ||
181 | temp64 = __builtin_mips_madd( temp64, psLPC_Q14[ -13 ], a_Q12_13 ); | ||
182 | temp64 = __builtin_mips_madd( temp64, psLPC_Q14[ -14 ], a_Q12_14 ); | ||
183 | temp64 = __builtin_mips_madd( temp64, psLPC_Q14[ -15 ], a_Q12_15 ); | ||
184 | } | ||
185 | temp64 += 32768; | ||
186 | LPC_pred_Q14 = __builtin_mips_extr_w(temp64, 16); | ||
187 | |||
188 | LPC_pred_Q14 = silk_LSHIFT( LPC_pred_Q14, 4 ); /* Q10 -> Q14 */ | ||
189 | |||
190 | /* Noise shape feedback */ | ||
191 | silk_assert( ( shapingLPCOrder & 1 ) == 0 ); /* check that order is even */ | ||
192 | /* Output of lowpass section */ | ||
193 | tmp2 = silk_SMLAWB( psLPC_Q14[ 0 ], psDD->sAR2_Q14[ 0 ], warping_Q16 ); | ||
194 | /* Output of allpass section */ | ||
195 | tmp1 = silk_SMLAWB( psDD->sAR2_Q14[ 0 ], psDD->sAR2_Q14[ 1 ] - tmp2, warping_Q16 ); | ||
196 | psDD->sAR2_Q14[ 0 ] = tmp2; | ||
197 | |||
198 | temp64 = __builtin_mips_mult(tmp2, AR_shp_Q13[ 0 ] ); | ||
199 | |||
200 | prev = psDD->sAR2_Q14[ 1 ]; | ||
201 | |||
202 | /* Loop over allpass sections */ | ||
203 | for( j = 2; j < shapingLPCOrder; j += 2 ) { | ||
204 | cur = psDD->sAR2_Q14[ j ]; | ||
205 | next = psDD->sAR2_Q14[ j+1 ]; | ||
206 | /* Output of allpass section */ | ||
207 | tmp2 = silk_SMLAWB( prev, cur - tmp1, warping_Q16 ); | ||
208 | psDD->sAR2_Q14[ j - 1 ] = tmp1; | ||
209 | temp64 = __builtin_mips_madd( temp64, tmp1, AR_shp_Q13[ j - 1 ] ); | ||
210 | temp64 = __builtin_mips_madd( temp64, tmp2, AR_shp_Q13[ j ] ); | ||
211 | /* Output of allpass section */ | ||
212 | tmp1 = silk_SMLAWB( cur, next - tmp2, warping_Q16 ); | ||
213 | psDD->sAR2_Q14[ j + 0 ] = tmp2; | ||
214 | prev = next; | ||
215 | } | ||
216 | psDD->sAR2_Q14[ shapingLPCOrder - 1 ] = tmp1; | ||
217 | temp64 = __builtin_mips_madd( temp64, tmp1, AR_shp_Q13[ shapingLPCOrder - 1 ] ); | ||
218 | temp64 += 32768; | ||
219 | n_AR_Q14 = __builtin_mips_extr_w(temp64, 16); | ||
220 | n_AR_Q14 = silk_LSHIFT( n_AR_Q14, 1 ); /* Q11 -> Q12 */ | ||
221 | n_AR_Q14 = silk_SMLAWB( n_AR_Q14, psDD->LF_AR_Q14, Tilt_Q14 ); /* Q12 */ | ||
222 | n_AR_Q14 = silk_LSHIFT( n_AR_Q14, 2 ); /* Q12 -> Q14 */ | ||
223 | |||
224 | n_LF_Q14 = silk_SMULWB( psDD->Shape_Q14[ *smpl_buf_idx ], LF_shp_Q14 ); /* Q12 */ | ||
225 | n_LF_Q14 = silk_SMLAWT( n_LF_Q14, psDD->LF_AR_Q14, LF_shp_Q14 ); /* Q12 */ | ||
226 | n_LF_Q14 = silk_LSHIFT( n_LF_Q14, 2 ); /* Q12 -> Q14 */ | ||
227 | |||
228 | /* Input minus prediction plus noise feedback */ | ||
229 | /* r = x[ i ] - LTP_pred - LPC_pred + n_AR + n_Tilt + n_LF + n_LTP */ | ||
230 | tmp1 = silk_ADD32( n_AR_Q14, n_LF_Q14 ); /* Q14 */ | ||
231 | tmp2 = silk_ADD32( n_LTP_Q14, LPC_pred_Q14 ); /* Q13 */ | ||
232 | tmp1 = silk_SUB32( tmp2, tmp1 ); /* Q13 */ | ||
233 | tmp1 = silk_RSHIFT_ROUND( tmp1, 4 ); /* Q10 */ | ||
234 | |||
235 | r_Q10 = silk_SUB32( x_Q10[ i ], tmp1 ); /* residual error Q10 */ | ||
236 | |||
237 | /* Flip sign depending on dither */ | ||
238 | if ( psDD->Seed < 0 ) { | ||
239 | r_Q10 = -r_Q10; | ||
240 | } | ||
241 | r_Q10 = silk_LIMIT_32( r_Q10, -(31 << 10), 30 << 10 ); | ||
242 | |||
243 | /* Find two quantization level candidates and measure their rate-distortion */ | ||
244 | q1_Q10 = silk_SUB32( r_Q10, offset_Q10 ); | ||
245 | q1_Q0 = silk_RSHIFT( q1_Q10, 10 ); | ||
246 | if( q1_Q0 > 0 ) { | ||
247 | q1_Q10 = silk_SUB32( silk_LSHIFT( q1_Q0, 10 ), QUANT_LEVEL_ADJUST_Q10 ); | ||
248 | q1_Q10 = silk_ADD32( q1_Q10, offset_Q10 ); | ||
249 | q2_Q10 = silk_ADD32( q1_Q10, 1024 ); | ||
250 | rd1_Q10 = silk_SMULBB( q1_Q10, Lambda_Q10 ); | ||
251 | rd2_Q10 = silk_SMULBB( q2_Q10, Lambda_Q10 ); | ||
252 | } else if( q1_Q0 == 0 ) { | ||
253 | q1_Q10 = offset_Q10; | ||
254 | q2_Q10 = silk_ADD32( q1_Q10, 1024 - QUANT_LEVEL_ADJUST_Q10 ); | ||
255 | rd1_Q10 = silk_SMULBB( q1_Q10, Lambda_Q10 ); | ||
256 | rd2_Q10 = silk_SMULBB( q2_Q10, Lambda_Q10 ); | ||
257 | } else if( q1_Q0 == -1 ) { | ||
258 | q2_Q10 = offset_Q10; | ||
259 | q1_Q10 = silk_SUB32( q2_Q10, 1024 - QUANT_LEVEL_ADJUST_Q10 ); | ||
260 | rd1_Q10 = silk_SMULBB( -q1_Q10, Lambda_Q10 ); | ||
261 | rd2_Q10 = silk_SMULBB( q2_Q10, Lambda_Q10 ); | ||
262 | } else { /* q1_Q0 < -1 */ | ||
263 | q1_Q10 = silk_ADD32( silk_LSHIFT( q1_Q0, 10 ), QUANT_LEVEL_ADJUST_Q10 ); | ||
264 | q1_Q10 = silk_ADD32( q1_Q10, offset_Q10 ); | ||
265 | q2_Q10 = silk_ADD32( q1_Q10, 1024 ); | ||
266 | rd1_Q10 = silk_SMULBB( -q1_Q10, Lambda_Q10 ); | ||
267 | rd2_Q10 = silk_SMULBB( -q2_Q10, Lambda_Q10 ); | ||
268 | } | ||
269 | rr_Q10 = silk_SUB32( r_Q10, q1_Q10 ); | ||
270 | rd1_Q10 = silk_RSHIFT( silk_SMLABB( rd1_Q10, rr_Q10, rr_Q10 ), 10 ); | ||
271 | rr_Q10 = silk_SUB32( r_Q10, q2_Q10 ); | ||
272 | rd2_Q10 = silk_RSHIFT( silk_SMLABB( rd2_Q10, rr_Q10, rr_Q10 ), 10 ); | ||
273 | |||
274 | if( rd1_Q10 < rd2_Q10 ) { | ||
275 | psSS[ 0 ].RD_Q10 = silk_ADD32( psDD->RD_Q10, rd1_Q10 ); | ||
276 | psSS[ 1 ].RD_Q10 = silk_ADD32( psDD->RD_Q10, rd2_Q10 ); | ||
277 | psSS[ 0 ].Q_Q10 = q1_Q10; | ||
278 | psSS[ 1 ].Q_Q10 = q2_Q10; | ||
279 | } else { | ||
280 | psSS[ 0 ].RD_Q10 = silk_ADD32( psDD->RD_Q10, rd2_Q10 ); | ||
281 | psSS[ 1 ].RD_Q10 = silk_ADD32( psDD->RD_Q10, rd1_Q10 ); | ||
282 | psSS[ 0 ].Q_Q10 = q2_Q10; | ||
283 | psSS[ 1 ].Q_Q10 = q1_Q10; | ||
284 | } | ||
285 | |||
286 | /* Update states for best quantization */ | ||
287 | |||
288 | /* Quantized excitation */ | ||
289 | exc_Q14 = silk_LSHIFT32( psSS[ 0 ].Q_Q10, 4 ); | ||
290 | if ( psDD->Seed < 0 ) { | ||
291 | exc_Q14 = -exc_Q14; | ||
292 | } | ||
293 | |||
294 | /* Add predictions */ | ||
295 | LPC_exc_Q14 = silk_ADD32( exc_Q14, LTP_pred_Q14 ); | ||
296 | xq_Q14 = silk_ADD32( LPC_exc_Q14, LPC_pred_Q14 ); | ||
297 | |||
298 | /* Update states */ | ||
299 | sLF_AR_shp_Q14 = silk_SUB32( xq_Q14, n_AR_Q14 ); | ||
300 | psSS[ 0 ].sLTP_shp_Q14 = silk_SUB32( sLF_AR_shp_Q14, n_LF_Q14 ); | ||
301 | psSS[ 0 ].LF_AR_Q14 = sLF_AR_shp_Q14; | ||
302 | psSS[ 0 ].LPC_exc_Q14 = LPC_exc_Q14; | ||
303 | psSS[ 0 ].xq_Q14 = xq_Q14; | ||
304 | |||
305 | /* Update states for second best quantization */ | ||
306 | |||
307 | /* Quantized excitation */ | ||
308 | exc_Q14 = silk_LSHIFT32( psSS[ 1 ].Q_Q10, 4 ); | ||
309 | if ( psDD->Seed < 0 ) { | ||
310 | exc_Q14 = -exc_Q14; | ||
311 | } | ||
312 | |||
313 | |||
314 | /* Add predictions */ | ||
315 | LPC_exc_Q14 = silk_ADD32( exc_Q14, LTP_pred_Q14 ); | ||
316 | xq_Q14 = silk_ADD32( LPC_exc_Q14, LPC_pred_Q14 ); | ||
317 | |||
318 | /* Update states */ | ||
319 | sLF_AR_shp_Q14 = silk_SUB32( xq_Q14, n_AR_Q14 ); | ||
320 | psSS[ 1 ].sLTP_shp_Q14 = silk_SUB32( sLF_AR_shp_Q14, n_LF_Q14 ); | ||
321 | psSS[ 1 ].LF_AR_Q14 = sLF_AR_shp_Q14; | ||
322 | psSS[ 1 ].LPC_exc_Q14 = LPC_exc_Q14; | ||
323 | psSS[ 1 ].xq_Q14 = xq_Q14; | ||
324 | } | ||
325 | |||
326 | *smpl_buf_idx = ( *smpl_buf_idx - 1 ) % DECISION_DELAY; | ||
327 | if( *smpl_buf_idx < 0 ) *smpl_buf_idx += DECISION_DELAY; | ||
328 | last_smple_idx = ( *smpl_buf_idx + decisionDelay ) % DECISION_DELAY; | ||
329 | |||
330 | /* Find winner */ | ||
331 | RDmin_Q10 = psSampleState[ 0 ][ 0 ].RD_Q10; | ||
332 | Winner_ind = 0; | ||
333 | for( k = 1; k < nStatesDelayedDecision; k++ ) { | ||
334 | if( psSampleState[ k ][ 0 ].RD_Q10 < RDmin_Q10 ) { | ||
335 | RDmin_Q10 = psSampleState[ k ][ 0 ].RD_Q10; | ||
336 | Winner_ind = k; | ||
337 | } | ||
338 | } | ||
339 | |||
340 | /* Increase RD values of expired states */ | ||
341 | Winner_rand_state = psDelDec[ Winner_ind ].RandState[ last_smple_idx ]; | ||
342 | for( k = 0; k < nStatesDelayedDecision; k++ ) { | ||
343 | if( psDelDec[ k ].RandState[ last_smple_idx ] != Winner_rand_state ) { | ||
344 | psSampleState[ k ][ 0 ].RD_Q10 = silk_ADD32( psSampleState[ k ][ 0 ].RD_Q10, silk_int32_MAX >> 4 ); | ||
345 | psSampleState[ k ][ 1 ].RD_Q10 = silk_ADD32( psSampleState[ k ][ 1 ].RD_Q10, silk_int32_MAX >> 4 ); | ||
346 | silk_assert( psSampleState[ k ][ 0 ].RD_Q10 >= 0 ); | ||
347 | } | ||
348 | } | ||
349 | |||
350 | /* Find worst in first set and best in second set */ | ||
351 | RDmax_Q10 = psSampleState[ 0 ][ 0 ].RD_Q10; | ||
352 | RDmin_Q10 = psSampleState[ 0 ][ 1 ].RD_Q10; | ||
353 | RDmax_ind = 0; | ||
354 | RDmin_ind = 0; | ||
355 | for( k = 1; k < nStatesDelayedDecision; k++ ) { | ||
356 | /* find worst in first set */ | ||
357 | if( psSampleState[ k ][ 0 ].RD_Q10 > RDmax_Q10 ) { | ||
358 | RDmax_Q10 = psSampleState[ k ][ 0 ].RD_Q10; | ||
359 | RDmax_ind = k; | ||
360 | } | ||
361 | /* find best in second set */ | ||
362 | if( psSampleState[ k ][ 1 ].RD_Q10 < RDmin_Q10 ) { | ||
363 | RDmin_Q10 = psSampleState[ k ][ 1 ].RD_Q10; | ||
364 | RDmin_ind = k; | ||
365 | } | ||
366 | } | ||
367 | |||
368 | /* Replace a state if best from second set outperforms worst in first set */ | ||
369 | if( RDmin_Q10 < RDmax_Q10 ) { | ||
370 | silk_memcpy( ( (opus_int32 *)&psDelDec[ RDmax_ind ] ) + i, | ||
371 | ( (opus_int32 *)&psDelDec[ RDmin_ind ] ) + i, sizeof( NSQ_del_dec_struct ) - i * sizeof( opus_int32) ); | ||
372 | silk_memcpy( &psSampleState[ RDmax_ind ][ 0 ], &psSampleState[ RDmin_ind ][ 1 ], sizeof( NSQ_sample_struct ) ); | ||
373 | } | ||
374 | |||
375 | /* Write samples from winner to output and long-term filter states */ | ||
376 | psDD = &psDelDec[ Winner_ind ]; | ||
377 | if( subfr > 0 || i >= decisionDelay ) { | ||
378 | pulses[ i - decisionDelay ] = (opus_int8)silk_RSHIFT_ROUND( psDD->Q_Q10[ last_smple_idx ], 10 ); | ||
379 | xq[ i - decisionDelay ] = (opus_int16)silk_SAT16( silk_RSHIFT_ROUND( | ||
380 | silk_SMULWW( psDD->Xq_Q14[ last_smple_idx ], delayedGain_Q10[ last_smple_idx ] ), 8 ) ); | ||
381 | NSQ->sLTP_shp_Q14[ NSQ->sLTP_shp_buf_idx - decisionDelay ] = psDD->Shape_Q14[ last_smple_idx ]; | ||
382 | sLTP_Q15[ NSQ->sLTP_buf_idx - decisionDelay ] = psDD->Pred_Q15[ last_smple_idx ]; | ||
383 | } | ||
384 | NSQ->sLTP_shp_buf_idx++; | ||
385 | NSQ->sLTP_buf_idx++; | ||
386 | |||
387 | /* Update states */ | ||
388 | for( k = 0; k < nStatesDelayedDecision; k++ ) { | ||
389 | psDD = &psDelDec[ k ]; | ||
390 | psSS = &psSampleState[ k ][ 0 ]; | ||
391 | psDD->LF_AR_Q14 = psSS->LF_AR_Q14; | ||
392 | psDD->sLPC_Q14[ NSQ_LPC_BUF_LENGTH + i ] = psSS->xq_Q14; | ||
393 | psDD->Xq_Q14[ *smpl_buf_idx ] = psSS->xq_Q14; | ||
394 | psDD->Q_Q10[ *smpl_buf_idx ] = psSS->Q_Q10; | ||
395 | psDD->Pred_Q15[ *smpl_buf_idx ] = silk_LSHIFT32( psSS->LPC_exc_Q14, 1 ); | ||
396 | psDD->Shape_Q14[ *smpl_buf_idx ] = psSS->sLTP_shp_Q14; | ||
397 | psDD->Seed = silk_ADD32_ovflw( psDD->Seed, silk_RSHIFT_ROUND( psSS->Q_Q10, 10 ) ); | ||
398 | psDD->RandState[ *smpl_buf_idx ] = psDD->Seed; | ||
399 | psDD->RD_Q10 = psSS->RD_Q10; | ||
400 | } | ||
401 | delayedGain_Q10[ *smpl_buf_idx ] = Gain_Q10; | ||
402 | } | ||
403 | /* Update LPC states */ | ||
404 | for( k = 0; k < nStatesDelayedDecision; k++ ) { | ||
405 | psDD = &psDelDec[ k ]; | ||
406 | silk_memcpy( psDD->sLPC_Q14, &psDD->sLPC_Q14[ length ], NSQ_LPC_BUF_LENGTH * sizeof( opus_int32 ) ); | ||
407 | } | ||
408 | } | ||
409 | |||
410 | #endif /* __NSQ_DEL_DEC_MIPSR1_H__ */ | ||