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