Line data Source code
1 : /*====================================================================================
2 : EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
3 : ====================================================================================*/
4 : #include <stdint.h>
5 : #include "options.h" /* Compilation switches */
6 : #include "cnst.h" /* Common constants */
7 : #include "prot_fx.h" /* Function prototypes */
8 : #include "rom_com.h" /* Static table prototypes */
9 : #include "assert.h" /* Static table prototypes */
10 : /*-------------------------------------------------------------------*
11 : * Local functions
12 : *-------------------------------------------------------------------*/
13 : static void add_pulses_fx( const Word16 pos[], const Word16 nb_pulse, const Word16 track, Word16 code[] );
14 : static void dec_1p_N1_fx( const Word32 index, const Word16 N, const Word16 offset, Word16 pos[] );
15 : static void dec_2p_2N1_fx( const Word32 index, const Word16 N, const Word16 offset, Word16 pos[] );
16 : static void dec_3p_3N1_fx( const Word32 index, const Word16 N, const Word16 offset, Word16 pos[] );
17 : static void dec_4p_4N1_fx( const Word32 index, const Word16 N, const Word16 offset, Word16 pos[] );
18 : static void dec_4p_4N_fx( const Word32 index, const Word16 N, const Word16 offset, Word16 pos[] );
19 : static void dec_5p_5N_fx( const Word32 index, const Word16 N, const Word16 offset, Word16 pos[] );
20 : static void dec_6p_6N2_fx( const Word32 index, const Word16 N, const Word16 offset, Word16 pos[] );
21 : static void fcb_decode_PI_fx( Word32 code_index, Word16 sector_6p[], Word16 pulse_num );
22 :
23 :
24 : /*==========================================================================*/
25 : /* FUNCTION : void dec_acelp_4t64_fx () */
26 : /*--------------------------------------------------------------------------*/
27 : /* PURPOSE : */
28 : /* * 20, 36 bits algebraic codebook decoder. */
29 : /* * 4 tracks x 16 positions per track = 64 samples. */
30 : /* * 20 bits --> 4 pulses in a frame of 64 samples. */
31 : /* * 36 bits --> 8 pulses in a frame of 64 samples. */
32 : /* * All pulses can have two (2) possible amplitudes: +1 or -1. */
33 : /* * Each pulse can have sixteen (16) possible positions. */
34 : /* * See cod4t64.c for more details of the algebraic code. */
35 : /*--------------------------------------------------------------------------*/
36 : /* INPUT ARGUMENTS : */
37 : /* _Word16 i_subfr i : subframe index */
38 : /* _Word16 nbbits i : number of bits per codebook */
39 : /* _Word16 FCB_5Sx4T_fla i : 5Sx4Track flag for PI */
40 : /*--------------------------------------------------------------------------*/
41 : /* OUTPUT ARGUMENTS : */
42 : /* _Word16 code[] o : algebraic (fixed) codebook excitation Q12 */
43 : /* _Word16 index_buf_4T[] o : 5Sx4Track buffer for PI */
44 : /*--------------------------------------------------------------------------*/
45 : /* INPUT/OUTPUT ARGUMENTS : */
46 : /*--------------------------------------------------------------------------*/
47 : /* RETURN ARGUMENTS : */
48 : /* _ None */
49 : /*--------------------------------------------------------------------------*/
50 : /* CALLED FROM : */
51 : /*==========================================================================*/
52 55201 : void dec_acelp_4t64_fx(
53 : Decoder_State *st_fx, /* i/o: decoder state structure */
54 : Word16 nbbits, /* i : number of bits per codebook */
55 : Word16 code[], /* o : algebraic (fixed) codebook excitation Q9*/
56 : const Word16 Opt_AMR_WB )
57 : {
58 : Word16 i, k, pos[7];
59 : Word32 L_index;
60 : Word32 ind1[NB_TRACK_FCB_4T];
61 : PulseConfig config;
62 : Word16 indexing_indices[6], wordcnt, bitcnt, index2;
63 :
64 55201 : IF( !Opt_AMR_WB )
65 : {
66 55201 : SWITCH( nbbits )
67 : {
68 695 : case 20:
69 695 : config.nb_pulse = 4;
70 695 : move16();
71 695 : BREAK;
72 :
73 2276 : case 28:
74 2276 : config.nb_pulse = 6;
75 2276 : move16();
76 2276 : BREAK;
77 :
78 52211 : case 36:
79 52211 : config.nb_pulse = 8;
80 52211 : move16();
81 52211 : BREAK;
82 :
83 0 : case 43:
84 0 : config.nb_pulse = 10;
85 0 : move16();
86 0 : BREAK;
87 :
88 0 : case 50:
89 0 : config.nb_pulse = 12;
90 0 : move16();
91 0 : BREAK;
92 :
93 19 : case 62:
94 19 : config.nb_pulse = 16;
95 19 : move16();
96 19 : BREAK;
97 :
98 0 : case 87:
99 0 : config.nb_pulse = 26;
100 0 : move16();
101 0 : BREAK;
102 : }
103 :
104 55201 : config.bits = nbbits;
105 55201 : move16();
106 55201 : config.codetrackpos = TRACKPOS_FIXED_FIRST;
107 55201 : move16();
108 :
109 :
110 55201 : wordcnt = shr( nbbits, 4 );
111 55201 : bitcnt = s_and( nbbits, 15 );
112 162651 : FOR( i = 0; i < wordcnt; i++ )
113 : {
114 107450 : indexing_indices[i] = extract_l( get_next_indice_fx( st_fx, 16 ) );
115 107450 : move16();
116 : }
117 55201 : IF( bitcnt )
118 : {
119 55201 : indexing_indices[i] = extract_l( get_next_indice_fx( st_fx, bitcnt ) );
120 55201 : move16();
121 : }
122 :
123 55201 : D_ACELP_indexing_fx( code, config, NB_TRACK_FCB_4T, indexing_indices, &st_fx->BER_detect );
124 : }
125 : ELSE
126 : {
127 0 : FOR( i = 0; i < L_SUBFR; i++ )
128 : {
129 0 : code[i] = 0;
130 0 : move16();
131 : }
132 :
133 0 : IF( EQ_16( nbbits, 20 ) )
134 : {
135 0 : FOR( k = 0; k < NB_TRACK_FCB_4T; k++ )
136 : {
137 0 : L_index = get_next_indice_fx( st_fx, 5 );
138 0 : dec_1p_N1_fx( L_index, 4, 0, pos );
139 0 : add_pulses_fx( pos, 1, k, code );
140 : }
141 : }
142 0 : ELSE IF( EQ_16( nbbits, 36 ) )
143 : {
144 0 : FOR( k = 0; k < NB_TRACK_FCB_4T; k++ )
145 : {
146 0 : L_index = get_next_indice_fx( st_fx, 9 );
147 0 : dec_2p_2N1_fx( L_index, 4, 0, pos );
148 0 : add_pulses_fx( pos, 2, k, code );
149 : }
150 : }
151 0 : ELSE IF( EQ_16( nbbits, 44 ) ) /* AMR-WB pulse indexing */
152 : {
153 0 : FOR( k = 0; k < NB_TRACK_FCB_4T - 2; k++ )
154 : {
155 0 : L_index = get_next_indice_fx( st_fx, 13 );
156 0 : dec_3p_3N1_fx( L_index, 4, 0, pos );
157 0 : add_pulses_fx( pos, 3, k, code );
158 : }
159 :
160 0 : FOR( k = 2; k < NB_TRACK_FCB_4T; k++ )
161 : {
162 0 : L_index = get_next_indice_fx( st_fx, 9 );
163 0 : dec_2p_2N1_fx( L_index, 4, 0, pos );
164 0 : add_pulses_fx( pos, 2, k, code );
165 : }
166 : }
167 0 : ELSE IF( EQ_16( nbbits, 52 ) ) /* AMR-WB pulse indexing */
168 : {
169 0 : FOR( k = 0; k < NB_TRACK_FCB_4T; k++ )
170 : {
171 0 : L_index = get_next_indice_fx( st_fx, 13 );
172 0 : dec_3p_3N1_fx( L_index, 4, 0, pos );
173 0 : add_pulses_fx( pos, 3, k, code );
174 : }
175 : }
176 0 : ELSE IF( EQ_16( nbbits, 64 ) ) /* AMR-WB pulse indexing */
177 : {
178 0 : FOR( k = 0; k < NB_TRACK_FCB_4T; k++ )
179 : {
180 0 : ind1[k] = get_next_indice_fx( st_fx, 2 );
181 0 : move32();
182 : }
183 0 : FOR( k = 0; k < NB_TRACK_FCB_4T; k++ )
184 : {
185 0 : index2 = get_next_indice_fx( st_fx, 14 );
186 0 : L_index = L_add( L_shl( ind1[k], 14 ), index2 );
187 0 : dec_4p_4N_fx( L_index, 4, 0, pos );
188 0 : add_pulses_fx( pos, 4, k, code );
189 : }
190 : }
191 0 : ELSE IF( EQ_16( nbbits, 72 ) )
192 : {
193 0 : FOR( k = 0; k < NB_TRACK_FCB_4T - 2; k++ )
194 : {
195 0 : ind1[k] = get_next_indice_fx( st_fx, 10 );
196 0 : move32();
197 : }
198 0 : FOR( k = 2; k < NB_TRACK_FCB_4T; k++ )
199 : {
200 0 : ind1[k] = get_next_indice_fx( st_fx, 2 );
201 0 : move32();
202 : }
203 0 : FOR( k = 0; k < NB_TRACK_FCB_4T - 2; k++ )
204 : {
205 0 : index2 = get_next_indice_fx( st_fx, 10 );
206 0 : L_index = L_add( L_shl( ind1[k], 10 ), index2 );
207 0 : dec_5p_5N_fx( L_index, 4, 0, pos );
208 0 : add_pulses_fx( pos, 5, k, code );
209 : }
210 0 : FOR( k = 2; k < NB_TRACK_FCB_4T; k++ )
211 : {
212 0 : index2 = get_next_indice_fx( st_fx, 14 );
213 0 : L_index = L_add( L_shl( ind1[k], 14 ), index2 );
214 0 : dec_4p_4N_fx( L_index, 4, 0, pos );
215 0 : add_pulses_fx( pos, 4, k, code );
216 : }
217 : }
218 0 : ELSE IF( EQ_16( nbbits, 88 ) )
219 : {
220 0 : FOR( k = 0; k < NB_TRACK_FCB_4T; k++ )
221 : {
222 0 : ind1[k] = get_next_indice_fx( st_fx, 11 );
223 0 : move16();
224 : }
225 0 : FOR( k = 0; k < NB_TRACK_FCB_4T; k++ )
226 : {
227 0 : index2 = get_next_indice_fx( st_fx, 11 );
228 0 : L_index = L_add( L_shl( ind1[k], 11 ), index2 );
229 0 : dec_6p_6N2_fx( L_index, 4, 0, pos );
230 0 : add_pulses_fx( pos, 6, k, code );
231 : }
232 : }
233 : }
234 :
235 55201 : return;
236 : }
237 : /*-------------------------------------------------------*
238 : * add_pulses()
239 : *
240 : * Add decoded pulses to the codeword
241 : *-------------------------------------------------------*/
242 172762 : static void add_pulses_fx(
243 : const Word16 pos[], /* i: pulse position */
244 : const Word16 nb_pulse, /* i: nb. of pulses */
245 : const Word16 track, /* i: no. of the tracks */
246 : Word16 code[] /* i/o: decoded codevector Q9*/
247 : )
248 : {
249 :
250 : Word16 i, k;
251 : Word16 *ptr;
252 172762 : ptr = code + track;
253 172762 : move16();
254 :
255 543681 : FOR( k = 0; k < nb_pulse; k++ )
256 : {
257 : /* i = ((pos[k] & (NB_POS-1))*NB_TRACK) + track */
258 370919 : logic16();
259 370919 : i = shl( s_and( pos[k], ( NB_POS_FCB_4T - 1 ) ), 2 );
260 :
261 370919 : logic16();
262 370919 : IF( ( pos[k] & NB_POS_FCB_4T ) == 0 )
263 : {
264 186449 : ptr[i] = add( ptr[i], 512 );
265 186449 : move16();
266 : }
267 : ELSE
268 : {
269 184470 : ptr[i] = sub( ptr[i], 512 );
270 184470 : move16();
271 : }
272 : }
273 172762 : return;
274 : }
275 :
276 : /*-------------------------------------------------------*
277 : * dec_1p_N1()
278 : *
279 : * Decode 1 pulse with N+1 bits
280 : *-------------------------------------------------------*/
281 40351 : void dec_1p_N1_fx(
282 : const Word32 index, /* i: quantization index */
283 : const Word16 N, /* i: nb. of bits */
284 : const Word16 offset, /* i: pulse position offset */
285 : Word16 pos[] /* o: pulse position */
286 : )
287 : {
288 : Word16 pos1;
289 : Word32 mask, i;
290 :
291 40351 : mask = L_deposit_l( sub( shl( 1, N ), 1 ) ); /* mask = ((1<<N)-1); */
292 :
293 :
294 40351 : logic16();
295 40351 : pos1 = add( extract_l( index & mask ), offset );
296 :
297 : /* i = ((index >> N) & 1); */
298 40351 : i = L_shr( index, N ) & 1L;
299 :
300 40351 : IF( i != 0 )
301 : {
302 19882 : pos1 = add( pos1, NB_POS_FCB_4T );
303 : }
304 40351 : pos[0] = pos1;
305 40351 : move16();
306 40351 : }
307 : /*-------------------------------------------------------*
308 : * dec_2p_2N1()
309 : *
310 : * Decode 2 pulses with 2*N+1 bits:
311 : *-------------------------------------------------------*/
312 :
313 66665 : void dec_2p_2N1_fx(
314 : const Word32 index, /* i: quantization index */
315 : const Word16 N, /* i: nb. of bits */
316 : const Word16 offset, /* i: pulse position offset */
317 : Word16 pos[] /* o: pulse position */
318 : )
319 : {
320 :
321 : Word16 pos1, pos2, tmp;
322 : Word32 mask, i;
323 :
324 66665 : mask = L_deposit_l( sub( shl( 1, N ), 1 ) ); /* mask = ((1<<N)-1); */
325 :
326 : /* pos1 = (((index >> N) & mask) + offset); */
327 66665 : logic16();
328 66665 : pos1 = extract_l( L_add( ( L_shr( index, N ) & mask ), L_deposit_l( offset ) ) );
329 :
330 : /* i = (index >> (2*N)) & 1; */
331 66665 : tmp = shl( N, 1 );
332 66665 : i = L_and( L_shr( index, tmp ), 1L );
333 :
334 : /* pos2 = ((index & mask) + offset); */
335 66665 : pos2 = add( extract_l( index & mask ), offset );
336 66665 : logic16();
337 :
338 :
339 66665 : IF( LT_16( pos2, pos1 ) )
340 : {
341 32024 : IF( i != 0 )
342 : {
343 15531 : pos1 = add( pos1, NB_POS_FCB_4T );
344 : }
345 : ELSE
346 : {
347 16493 : pos2 = add( pos2, NB_POS_FCB_4T );
348 : }
349 : }
350 : ELSE
351 : {
352 34641 : IF( i != 0 )
353 : {
354 17242 : pos1 = add( pos1, NB_POS_FCB_4T );
355 17242 : pos2 = add( pos2, NB_POS_FCB_4T );
356 : }
357 : }
358 :
359 66665 : pos[0] = pos1;
360 66665 : move16();
361 66665 : pos[1] = pos2;
362 66665 : move16();
363 :
364 66665 : return;
365 : }
366 : /*-------------------------------------------------------*
367 : * Dec_3p_3N1
368 : *
369 : * Decode 3 pulses with 3*N+1 bits:
370 : *-------------------------------------------------------*/
371 0 : static void dec_3p_3N1_fx(
372 : const Word32 index, /* i : quantization index */
373 : const Word16 N, /* i : nb. of bits */
374 : const Word16 offset, /* i : pulse position offset */
375 : Word16 pos[] /* o : pulse position */
376 : )
377 : {
378 : Word16 j, tmp;
379 : Word32 mask, idx;
380 :
381 0 : tmp = sub( shl( N, 1 ), 1 ); /* mask = ((1<<((2*N)-1))-1); */
382 0 : mask = L_sub( L_shl( 1L, tmp ), 1L );
383 :
384 0 : idx = L_and( index, mask );
385 0 : j = offset;
386 0 : move16();
387 0 : tmp = sub( shl( N, 1 ), 1 );
388 :
389 0 : logic16();
390 0 : IF( ( L_shr( index, tmp ) & 1L ) != 0 )
391 : {
392 : /* IF (((index >> ((2*N)-1)) & 1) == 1){ */
393 0 : j = add( j, shl( 1, sub( N, 1 ) ) ); /* j += (1<<(N-1)); */
394 : }
395 0 : dec_2p_2N1_fx( idx, sub( N, 1 ), j, pos );
396 :
397 0 : mask = sub( shl( 1, add( N, 1 ) ), 1 ); /* mask = ((1<<(N+1))-1); */
398 0 : tmp = shl( N, 1 ); /* idx = (index >> (2*N)) & mask; */
399 0 : idx = L_shr( index, tmp ) & mask;
400 0 : logic16();
401 :
402 0 : dec_1p_N1_fx( idx, N, offset, pos + 2 );
403 0 : }
404 :
405 : /*-------------------------------------------------------*
406 : * Dec_4p_4N1
407 : *
408 : * Decode 4 pulses with 4*N+1 bits:
409 : *-------------------------------------------------------*/
410 0 : static void dec_4p_4N1_fx(
411 : const Word32 index, /* i : quantization index */
412 : const Word16 N, /* i : nb. of bits */
413 : const Word16 offset, /* i : pulse position offset */
414 : Word16 pos[] /* o : pulse position */
415 : )
416 : {
417 : Word16 j, tmp;
418 : Word32 mask, idx;
419 :
420 0 : tmp = sub( shl( N, 1 ), 1 ); /* mask = ((1<<((2*N)-1))-1); */
421 0 : mask = L_sub( L_shl( 1L, tmp ), 1L );
422 0 : idx = L_and( index, mask );
423 0 : j = offset;
424 0 : move16();
425 0 : tmp = sub( shl( N, 1 ), 1 );
426 :
427 0 : logic16();
428 0 : IF( ( L_shr( index, tmp ) & 1L ) != 0L )
429 : {
430 : /* (((index >> ((2*N)-1)) & 1) == 1) */
431 0 : j = add( j, shl( 1, sub( N, 1 ) ) ); /* j += (1<<(N-1)); */
432 : }
433 0 : dec_2p_2N1_fx( idx, sub( N, 1 ), j, pos );
434 :
435 :
436 0 : tmp = add( shl( N, 1 ), 1 ); /* mask = ((1<<((2*N)+1))-1); */
437 0 : mask = L_sub( L_shl( 1L, tmp ), 1L );
438 0 : idx = L_shr( index, shl( N, 1 ) ) & mask;
439 0 : logic16(); /* idx = (index >> (2*N)) & mask; */
440 0 : dec_2p_2N1_fx( idx, N, offset, pos + 2 ); /* Dec_2p_2N1(idx, N, offset, pos+2); */
441 0 : }
442 :
443 :
444 : /*-------------------------------------------------------*
445 : * Dec_4p_4N
446 : *
447 : * Decode 4 pulses with 4*N bits:
448 : *-------------------------------------------------------*/
449 0 : static void dec_4p_4N_fx(
450 : const Word32 index, /* i : quantization index */
451 : const Word16 N, /* i : nb. of bits */
452 : const Word16 offset, /* i : pulse position offset */
453 : Word16 pos[] /* o : pulse position */
454 : )
455 : {
456 : Word16 j, n_1, tmp;
457 :
458 0 : n_1 = sub( N, 1 );
459 0 : j = add( offset, shl( 1, n_1 ) ); /* j = offset + (1 << n_1) */
460 :
461 0 : tmp = sub( shl( N, 2 ), 2 );
462 0 : logic16();
463 0 : SWITCH( L_shr( index, tmp ) & 3 )
464 : {
465 : /* ((index >> ((4*N)-2)) & 3) */
466 0 : case 0:
467 0 : tmp = add( shl( n_1, 2 ), 1 );
468 :
469 0 : logic16();
470 0 : IF( ( L_shr( index, tmp ) & 1 ) == 0 )
471 : {
472 : /* (((index >> ((4*n_1)+1)) & 1) == 0) */
473 0 : dec_4p_4N1_fx( index, n_1, offset, pos );
474 : }
475 : ELSE
476 : {
477 0 : dec_4p_4N1_fx( index, n_1, j, pos );
478 : }
479 0 : BREAK;
480 0 : case 1:
481 0 : tmp = add( extract_l( L_shr( L_mult( 3, n_1 ), 1 ) ), 1 ); /* Dec_1p_N1((index>>((3*n_1)+1)), n_1, offset, pos) */
482 0 : dec_1p_N1_fx( L_shr( index, tmp ), n_1, offset, pos );
483 0 : dec_3p_3N1_fx( index, n_1, j, pos + 1 );
484 0 : move16();
485 0 : BREAK;
486 0 : case 2:
487 0 : tmp = add( shl( n_1, 1 ), 1 ); /* Dec_2p_2N1((index>>((2*n_1)+1)), n_1, offset, pos) */
488 0 : dec_2p_2N1_fx( L_shr( index, tmp ), n_1, offset, pos );
489 0 : dec_2p_2N1_fx( index, n_1, j, pos + 2 );
490 0 : move16();
491 0 : BREAK;
492 0 : case 3:
493 0 : tmp = add( n_1, 1 ); /* Dec_3p_3N1((index>>(n_1+1)), n_1, offset, pos) */
494 0 : dec_3p_3N1_fx( L_shr( index, tmp ), n_1, offset, pos );
495 0 : dec_1p_N1_fx( index, n_1, j, pos + 3 );
496 0 : move16();
497 0 : BREAK;
498 : }
499 0 : }
500 :
501 :
502 : /*-------------------------------------------------------*
503 : * Dec_5p_5N
504 : *
505 : * Decode 5 pulses with 5*N bits:
506 : *-------------------------------------------------------*/
507 0 : static void dec_5p_5N_fx(
508 : const Word32 index, /* i : quantization index */
509 : const Word16 N, /* i : nb. of bits */
510 : const Word16 offset, /* i : pulse position offset */
511 : Word16 pos[] /* o : pulse position */
512 : )
513 : {
514 : Word16 j, n_1, tmp;
515 : Word32 idx;
516 :
517 0 : n_1 = sub( N, 1 );
518 0 : j = add( offset, shl( 1, n_1 ) ); /* j = offset + (1 << n_1); */
519 0 : tmp = add( shl( N, 1 ), 1 ); /* idx = (index >> ((2*N)+1)); */
520 0 : idx = L_shr( index, tmp );
521 0 : tmp = sub( extract_l( L_shr( L_mult( 5, N ), 1 ) ), 1 ); /* ((5*N)-1)) */
522 :
523 0 : logic16();
524 0 : IF( ( L_shr( index, tmp ) & 1 ) == 0 ) /* ((index >> ((5*N)-1)) & 1) */
525 : {
526 0 : dec_3p_3N1_fx( idx, n_1, offset, pos );
527 0 : dec_2p_2N1_fx( index, N, offset, pos + 3 );
528 0 : move16();
529 : }
530 : ELSE
531 : {
532 0 : dec_3p_3N1_fx( idx, n_1, j, pos );
533 0 : dec_2p_2N1_fx( index, N, offset, pos + 3 );
534 0 : move16();
535 : }
536 0 : }
537 :
538 : /*-------------------------------------------------------*
539 : * Dec_6p_6N_2
540 : *
541 : * Decode 6 pulses with 6*N+2 bits:
542 : *-------------------------------------------------------*/
543 0 : static void dec_6p_6N2_fx(
544 : const Word32 index, /* i : quantization index */
545 : const Word16 N, /* i : nb. of bits */
546 : const Word16 offset, /* i : pulse position offset */
547 : Word16 pos[] /* o : pulse position */
548 : )
549 : {
550 : Word16 j, n_1, offsetA, offsetB, n_6;
551 :
552 0 : n_1 = sub( N, 1 );
553 0 : j = add( offset, shl( 1, n_1 ) ); /* j = offset + (1 << n_1); */
554 0 : n_6 = extract_l( L_mult0( N, 6 ) );
555 :
556 : /* !! N and n_1 are constants -> it doesn't need to be operated by Basic Operators */
557 :
558 0 : offsetA = offsetB = j;
559 0 : move16();
560 0 : move16();
561 0 : logic16();
562 0 : IF( L_and( L_shr( index, sub( n_6, 5 ) ), 1L ) == 0 )
563 : {
564 : /* IF (((index >> ((6*N)-5)) & 1) == 0) */
565 0 : offsetA = offset;
566 0 : move16();
567 : }
568 : ELSE
569 : {
570 0 : offsetB = offset;
571 0 : move16();
572 : }
573 :
574 :
575 0 : logic16();
576 0 : SWITCH( L_shr( index, sub( n_6, 4 ) ) & 3 )
577 : {
578 : /* (index >> ((6*N)-4)) & 3 */
579 0 : case 0:
580 0 : dec_5p_5N_fx( L_shr( index, N ), n_1, offsetA, pos ); /* Dec_5p_5N(index>>N, n_1, offsetA, pos); */
581 0 : dec_1p_N1_fx( index, n_1, offsetA, pos + 5 );
582 0 : BREAK;
583 0 : case 1:
584 0 : dec_5p_5N_fx( L_shr( index, N ), n_1, offsetA, pos ); /* Dec_5p_5N(index>>N, n_1, offsetA, pos); */
585 0 : dec_1p_N1_fx( index, n_1, offsetB, pos + 5 );
586 0 : BREAK;
587 0 : case 2:
588 0 : dec_4p_4N_fx( L_shr( index, add( shl( n_1, 1 ), 1 ) ), n_1, offsetA, pos ); /* Dec_4p_4N(index>>((2*n_1)+1 ), n_1, offsetA, pos); */
589 0 : dec_2p_2N1_fx( index, n_1, offsetB, pos + 4 );
590 0 : BREAK;
591 0 : case 3:
592 0 : dec_3p_3N1_fx( L_shr( index, add( add( shl( n_1, 1 ), n_1 ), 1 ) ), n_1, offset, pos ); /* Dec_3p_3N1(index>>((3*n_1)+ 1), n_1, offset, pos); */
593 0 : dec_3p_3N1_fx( index, n_1, j, pos + 3 );
594 0 : BREAK;
595 : }
596 0 : }
597 :
598 65746 : static Word32 fcb_decode_class_all_p_fx( /* o: The index of pulse positions */
599 : Word32 *code_index, /* i: fcb index information */
600 : Word16 sector_6p_num[], /* o: Number of pulses for each position */
601 : Word16 pulse_num, /* i: Number of pulses on a track. */
602 : Word16 *pos_num /* o: Number of positions which have pulses on the track.*/
603 : )
604 : {
605 : Word16 i;
606 : Word32 mn9, j, k;
607 : Word16 pulse_pos_num;
608 : Word32 L_tmp, L_tmp1;
609 138751 : FOR( i = 1; i <= pulse_num; i++ ){
610 138437 : IF( LT_32( ( *code_index ), PI_offset[pulse_num][i] ) ){
611 65432 : BREAK;
612 : }
613 : }
614 :
615 : /* (*code_index) -= PI_offset[pulse_num][i-1];*/
616 65746 : ( *code_index ) = L_sub( ( *code_index ), PI_offset[pulse_num][i - 1] );
617 65746 : move32();
618 :
619 : /*pulse_pos_num = pulse_num - i + 2;*/
620 65746 : pulse_pos_num = add( sub( pulse_num, i ), 2 );
621 :
622 : /* j = (*code_index)>>pulse_pos_num;*/
623 65746 : j = L_shr( ( *code_index ), pulse_pos_num );
624 65746 : IF( LT_32( j, PI_select_table[16][pulse_pos_num] ) )
625 : {
626 62335 : k = L_deposit_l( 0 );
627 62335 : mn9 = L_add( j, 0 );
628 : }
629 : ELSE
630 : {
631 3411 : L_tmp = L_deposit_l( 0 );
632 3411 : L_tmp1 = L_add( j, 0 );
633 6822 : WHILE( GE_32( L_tmp1, PI_select_table[16][pulse_pos_num] ) )
634 : {
635 3411 : L_tmp = L_add( L_tmp, 1 );
636 3411 : L_tmp1 = L_sub( L_tmp1, PI_select_table[16][pulse_pos_num] );
637 : }
638 3411 : k = L_add( L_tmp, 0 );
639 3411 : mn9 = L_add( L_tmp1, 0 );
640 : }
641 : /* mn9 = Mult_32_32(sub(j , k) , PI_select_table[16][pulse_pos_num]);*/
642 :
643 65746 : test();
644 65746 : IF( ( LT_16( pulse_pos_num, pulse_num ) ) && ( GT_16( pulse_pos_num, 1 ) ) )
645 : {
646 19893 : FOR( i = 0; i < pulse_pos_num; i++ )
647 : {
648 13262 : sector_6p_num[i] = 1;
649 13262 : move16();
650 : }
651 6631 : sector_6p_num[k] = add( sector_6p_num[k], 1 );
652 6631 : move16();
653 : }
654 : ELSE{
655 :
656 59115 : IF( EQ_16( pulse_pos_num, 1 ) ){
657 314 : sector_6p_num[0] = pulse_num;
658 314 : move16();
659 : }
660 : ELSE
661 : {
662 235204 : FOR( i = 0; i < pulse_num; i++ )
663 : {
664 176403 : sector_6p_num[i] = 1;
665 176403 : move16();
666 : }
667 : }
668 : }
669 :
670 65746 : *pos_num = pulse_pos_num;
671 65746 : move16();
672 :
673 65746 : return mn9;
674 : }
675 :
676 65746 : static void fcb_decode_position_fx(
677 : Word32 index, /* i: position index information */
678 : Word16 pos_vector[], /* o: the positon vector */
679 : Word16 pos_num /* i: number of positions */
680 : )
681 : {
682 : Word32 i, k, l;
683 : Word16 temp;
684 :
685 65746 : k = L_add( index, 0 );
686 65746 : l = L_deposit_l( 0 );
687 65746 : temp = pos_num;
688 65746 : move16();
689 189979 : FOR( i = 0; i < pos_num - 1; i++ )
690 : {
691 : /* k = PI_select_table[16-l][temp] - k ;*/
692 124233 : k = L_sub( PI_select_table[( 16 - l )][temp], k );
693 :
694 428738 : FOR( ; PI_select_table[( 16 - l )][temp] >= k; l += 2 );
695 :
696 124233 : IF( GT_32( k, PI_select_table[( 17 - l )][temp] ) )
697 : {
698 68975 : l = L_sub( l, 1 );
699 : }
700 :
701 : /* k = PI_select_table[17-l][temp--] - k ;*/
702 124233 : k = L_sub( PI_select_table[( 17 - l )][temp], k );
703 124233 : temp = sub( temp, 1 );
704 124233 : pos_vector[i] = extract_l( L_sub( l, 1 ) );
705 124233 : move16();
706 : }
707 65746 : pos_vector[i] = extract_l( L_add( l, k ) );
708 65746 : move16();
709 :
710 65746 : return;
711 : }
712 :
713 65746 : static void fcb_decode_PI_fx( /* o: return pulse position number */
714 : Word32 code_index, /* i: fcb index information */
715 : Word16 sector_6p[], /* o: decoded pulse position */
716 : Word16 pulse_num /* i: pulse number for the track */
717 : )
718 : {
719 : Word16 i, l, j;
720 : Word32 mn9;
721 : Word16 pulse_pos_num;
722 : Word16 sector_6p_temp[7], sector_6p_num_temp[7];
723 : Word16 *sector_6p_ptr0;
724 : Word16 *sector_6p_ptr1;
725 :
726 : /*get the position number and the pulse number on every position */
727 65746 : mn9 = fcb_decode_class_all_p_fx( &code_index, sector_6p_num_temp, pulse_num, &pulse_pos_num );
728 :
729 : /* rebuild the vector*/
730 : /* decode the pulse position not same to the others*/
731 65746 : fcb_decode_position_fx( mn9, sector_6p_temp, pulse_pos_num );
732 255725 : FOR( i = pulse_pos_num - 1; i >= 0; i-- )
733 : {
734 : /*sector_6p_temp[i] += ((code_index&0x1)<<4) ;*/
735 189979 : sector_6p_temp[i] = add( sector_6p_temp[i], extract_l( L_shl( ( code_index & 0x1 ), 4 ) ) );
736 189979 : move16();
737 : /*code_index = code_index>>1;*/
738 189979 : code_index = L_shr( code_index, 1 );
739 : }
740 :
741 : /* decode the pulse position maybe some pulse position same to other pulse */
742 65746 : sector_6p_ptr0 = §or_6p[pulse_num];
743 65746 : sector_6p_ptr1 = §or_6p_temp[pulse_pos_num];
744 255725 : FOR( i = 0; i < pulse_pos_num; i++ )
745 : {
746 189979 : sector_6p_ptr1--;
747 189979 : j = sub( pulse_pos_num, add( 1, i ) );
748 387217 : FOR( l = 0; l < sector_6p_num_temp[j]; l++ )
749 : {
750 197238 : *--sector_6p_ptr0 = *sector_6p_ptr1;
751 197238 : move16();
752 : }
753 : }
754 :
755 65746 : return;
756 : }
757 :
758 :
759 : /*---------------------------------------------------------------------*
760 : * Read FCB index *
761 : *---------------------------------------------------------------------*/
762 :
763 32873 : void D_ACELP_decode_43bit_fx( UWord16 idxs[], Word16 code[], Word16 *pulsestrack )
764 : {
765 : Word32 ps[8];
766 : Word16 pos[7];
767 : Word32 joint_index;
768 32873 : Word32 joint_offset = 3611648; /*offset for 3 pulses per track*/
769 :
770 32873 : set16_fx( code, 0, L_SUBFR );
771 :
772 32873 : ps[3] = L_and( idxs[0], 0x1ff );
773 32873 : move32();
774 32873 : ps[2] = L_add( L_shl( L_and( idxs[1], 3 ), 7 ), L_shr( idxs[0], 9 ) );
775 32873 : move32();
776 32873 : joint_index = L_shr( L_add( L_shl( (Word32) idxs[2], 16 ), (Word32) idxs[1] ), 2 );
777 :
778 32873 : IF( GE_32( joint_index, joint_offset ) )
779 : {
780 27443 : joint_index = L_sub( joint_index, joint_offset );
781 : }
782 :
783 32873 : iDiv_and_mod_32( joint_index, 5472, &ps[0], &ps[1], 0 );
784 32873 : fcb_decode_PI_fx( ps[0], pos, 3 );
785 32873 : add_pulses_fx( pos, pulsestrack[0], 0, code );
786 32873 : fcb_decode_PI_fx( ps[1], pos, 3 );
787 32873 : add_pulses_fx( pos, pulsestrack[1], 1, code );
788 :
789 32873 : dec_2p_2N1_fx( ps[2], 4, 0, pos );
790 32873 : add_pulses_fx( pos, pulsestrack[2], 2, code );
791 32873 : dec_2p_2N1_fx( ps[3], 4, 0, pos );
792 32873 : add_pulses_fx( pos, pulsestrack[3], 3, code );
793 :
794 32873 : return;
795 : }
796 :
797 :
798 : /*-------------------------------------------------------*
799 : * dec_1p_N1()
800 : *
801 : * Decode 1 pulse with N+1 bits
802 : *-------------------------------------------------------*/
803 :
804 0 : static void dec_1p_N1_L_subfr_fx(
805 : const Word32 index, /* i : quantization index */
806 : const Word16 nb_pos, /* i : number of positions */
807 : const Word16 N, /* i : nb. of bits */
808 : Word16 pos[] /* o : pulse position */
809 : )
810 : {
811 : Word16 pos1;
812 : Word32 mask, i;
813 :
814 0 : mask = L_deposit_l( sub( shl( 1, N ), 1 ) );
815 0 : pos1 = extract_l( index & mask );
816 0 : i = L_shr( index, N ) & 1L;
817 :
818 0 : IF( EQ_32( i, 1 ) )
819 : {
820 0 : pos1 = add( pos1, nb_pos );
821 : }
822 :
823 0 : pos[0] = pos1;
824 0 : move16();
825 :
826 0 : return;
827 : }
828 :
829 0 : static void add_pulses_L_subfr_fx(
830 : const Word16 nb_pos, /* i : number of positions */
831 : const Word16 pos[], /* i : pulse position */
832 : const Word16 nb_pulse, /* i : nb. of pulses */
833 : const Word16 track, /* i : no. of the tracks */
834 : Word16 code[] /* i/o: decoded codevector Q12 */
835 : )
836 : {
837 : Word16 i, k;
838 : Word16 *ptr;
839 0 : ptr = code + track;
840 :
841 0 : FOR( k = 0; k < nb_pulse; k++ )
842 : {
843 0 : i = shl( s_and( pos[k], sub( nb_pos, 1 ) ), 2 );
844 0 : IF( EQ_16( sub( pos[k], nb_pos ), 0 ) )
845 : {
846 0 : ptr[i] = add( ptr[i], 512 );
847 0 : move16();
848 : }
849 : ELSE
850 : {
851 0 : ptr[i] = sub( ptr[i], 512 );
852 0 : move16();
853 : }
854 : }
855 :
856 0 : return;
857 : }
858 :
859 25745 : void dec_acelp_fast_fx(
860 : Decoder_State *st, /* i/o: decoder state structure */
861 : const Word16 cdk_index, /* i : codebook index */
862 : Word16 code[], /* o : algebraic (fixed) codebook excitation Q9*/
863 : const Word16 L_subfr /* i : subframe length */
864 : )
865 : {
866 : Word16 k, pos[7], skip_track;
867 : Word32 L_index;
868 : PulseConfig config;
869 :
870 25745 : skip_track = -1;
871 25745 : move16();
872 25745 : set16_fx( code, 0, L_subfr );
873 :
874 25745 : st->total_num_bits = extract_l( st->total_brate / FRAMES_PER_SEC );
875 :
876 25745 : IF( EQ_16( L_subfr, L_SUBFR ) )
877 : {
878 22101 : config = PulseConfTable[cdk_index];
879 :
880 22101 : IF( EQ_16( cdk_index, 2 ) )
881 : {
882 8331 : dec_acelp_2t32_fx( st, code ); // needs to be imported
883 : }
884 13770 : ELSE IF( EQ_16( config.nb_pulse, 2 ) )
885 : {
886 : /* 10 bits, 2 pulses, 4 tracks 1010 (used only even tracks) */
887 4143 : FOR( k = 0; k < NB_TRACK_FCB_4T - 1; k += 2 )
888 : {
889 2762 : L_index = get_next_indice_fx( st, 5 ); // already fixed
890 2762 : dec_1p_N1_fx( L_index, 4, 0, pos ); // already fixed
891 2762 : add_pulses_fx( pos, 1, k, code ); // needs to be imported
892 : }
893 : }
894 12389 : ELSE IF( EQ_16( config.nb_pulse, 3 ) )
895 : {
896 11048 : IF( EQ_16( (Word16) config.codetrackpos, (Word16) TRACKPOS_FIXED_FIRST ) )
897 : {
898 : /* 15 bits, 3 pulses, 4 tracks 1110 fixed track to first ? */
899 41500 : FOR( k = 0; k < NB_TRACK_FCB_4T - 1; k++ )
900 : {
901 31125 : L_index = get_next_indice_fx( st, 5 );
902 31125 : dec_1p_N1_fx( L_index, 4, 0, pos );
903 31125 : add_pulses_fx( pos, 1, k, code );
904 : }
905 : }
906 673 : ELSE IF( EQ_16( (Word16) config.codetrackpos, (Word16) TRACKPOS_FREE_THREE ) )
907 : {
908 : /* 17 bits, 3 pulses, 4 tracks (used all tracks) - 1110, 1101, 1011, 0111 */
909 673 : skip_track = get_next_indice_fx( st, 2 );
910 3365 : FOR( k = 0; k < NB_TRACK_FCB_4T; k++ )
911 : {
912 2692 : IF( NE_16( k, skip_track ) )
913 : {
914 2019 : L_index = get_next_indice_fx( st, 5 );
915 2019 : dec_1p_N1_fx( L_index, 4, 0, pos );
916 2019 : add_pulses_fx( pos, 1, k, code );
917 : }
918 : }
919 : }
920 : }
921 : ELSE
922 : {
923 1341 : IF( EQ_16( config.bits, 20 ) )
924 : {
925 422 : skip_track = -1;
926 422 : move16();
927 : }
928 919 : ELSE IF( EQ_16( (Word16) config.codetrackpos, (Word16) TRACKPOS_FIXED_FIRST ) )
929 : {
930 538 : skip_track = 0;
931 538 : move16();
932 : }
933 381 : ELSE IF( EQ_16( (Word16) config.codetrackpos, (Word16) TRACKPOS_FREE_ONE ) )
934 : {
935 381 : skip_track = get_next_indice_fx( st, 2 );
936 : }
937 :
938 6705 : FOR( k = 0; k < NB_TRACK_FCB_4T; k++ )
939 : {
940 5364 : IF( EQ_16( k, skip_track ) )
941 : {
942 919 : L_index = get_next_indice_fx( st, 9 );
943 919 : dec_2p_2N1_fx( L_index, 4, 0, pos );
944 919 : add_pulses_fx( pos, 2, k, code );
945 : }
946 : ELSE
947 : {
948 4445 : L_index = get_next_indice_fx( st, 5 );
949 4445 : dec_1p_N1_fx( L_index, 4, 0, pos );
950 4445 : add_pulses_fx( pos, 1, k, code );
951 : }
952 : }
953 : }
954 : }
955 : ELSE /* L_subfr == 2*L_SUBFR */
956 : {
957 3644 : config.bits = cdk_index;
958 3644 : move16();
959 :
960 3644 : IF( EQ_16( cdk_index, 14 ) )
961 : {
962 : /* 14 bits, 2 pulses, 2 tracks: 11 (used all tracks) */
963 : Word16 index, i0, i1;
964 :
965 3644 : index = get_next_indice_fx( st, 14 );
966 :
967 :
968 3644 : i0 = shl( s_and( shr( index, 7 ), ( NB_POS_FCB_2T_128 - 1 ) ), 1 );
969 3644 : i1 = add( shl( s_and( index, ( NB_POS_FCB_2T_128 - 1 ) ), 1 ), 1 );
970 :
971 3644 : code[i0] = -512; //-1 in Q9
972 3644 : move16();
973 3644 : IF( EQ_16( s_and( index, 0x2000 ), 0 ) )
974 : {
975 1877 : code[i0] = 512; // 1 in Q9
976 1877 : move16();
977 : }
978 :
979 3644 : code[i1] = -512; //-1 in Q9
980 3644 : move16();
981 3644 : IF( EQ_16( s_and( index, 0x40 ), 0 ) )
982 : {
983 1900 : code[i1] = 512; // 1 in Q9
984 1900 : move16();
985 : }
986 : }
987 0 : ELSE IF( EQ_16( cdk_index, 12 ) )
988 : {
989 : /* 12 bits, 2 pulses, 4 tracks: 1010 (used only even tracks) */
990 0 : FOR( k = 0; k < NB_TRACK_FCB_4T - 1; k += 2 )
991 : {
992 0 : L_index = get_next_indice_fx( st, 6 );
993 0 : dec_1p_N1_L_subfr_fx( L_index, NB_POS_FCB_4T_128, 5, pos );
994 0 : add_pulses_L_subfr_fx( NB_POS_FCB_4T_128, pos, 1, k, code );
995 : }
996 : }
997 0 : ELSE IF( EQ_16( cdk_index, 18 ) )
998 : {
999 : /* 18 bits, 3 pulses, 4 tracks: 1110 (used first three tracks) */
1000 0 : FOR( k = 0; k < NB_TRACK_FCB_4T - 1; k++ )
1001 : {
1002 0 : L_index = get_next_indice_fx( st, 6 );
1003 0 : dec_1p_N1_L_subfr_fx( L_index, NB_POS_FCB_4T_128, 5, pos );
1004 0 : add_pulses_L_subfr_fx( NB_POS_FCB_4T_128, pos, 1, k, code );
1005 : }
1006 : }
1007 0 : ELSE IF( EQ_16( cdk_index, 20 ) )
1008 : {
1009 : /* 20 bits, 3 pulses, 4 tracks (used all tracks): 1110, 1101, 1011, 0111 */
1010 0 : skip_track = get_next_indice_fx( st, 2 );
1011 0 : FOR( k = 0; k < NB_TRACK_FCB_4T; k++ )
1012 : {
1013 0 : IF( NE_16( k, skip_track ) )
1014 : {
1015 0 : L_index = get_next_indice_fx( st, 6 );
1016 0 : dec_1p_N1_L_subfr_fx( L_index, NB_POS_FCB_4T_128, 5, pos );
1017 0 : add_pulses_L_subfr_fx( NB_POS_FCB_4T_128, pos, 1, k, code );
1018 : }
1019 : }
1020 : }
1021 0 : ELSE IF( EQ_16( cdk_index, 24 ) )
1022 : {
1023 : /* 24 bits, 4 pulses, 4 tracks: 1111 */
1024 0 : FOR( k = 0; k < NB_TRACK_FCB_4T; k++ )
1025 : {
1026 0 : L_index = get_next_indice_fx( st, 6 );
1027 0 : dec_1p_N1_L_subfr_fx( L_index, NB_POS_FCB_4T_128, 5, pos );
1028 0 : add_pulses_L_subfr_fx( NB_POS_FCB_4T_128, pos, 1, k, code );
1029 : }
1030 : }
1031 : }
1032 :
1033 25745 : return;
1034 : }
|
