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_com.h" /* Static table prototypes */
9 : #include "prot_fx.h" /* Function prototypes */
10 : #include "ivas_prot_fx.h"
11 :
12 : /*-------------------------------------------------------------------*
13 : * Local prototypes
14 : *
15 : *-------------------------------------------------------------------*/
16 : static Word16 get_pvq_splits_fx( Decoder_State *st_fx, PVQ_DEC_HANDLE hPVQ, const Word16 band_bits, const Word16 sfmsize, Word16 *bits );
17 : static void densitySymbolIndexDecode_fx( Decoder_State *st_fx, PVQ_DEC_HANDLE hPVQ, const Word16 density, const Word16 opp_sz, const Word16 near_sz, Word16 *index_phi );
18 : /*-------------------------------------------------------------------*
19 : * pvq_decode_band()
20 : *
21 : *-------------------------------------------------------------------*/
22 272781 : static void pvq_decode_band_fx(
23 : Decoder_State *st_fx, /* i/o: Decoder state */
24 : PVQ_DEC_HANDLE hPVQ, /* i/o: PVQ decoder handle */
25 : Word16 *pulse_vector, /* i/o: decoded integer shape vector */
26 : Word16 *npulses, /* i/o: number of pulses */
27 : Word16 *coefs_quant, /* i/o: decoded coefficients buffer Qx */
28 : const Word16 sfmsize, /* i : band length */
29 : const Word16 band_bits, /* i : assigned bit budget */
30 : Word16 *bits_left, /* i/o: number of bits / bits remaining */
31 : const Word16 strict_bits /* i : Conservative rounding flag */
32 : )
33 : {
34 :
35 : Word16 K_val;
36 :
37 : Word16 j, Np;
38 : Word16 part_start[MAX_SPLITS + 1], dim_part[MAX_SPLITS + 1], bits_part[MAX_SPLITS + 1];
39 : Word16 pool_tot, pool_part, dim_parts;
40 : Word16 g_part[MAX_SPLITS];
41 : Word16 g_part_neg[MAX_SPLITS];
42 : Word16 sg_part[MAX_SPLITS + 1];
43 : Word16 idx_sort[MAX_SPLITS + 1];
44 : Word16 js, band_bits_tot, split_bit;
45 :
46 272781 : Np = get_pvq_splits_fx( st_fx, hPVQ, band_bits, sfmsize, &split_bit );
47 272781 : band_bits_tot = sub( band_bits, split_bit );
48 :
49 272781 : dim_parts = extract_h( L_mult( negate( sfmsize ), lim_neg_inv_tbl_fx[Np] ) );
50 272781 : set16_fx( dim_part, dim_parts, sub( Np, 1 ) );
51 272781 : dim_part[Np - 1] = sub( sfmsize, i_mult2( dim_parts, sub( Np, 1 ) ) );
52 272781 : move16();
53 :
54 272781 : part_start[0] = 0;
55 272781 : move16();
56 303123 : FOR( j = 1; j < Np; j++ )
57 : {
58 30342 : part_start[j] = add( part_start[j - 1], dim_part[j - 1] );
59 30342 : move16();
60 : }
61 :
62 : /* Encode energies */
63 272781 : set16_fx( g_part_neg, -32768, Np );
64 272781 : IF( GT_16( Np, 1 ) )
65 : {
66 27097 : decode_energies_fx( st_fx, hPVQ, Np, dim_part, bits_part, g_part_neg, band_bits_tot, bits_left, sfmsize, strict_bits );
67 : }
68 : ELSE
69 : {
70 245684 : bits_part[0] = band_bits_tot;
71 245684 : move16();
72 : }
73 :
74 272781 : pool_tot = 0;
75 272781 : move16();
76 272781 : pool_part = 0;
77 272781 : move16();
78 : BASOP_SATURATE_WARNING_OFF_EVS
79 575904 : FOR( j = 0; j < Np; j++ )
80 : {
81 303123 : g_part[j] = negate( g_part_neg[j] );
82 303123 : move16();
83 : }
84 : BASOP_SATURATE_WARNING_ON_EVS
85 272781 : srt_vec_ind16_fx( g_part, sg_part, idx_sort, Np );
86 575904 : FOR( j = 0; j < Np; j++ )
87 : {
88 303123 : js = idx_sort[Np - 1 - j];
89 303123 : pool_part = shrtCDivSignedApprox( pool_tot, sub( Np, j ) );
90 303123 : bits_part[js] = s_max( 0, s_min( add( bits_part[js], pool_part ), 256 ) );
91 303123 : move16();
92 :
93 303123 : conservativeL1Norm_fx( dim_part[js], bits_part[js], strict_bits, *bits_left, pool_tot, *npulses, /* inputs */
94 : &K_val, bits_left, &pool_tot, npulses ); /* outputs */
95 :
96 303123 : IF( K_val > 0 )
97 : {
98 :
99 276160 : pvq_decode_fx( st_fx, hPVQ, coefs_quant + part_start[js], pulse_vector + part_start[js],
100 276160 : K_val, dim_part[js], g_part_neg[js] );
101 : }
102 : ELSE
103 : {
104 26963 : set16_fx( coefs_quant + part_start[js], 0, dim_part[js] );
105 26963 : set16_fx( pulse_vector + part_start[js], 0, dim_part[js] );
106 : }
107 : }
108 :
109 272781 : return;
110 : }
111 :
112 28429 : void pvq_decode_frame_fx(
113 : Decoder_State *st_fx,
114 : Word16 *coefs_quant, /* o : quantized coefficients Qx */
115 : Word16 *npulses, /* o : number of pulses per band */
116 : Word16 *pulse_vector, /* o : non-normalized pulse shapes */
117 : const Word16 *sfm_start, /* i : indices of first coefficients in the bands */
118 : const Word16 *sfm_end, /* i : indices of last coefficients in the bands */
119 : const Word16 *sfmsize, /* i : band sizes */
120 : const Word16 nb_sfm, /* i : total number of bands */
121 : const Word16 *R, /* i : bitallocation per band Q3 */
122 : const Word16 pvq_bits, /* i : number of bits avaiable */
123 : const Word16 core /* i : core */
124 : )
125 : {
126 : Word16 i, j;
127 : Word16 band_bits, bits_left;
128 28429 : Word16 bit_pool = 0;
129 : Word16 coded_bands, bands_to_code;
130 : Word16 bits;
131 : Word16 R_sort[NB_SFM];
132 : Word16 is, i_sort[NB_SFM];
133 : Word16 strict_bits;
134 : PVQ_DEC_DATA pvq_dec;
135 28429 : PVQ_DEC_HANDLE hPVQ = &pvq_dec;
136 28429 : move16();
137 :
138 28429 : rc_dec_init_fx( st_fx, hPVQ, pvq_bits );
139 :
140 28429 : bits = shl( sub( pvq_bits, RC_BITS_RESERVED ), 3 );
141 :
142 28429 : bands_to_code = 0;
143 28429 : move16();
144 442506 : FOR( i = 0; i < nb_sfm; i++ )
145 : {
146 414077 : if ( R[i] > 0 )
147 : {
148 272781 : bands_to_code = add( bands_to_code, 1 );
149 : }
150 : }
151 :
152 28429 : IF( core == ACELP_CORE )
153 : {
154 20591 : strict_bits = PVQ_CONS;
155 20591 : move16();
156 20591 : srt_vec_ind16_fx( R, R_sort, i_sort, nb_sfm );
157 : }
158 : ELSE
159 : {
160 7838 : strict_bits = PVQ_NEAREST;
161 7838 : move16();
162 274930 : FOR( i = 0; i < nb_sfm; i++ )
163 : {
164 267092 : i_sort[i] = i;
165 267092 : move16();
166 : }
167 : }
168 :
169 28429 : coded_bands = 0;
170 28429 : move16();
171 442506 : FOR( i = 0; i < nb_sfm; i++ )
172 : {
173 414077 : is = i_sort[i];
174 414077 : move16();
175 414077 : IF( R[is] > 0 )
176 : {
177 272781 : bandBitsAdjustment_fx( hPVQ->rc_num_bits, hPVQ->rc_range, bits, bands_to_code, sub( bands_to_code, coded_bands ), sfmsize[is], R[is], bit_pool, /* inputs */
178 : &band_bits, &bits_left, &bit_pool ); /* outputs */
179 :
180 272781 : pvq_decode_band_fx( st_fx, hPVQ, &pulse_vector[sfm_start[is]], &npulses[is],
181 272781 : &coefs_quant[sfm_start[is]], sfmsize[is], band_bits,
182 : &bits_left, strict_bits );
183 :
184 : /* Updates */
185 272781 : coded_bands = add( coded_bands, 1 );
186 : }
187 : ELSE
188 : {
189 3396974 : FOR( j = sfm_start[is]; j < sfm_end[is]; j++ )
190 : {
191 3255678 : coefs_quant[j] = 0;
192 3255678 : move16();
193 3255678 : pulse_vector[j] = 0;
194 3255678 : move16();
195 : }
196 : }
197 : }
198 :
199 28429 : rc_dec_finish_fx( st_fx, hPVQ );
200 28429 : }
201 :
202 : /*-------------------------------------------------------------------*
203 : * pvq_core_dec()
204 : *
205 : *-------------------------------------------------------------------*/
206 :
207 6201 : Word16 ivas_pvq_core_dec_fx(
208 : Decoder_State *st_fx,
209 : const Word16 *sfm_start,
210 : const Word16 *sfm_end,
211 : const Word16 *sfmsize,
212 : Word16 coefs_quant[], /* o : output MDCT, Q_coefs */
213 : Word16 *Q_coefs,
214 : Word16 bits_tot,
215 : Word16 nb_sfm,
216 : Word16 *R, /* Q3 */
217 : Word16 *Rs,
218 : Word16 *npulses,
219 : Word16 *maxpulse,
220 : const Word16 core )
221 : {
222 : Word16 i;
223 : Word16 R_upd;
224 : Word16 ord[NB_SFM_MAX];
225 : Word16 pulse_vector[L_SPEC48k_EXT];
226 : Word16 pvq_bits;
227 : Word16 gain_bits_array[NB_SFM];
228 : Word16 fg_pred[NB_SFM_MAX];
229 :
230 6201 : if ( st_fx->hHQ_core != NULL )
231 : {
232 6201 : st_fx->hHQ_core->ber_occured_in_pvq = 0;
233 6201 : move16();
234 : }
235 :
236 6201 : R_upd = shl( bits_tot, 3 ); // Q0 -> Q3
237 6201 : ivas_assign_gain_bits_fx( core, nb_sfm, sfmsize, R, gain_bits_array, &R_upd );
238 :
239 6201 : pvq_bits = shr( R_upd, 3 ); // Q3 -> Q0
240 :
241 6201 : pvq_decode_frame_fx( st_fx, coefs_quant, npulses, pulse_vector, sfm_start,
242 : sfm_end, sfmsize, nb_sfm, R, pvq_bits, core );
243 :
244 6201 : IF( Rs != NULL )
245 : {
246 255221 : FOR( i = 0; i < nb_sfm; i++ )
247 : {
248 249020 : IF( ( npulses[i] <= 0 ) )
249 : {
250 119974 : Rs[i] = 0;
251 119974 : move16(); /* Update Rs in case no pulses were assigned */
252 : }
253 : }
254 : }
255 :
256 255221 : FOR( i = 0; i < nb_sfm; i++ )
257 : {
258 249020 : ord[i] = i;
259 249020 : move16();
260 249020 : if ( ( npulses[i] <= 0 ) )
261 : {
262 119974 : R[i] = 0;
263 119974 : move16(); /* Update in case no pulses were assigned */
264 : }
265 : }
266 :
267 6201 : get_max_pulses_fx( sfm_start, sfm_end, ord, npulses, nb_sfm, pulse_vector, maxpulse );
268 :
269 6201 : ivas_fine_gain_pred_fx( sfm_start, sfm_end, sfmsize, ord, npulses, maxpulse, R,
270 : nb_sfm, coefs_quant, pulse_vector, fg_pred, core );
271 :
272 6201 : fine_gain_dec_fx( st_fx, ord, nb_sfm, gain_bits_array, fg_pred );
273 6201 : IF( st_fx->hHQ_core != NULL )
274 : {
275 6201 : IF( ( st_fx->hHQ_core->ber_occured_in_pvq != 0 ) )
276 : {
277 0 : set16_fx( fg_pred, 1, nb_sfm ); /* low complex ECU action in case of detetected BER in PVQ decoding */
278 : }
279 : }
280 6201 : apply_gain_fx( ord, sfm_start, sfm_end, nb_sfm, fg_pred, coefs_quant );
281 6201 : *Q_coefs = 12;
282 6201 : move16();
283 :
284 6201 : return bits_tot;
285 : }
286 :
287 20997 : Word16 pvq_core_dec_fx(
288 : Decoder_State *st_fx,
289 : const Word16 *sfm_start,
290 : const Word16 *sfm_end,
291 : const Word16 *sfmsize,
292 : Word16 coefs_quant[], /* o : output MDCT */
293 : Word16 *Q_coefs,
294 : Word16 bits_tot,
295 : Word16 nb_sfm,
296 : Word16 *R, /* Q3 */
297 : Word16 *Rs,
298 : Word16 *npulses,
299 : Word16 *maxpulse,
300 : const Word16 core )
301 : {
302 : Word16 i;
303 : Word16 R_upd;
304 : Word16 ord[NB_SFM_MAX];
305 : Word16 pulse_vector[L_FRAME48k];
306 : Word16 pvq_bits;
307 : Word16 gain_bits_array[NB_SFM];
308 : Word16 fg_pred[NB_SFM_MAX];
309 :
310 20997 : if ( st_fx->hHQ_core != NULL )
311 : {
312 20971 : st_fx->hHQ_core->ber_occured_in_pvq = 0;
313 20971 : move16();
314 : }
315 :
316 20997 : R_upd = shl( bits_tot, 3 ); // Q0 -> Q3
317 20997 : assign_gain_bits_fx( core, nb_sfm, sfmsize, R, gain_bits_array, &R_upd );
318 :
319 20997 : pvq_bits = shr( R_upd, 3 ); // Q3 -> Q0
320 :
321 20997 : pvq_decode_frame_fx( st_fx, coefs_quant, npulses, pulse_vector, sfm_start,
322 : sfm_end, sfmsize, nb_sfm, R, pvq_bits, core );
323 :
324 20997 : IF( Rs != NULL )
325 : {
326 16040 : FOR( i = 0; i < nb_sfm; i++ )
327 : {
328 15634 : if ( npulses[i] <= 0 )
329 : {
330 2419 : Rs[i] = 0;
331 2419 : move16(); /* Update Rs in case no pulses were assigned */
332 : }
333 : }
334 : }
335 :
336 183616 : FOR( i = 0; i < nb_sfm; i++ )
337 : {
338 162619 : ord[i] = i;
339 162619 : move16();
340 162619 : if ( npulses[i] <= 0 )
341 : {
342 48136 : R[i] = 0;
343 48136 : move16(); /* Update in case no pulses were assigned */
344 : }
345 : }
346 :
347 20997 : get_max_pulses_fx( sfm_start, sfm_end, ord, npulses, nb_sfm, pulse_vector, maxpulse );
348 :
349 20997 : fine_gain_pred_fx( sfm_start, sfm_end, sfmsize, ord, npulses, maxpulse, R,
350 : nb_sfm, coefs_quant, pulse_vector, fg_pred, core );
351 :
352 20997 : fine_gain_dec_fx( st_fx, ord, nb_sfm, gain_bits_array, fg_pred );
353 20997 : IF( st_fx->hHQ_core != NULL )
354 : {
355 20971 : IF( st_fx->hHQ_core->ber_occured_in_pvq != 0 )
356 : {
357 0 : set16_fx( fg_pred, 1, nb_sfm ); /* low complex ECU action in case of detetected BER in PVQ decoding */
358 : }
359 : }
360 20997 : apply_gain_fx( ord, sfm_start, sfm_end, nb_sfm, fg_pred, coefs_quant );
361 20997 : *Q_coefs = 12;
362 20997 : move16();
363 :
364 20997 : return bits_tot;
365 : }
366 :
367 : /*-------------------------------------------------------------------*
368 : * decode_energies()
369 : *
370 : *-------------------------------------------------------------------*/
371 30342 : void decode_energies_fx(
372 : Decoder_State *st_fx,
373 : PVQ_DEC_HANDLE hPVQ, /* i/o: PVQ decoder handle */
374 : Word16 Np,
375 : Word16 *dim_part,
376 : Word16 *bits_part,
377 : Word16 *g_part, /* Q15 */
378 : Word16 qband,
379 : Word16 *bits_left,
380 : Word16 dim,
381 : const Word16 strict_bits )
382 : {
383 : Word16 density;
384 : Word16 i, l_Np, r_Np;
385 : Word16 l_bits, r_bits, l_dim, r_dim;
386 : Word16 il, ir;
387 : Word16 oppRQ3, qzero;
388 : Word16 l_gain, r_gain;
389 30342 : Word16 index_phi = -1;
390 30342 : move16();
391 :
392 30342 : l_Np = shr( Np, 1 );
393 30342 : r_Np = sub( Np, l_Np );
394 :
395 30342 : l_bits = 0;
396 30342 : move16();
397 30342 : l_dim = 0;
398 30342 : move16();
399 60928 : FOR( i = 0; i < l_Np; i++ )
400 : {
401 30586 : l_dim = add( l_dim, dim_part[i] );
402 : }
403 30342 : r_dim = sub( dim, l_dim );
404 :
405 30342 : obtainEnergyQuantizerDensity_fx( dim, qband, &density );
406 30342 : rangeCoderFinalizationFBits_fx( hPVQ->rc_num_bits, hPVQ->rc_range, &qzero );
407 :
408 30342 : densitySymbolIndexDecode_fx( st_fx, hPVQ, density, r_dim, l_dim, &index_phi );
409 30342 : densityAngle2RmsProjDec_fx( density, index_phi, &ir, &il, &oppRQ3 );
410 :
411 :
412 30342 : l_gain = il; /* Q15 */
413 30342 : move16();
414 30342 : r_gain = ir; /* Q15 */
415 30342 : move16();
416 :
417 60928 : FOR( i = 0; i < l_Np; i++ )
418 : {
419 30586 : g_part[i] = mult_r( l_gain, g_part[i] );
420 30586 : move16();
421 : }
422 :
423 63744 : FOR( i = l_Np; i < Np; i++ )
424 : {
425 33402 : g_part[i] = mult_r( r_gain, g_part[i] );
426 33402 : move16();
427 : }
428 :
429 30342 : NearOppSplitAdjustment_fx( qband, qzero, hPVQ->rc_num_bits, hPVQ->rc_range, *bits_left,
430 30342 : strict_bits, Np, dim_part[0], dim_part[Np - 1],
431 : l_dim, r_dim, oppRQ3,
432 : &l_bits, &r_bits, bits_left );
433 :
434 :
435 30342 : IF( GT_16( l_Np, 1 ) )
436 : {
437 237 : decode_energies_fx( st_fx, hPVQ, l_Np, dim_part, bits_part, g_part, l_bits, bits_left, l_dim, strict_bits );
438 : }
439 : ELSE
440 : {
441 30105 : bits_part[0] = l_bits;
442 30105 : move16();
443 : }
444 :
445 30342 : IF( GT_16( r_Np, 1 ) )
446 : {
447 3008 : decode_energies_fx( st_fx, hPVQ, r_Np, &dim_part[l_Np], &bits_part[l_Np], &g_part[l_Np], r_bits, bits_left, r_dim, strict_bits );
448 : }
449 : ELSE
450 : {
451 27334 : bits_part[1] = r_bits;
452 27334 : move16();
453 : }
454 :
455 30342 : return;
456 : }
457 :
458 : /*-------------------------------------------------------------------*
459 : * densitySymbolIndexDecode()
460 : *
461 : *-------------------------------------------------------------------*/
462 30342 : static void densitySymbolIndexDecode_fx(
463 : Decoder_State *st_fx,
464 : PVQ_DEC_HANDLE hPVQ, /* i/o: PVQ decoder handle */
465 : const Word16 density,
466 : const Word16 opp_sz,
467 : const Word16 near_sz,
468 : Word16 *index_phi )
469 : {
470 : Word16 density1, density2;
471 : Word32 tmp1;
472 : Word16 tmp2;
473 : Word16 c, density_alpha, density_c;
474 : Word32 sym_freq, cum_freq, tot, dec_freq;
475 : Word16 angle, expo, r;
476 : UWord16 lsb;
477 : Word32 acc;
478 30342 : Word16 alpha = 0;
479 30342 : move16();
480 : #ifndef ISSUE_1866_replace_overflow_libdec
481 : #ifdef BASOP_NOGLOB_DECLARE_LOCAL
482 : Flag Overflow = 0;
483 : move16();
484 : #endif
485 : #endif
486 30342 : IF( s_and( (Word16) 0xFFFE, density ) == 0 )
487 : {
488 : /* odd density exit */
489 157 : *index_phi = -1;
490 157 : move16();
491 157 : return;
492 : }
493 :
494 30185 : sym_freq = L_deposit_l( 1 );
495 :
496 30185 : angle = atan2_fx( SQRT_DIM_fx[opp_sz], SQRT_DIM_fx[near_sz] ); // Q13
497 : #ifdef ISSUE_1866_replace_overflow_libdec
498 30185 : angle = shl_sat( angle, 1 );
499 : #else
500 : angle = shl_o( angle, 1, &Overflow );
501 : #endif
502 30185 : angle = mult_r( angle, 20861 );
503 30185 : c = mult_r( density, angle );
504 30185 : density_c = sub( density, c );
505 :
506 30185 : tot = L_mac0( 1L, density, add( density, 1 ) );
507 30185 : IF( c == 0 )
508 : {
509 0 : dec_freq = rc_decode_fx( &st_fx->BER_detect, hPVQ, tot );
510 :
511 0 : density1 = add( density, 1 );
512 0 : acc = L_mult0( density1, density1 );
513 0 : acc = L_sub( acc, dec_freq );
514 0 : alpha = add( getSqrtWord32( acc ), density1 );
515 0 : sym_freq = L_mac( 1L, sub( density, alpha ), 1 );
516 0 : cum_freq = L_mac0( L_mult( alpha, density ), alpha, 1 );
517 : }
518 30185 : ELSE IF( EQ_16( c, density ) )
519 : {
520 0 : dec_freq = rc_decode_fx( &st_fx->BER_detect, hPVQ, tot );
521 :
522 0 : alpha = getSqrtWord32( dec_freq );
523 0 : sym_freq = L_add( L_shl( alpha, 1 ), 1 );
524 0 : cum_freq = L_mult0( alpha, alpha );
525 : }
526 : ELSE
527 : {
528 30185 : acc = L_mult0( density, c );
529 30185 : Mpy_32_16_ss( acc, density_c, &acc, &lsb );
530 30185 : acc = L_or( L_shl( acc, 16 ), L_and( lsb, 0xffffL ) ); /* Concatenate acc and lsb forming 48 bits; upshift 16 bits; keep 32 MSB. */
531 30185 : acc = L_shr( acc, 1 ); /* Compensate fractional mode multiply (Mpy_32_16_ss) */
532 30185 : tot = L_add( L_add( acc, L_deposit_l( density ) ), 1L );
533 :
534 30185 : dec_freq = rc_decode_fx( &st_fx->BER_detect, hPVQ, tot );
535 :
536 30185 : acc = L_mult0( sub( density_c, 1 ), density_c );
537 30185 : Mpy_32_16_ss( acc, c, &acc, &lsb );
538 30185 : acc = L_or( L_shl( acc, 16 ), L_and( lsb, 0xffffL ) ); /* Concatenate acc and lsb forming 48 bits; upshift 16 bits; keep 32 MSB. */
539 30185 : acc = L_shr( acc, 1 ); /* Compensate fractional mode multiply (Mpy_32_16_ss) */
540 30185 : acc = L_add( acc, L_add( density, 1 ) );
541 30185 : acc = L_sub( acc, L_add( c, 1 ) );
542 30185 : acc = L_sub( tot, acc );
543 30185 : IF( LT_32( dec_freq, acc ) )
544 : {
545 17240 : acc = L_add( (Word32) density_c, L_shl( dec_freq, 2 ) );
546 17240 : acc = L_sub( acc, 2 );
547 17240 : Mpy_32_16_ss( acc, density_c, &acc, &lsb );
548 17240 : acc = L_or( L_shl( acc, 16 ), L_and( lsb, 0xffffL ) ); /* Concatenate acc and lsb forming 48 bits; upshift 16 bits; keep 32 MSB. */
549 17240 : acc = L_shr( acc, 1 ); /* Compensate fractional mode multiply (Mpy_32_16_ss) */
550 17240 : acc = L_add( acc, 1 );
551 17240 : tmp2 = getSqrtWord32( acc );
552 17240 : acc = L_add( density_c, tmp2 );
553 17240 : acc = L_sub( acc, 1 );
554 17240 : r = ratio( acc, L_shl( density_c, 1 ), &expo );
555 17240 : alpha = shr( r, add( 14, expo ) );
556 :
557 17240 : acc = L_mult( alpha, density_c );
558 17240 : sym_freq = L_add( acc, 1 );
559 17240 : acc = L_mult0( sub( alpha, 1 ), density_c );
560 17240 : acc = L_add( acc, 1 );
561 17240 : cum_freq = L_mult0( alpha, extract_l( acc ) );
562 : }
563 : ELSE
564 : {
565 12945 : density1 = add( density, 1 );
566 12945 : density2 = add( shl( density, 1 ), 1 );
567 :
568 12945 : acc = L_mult0( density, density1 );
569 12945 : Mpy_32_16_ss( acc, c, &acc, &lsb );
570 12945 : acc = L_or( L_shl( acc, 16 ), L_and( lsb, 0xffffL ) ); /* Concatenate acc and lsb forming 48-bit; upshift 16 bits; keep 32 MSB. */
571 12945 : acc = L_shr( acc, 1 ); /* Compensate fractional mode multiply (Mpy_32_16_ss) */
572 12945 : acc = L_add( density1, acc );
573 12945 : acc = L_add( dec_freq, acc );
574 12945 : acc = L_sub( tot, acc );
575 12945 : Mpy_32_16_ss( acc, c, &acc, &lsb );
576 12945 : acc = L_or( L_shl( acc, 16 ), L_and( lsb, 0xffffL ) );
577 12945 : acc = L_shr( acc, 1 - 2 );
578 :
579 12945 : tmp2 = extract_l( L_mac0( 1L, c, density2 ) );
580 12945 : tmp1 = L_mult0( tmp2, tmp2 );
581 12945 : tmp1 = L_add( tmp1, acc );
582 12945 : tmp2 = getSqrtWord32( tmp1 ); /* floor */
583 12945 : IF( L_msu0( tmp1, tmp2, tmp2 ) != 0 )
584 : {
585 12459 : tmp2 = add( tmp2, 1 ); /* convert to ceil */
586 : }
587 :
588 12945 : acc = L_mult0( c, density2 );
589 12945 : acc = L_add( acc, 1 );
590 12945 : acc = L_sub( acc, tmp2 );
591 12945 : r = ratio( acc, L_shl( c, 1 ), &expo );
592 12945 : alpha = shr( r, add( 14, expo ) );
593 :
594 12945 : density_alpha = sub( density, alpha );
595 12945 : sym_freq = L_mac( 1L, density_alpha, c );
596 12945 : acc = L_mult0( density_alpha, add( density_alpha, 1 ) );
597 12945 : Mpy_32_16_ss( acc, c, &acc, &lsb );
598 12945 : acc = L_or( L_shl( acc, 16 ), L_and( lsb, 0xffffL ) ); /* Concatenate acc and lsb forming 48-bit; upshift 16 bits; keep 32 MSB. */
599 12945 : acc = L_shr( acc, 1 ); /* Compensate fractional mode multiply (Mpy_32_16_ss) */
600 12945 : acc = L_sub( acc, alpha );
601 12945 : acc = L_add( acc, density1 );
602 12945 : cum_freq = L_sub( tot, acc );
603 : }
604 : }
605 :
606 30185 : rc_dec_update_fx( st_fx, hPVQ, cum_freq, sym_freq );
607 30185 : *index_phi = alpha;
608 30185 : move16();
609 30185 : return;
610 : }
611 :
612 :
613 : /*--------------------------------------------------------------------------*
614 : * get_pvq_splits()
615 : *
616 : * Retrieve the number of segments
617 : *--------------------------------------------------------------------------*/
618 :
619 272781 : static Word16 get_pvq_splits_fx( /* o : Number of segments */
620 : Decoder_State *st_fx, /* i/o: Decoder state */
621 : PVQ_DEC_HANDLE hPVQ, /* i/o: PVQ decoder handle */
622 : const Word16 band_bits, /* i : Band bit budget */
623 : const Word16 sfmsize, /* i : Band width */
624 : Word16 *bits /* o : Used bits */
625 : )
626 : {
627 : Word16 Np, i;
628 : Word32 acc, flag;
629 :
630 272781 : IF( band_bits == 0 )
631 : {
632 100 : Np = 1;
633 100 : move16();
634 : }
635 : ELSE
636 : {
637 272681 : acc = L_mult0( band_bits, 0x7a44 );
638 272681 : Np = extract_l( L_shr( acc, 23 ) ); /* Get integer part. */
639 272681 : if ( L_and( acc, 0x7fffffL ) != 0 ) /* If fractional part != 0, add 1. */
640 : {
641 272681 : Np = add( Np, 1 ); /* ceiling operation */
642 : }
643 : }
644 272781 : *bits = 0;
645 272781 : move16();
646 272781 : IF( LT_16( Np, MAX_SPLITS ) )
647 : {
648 272781 : acc = L_mult0( 8 * THR_ADD_SPLIT, sfmsize );
649 272781 : IF( GT_32( band_bits, acc ) )
650 : {
651 70 : flag = rc_dec_bits_fx( st_fx, hPVQ, 1 );
652 70 : *bits = 8;
653 70 : move16();
654 70 : if ( flag != 0 )
655 : {
656 16 : Np = add( Np, 1 );
657 : }
658 : }
659 : }
660 : /* Check constraints for number of splits */
661 : /* The following code assumes that PVQ_MAX_BAND_SIZE is 64 */
662 272781 : i = shr( sfmsize, 6 ); /* 6 = log2(64) = log2(PVQ_MAX_BAND_SIZE) */
663 272781 : if ( s_and( sfmsize, 0x3f ) != 0 )
664 : {
665 272781 : i = add( i, 1 ); /* ceiling operation */
666 : }
667 :
668 272781 : Np = s_max( i, Np );
669 272781 : Np = s_min( MAX_SPLITS, Np );
670 272781 : Np = s_min( sfmsize, Np ); /* The code line assumes that MIN_BAND_SIZE is 1 */
671 272781 : return Np;
672 : }
|
