Line data Source code
1 : /*====================================================================================
2 : EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
3 : ====================================================================================*/
4 :
5 : #include <stdint.h>
6 : #include "options.h" /* Compilation switches */
7 : #include "cnst.h" /* Common constants */
8 : #include "rom_enc.h" /* Encoder static table prototypes */
9 : #include "rom_com.h"
10 : #include "basop_util.h"
11 : #include "ivas_cnst.h"
12 : #include "prot_fx.h" /* Function prototypes */
13 : #include "ivas_prot_fx.h" /* Function prototypes */
14 : #include "prot_fx_enc.h" /* Function prototypes */
15 :
16 : /*-------------------------------------------------------------------*
17 : * Local constants
18 : *-------------------------------------------------------------------*/
19 : #define BWD_MIN_BRATE_WIDER_BW_MDCT IVAS_48k
20 : #define BWD_MIN_BRATE_WIDER_BW_ISM IVAS_32k
21 : #define BWD_MAX_BRATE_WIDER_BW_MDCT IVAS_80k
22 : #define BWD_MAX_BRATE_WIDER_BW_ISM IVAS_64k
23 :
24 : #define ALPHA_BWD_FX 24576 /* 0.75 in Q15*/
25 : #define BWD_LT_THRESH_FX 19661 /* 0.6 in Q15*/
26 :
27 : #define BWD_COUNT_MAX 100
28 : #define BWD_COUNT_WIDER_BW 10
29 : #define BWD_COUNT_WIDER_BW_MDCT 0
30 :
31 : #define BWD_N_BINS_MAX 13
32 :
33 : #define CLDFB_ENER_OFFSET_FX 26214 /* 1.6 in Q14 */
34 :
35 : /*-------------------------------------------------------------------*
36 : * bw_detect()
37 : *
38 : * WB, SWB and FB bandwidth detector
39 : *--------------------------------------------------------------------*/
40 :
41 1083327 : void bw_detect_fx(
42 : Encoder_State *st, /* i/o: Encoder State */
43 : const Word16 signal_in[], /* i : input signal */
44 : Word16 *spectrum, /* i : MDCT spectrum Q_spec */
45 : const Word32 *enerBuffer, /* i : CLDFB Energy Q31 */
46 : const Word16 *cldfbBuf_Ener_Exp, /* i : CLDFB Energy Exponent */
47 : const IVAS_FORMAT ivas_format, /* i : IVAS format */
48 : const Word16 mct_on, /* i : flag MCT mode */
49 : const Word16 Q_spec )
50 : {
51 : Word16 Q_dct, E_spect_bin, tmp_1;
52 : Word16 i, j, k, bw_max, bin_width, n_bins;
53 : Word16 max_NB, max_WB, max_SWB, max_FB, mean_NB, mean_WB, mean_SWB, mean_FB; /* Q11*/
54 : const Word16 *pt, *pt1;
55 : Word16 spect[L_FRAME48k], spect_bin[BWD_N_BINS_MAX];
56 : Word32 spect32[L_FRAME48k], in_win32[BWD_TOTAL_WIDTH];
57 : Word16 e_tmp, f_tmp;
58 : Word32 L_tmp, sum32;
59 :
60 : Word32 L_tmp1, L_tmp2, L_tmp3;
61 : Word16 scale;
62 : Word16 ScalFac, ScalFacInv;
63 : Word32 cldfb_bin[9];
64 : Word16 cldfb_bin_Exp[9];
65 1083327 : Word16 cldfb_bin_width = 4;
66 1083327 : move16();
67 : const Word32 *pt32;
68 : Word32 max_NB32, max_WB32, max_SWB32, max_FB32, mean_NB32, mean_WB32, mean_SWB32, mean_FB32; /* Q11*/ /* we need Word32 for the new cldfb energy vectors */
69 : Word16 bwd_count_wider_bw;
70 : Word16 lp_noise_fx;
71 :
72 1083327 : bwd_count_wider_bw = BWD_COUNT_WIDER_BW;
73 1083327 : move16();
74 1083327 : test();
75 1083327 : test();
76 1083327 : test();
77 1083327 : test();
78 1083327 : test();
79 1497704 : if ( st->ini_frame > 0 && ( ( EQ_16( st->element_mode, IVAS_CPE_MDCT ) && ( GE_32( st->element_brate, BWD_MIN_BRATE_WIDER_BW_MDCT ) || mct_on ) ) ||
80 691823 : ( EQ_16( ivas_format, ISM_FORMAT ) && GE_32( st->element_brate, BWD_MIN_BRATE_WIDER_BW_ISM ) ) ) )
81 : {
82 812509 : bwd_count_wider_bw = BWD_COUNT_WIDER_BW_MDCT;
83 812509 : move16();
84 : }
85 1083327 : IF( GT_32( st->input_Fs, 8000 ) )
86 : {
87 :
88 1083327 : IF( enerBuffer != NULL )
89 : {
90 417483 : n_bins = 9;
91 417483 : move16();
92 417483 : scale = st->cldfbAnaEnc->scale;
93 417483 : move16(); /* 7Q8 */
94 :
95 : /*ScalFac = 1/ ( st->cldfbAnaEnc->scale * st->cldfbAnaEnc->scale * 8.f);*/
96 : /*hs->CLDFBscalingFactor = div_s(1, shl(i_mult2(CLDFBscale, CLDFBscale), 3));*/
97 :
98 417483 : assert( 2048 /*1.0/(1<<4) Q15*/ < mult( scale, scale ) );
99 : /* Exponent ScalFacInv: -16 = -(2*7 (CLDFBscale) + 2 (8.0) */
100 417483 : ScalFacInv = shl( mult( scale, scale ), 1 ); /* Q8*Q8 = Q16 + shl -> Q17 -16 -> Q1; shl -> Q2 */
101 : /* Exponent ScalFac: -15 = -(2*7 (CLDFBscale) + 2 (8.0) - 1 (1.0)) */
102 417483 : ScalFac = div_s( 0x4000, ScalFacInv ); /* bin(17214) *2^-15 * 2^-15 = 0.0000160 , use CLDFBscalingFactor_EXP for this*/ /*Q15*/
103 :
104 :
105 : /*set_f( cldfb_bin, 0.001f, 9 );*/
106 417483 : set32_fx( cldfb_bin, 1, n_bins ); /* Q31*/
107 417483 : set16_fx( cldfb_bin_Exp, -15, n_bins );
108 :
109 : /* NB: 1.2 - 2.8 kHz, 4 cldfb-bands */
110 2087415 : FOR( i = 0; i < cldfb_bin_width; i++ )
111 : {
112 1669932 : cldfb_bin[0] = BASOP_Util_Add_Mant32Exp( cldfb_bin[0], cldfb_bin_Exp[0], enerBuffer[3 + i], cldfbBuf_Ener_Exp[3 + i], &( cldfb_bin_Exp[0] ) );
113 1669932 : move32(); /* result: Q31 */
114 : }
115 :
116 417483 : cldfb_bin[0] = Mpy_32_16_1( cldfb_bin[0], ScalFac ); // Q(31-cldfb_bin_Exp)
117 417483 : move32(); /* Q31 */
118 417483 : cldfb_bin_Exp[0] = add( cldfb_bin_Exp[0], CLDFBscalingFactor_EXP );
119 417483 : move16();
120 : #ifdef FIX_2141_ASSERT_IN_OMASA_BITRATE_SWITSCHING
121 417483 : if ( cldfb_bin[0] == 0 )
122 : {
123 29 : cldfb_bin[0] = L_deposit_l( 1 );
124 29 : move32();
125 : }
126 : #else
127 : if ( cldfb_bin[i] == 0 )
128 : {
129 : cldfb_bin[i] = L_deposit_l( 1 );
130 : move32();
131 : }
132 : #endif
133 417483 : L_tmp = BASOP_Util_Log2( cldfb_bin[0] ); /*(log2(660423549*2^(-31))/64)*2^31*/
134 : #ifdef FIX_2141_ASSERT_IN_OMASA_BITRATE_SWITSCHING
135 417483 : L_tmp = L_add_sat( L_tmp, L_shl_sat( L_deposit_l( cldfb_bin_Exp[0] ), 31 - LD_DATA_SCALE ) ); /* Q25 */
136 : #else
137 : L_tmp = L_add_sat( L_tmp, L_shl( L_deposit_l( cldfb_bin_Exp[0] ), 31 - LD_DATA_SCALE ) ); /* Q25 */
138 : #endif
139 417483 : cldfb_bin[0] = Mpy_32_16_1( L_tmp, 9864 /*1.0f/3.3219280948873623478703194294894f Q15*/ );
140 417483 : move32(); /* 1/log2(10) */ /* Q25 */
141 :
142 : /* WB: 4.4 - 7.2 kHz, 8 cldfb-bands, mid band(14) counted twice */
143 417483 : IF( GE_32( st->input_Fs, 16000 ) )
144 : {
145 : /*
146 : cldfb_bin[1] += Sum( &(enerBuffer[11]), cldfb_bin_width );
147 : cldfb_bin[2] += Sum( &(enerBuffer[14]), cldfb_bin_width );*/
148 2087415 : FOR( i = 0; i < cldfb_bin_width; i++ )
149 : {
150 1669932 : cldfb_bin[1] = BASOP_Util_Add_Mant32Exp( cldfb_bin[1], cldfb_bin_Exp[1], enerBuffer[11 + i], cldfbBuf_Ener_Exp[11 + i], &( cldfb_bin_Exp[1] ) );
151 1669932 : move32();
152 1669932 : cldfb_bin[2] = BASOP_Util_Add_Mant32Exp( cldfb_bin[2], cldfb_bin_Exp[2], enerBuffer[14 + i], cldfbBuf_Ener_Exp[14 + i], &( cldfb_bin_Exp[2] ) );
153 1669932 : move32();
154 : }
155 1252449 : FOR( i = 1; i <= 2; i++ )
156 : {
157 834966 : cldfb_bin[i] = Mpy_32_16_1( cldfb_bin[i], ScalFac ); // Q(31-(cldfv_bin_Exp+CLDFBscalingFactor_EXP))
158 834966 : move32();
159 834966 : cldfb_bin_Exp[i] = add( cldfb_bin_Exp[i], CLDFBscalingFactor_EXP );
160 834966 : move16();
161 :
162 834966 : if ( cldfb_bin[i] == 0 )
163 : {
164 58 : cldfb_bin[i] = L_deposit_l( 1 );
165 58 : move32();
166 : }
167 834966 : L_tmp = BASOP_Util_Log2( cldfb_bin[i] ); /*(log2(660423549*2^(-31))/64)*2^31*/
168 : #ifdef FIX_2141_ASSERT_IN_OMASA_BITRATE_SWITSCHING
169 834966 : L_tmp = L_add( L_tmp, L_shl_sat( L_deposit_l( cldfb_bin_Exp[i] ), 31 - LD_DATA_SCALE ) ); /* Q25 */
170 : #else
171 : L_tmp = L_add( L_tmp, L_shl( L_deposit_l( cldfb_bin_Exp[i] ), 31 - LD_DATA_SCALE ) ); /* Q25 */
172 : #endif
173 834966 : cldfb_bin[i] = Mpy_32_16_1( L_tmp, 9864 /*1.0f/3.3219280948873623478703194294894f Q15*/ );
174 834966 : move32(); /* 1/log2(10) */ /* Q25 */
175 : }
176 : }
177 :
178 : /* SWB: 9.2 - 15.6 kHz, 16 cldfb-bands */
179 417483 : IF( GE_32( st->input_Fs, 32000 ) )
180 : {
181 : /*
182 : cldfb_bin[3] += Sum( &(enerBuffer[23]), cldfb_bin_width );
183 : cldfb_bin[4] += Sum( &(enerBuffer[27]), cldfb_bin_width );
184 : cldfb_bin[5] += Sum( &(enerBuffer[31]), cldfb_bin_width );
185 : cldfb_bin[6] += Sum( &(enerBuffer[35]), cldfb_bin_width );
186 : */
187 1996415 : FOR( i = 0; i < cldfb_bin_width; i++ )
188 : {
189 1597132 : cldfb_bin[3] = BASOP_Util_Add_Mant32Exp( cldfb_bin[3], cldfb_bin_Exp[3], enerBuffer[23 + i], cldfbBuf_Ener_Exp[23 + i], &( cldfb_bin_Exp[3] ) );
190 1597132 : move32();
191 1597132 : cldfb_bin[4] = BASOP_Util_Add_Mant32Exp( cldfb_bin[4], cldfb_bin_Exp[4], enerBuffer[27 + i], cldfbBuf_Ener_Exp[27 + i], &( cldfb_bin_Exp[4] ) );
192 1597132 : move32();
193 1597132 : cldfb_bin[5] = BASOP_Util_Add_Mant32Exp( cldfb_bin[5], cldfb_bin_Exp[5], enerBuffer[31 + i], cldfbBuf_Ener_Exp[31 + i], &( cldfb_bin_Exp[5] ) );
194 1597132 : move32();
195 1597132 : cldfb_bin[6] = BASOP_Util_Add_Mant32Exp( cldfb_bin[6], cldfb_bin_Exp[6], enerBuffer[35 + i], cldfbBuf_Ener_Exp[35 + i], &( cldfb_bin_Exp[6] ) );
196 1597132 : move32();
197 : }
198 1996415 : FOR( i = 3; i <= 6; i++ )
199 : {
200 1597132 : cldfb_bin[i] = Mpy_32_16_1( cldfb_bin[i], ScalFac ); // Q(31-(cldfv_bin_Exp+CLDFBscalingFactor_EXP))
201 1597132 : move32();
202 1597132 : cldfb_bin_Exp[i] = add( cldfb_bin_Exp[i], CLDFBscalingFactor_EXP );
203 1597132 : move16();
204 :
205 1597132 : if ( cldfb_bin[i] == 0 )
206 : {
207 5776 : cldfb_bin[i] = L_deposit_l( 1 );
208 5776 : move32();
209 : }
210 1597132 : L_tmp = BASOP_Util_Log2( cldfb_bin[i] ); /*(log2(660423549*2^(-31))/64)*2^31*/
211 : #ifdef FIX_2141_ASSERT_IN_OMASA_BITRATE_SWITSCHING
212 1597132 : L_tmp = L_add( L_tmp, L_shl_sat( L_deposit_l( cldfb_bin_Exp[i] ), 31 - LD_DATA_SCALE ) ); /* Q25 */
213 : #else
214 : L_tmp = L_add( L_tmp, L_shl( L_deposit_l( cldfb_bin_Exp[i] ), 31 - LD_DATA_SCALE ) ); /* Q25 */
215 : #endif
216 1597132 : cldfb_bin[i] = Mpy_32_16_1( L_tmp, 9864 /*1.0f/3.3219280948873623478703194294894f Q15*/ );
217 1597132 : move32(); /* 1/log2(10) */ /* Q25 */
218 : }
219 : }
220 :
221 : /* FB: 16.8 - 20.0 kHz, 8 cldfb-bands */
222 417483 : IF( GE_32( st->input_Fs, 48000 ) )
223 : {
224 : /*
225 : cldfb_bin[7] += Sum( &(enerBuffer[42]), cldfb_bin_width );
226 : cldfb_bin[8] += Sum( &(enerBuffer[46]), cldfb_bin_width );
227 : */
228 1713525 : FOR( i = 0; i < cldfb_bin_width; i++ )
229 : {
230 1370820 : cldfb_bin[7] = BASOP_Util_Add_Mant32Exp( cldfb_bin[7], cldfb_bin_Exp[7], enerBuffer[42 + i], cldfbBuf_Ener_Exp[42 + i], &( cldfb_bin_Exp[7] ) );
231 1370820 : move32();
232 1370820 : cldfb_bin[8] = BASOP_Util_Add_Mant32Exp( cldfb_bin[8], cldfb_bin_Exp[8], enerBuffer[46 + i], cldfbBuf_Ener_Exp[46 + i], &( cldfb_bin_Exp[8] ) );
233 1370820 : move32();
234 : }
235 1028115 : FOR( i = 7; i <= 8; i++ )
236 : {
237 685410 : cldfb_bin[i] = Mpy_32_16_1( cldfb_bin[i], ScalFac );
238 685410 : move32();
239 685410 : cldfb_bin_Exp[i] = add( cldfb_bin_Exp[i], CLDFBscalingFactor_EXP );
240 685410 : move16();
241 :
242 685410 : if ( cldfb_bin[i] == 0 )
243 : {
244 19642 : cldfb_bin[i] = L_deposit_l( 1 );
245 19642 : move32();
246 : }
247 685410 : L_tmp = BASOP_Util_Log2( cldfb_bin[i] ); /*(log2(660423549*2^(-31))/64)*2^31*/
248 : #ifdef FIX_2141_ASSERT_IN_OMASA_BITRATE_SWITSCHING
249 685410 : L_tmp = L_add( L_tmp, L_shl_sat( L_deposit_l( cldfb_bin_Exp[i] ), 31 - LD_DATA_SCALE ) ); /* Q25 */
250 : #else
251 : L_tmp = L_add( L_tmp, L_shl( L_deposit_l( cldfb_bin_Exp[i] ), 31 - LD_DATA_SCALE ) ); /* Q25 */
252 : #endif
253 685410 : cldfb_bin[i] = Mpy_32_16_1( L_tmp, 9864 /*1.0f/3.3219280948873623478703194294894f Q15*/ );
254 685410 : move32(); /* 1/log2(10) */ /* Q25 */
255 : }
256 : }
257 : /* cldfb_bin_Exp[] are applied now in cldfb_bin[i] -> don't use again */
258 417483 : set16_fx( cldfb_bin_Exp, 0, n_bins );
259 : }
260 : ELSE
261 : {
262 :
263 : /* set width of a speactral bin (corresponds to 1.5kHz) */
264 665844 : IF( EQ_32( st->input_Fs, 16000 ) )
265 : {
266 41982 : bw_max = WB;
267 41982 : move16();
268 41982 : bin_width = 60;
269 41982 : move16();
270 41982 : n_bins = 5;
271 41982 : move16(); /* spectrum to 7.5 kHz */
272 : }
273 623862 : ELSE IF( EQ_32( st->input_Fs, 32000 ) )
274 : {
275 163907 : bw_max = SWB;
276 163907 : move16();
277 163907 : bin_width = 30;
278 163907 : move16();
279 163907 : n_bins = 10;
280 163907 : move16(); /* spectrum to 15.0 kHz */
281 : }
282 : ELSE /* st->input_Fs == 48000 */
283 : {
284 459955 : bw_max = FB;
285 459955 : move16();
286 459955 : bin_width = 20;
287 459955 : move16();
288 459955 : n_bins = BWD_N_BINS_MAX;
289 459955 : move16(); /* spectrum to 19.5 kHz */
290 : }
291 665844 : Q_dct = 0;
292 665844 : move16();
293 665844 : IF( signal_in != NULL )
294 : {
295 : /*---------------------------------------------------------------------*
296 : * windowing of the input signal
297 : *---------------------------------------------------------------------*/
298 0 : pt = signal_in;
299 0 : pt1 = hann_window_320_fx;
300 : /* 1st half of the window */
301 0 : FOR( i = 0; i < BWD_TOTAL_WIDTH / 2; i++ )
302 : {
303 : /*in_win[i] = *pt++ * *pt1++;*/
304 0 : in_win32[i] = L_mult( *pt++, *pt1++ );
305 0 : move32(); /* Q0*Q15 -> Q16*/
306 : }
307 0 : pt1--;
308 : /* 2nd half of the window */
309 0 : FOR( ; i < BWD_TOTAL_WIDTH; i++ )
310 : {
311 : /*in_win[i] = *pt++ * *pt1--;*/
312 0 : in_win32[i] = L_mult( *pt++, *pt1-- );
313 0 : move32();
314 : }
315 0 : edct_fx( in_win32, spect32, BWD_TOTAL_WIDTH, &Q_dct /*,st->element_mode*/ );
316 :
317 0 : FOR( i = 0; i < BWD_TOTAL_WIDTH; i++ )
318 : {
319 0 : spect[i] = round_fx_sat( L_shr_sat( spect32[i], Q_dct ) );
320 0 : move16();
321 : }
322 0 : Q_dct = -2;
323 0 : move16();
324 : }
325 : ELSE
326 : {
327 665844 : Word16 l_frame = extract_l( st->input_Fs / FRAMES_PER_SEC );
328 665844 : IF( EQ_16( st->core, TCX_10_CORE ) )
329 : {
330 29640 : l_frame = shr( l_frame, 1 );
331 : }
332 :
333 665844 : bin_width = i_mult( bin_width, l_frame / BWD_TOTAL_WIDTH );
334 665844 : Copy( spectrum, spect, l_frame );
335 665844 : if ( st->element_mode != EVS_MONO )
336 : {
337 665844 : Q_dct = Q_spec;
338 665844 : move16();
339 : }
340 : }
341 : /*---------------------------------------------------------------------*
342 : * compute energy per spectral bins
343 : *---------------------------------------------------------------------*/
344 :
345 665844 : set16_fx( spect_bin, 1, n_bins );
346 665844 : Q_dct = shl( Q_dct, 1 );
347 665844 : E_spect_bin = sub( Q31, Q_dct );
348 :
349 3081349 : FOR( k = 0; k <= bw_max; k++ )
350 : {
351 7828395 : FOR( i = bwd_start_bin[k]; i <= bwd_end_bin[k]; i++ )
352 : {
353 5412890 : sum32 = L_deposit_l( 1 );
354 5412890 : pt1 = &spect[i_mult2( i, bin_width )];
355 320946170 : FOR( j = 0; j < bin_width; j++ )
356 : {
357 315533280 : sum32 = L_mac0_sat( sum32, *pt1, *pt1 );
358 315533280 : pt1++;
359 : }
360 5412890 : tmp_1 = BASOP_Util_Cmp_Mant32Exp( sum32, E_spect_bin, MAX_32, Q31 - 41 ); /* Any sum32 in Q_dct if it is less than MAX_32 in Q41 will be less than 0.001 */
361 5412890 : test();
362 5412890 : IF( st->element_mode != EVS_MONO && tmp_1 < 0 )
363 : {
364 55689 : spect_bin[i] = -6144; /* log10f( 0.00100000005 ) in Q11 */
365 55689 : move16();
366 : }
367 : ELSE
368 : {
369 5357201 : IF( LE_32( sum32, 1 ) )
370 : {
371 : /*deal with zero spectrum*/
372 4569 : spect_bin[i] = -1;
373 4569 : move16();
374 : }
375 : ELSE
376 : {
377 : /* spect_bin[i] = (float)log10(spect_bin[i]);
378 : = log2(spect_bin[i])*log10(2); */
379 5352632 : e_tmp = norm_l( sum32 );
380 5352632 : L_tmp = L_shl( sum32, e_tmp );
381 5352632 : f_tmp = Log2_norm_lc( L_tmp );
382 5352632 : e_tmp = sub( sub( 30, e_tmp ), Q_dct );
383 5352632 : L_tmp = Mpy_32_16( e_tmp, f_tmp, 9864 ); /* Q16 */
384 5352632 : spect_bin[i] = round_fx( L_shl( L_tmp, 11 ) ); /* Q11 */
385 5352632 : move16();
386 : }
387 : }
388 : }
389 : }
390 : }
391 :
392 1083327 : IF( enerBuffer != NULL )
393 : {
394 : Word16 cldfb_ener_offset;
395 : Word32 cldfb_ener_offset_32;
396 :
397 417483 : pt32 = cldfb_bin; /* Q25 */
398 : /* cldfb detections */
399 :
400 : /* NB: 1,6 - 3,2 kHz, 4 cldfb-bands (1 bin) */
401 417483 : mean_NB32 = L_add( *pt32++, 0 );
402 417483 : max_NB32 = L_add( mean_NB32, 0 );
403 :
404 : /* WB: 4,4 - 7,6 kHz, 8 cldfb-bands (2 bins) */
405 :
406 417483 : maximum_32_fx( pt32, 2, &max_WB32 );
407 :
408 417483 : L_tmp = L_shr( *pt32++, 1 );
409 417483 : mean_WB32 = L_add( L_tmp, L_shr( *pt32++, 1 ) ); /* FL2WORD32( 0.5)*/
410 : /*L_tmp = L_mac(L_tmp,*pt32++,16384);*/
411 : /*mean_WB = round_fx(L_tmp);*/
412 :
413 : /* Q25 + Q14*/
414 :
415 417483 : cldfb_ener_offset = (Word16) CLDFB_ENER_OFFSET_FX; /* Q14 */
416 417483 : move16();
417 417483 : cldfb_ener_offset_32 = L_deposit_l( cldfb_ener_offset ); /* Q14 in 32bit var */
418 417483 : cldfb_ener_offset_32 = L_shl( cldfb_ener_offset_32, 25 - 14 ); /* Q14 -> Q25 */
419 :
420 417483 : mean_NB = extract_l( L_shr( L_add( mean_NB32, cldfb_ener_offset_32 ), 25 - 11 ) ); /* (Q25 + Q25) -> Q11 */
421 417483 : max_NB = extract_l( L_shr( L_add( max_NB32, cldfb_ener_offset_32 ), 25 - 11 ) ); /* (Q25 + Q25) -> Q11 */
422 417483 : mean_WB = extract_l( L_shr( L_add( mean_WB32, cldfb_ener_offset_32 ), 25 - 11 ) ); /* (Q25 + Q25) -> Q11 */
423 417483 : max_WB = extract_l( L_shr( L_add( max_WB32, cldfb_ener_offset_32 ), 25 - 11 ) ); /* (Q25 + Q25) -> Q11 */
424 :
425 :
426 : /*if WB */
427 417483 : IF( EQ_32( st->input_Fs, 16000 ) )
428 : {
429 : /* for 16kHz sampled inputs, do not check SWB & FB */
430 18200 : mean_SWB = 0;
431 18200 : move16();
432 18200 : max_SWB = 0;
433 18200 : move16();
434 18200 : mean_FB = 0;
435 18200 : move16();
436 18200 : max_FB = 0;
437 18200 : move16();
438 : }
439 : ELSE
440 : {
441 : /* else if SWB */
442 399283 : IF( EQ_32( st->input_Fs, 32000 ) )
443 : {
444 :
445 : /* for 32kHz sampled inputs, do not check FB */
446 56578 : mean_FB = 0;
447 56578 : move16();
448 56578 : max_FB = 0;
449 56578 : move16();
450 :
451 : /* SWB: 8,8 - 15,2 kHz, 16 cldfb-bands (4 bins) */
452 :
453 56578 : maximum_32_fx( pt32, 4, &max_SWB32 );
454 :
455 56578 : L_tmp = L_shr( *pt32++, 2 ); /* /4 */
456 56578 : L_tmp = L_add( L_tmp, L_shr( *pt32++, 2 ) );
457 56578 : L_tmp = L_add( L_tmp, L_shr( *pt32++, 2 ) );
458 56578 : mean_SWB32 = L_add( L_tmp, L_shr( *pt32++, 2 ) );
459 :
460 56578 : mean_SWB = extract_l( L_shr( L_add( mean_SWB32, cldfb_ener_offset_32 ), 25 - 11 ) ); /* (Q25 + Q25) -> Q11 */
461 56578 : max_SWB = extract_l( L_shr( L_add( max_SWB32, cldfb_ener_offset_32 ), 25 - 11 ) ); /* (Q25 + Q25) -> Q11 */
462 : }
463 : ELSE
464 : { /* FB */
465 : /* SWB: 8,8 - 15,2 kHz, 16 cldfb-bands (4 bins) */
466 :
467 342705 : maximum_32_fx( pt32, 4, &max_SWB32 );
468 :
469 342705 : L_tmp = L_shr( *pt32++, 2 ); /* /4 */
470 342705 : L_tmp = L_add( L_tmp, L_shr( *pt32++, 2 ) );
471 342705 : L_tmp = L_add( L_tmp, L_shr( *pt32++, 2 ) );
472 342705 : mean_SWB32 = L_add( L_tmp, L_shr( *pt32++, 2 ) );
473 :
474 342705 : mean_SWB = extract_l( L_shr( L_add( mean_SWB32, cldfb_ener_offset_32 ), 25 - 11 ) ); /* (Q25 + Q25) -> Q11 */
475 342705 : max_SWB = extract_l( L_shr( L_add( max_SWB32, cldfb_ener_offset_32 ), 25 - 11 ) ); /* (Q25 + Q25) -> Q11 */
476 :
477 :
478 : /* FB: 16,4 - 19,6 kHz, 8 cldfb-bands (2 bins) */
479 :
480 342705 : maximum_32_fx( pt32, 2, &max_FB32 );
481 :
482 342705 : L_tmp = L_shr( *pt32++, 1 );
483 342705 : mean_FB32 = L_add( L_tmp, L_shr( *pt32++, 1 ) );
484 :
485 342705 : mean_FB = extract_l( L_shr( L_add( mean_FB32, cldfb_ener_offset_32 ), 25 - 11 ) ); /* (Q25 + Q25) -> Q11 */
486 342705 : max_FB = extract_l( L_shr( L_add( max_FB32, cldfb_ener_offset_32 ), 25 - 11 ) ); /* (Q25 + Q25) -> Q11 */
487 : }
488 : }
489 : }
490 : ELSE
491 : {
492 665844 : pt = (const Word16 *) spect_bin;
493 : /* NB: 1.5-3.0kHz (1 bin) */
494 665844 : pt++;
495 665844 : mean_NB = *pt++;
496 665844 : move16();
497 665844 : max_NB = mean_NB;
498 665844 : move16();
499 :
500 : /* WB: 4.5-7.5kHz (2 bins) */
501 665844 : pt++;
502 665844 : maximum_fx( pt, 2, &max_WB );
503 665844 : L_tmp = L_mult( *pt++, 16384 );
504 665844 : L_tmp = L_mac( L_tmp, *pt++, 16384 );
505 665844 : mean_WB = round_fx( L_tmp );
506 :
507 665844 : IF( EQ_32( st->input_Fs, 16000 ) )
508 : {
509 : /* for 16kHz sampled inputs, do not check SWB & FB */
510 41982 : mean_SWB = 0;
511 41982 : move16();
512 41982 : max_SWB = 0;
513 41982 : move16();
514 41982 : mean_FB = 0;
515 41982 : move16();
516 41982 : max_FB = 0;
517 41982 : move16();
518 : }
519 : ELSE
520 : {
521 : /* SWB: 9.0-15.0kHz (4 bins) */
522 623862 : pt++;
523 623862 : maximum_fx( pt, 4, &max_SWB );
524 623862 : L_tmp = L_mult( *pt++, 8192 );
525 623862 : L_tmp = L_mac( L_tmp, *pt++, 8192 );
526 623862 : L_tmp = L_mac( L_tmp, *pt++, 8192 );
527 623862 : L_tmp = L_mac( L_tmp, *pt++, 8192 );
528 623862 : mean_SWB = round_fx( L_tmp );
529 :
530 623862 : IF( EQ_32( st->input_Fs, 48000 ) )
531 : {
532 : /* FB: 16.5-19.5kHz (2 bins) */
533 459955 : pt++;
534 459955 : maximum_fx( pt, 2, &max_FB );
535 459955 : L_tmp = L_mult( *pt++, 16384 );
536 459955 : L_tmp = L_mac( L_tmp, *pt++, 16384 );
537 459955 : mean_FB = round_fx( L_tmp );
538 : }
539 : ELSE
540 : {
541 : /* for 32kHz sampled inputs, do not check FB */
542 163907 : mean_FB = 0;
543 163907 : move16();
544 163907 : max_FB = 0;
545 163907 : move16();
546 : }
547 : }
548 : }
549 : /*---------------------------------------------------------------------*
550 : * update LT counters and energies
551 : *---------------------------------------------------------------------*/
552 :
553 : /*if( localVAD || st->lp_noise > 30 )*/
554 1083327 : test();
555 1083327 : IF( EQ_16( st->element_mode, EVS_MONO ) )
556 : {
557 3100 : lp_noise_fx = st->lp_noise_fx;
558 3100 : move16();
559 : }
560 : ELSE
561 : {
562 1080227 : lp_noise_fx = extract_h( st->lp_noise_32fx );
563 : }
564 :
565 1083327 : IF( st->localVAD || GT_32( ( lp_noise_fx ), 7680 /*30 in Q8*/ ) )
566 : {
567 : /*st->lt_mean_NB_fx = ALPHA_BWD * st->lt_mean_NB_fx + (1-ALPHA_BWD) * mean_NB;*/
568 1015365 : L_tmp = L_mult( ALPHA_BWD_FX, st->lt_mean_NB_fx ); /* Q15 * Q11 -> Q27 */
569 1015365 : L_tmp = L_mac( L_tmp, 32768 - ALPHA_BWD_FX, mean_NB ); /* Q15 * Q11) -> L_mac(Q27, Q27) -> Q27*/
570 1015365 : st->lt_mean_NB_fx = round_fx( L_tmp ); /* Q11 (27-16) */
571 1015365 : move16();
572 :
573 : /*st->lt_mean_WB_fx = ALPHA_BWD * st->lt_mean_WB_fx + (1-ALPHA_BWD) * mean_WB;*/
574 1015365 : L_tmp = L_mult( ALPHA_BWD_FX, st->lt_mean_WB_fx );
575 1015365 : L_tmp = L_mac( L_tmp, 32768 - ALPHA_BWD_FX, mean_WB );
576 1015365 : st->lt_mean_WB_fx = round_fx( L_tmp );
577 1015365 : move16();
578 :
579 : /*st->lt_mean_SWB_fx = ALPHA_BWD * st->lt_mean_SWB_fx + (1-ALPHA_BWD) * mean_SWB;*/
580 1015365 : L_tmp = L_mult( ALPHA_BWD_FX, st->lt_mean_SWB_fx );
581 1015365 : L_tmp = L_mac( L_tmp, 32768 - ALPHA_BWD_FX, mean_SWB );
582 1015365 : st->lt_mean_SWB_fx = round_fx( L_tmp );
583 1015365 : move16();
584 :
585 1015365 : IF( enerBuffer != NULL )
586 : {
587 : /*if( 0.9f * max_WB > BWD_LT_THRESH_FX * st->lt_mean_NB_fx )*/
588 :
589 : /* optim: if( max_WB > (BWD_LT_THRESH_FX / 0.9) * st->lt_mean_NB_fx )*/
590 :
591 373634 : L_tmp = L_mult( 3686, max_WB ); /* (0.9 in Q12) x Q11 -> Q24*/
592 :
593 373634 : L_tmp1 = L_mult( BWD_LT_THRESH_FX, st->lt_mean_NB_fx ); /* Q15 x Q11 -> Q27 */
594 373634 : L_tmp1 = L_shl( L_tmp1, 24 - 27 ); /* Q27 -> Q24) */
595 373634 : L_tmp1 = L_sub( L_tmp, L_tmp1 );
596 :
597 373634 : IF( L_tmp1 > 0 )
598 : {
599 : /*if( 2.5f * max_WB > max_NB )*/
600 259005 : L_tmp = L_mult( 10240, max_WB ); /* 2.5 in Q12 x Q11 -> Q24 */
601 259005 : L_tmp1 = L_mult( max_NB, 4096 ); /* Q11 x (1 in Q12) -> Q24 */
602 259005 : IF( GT_32( L_tmp, L_tmp1 ) ) /* Q24 */
603 : {
604 258756 : st->count_WB = add( st->count_WB, 1 );
605 258756 : move16();
606 : }
607 : }
608 : ELSE
609 : {
610 : /*if( 3.5f * mean_WB < mean_NB )*/
611 114629 : L_tmp = L_mult( 14336, mean_WB ); /* 3.5 in Q12 x Q11 -> Q24*/
612 114629 : L_tmp1 = L_mult( mean_NB, 4096 );
613 114629 : L_tmp = L_sub( L_tmp, L_tmp1 );
614 114629 : IF( L_tmp < 0 )
615 : {
616 6782 : st->count_WB = sub( st->count_WB, 1 );
617 6782 : move16();
618 : }
619 : }
620 :
621 : /*if( 0.83f * max_SWB > BWD_LT_THRESH_FX * st->lt_mean_WB_fx && max_WB > BWD_LT_THRESH_FX * st->lt_mean_NB_fx )*/
622 : /* IF( L_msu( L_tmp,BWD_LT_THRESH_FX,st->lt_mean_WB_fx) > 0 && L_msu( L_deposit_h(max_WB),BWD_LT_THRESH_FX,st->lt_mean_NB_fx) > 0 )
623 : {*/
624 :
625 373634 : L_tmp = L_mult( 3400, max_SWB ); /* (0.83 in Q12) x Q11 -> Q24*/
626 373634 : L_tmp1 = L_mult( BWD_LT_THRESH_FX, st->lt_mean_WB_fx ); /* Q15 x Q11 -> Q27 */
627 373634 : L_tmp1 = L_shl( L_tmp1, 24 - 27 ); /* Q27 -> Q24) */
628 373634 : L_tmp1 = L_sub( L_tmp, L_tmp1 );
629 :
630 373634 : L_tmp = L_mult( max_WB, 4096 );
631 373634 : L_tmp2 = L_mult( BWD_LT_THRESH_FX, st->lt_mean_NB_fx ); /* Q15 x Q11 -> Q27 */
632 373634 : L_tmp2 = L_shl( L_tmp2, 24 - 27 ); /* Q27 -> Q24) */
633 373634 : L_tmp2 = L_sub( L_tmp, L_tmp2 );
634 :
635 373634 : test();
636 373634 : IF( L_tmp1 > 0 && L_tmp2 > 0 )
637 : {
638 : /*if( 2 * max_SWB > max_WB )*/
639 265960 : L_tmp = L_mult( max_WB, 4096 );
640 265960 : L_tmp1 = L_mult( 8192, max_SWB ); /* 2.0 in Q12 x Q11 -> Q24*/
641 265960 : L_tmp1 = L_sub( L_tmp1, L_tmp ); /* Q24 - (Q11 x (1 in Q12) ) = Q24 */
642 265960 : IF( L_tmp1 > 0 )
643 : {
644 265300 : st->count_SWB = add( st->count_SWB, 1 );
645 265300 : move16();
646 : }
647 : }
648 : ELSE
649 : {
650 : /*if( 3 * mean_SWB < mean_WB )*/
651 107674 : L_tmp = L_mult( mean_WB, 4096 );
652 107674 : L_tmp1 = L_mult( 12288, mean_SWB ); /* 3.0 in Q12 x Q11 -> Q24*/
653 107674 : L_tmp1 = L_sub( L_tmp1, L_tmp ); /* Q24 - (Q11 x (1 in Q12) ) = Q24 */
654 107674 : IF( L_tmp1 < 0 )
655 : {
656 23246 : st->count_SWB = sub( st->count_SWB, 1 );
657 23246 : move16();
658 : }
659 : }
660 : /*if( max_FB > BWD_LT_THRESH_FX * st->lt_mean_SWB_fx && 0.83f * max_SWB > BWD_LT_THRESH_FX * st->lt_mean_WB_fx && max_WB > BWD_LT_THRESH_FX * st->lt_mean_NB_fx )*/
661 :
662 373634 : L_tmp = L_mult( max_FB, 4096 ); /* Q11 x (1 in Q12) = Q24 */
663 373634 : L_tmp1 = L_mult( BWD_LT_THRESH_FX, st->lt_mean_SWB_fx ); /* Q15 x Q11 -> Q27 */
664 373634 : L_tmp1 = L_shl( L_tmp1, 24 - 27 ); /* Q27 -> Q24) */
665 373634 : L_tmp1 = L_sub( L_tmp, L_tmp1 ); /* Q24 */
666 :
667 373634 : L_tmp = L_mult( max_SWB, 3400 ); /* (0.83 in Q12) x Q11) = Q24 */
668 373634 : L_tmp2 = L_mult( BWD_LT_THRESH_FX, st->lt_mean_WB_fx ); /* Q15 x Q11 -> Q27 */
669 373634 : L_tmp2 = L_shl( L_tmp2, 24 - 27 ); /* Q27 -> Q24) */
670 373634 : L_tmp2 = L_sub( L_tmp, L_tmp2 ); /* Q24 */
671 :
672 373634 : L_tmp = L_mult( max_WB, 4096 ); /* Q11 x (1 in Q12) = Q24*/
673 :
674 373634 : L_tmp3 = L_mult( BWD_LT_THRESH_FX, st->lt_mean_NB_fx ); /* Q15 x Q11 -> Q27 */
675 373634 : L_tmp3 = L_shl( L_tmp3, 24 - 27 ); /* Q27 -> Q24) */
676 373634 : L_tmp3 = L_sub( L_tmp, L_tmp3 );
677 :
678 373634 : test();
679 373634 : test();
680 373634 : IF( L_tmp1 > 0 && L_tmp2 > 0 && L_tmp3 > 0 )
681 : {
682 : /*if( 3 * max_FB > max_SWB )*/
683 187955 : L_tmp = L_mult( max_SWB, 4096 ); /* Q11 x (1 in Q12) = Q24*/
684 187955 : L_tmp1 = L_mult( 12288, max_FB ); /* 3.0 in Q12 x Q11 -> Q24*/
685 187955 : L_tmp1 = L_sub( L_tmp1, L_tmp ); /* Q24 */
686 187955 : IF( L_tmp1 > 0 )
687 : {
688 187466 : st->count_FB = add( st->count_FB, 1 );
689 187466 : move16();
690 : }
691 : }
692 : ELSE
693 : {
694 : /* if( 4.1f * mean_FB < mean_SWB )*/
695 185679 : L_tmp = L_mult( mean_SWB, 4096 ); /* Q11 x (1 in Q12) = Q24 */
696 185679 : L_tmp1 = L_mult( 16794, mean_FB ); /* 4.1 in Q12 x Q11 -> Q24*/
697 185679 : L_tmp1 = L_sub( L_tmp1, L_tmp ); /* Q24 */
698 185679 : IF( L_tmp1 < 0 )
699 : {
700 86622 : st->count_FB = sub( st->count_FB, 1 );
701 86622 : move16();
702 : }
703 : }
704 : }
705 : ELSE /* DCT based detection */
706 : {
707 : /*if( max_WB > BWD_LT_THRESH * st->lt_mean_NB_fx )*/
708 641731 : IF( L_msu( L_deposit_h( max_WB ), BWD_LT_THRESH_FX, st->lt_mean_NB_fx ) > 0 )
709 : {
710 : /*if( 2 * max_WB > max_NB )*/
711 550921 : L_tmp = L_mult( 8192, max_WB ); /* 2.0 in Q12 x Q11 -> Q24*/
712 550921 : IF( L_msu( L_tmp, max_NB, 4096 ) > 0 )
713 : {
714 549572 : st->count_WB = add( st->count_WB, 1 );
715 549572 : move16();
716 : }
717 : }
718 : ELSE
719 : {
720 : /*if( 2.6f * mean_WB < mean_NB )*/
721 90810 : L_tmp = L_mult( 10650, mean_WB ); /* 2.6 in Q12 x Q11 -> Q24*/
722 90810 : L_tmp = L_msu( L_tmp, mean_NB, 4096 );
723 90810 : test();
724 90810 : test();
725 90810 : IF( L_tmp < 0 && !( EQ_16( mean_WB, -1 ) && EQ_16( mean_NB, -1 ) ) )
726 : {
727 16999 : st->count_WB = sub( st->count_WB, 1 );
728 16999 : move16();
729 : }
730 : }
731 :
732 : /*if( max_SWB > BWD_LT_THRESH * st->lt_mean_WB_fx && max_WB > BWD_LT_THRESH * st->lt_mean_NB_fx )*/
733 641731 : test();
734 641731 : IF( L_msu( L_deposit_h( max_SWB ), BWD_LT_THRESH_FX, st->lt_mean_WB_fx ) > 0 && L_msu( L_deposit_h( max_WB ), BWD_LT_THRESH_FX, st->lt_mean_NB_fx ) > 0 )
735 : {
736 : /*if( 2 * max_SWB > max_WB )*/
737 503431 : L_tmp = L_mult( 8192, max_SWB ); /* 2.0 in Q12 x Q11 -> Q24*/
738 503431 : IF( L_msu( L_tmp, max_WB, 4096 ) > 0 )
739 : {
740 501439 : st->count_SWB = add( st->count_SWB, 1 );
741 501439 : move16();
742 : }
743 : }
744 : ELSE
745 : {
746 : /*if( 3 * mean_SWB < mean_WB )*/
747 138300 : L_tmp = L_mult( 12288, mean_SWB ); /* 3.0 in Q12 x Q11 -> Q24*/
748 138300 : L_tmp = L_msu( L_tmp, mean_WB, 4096 );
749 138300 : test();
750 138300 : test();
751 138300 : IF( L_tmp < 0 && !( EQ_16( mean_SWB, -1 ) && EQ_16( mean_WB, -1 ) ) )
752 : {
753 44187 : st->count_SWB = sub( st->count_SWB, 1 );
754 44187 : move16();
755 : }
756 : }
757 :
758 641731 : test();
759 641731 : test();
760 : /*if( max_FB > BWD_LT_THRESH * st->lt_mean_SWB_fx && max_SWB > BWD_LT_THRESH * st->lt_mean_WB_fx && max_WB > BWD_LT_THRESH * st->lt_mean_NB_fx )*/
761 641731 : IF( L_msu( L_deposit_h( max_FB ), BWD_LT_THRESH_FX, st->lt_mean_SWB_fx ) > 0 && L_msu( L_deposit_h( max_SWB ), BWD_LT_THRESH_FX, st->lt_mean_WB_fx ) > 0 && L_msu( L_deposit_h( max_WB ), BWD_LT_THRESH_FX, st->lt_mean_NB_fx ) > 0 )
762 : {
763 : /*if( 2 * max_FB > max_SWB )*/
764 348200 : L_tmp = L_mult( 8192, max_FB ); /* 2.0 in Q12 x Q11 -> Q24*/
765 348200 : IF( L_msu( L_tmp, max_SWB, 4096 ) > 0 )
766 : {
767 344677 : st->count_FB = add( st->count_FB, 1 );
768 344677 : move16();
769 : }
770 : }
771 : ELSE
772 : {
773 : /*if( 3 * mean_FB < mean_SWB )*/
774 293531 : L_tmp = L_mult( 12288, mean_FB ); /* 3.0 in Q12 x Q11 -> Q24*/
775 293531 : test();
776 293531 : test();
777 293531 : IF( L_msu( L_tmp, mean_SWB, 4096 ) < 0 && !( EQ_16( mean_FB, -1 ) && EQ_16( mean_SWB, -1 ) ) )
778 : {
779 161545 : st->count_FB = sub( st->count_FB, 1 );
780 161545 : move16();
781 : }
782 : }
783 : }
784 :
785 1015365 : st->count_WB = s_min( st->count_WB, BWD_COUNT_MAX );
786 1015365 : move16();
787 1015365 : st->count_SWB = s_min( st->count_SWB, BWD_COUNT_MAX );
788 1015365 : move16();
789 1015365 : st->count_FB = s_min( st->count_FB, BWD_COUNT_MAX );
790 1015365 : move16();
791 1015365 : st->count_WB = s_max( st->count_WB, 0 );
792 1015365 : move16();
793 1015365 : st->count_SWB = s_max( st->count_SWB, 0 );
794 1015365 : move16();
795 1015365 : st->count_FB = s_max( st->count_FB, 0 );
796 1015365 : move16();
797 :
798 : /*---------------------------------------------------------------------*
799 : * check against thresholds
800 : * detect a band-width change
801 : *---------------------------------------------------------------------*/
802 :
803 : /* switching to a higher BW */
804 1015365 : IF( EQ_16( st->last_input_bwidth, NB ) )
805 : {
806 3297 : IF( GT_16( st->count_WB, bwd_count_wider_bw ) )
807 : {
808 59 : st->input_bwidth = WB;
809 59 : move16();
810 59 : st->count_WB = BWD_COUNT_MAX;
811 59 : move16();
812 :
813 59 : IF( GT_16( st->count_SWB, bwd_count_wider_bw ) )
814 : {
815 17 : st->input_bwidth = SWB;
816 17 : move16();
817 17 : st->count_SWB = BWD_COUNT_MAX;
818 17 : move16();
819 :
820 17 : IF( GT_16( st->count_FB, bwd_count_wider_bw ) )
821 : {
822 0 : st->input_bwidth = FB;
823 0 : move16();
824 0 : st->count_FB = BWD_COUNT_MAX;
825 0 : move16();
826 : }
827 : }
828 : }
829 : }
830 :
831 1015365 : test();
832 1015365 : IF( EQ_16( st->last_input_bwidth, WB ) && GT_32( st->input_Fs, 16000 ) )
833 : {
834 28166 : IF( GT_16( st->count_SWB, bwd_count_wider_bw ) )
835 : {
836 28058 : st->input_bwidth = SWB;
837 28058 : move16();
838 28058 : st->count_SWB = BWD_COUNT_MAX;
839 28058 : move16();
840 :
841 28058 : IF( GT_16( st->count_FB, bwd_count_wider_bw ) )
842 : {
843 28041 : st->input_bwidth = FB;
844 28041 : move16();
845 28041 : st->count_FB = BWD_COUNT_MAX;
846 28041 : move16();
847 : }
848 : }
849 : }
850 :
851 1015365 : test();
852 1015365 : IF( EQ_16( st->last_input_bwidth, SWB ) && GT_32( st->input_Fs, 32000 ) )
853 : {
854 123010 : IF( GT_16( st->count_FB, bwd_count_wider_bw ) )
855 : {
856 109276 : st->input_bwidth = FB;
857 109276 : move16();
858 109276 : st->count_FB = BWD_COUNT_MAX;
859 109276 : move16();
860 : }
861 : }
862 :
863 : /* switching to a lower BW */
864 1015365 : IF( EQ_16( st->last_input_bwidth, FB ) )
865 : {
866 602981 : IF( LT_16( st->count_FB, 10 ) )
867 : {
868 28 : st->input_bwidth = SWB;
869 28 : move16();
870 28 : st->count_FB = 0;
871 28 : move16();
872 : }
873 602981 : IF( LT_16( st->count_SWB, 10 ) )
874 : {
875 0 : st->input_bwidth = WB;
876 0 : move16();
877 0 : st->count_SWB = 0;
878 0 : move16();
879 0 : st->count_FB = 0;
880 0 : move16();
881 : }
882 602981 : IF( LT_16( st->count_WB, 10 ) )
883 : {
884 20 : st->input_bwidth = NB;
885 20 : move16();
886 20 : st->count_WB = 0;
887 20 : move16();
888 20 : st->count_SWB = 0;
889 20 : move16();
890 20 : st->count_FB = 0;
891 20 : move16();
892 : }
893 : }
894 :
895 1015365 : IF( EQ_16( st->last_input_bwidth, SWB ) )
896 : {
897 323825 : IF( LT_16( st->count_SWB, 10 ) )
898 : {
899 8 : st->input_bwidth = WB;
900 8 : move16();
901 8 : st->count_SWB = 0;
902 8 : move16();
903 8 : st->count_FB = 0;
904 8 : move16();
905 : }
906 323825 : IF( LT_16( st->count_WB, 10 ) )
907 : {
908 45 : st->input_bwidth = NB;
909 45 : move16();
910 45 : st->count_WB = 0;
911 45 : move16();
912 45 : st->count_SWB = 0;
913 45 : move16();
914 45 : st->count_FB = 0;
915 45 : move16();
916 : }
917 : }
918 :
919 1015365 : IF( EQ_16( st->last_input_bwidth, WB ) )
920 : {
921 85262 : IF( LT_16( st->count_WB, 10 ) )
922 : {
923 20 : st->input_bwidth = NB;
924 20 : move16();
925 20 : st->count_WB = 0;
926 20 : move16();
927 20 : st->count_SWB = 0;
928 20 : move16();
929 20 : st->count_FB = 0;
930 20 : move16();
931 : }
932 : }
933 : }
934 : }
935 :
936 :
937 : /* verify that maximum encoded bandwidth (specified on the command line) is not exceeded */
938 1083327 : if ( GT_16( st->input_bwidth, st->max_bwidth ) )
939 : {
940 137430 : st->input_bwidth = st->max_bwidth;
941 137430 : move16();
942 : }
943 1083327 : IF( st->element_mode == EVS_MONO )
944 : {
945 3100 : set_bw_fx( -1, -1, st, st->codec_mode );
946 : }
947 :
948 :
949 1083327 : return;
950 : }
951 :
952 : /*-------------------------------------------------------------------*
953 : * set_bw_fx()
954 : *
955 : * Set and limit the encoded bandwidth
956 : *-------------------------------------------------------------------*/
957 :
958 454203 : void set_bw_fx(
959 : const Word16 element_mode, /* i : element mode */
960 : const Word32 element_brate, /* i : element bitrate */
961 : Encoder_State *st, /* i/o: Encoder State */
962 : const Word16 codec_mode /* i : codec mode */
963 : )
964 : {
965 : Word32 total_brate_fx, L_tmp;
966 : /* initialization */
967 454203 : st->bwidth = st->input_bwidth;
968 454203 : move16();
969 :
970 : /* Set and limit the encoded bandwidth */
971 454203 : IF( EQ_16( st->codec_mode, MODE1 ) )
972 : {
973 :
974 453153 : st->bwidth = st->input_bwidth;
975 453153 : move16();
976 :
977 453153 : total_brate_fx = st->total_brate;
978 453153 : move32();
979 : /* change the encoded bandwidth, if not supported at particular bitrate */
980 453153 : test();
981 453153 : test();
982 453153 : test();
983 453153 : test();
984 453153 : IF( GT_16( element_mode, IVAS_SCE ) )
985 : {
986 : // PMT("this IVAS_SCE section has not been verified ")
987 67281 : IF( LT_32( element_brate, MIN_BRATE_SWB_STEREO ) )
988 : {
989 0 : st->bwidth = WB;
990 0 : move16();
991 : }
992 : ELSE
993 : {
994 67281 : test();
995 67281 : IF( st->idchan == 0 || EQ_16( element_mode, IVAS_CPE_MDCT ) )
996 : {
997 63470 : IF( GE_32( element_brate, MIN_BRATE_FB_STEREO ) )
998 : {
999 23350 : st->bwidth = s_min( st->bwidth, FB );
1000 23350 : move16();
1001 : }
1002 : ELSE
1003 : {
1004 40120 : st->bwidth = s_min( st->bwidth, SWB );
1005 40120 : move16();
1006 : }
1007 63470 : st->bwidth = s_max( st->bwidth, WB );
1008 63470 : move16();
1009 : }
1010 : ELSE
1011 : {
1012 3811 : st->bwidth = WB;
1013 3811 : move16();
1014 : }
1015 : }
1016 : }
1017 385872 : ELSE IF( EQ_16( element_mode, IVAS_SCE ) )
1018 : {
1019 383822 : test();
1020 383822 : test();
1021 383822 : test();
1022 383822 : test();
1023 383822 : test();
1024 383822 : IF( LT_32( element_brate, MIN_BRATE_SWB_SCE ) || LT_16( st->bwidth, WB ) )
1025 : {
1026 9710 : st->bwidth = WB;
1027 9710 : move16();
1028 : }
1029 374112 : ELSE IF( GT_16( st->bwidth, SWB ) && ( ( LT_32( element_brate, MIN_BRATE_FB_STEREO ) && !st->is_ism_format ) || ( LT_32( element_brate, MIN_BRATE_FB_ISM ) && st->is_ism_format ) ) )
1030 : {
1031 1983 : st->bwidth = SWB;
1032 1983 : move16();
1033 : }
1034 372129 : ELSE IF( GT_32( element_brate, BWD_MAX_BRATE_WIDER_BW_ISM ) )
1035 : {
1036 28308 : st->bwidth = st->max_bwidth;
1037 28308 : move16();
1038 : }
1039 : }
1040 : /* element_mode == EVS_MONO */
1041 2050 : ELSE IF( LE_32( total_brate_fx, ACELP_9k60 ) && GT_16( st->bwidth, WB ) )
1042 : {
1043 0 : st->bwidth = WB;
1044 0 : move16();
1045 : }
1046 2050 : ELSE IF( GE_32( st->total_brate, ACELP_13k20 ) && LE_32( st->total_brate, ACELP_16k40 ) && GT_16( st->bwidth, SWB ) )
1047 : {
1048 0 : st->bwidth = SWB;
1049 0 : move16();
1050 : }
1051 2050 : ELSE IF( GE_32( st->total_brate, ACELP_32k ) && LT_16( st->bwidth, WB ) )
1052 : {
1053 0 : st->bwidth = WB;
1054 0 : move16();
1055 : }
1056 : }
1057 1050 : ELSE IF( EQ_16( codec_mode, MODE2 ) )
1058 : {
1059 : Word16 n, bits_frame_nominal;
1060 :
1061 : UWord16 lsb;
1062 : Word16 tmpbandwidthMin;
1063 :
1064 1050 : Mpy_32_16_ss( st->total_brate, 5243, &L_tmp, &lsb ); /* 5243 is 1/50 in Q18. (0+18-15=3) */
1065 1050 : bits_frame_nominal = extract_l( L_shr( L_tmp, 3 ) ); /* Q0 */
1066 :
1067 8400 : FOR( n = 0; n < FRAME_SIZE_NB; n++ )
1068 : {
1069 8400 : IF( EQ_16( FrameSizeConfig[n].frame_bits, bits_frame_nominal ) )
1070 : {
1071 1050 : BREAK;
1072 : }
1073 : }
1074 1050 : IF( EQ_16( n, FRAME_SIZE_NB ) )
1075 : {
1076 0 : assert( !"Bitrate not supported: not part of EVS" );
1077 : }
1078 1050 : tmpbandwidthMin = FrameSizeConfig[n].bandwidth_min;
1079 1050 : move16();
1080 1050 : if ( EQ_16( st->rf_mode, 1 ) )
1081 : {
1082 0 : tmpbandwidthMin = WB;
1083 0 : move16();
1084 : }
1085 1050 : st->bwidth = s_max( s_min( st->input_bwidth, FrameSizeConfig[n].bandwidth_max ), tmpbandwidthMin );
1086 1050 : move16();
1087 : }
1088 454203 : }
1089 :
1090 :
1091 : /*-------------------------------------------------------------------*
1092 : * set_bw_stereo()
1093 : *
1094 : * Set encoded bandwidth for stereo (CPE) channels
1095 : *-------------------------------------------------------------------*/
1096 :
1097 83783 : void set_bw_stereo_fx(
1098 : CPE_ENC_HANDLE hCPE /* i/o: CPE encoder structures */
1099 : )
1100 : {
1101 83783 : Encoder_State **sts = hCPE->hCoreCoder;
1102 :
1103 83783 : IF( GT_32( hCPE->element_brate, BWD_MAX_BRATE_WIDER_BW_MDCT ) )
1104 : {
1105 14925 : sts[0]->bwidth = sts[0]->max_bwidth;
1106 14925 : move16();
1107 14925 : sts[1]->bwidth = sts[1]->max_bwidth;
1108 14925 : move16();
1109 : }
1110 68858 : ELSE IF( EQ_16( hCPE->element_mode, IVAS_CPE_MDCT ) )
1111 : {
1112 : /* ensure that both CPE channels have the same audio band-width */
1113 68858 : IF( EQ_16( sts[0]->input_bwidth, sts[1]->input_bwidth ) )
1114 : {
1115 68049 : sts[0]->bwidth = sts[0]->input_bwidth;
1116 68049 : move16();
1117 68049 : sts[1]->bwidth = sts[0]->input_bwidth;
1118 68049 : move16();
1119 : }
1120 : ELSE
1121 : {
1122 809 : sts[0]->bwidth = s_max( sts[0]->input_bwidth, sts[1]->input_bwidth );
1123 809 : move16();
1124 809 : sts[1]->bwidth = s_max( sts[0]->input_bwidth, sts[1]->input_bwidth );
1125 809 : move16();
1126 : }
1127 : }
1128 :
1129 83783 : sts[0]->bwidth = s_max( sts[0]->bwidth, WB );
1130 83783 : move16();
1131 83783 : sts[1]->bwidth = s_max( sts[1]->bwidth, WB );
1132 83783 : move16();
1133 :
1134 83783 : return;
1135 : }
1136 :
1137 :
1138 : /*-------------------------------------------------------------------*
1139 : * set_bw_mct()
1140 : *
1141 : * Set encoded bandwidth for MCT
1142 : *-------------------------------------------------------------------*/
1143 :
1144 : /*! r: flag indicating whether the coded BW has changed */
1145 101939 : Word16 set_bw_mct_fx(
1146 : CPE_ENC_HANDLE hCPE[MCT_MAX_BLOCKS], /* i/o: CPE encoder structures */
1147 : const Word16 nCPE /* i : number of CPEs */
1148 : )
1149 : {
1150 : Encoder_State *st;
1151 : Word16 ch, cpe_id;
1152 : Word16 mct_bwidth, last_mct_bwidth, bw_changed;
1153 :
1154 101939 : mct_bwidth = WB; /* minimum coded audio band-width */
1155 101939 : last_mct_bwidth = hCPE[0]->hCoreCoder[0]->last_bwidth; /* supposes that LFE is not in the first channel */
1156 101939 : move16();
1157 101939 : move16();
1158 :
1159 374247 : FOR( cpe_id = 0; cpe_id < nCPE; cpe_id++ )
1160 : {
1161 816924 : FOR( ch = 0; ch < CPE_CHANNELS; ch++ )
1162 : {
1163 544616 : st = hCPE[cpe_id]->hCoreCoder[ch];
1164 544616 : IF( EQ_32( st->mct_chan_mode, MCT_CHAN_MODE_IGNORE ) )
1165 : {
1166 59829 : CONTINUE;
1167 : }
1168 :
1169 484787 : mct_bwidth = s_max( mct_bwidth, st->input_bwidth );
1170 : }
1171 : }
1172 :
1173 374247 : FOR( cpe_id = 0; cpe_id < nCPE; cpe_id++ )
1174 : {
1175 272308 : IF( GT_32( hCPE[cpe_id]->element_brate, BWD_MAX_BRATE_WIDER_BW_MDCT ) )
1176 : {
1177 224148 : mct_bwidth = s_max( mct_bwidth, hCPE[cpe_id]->hCoreCoder[0]->max_bwidth );
1178 : }
1179 : }
1180 :
1181 101939 : bw_changed = 0;
1182 101939 : move16();
1183 101939 : IF( NE_16( mct_bwidth, last_mct_bwidth ) )
1184 : {
1185 179 : bw_changed = 1;
1186 179 : move16();
1187 : }
1188 :
1189 : /*
1190 : * always set bw for all CPEs even if it is the same value as before,
1191 : * in case of bw + br switching when changing to MCT, this overwrites
1192 : * potentially incorrect initial values
1193 : */
1194 374247 : FOR( cpe_id = 0; cpe_id < nCPE; cpe_id++ )
1195 : {
1196 816924 : FOR( ch = 0; ch < CPE_CHANNELS; ch++ )
1197 : {
1198 544616 : st = hCPE[cpe_id]->hCoreCoder[ch];
1199 544616 : st->bwidth = mct_bwidth;
1200 544616 : move16();
1201 : }
1202 : }
1203 101939 : return bw_changed;
1204 : }
|
