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" /* VMR-WB compilation switches */
6 : #include "cnst.h" /* Common constants */
7 : #include "rom_enc.h" /* Encoder static table prototypes */
8 : #include "prot_fx.h" /* Function prototypes */
9 : #include "rom_com_fx.h" /* Static table prototypes */
10 : #include "rom_com.h" /* Static table prototypes */
11 : #include "prot_fx_enc.h" /* Function prototypes */
12 :
13 :
14 : /*-------------------------------------------------------------------*
15 : * Local constants
16 : *-------------------------------------------------------------------*/
17 :
18 : #define STEP 4
19 : #define MSIZE 256
20 : #define NB_MAX 8
21 :
22 : /*-------------------------------------------------------------------*
23 : * Local function prototypes
24 : *-------------------------------------------------------------------*/
25 : static Word16 quant_1p_N1_fx( const Word16 pos, const Word16 N );
26 : static Word16 quant_3p_3N1_fx( const Word16 pos1, const Word16 pos2, const Word16 pos3, const Word16 N );
27 : static Word32 quant_4p_4N_fx( const Word16 pos[], const Word16 N );
28 : static Word32 quant_5p_5N_fx( const Word16 pos[], const Word16 N );
29 : static Word32 quant_6p_6N_2_fx( const Word16 pos[], const Word16 N );
30 :
31 :
32 : static Word32 fcb_encode_position_fx( const Word16 pos_vector[], Word32 n, const Word32 pos_num, const Word32 flag );
33 : static Word32 fcb_encode_class_fx( const Word32 sector_6p_num[], const Word32 pulse_num, const Word32 pulse_pos_num );
34 : static Word32 fcb_encode_PI_fx( const Word16 v[], const Word32 pulse_num );
35 : static Word32 pre_process_fx( const Word16 v[], Word16 sector_6p[], Word32 sector_6p_num[], Word32 *pulse_pos_num );
36 :
37 : /*---------------------------------------------------------------------*
38 : * ACELP_4t64()
39 : *
40 : * 20, 36, 44, 52, 64, 72, 88 bits algebraic codebook.
41 : * 4 tracks x 16 positions per track = 64 samples.
42 : *
43 : * 20 bits --> 4 pulses in a frame of 64 samples.
44 : * 36 bits --> 8 pulses in a frame of 64 samples.
45 : * 44 bits 13 + 9 + 13 + 9 --> 10 pulses in a frame of 64 samples.
46 : * 52 bits 13 + 13 + 13 + 13 --> 12 pulses in a frame of 64 samples.
47 : * 64 bits 2 + 2 + 2 + 2 + 14 + 14 + 14 + 14 -->
48 : * 16 pulses in a frame of 64 samples.
49 : * 72 bits 10 + 2 + 10 + 2 + 10 + 14 + 10 + 14 -->
50 : * 18 pulses in a frame of 64 samples.
51 : * 88 bits 11 + 11 + 11 + 11 + 11 + 11 + 11 + 11 -->
52 : * 24 pulses in a frame of 64 samples.
53 : * All pulses can have two (2) possible amplitudes: +1 or -1.
54 : * Each pulse can have sixteen (16) possible positions.
55 : *---------------------------------------------------------------------*/
56 :
57 6376 : Word16 acelp_4t64_fx(
58 : BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */
59 : Word16 dn[], /* i : corr. between target and h[]. */
60 : const Word16 cn[], /* i : residual after long term prediction Q_new*/
61 : const Word16 H[], /* i : impulse response of weighted synthesis filter Q12*/
62 : Word16 R[], /* i : autocorrelation values */
63 : const Word16 acelpautoc, /* i : autocorrealtion flag */
64 : Word16 code[], /* o : algebraic (fixed) codebook excitation Q9*/
65 : Word16 y[], /* o : filtered fixed codebook excitation Q9*/
66 : Word16 nbbits, /* i : number of bits per codebook */
67 : const Word16 cmpl_flag, /* i : complexity reduction flag */
68 : const Word16 Opt_AMR_WB /* i : flag indicating AMR-WB IO mode */
69 : )
70 : {
71 :
72 : Word16 i, k, index, track;
73 : Word32 L_index;
74 : Word16 ind[NPMAXPT * NB_TRACK_FCB_4T + 32]; /* VE3: why +32 ???*/
75 6376 : Word16 codvec[NB_PULSE_MAX + 4] = { 0 };
76 6376 : Word16 saved_bits = 0;
77 :
78 : PulseConfig config;
79 : Word16 indexing_indices[6], wordcnt, bitcnt;
80 :
81 6376 : set16_fx( codvec, 0, NB_PULSE_MAX + 4 );
82 6376 : SWITCH( nbbits )
83 : {
84 :
85 0 : case 20: /* EVS/AMR-WB pulse indexing: 20 bits, 4 pulses, 4 tracks */
86 0 : config.nbiter = 4;
87 0 : move16(); /* 4x12x16=768 loop */
88 0 : config.alp = 16384;
89 0 : move16(); /* 2 in Q13*/
90 0 : config.nb_pulse = 4;
91 0 : move16();
92 0 : config.fixedpulses = 0;
93 0 : move16();
94 0 : config.nbpos[0] = 4;
95 0 : move16();
96 0 : config.nbpos[1] = 8;
97 0 : move16();
98 0 : BREAK;
99 :
100 2035 : case 28: /* EVS pulse indexing: 28 bits, 6 pulses, 4 tracks */
101 2035 : config.nbiter = 4;
102 2035 : move16(); /* 4x20x16=1280 loops */
103 2035 : config.alp = 8192; /*1 in Q13*/
104 2035 : move16(); /* coeff FOR sign setting */
105 2035 : config.nb_pulse = 6;
106 2035 : move16();
107 2035 : config.fixedpulses = 0;
108 2035 : move16();
109 2035 : config.nbpos[0] = 6;
110 2035 : move16();
111 2035 : config.nbpos[1] = 6;
112 2035 : move16();
113 2035 : config.nbpos[2] = 8;
114 2035 : move16();
115 2035 : BREAK;
116 :
117 4322 : case 36: /* EVS/AMR-WB pulse indexing: 36 bits, 8 pulses, 4 tracks */
118 4322 : config.nbiter = 4;
119 4322 : move16(); /* 4x20x16=1280 loops */
120 4322 : config.alp = 8192; /*1 in Q13*/
121 4322 : move16(); /* coeff FOR sign setting */
122 4322 : config.nb_pulse = 8;
123 4322 : move16();
124 4322 : config.fixedpulses = 2;
125 4322 : move16();
126 4322 : config.nbpos[0] = 4;
127 4322 : move16();
128 4322 : config.nbpos[1] = 8;
129 4322 : move16();
130 4322 : config.nbpos[2] = 8;
131 4322 : move16();
132 4322 : BREAK;
133 :
134 0 : case 43: /* EVS pulse indexing: 43 bits, 10 pulses, 4 tracks */
135 : case 44: /* AMR-WB pulse indexing: 44 bits, 10 pulses, 4 tracks */
136 0 : config.nbiter = 4;
137 0 : move16(); /* 4x26x16=1664 loops */
138 0 : config.alp = 8192; /*1 in Q13*/
139 0 : move16();
140 0 : config.nb_pulse = 10;
141 0 : move16();
142 0 : config.fixedpulses = 2;
143 0 : move16();
144 0 : config.nbpos[0] = 4;
145 0 : move16();
146 0 : config.nbpos[1] = 6;
147 0 : move16();
148 0 : config.nbpos[2] = 8;
149 0 : move16();
150 0 : config.nbpos[3] = 8;
151 0 : move16();
152 0 : BREAK;
153 :
154 0 : case 50: /* EVS pulse indexing: 50 bits, 12 pulses, 4 tracks */
155 : case 52: /* AMR-WB pulse indexing: 52 bits, 12 pulses, 4 tracks */
156 0 : config.nbiter = 4;
157 0 : move16(); /* 4x26x16=1664 loops */
158 0 : config.alp = 8192; /*1 in Q13*/
159 0 : move16();
160 0 : config.nb_pulse = 12;
161 0 : move16();
162 0 : config.fixedpulses = 4;
163 0 : move16();
164 0 : config.nbpos[0] = 4;
165 0 : move16();
166 0 : config.nbpos[1] = 6;
167 0 : move16();
168 0 : config.nbpos[2] = 8;
169 0 : move16();
170 0 : config.nbpos[3] = 8;
171 0 : move16();
172 0 : BREAK;
173 :
174 19 : case 62: /* EVS pulse indexing: 62 bits, 16 pulses, 4 tracks */
175 : case 64: /* AMR-WB pulse indexing: 64 bits, 16 pulses, 4 tracks */
176 19 : config.nbiter = 3;
177 19 : move16(); /* 3x36x16=1728 loops */
178 19 : config.alp = 6554; /*.8f in Q13*/
179 19 : move16();
180 19 : config.nb_pulse = 16;
181 19 : move16();
182 19 : config.fixedpulses = 4;
183 19 : move16();
184 19 : config.nbpos[0] = 4;
185 19 : move16();
186 19 : config.nbpos[1] = 4;
187 19 : move16();
188 19 : config.nbpos[2] = 6;
189 19 : move16();
190 19 : config.nbpos[3] = 6;
191 19 : move16();
192 19 : config.nbpos[4] = 8;
193 19 : move16();
194 19 : config.nbpos[5] = 8;
195 19 : move16();
196 19 : BREAK;
197 :
198 0 : case 72: /* AMR-WB pulse indexing: 72 bits, 18 pulses, 4 tracks */
199 0 : config.nbiter = 3;
200 0 : move16(); /* 3x35x16=1680 loops */
201 0 : config.alp = 6144; /*.75f in Q13*/
202 0 : move16();
203 0 : config.nb_pulse = 18;
204 0 : move16();
205 0 : config.fixedpulses = 4;
206 0 : move16();
207 0 : config.nbpos[0] = 2;
208 0 : move16();
209 0 : config.nbpos[1] = 3;
210 0 : move16();
211 0 : config.nbpos[2] = 4;
212 0 : move16();
213 0 : config.nbpos[3] = 5;
214 0 : move16();
215 0 : config.nbpos[4] = 6;
216 0 : move16();
217 0 : config.nbpos[5] = 7;
218 0 : move16();
219 0 : config.nbpos[6] = 8;
220 0 : move16();
221 0 : BREAK;
222 :
223 0 : case 88: /* AMR-WB pulse indexing: 88 bits, 24 pulses, 4 tracks */
224 0 : config.nbiter = 2;
225 0 : move16(); /* 2x53x16=1696 loop */
226 0 : config.alp = 4096; /*.5f in Q13*/
227 0 : move16();
228 0 : config.nb_pulse = 24;
229 0 : move16();
230 0 : config.fixedpulses = 4;
231 0 : move16();
232 0 : config.nbpos[0] = 2;
233 0 : move16();
234 0 : config.nbpos[1] = 2;
235 0 : move16();
236 0 : config.nbpos[2] = 3;
237 0 : move16();
238 0 : config.nbpos[3] = 4;
239 0 : move16();
240 0 : config.nbpos[4] = 5;
241 0 : move16();
242 0 : config.nbpos[5] = 6;
243 0 : move16();
244 0 : config.nbpos[6] = 7;
245 0 : move16();
246 0 : config.nbpos[7] = 8;
247 0 : move16();
248 0 : config.nbpos[8] = 8;
249 0 : move16();
250 0 : config.nbpos[9] = 8;
251 0 : move16();
252 0 : BREAK;
253 :
254 0 : case 87: /* EVS pulse indexing: 87 bits, 26 pulses, 4 tracks */
255 0 : config.nbiter = 1;
256 0 : move16();
257 0 : config.alp = 4096; /*.5f in Q13*/
258 0 : move16();
259 0 : config.nb_pulse = 26;
260 0 : move16();
261 0 : config.fixedpulses = 4;
262 0 : move16();
263 0 : config.nbpos[0] = 4;
264 0 : move16();
265 0 : config.nbpos[1] = 6;
266 0 : move16();
267 0 : config.nbpos[2] = 6;
268 0 : move16();
269 0 : config.nbpos[3] = 8;
270 0 : move16();
271 0 : config.nbpos[4] = 8;
272 0 : move16();
273 0 : config.nbpos[5] = 8;
274 0 : move16();
275 0 : config.nbpos[6] = 8;
276 0 : move16();
277 0 : config.nbpos[7] = 8;
278 0 : move16();
279 0 : config.nbpos[8] = 8;
280 0 : move16();
281 0 : config.nbpos[9] = 8;
282 0 : move16();
283 0 : config.nbpos[10] = 8;
284 0 : move16();
285 0 : BREAK;
286 : }
287 :
288 : /* reduce the number of iterations as a compromise between the performance and complexity */
289 6376 : if ( cmpl_flag > 0 )
290 : {
291 3531 : config.nbiter = cmpl_flag;
292 3531 : move16();
293 : }
294 :
295 6376 : config.codetrackpos = TRACKPOS_FIXED_FIRST;
296 6376 : move16();
297 6376 : config.bits = nbbits;
298 6376 : move16();
299 :
300 6376 : IF( acelpautoc )
301 : {
302 3389 : E_ACELP_4tsearchx_fx( dn, cn, R, code, &config, ind );
303 :
304 : /* Generate weighted code */
305 3389 : E_ACELP_weighted_code( code, H, 12, y );
306 : }
307 : ELSE
308 : {
309 2987 : E_ACELP_4tsearch_fx( dn, cn, H, code, &config, ind, y );
310 :
311 194155 : FOR( i = 0; i < L_SUBFR; i++ )
312 : {
313 191168 : y[i] = shr( y[i], 3 );
314 191168 : move16(); /*Q9 */
315 : }
316 : }
317 :
318 : /*-----------------------------------------------------------------*
319 : * Indexing
320 : *-----------------------------------------------------------------*/
321 :
322 6376 : IF( !Opt_AMR_WB )
323 : {
324 6376 : saved_bits = E_ACELP_indexing_fx( code, &config, NB_TRACK_FCB_4T, indexing_indices );
325 :
326 6376 : saved_bits = 0;
327 6376 : move16();
328 :
329 6376 : wordcnt = shr( nbbits, 4 );
330 6376 : bitcnt = s_and( nbbits, 15 );
331 17112 : FOR( i = 0; i < wordcnt; i++ )
332 : {
333 10736 : push_indice( hBstr, IND_ALG_CDBK_4T64, indexing_indices[i], 16 );
334 : }
335 6376 : IF( bitcnt )
336 : {
337 6376 : push_indice( hBstr, IND_ALG_CDBK_4T64, indexing_indices[i], bitcnt );
338 : }
339 : }
340 : ELSE
341 : {
342 : /* AMR-WB pulse indexing */
343 :
344 0 : IF( EQ_16( nbbits, 20 ) )
345 : {
346 0 : FOR( track = 0; track < NB_TRACK_FCB_4T; track++ )
347 : {
348 0 : k = i_mult2( track, NPMAXPT );
349 0 : index = quant_1p_N1_fx( ind[k], 4 );
350 0 : push_indice( hBstr, IND_ALG_CDBK_4T64, index, 5 );
351 : }
352 : }
353 0 : ELSE IF( EQ_16( nbbits, 36 ) )
354 : {
355 0 : FOR( track = 0; track < NB_TRACK_FCB_4T; track++ )
356 : {
357 :
358 0 : k = i_mult2( track, NPMAXPT ); /* k = track * NPMAXPT;*/
359 0 : index = quant_2p_2N1_fx( ind[k], ind[k + 1], 4 );
360 0 : push_indice( hBstr, IND_ALG_CDBK_4T64, index, 9 );
361 : }
362 : }
363 0 : ELSE IF( EQ_16( nbbits, 44 ) ) /* AMR-WB pulse indexing */
364 : {
365 0 : FOR( track = 0; track < ( NB_TRACK_FCB_4T - 2 ); track++ )
366 : {
367 0 : k = i_mult2( track, NPMAXPT );
368 0 : index = quant_3p_3N1_fx( ind[k], ind[k + 1], ind[k + 2], 4 );
369 0 : push_indice( hBstr, IND_ALG_CDBK_4T64, index, 13 );
370 : }
371 :
372 0 : FOR( track = 2; track < NB_TRACK_FCB_4T; track++ )
373 : {
374 0 : k = i_mult2( track, NPMAXPT );
375 0 : index = quant_2p_2N1_fx( ind[k], ind[k + 1], 4 );
376 0 : push_indice( hBstr, IND_ALG_CDBK_4T64, index, 9 );
377 : }
378 : }
379 0 : ELSE IF( EQ_16( nbbits, 52 ) ) /* AMR-WB pulse indexing */
380 : {
381 0 : FOR( track = 0; track < NB_TRACK_FCB_4T; track++ )
382 : {
383 0 : k = i_mult2( track, NPMAXPT );
384 0 : index = quant_3p_3N1_fx( ind[k], ind[k + 1], ind[k + 2], 4 );
385 0 : push_indice( hBstr, IND_ALG_CDBK_4T64, index, 13 );
386 : }
387 : }
388 0 : ELSE IF( EQ_16( nbbits, 64 ) ) /* AMR-WB pulse indexing */
389 : {
390 0 : FOR( track = 0; track < NB_TRACK_FCB_4T; track++ )
391 : {
392 0 : k = i_mult2( track, NPMAXPT );
393 0 : L_index = quant_4p_4N_fx( &ind[k], 4 );
394 0 : index = extract_l( L_shr( L_index, 14 ) & 3 );
395 0 : logic16();
396 0 : push_indice( hBstr, IND_ALG_CDBK_4T64_1, index, 2 );
397 : }
398 :
399 0 : FOR( track = 0; track < NB_TRACK_FCB_4T; track++ )
400 : {
401 0 : k = i_mult2( track, NPMAXPT );
402 0 : L_index = quant_4p_4N_fx( &ind[k], 4 );
403 0 : index = extract_l( L_index & 0x3FFF );
404 0 : logic16();
405 0 : push_indice( hBstr, IND_ALG_CDBK_4T64_2, index, 14 );
406 : }
407 : }
408 0 : ELSE IF( EQ_16( nbbits, 72 ) )
409 : {
410 0 : FOR( track = 0; track < ( NB_TRACK_FCB_4T - 2 ); track++ )
411 : {
412 0 : k = i_mult2( track, NPMAXPT );
413 0 : L_index = quant_5p_5N_fx( &ind[k], 4 );
414 0 : index = extract_l( L_shr( L_index, 10 ) & 0x03FF );
415 0 : logic16();
416 0 : push_indice( hBstr, IND_ALG_CDBK_4T64_1, index, 10 );
417 : }
418 :
419 0 : FOR( track = 2; track < NB_TRACK_FCB_4T; track++ )
420 : {
421 0 : k = i_mult2( track, NPMAXPT );
422 0 : L_index = quant_4p_4N_fx( &ind[k], 4 );
423 0 : index = extract_l( L_shr( L_index, 14 ) & 3 );
424 0 : logic16();
425 0 : push_indice( hBstr, IND_ALG_CDBK_4T64_1, index, 2 );
426 : }
427 :
428 0 : FOR( track = 0; track < ( NB_TRACK_FCB_4T - 2 ); track++ )
429 : {
430 0 : k = i_mult2( track, NPMAXPT );
431 0 : L_index = quant_5p_5N_fx( &ind[k], 4 );
432 0 : index = extract_l( L_index & 0x03FF );
433 0 : logic16();
434 0 : push_indice( hBstr, IND_ALG_CDBK_4T64_2, index, 10 );
435 : }
436 :
437 0 : FOR( track = 2; track < NB_TRACK_FCB_4T; track++ )
438 : {
439 0 : k = i_mult2( track, NPMAXPT );
440 0 : L_index = quant_4p_4N_fx( &ind[k], 4 );
441 0 : index = extract_l( L_index & 0x3FFF );
442 0 : logic16();
443 0 : push_indice( hBstr, IND_ALG_CDBK_4T64_2, index, 14 );
444 : }
445 : }
446 0 : ELSE IF( EQ_16( nbbits, 88 ) )
447 : {
448 0 : FOR( track = 0; track < NB_TRACK_FCB_4T; track++ )
449 : {
450 0 : k = i_mult2( track, NPMAXPT );
451 0 : L_index = quant_6p_6N_2_fx( &ind[k], 4 );
452 0 : index = extract_l( L_shr( L_index, 11 ) & 0x07FF );
453 0 : logic16();
454 0 : push_indice( hBstr, IND_ALG_CDBK_4T64_1, index, 11 );
455 : }
456 :
457 0 : FOR( track = 0; track < NB_TRACK_FCB_4T; track++ )
458 : {
459 0 : k = i_mult2( track, NPMAXPT );
460 0 : L_index = quant_6p_6N_2_fx( &ind[k], 4 );
461 0 : index = extract_l( L_index & 0x07FF );
462 0 : logic16();
463 0 : push_indice( hBstr, IND_ALG_CDBK_4T64_2, index, 11 );
464 : }
465 : }
466 : }
467 :
468 6376 : return saved_bits;
469 : }
470 :
471 :
472 58451 : Word16 acelp_4t64_ivas_fx(
473 : BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */
474 : Word16 dn[], /* i : corr. between target and h[]. */
475 : const Word16 cn[], /* i : residual after long term prediction Q_new*/
476 : const Word16 H[], /* i : impulse response of weighted synthesis filter Q12*/
477 : Word16 R[], /* i : autocorrelation values */
478 : const Word16 acelpautoc, /* i : autocorrealtion flag */
479 : Word16 code[], /* o : algebraic (fixed) codebook excitation Q9*/
480 : Word16 y[], /* o : filtered fixed codebook excitation Q9*/
481 : Word16 nbbits, /* i : number of bits per codebook */
482 : const Word16 cmpl_flag, /* i : complexity reduction flag */
483 : const Word16 Opt_AMR_WB, /* i : flag indicating AMR-WB IO mode */
484 : Word16 element_mode )
485 : {
486 :
487 : Word16 i, k, index, track;
488 : Word32 L_index;
489 : Word16 ind[NPMAXPT * NB_TRACK_FCB_4T + 32]; /* VE3: why +32 ???*/
490 58451 : Word16 codvec[NB_PULSE_MAX + 4] = { 0 };
491 58451 : Word16 saved_bits = 0;
492 :
493 : PulseConfig config;
494 : Word16 indexing_indices[6], wordcnt, bitcnt;
495 :
496 58451 : set16_fx( codvec, 0, NB_PULSE_MAX + 4 );
497 58451 : SWITCH( nbbits )
498 : {
499 :
500 696 : case 20: /* EVS/AMR-WB pulse indexing: 20 bits, 4 pulses, 4 tracks */
501 696 : config.nbiter = 4;
502 696 : move16(); /* 4x12x16=768 loop */
503 696 : config.alp = 16384;
504 696 : move16(); /* 2 in Q13*/
505 696 : config.nb_pulse = 4;
506 696 : move16();
507 696 : config.fixedpulses = 0;
508 696 : move16();
509 696 : config.nbpos[0] = 4;
510 696 : move16();
511 696 : config.nbpos[1] = 8;
512 696 : move16();
513 696 : BREAK;
514 :
515 274 : case 28: /* EVS pulse indexing: 28 bits, 6 pulses, 4 tracks */
516 274 : config.nbiter = 4;
517 274 : move16(); /* 4x20x16=1280 loops */
518 274 : config.alp = 8192; /*1 in Q13*/
519 274 : move16(); /* coeff FOR sign setting */
520 274 : config.nb_pulse = 6;
521 274 : move16();
522 274 : config.fixedpulses = 0;
523 274 : move16();
524 274 : config.nbpos[0] = 6;
525 274 : move16();
526 274 : config.nbpos[1] = 6;
527 274 : move16();
528 274 : config.nbpos[2] = 8;
529 274 : move16();
530 274 : BREAK;
531 :
532 57481 : case 36: /* EVS/AMR-WB pulse indexing: 36 bits, 8 pulses, 4 tracks */
533 57481 : config.nbiter = 4;
534 57481 : move16(); /* 4x20x16=1280 loops */
535 57481 : config.alp = 8192; /*1 in Q13*/
536 57481 : move16(); /* coeff FOR sign setting */
537 57481 : config.nb_pulse = 8;
538 57481 : move16();
539 57481 : config.fixedpulses = 2;
540 57481 : move16();
541 57481 : config.nbpos[0] = 4;
542 57481 : move16();
543 57481 : config.nbpos[1] = 8;
544 57481 : move16();
545 57481 : config.nbpos[2] = 8;
546 57481 : move16();
547 57481 : BREAK;
548 :
549 0 : case 43: /* EVS pulse indexing: 43 bits, 10 pulses, 4 tracks */
550 : case 44: /* AMR-WB pulse indexing: 44 bits, 10 pulses, 4 tracks */
551 0 : config.nbiter = 4;
552 0 : move16(); /* 4x26x16=1664 loops */
553 0 : config.alp = 8192; /*1 in Q13*/
554 0 : move16();
555 0 : config.nb_pulse = 10;
556 0 : move16();
557 0 : config.fixedpulses = 2;
558 0 : move16();
559 0 : config.nbpos[0] = 4;
560 0 : move16();
561 0 : config.nbpos[1] = 6;
562 0 : move16();
563 0 : config.nbpos[2] = 8;
564 0 : move16();
565 0 : config.nbpos[3] = 8;
566 0 : move16();
567 0 : BREAK;
568 :
569 0 : case 50: /* EVS pulse indexing: 50 bits, 12 pulses, 4 tracks */
570 : case 52: /* AMR-WB pulse indexing: 52 bits, 12 pulses, 4 tracks */
571 0 : config.nbiter = 4;
572 0 : move16(); /* 4x26x16=1664 loops */
573 0 : config.alp = 8192; /*1 in Q13*/
574 0 : move16();
575 0 : config.nb_pulse = 12;
576 0 : move16();
577 0 : config.fixedpulses = 4;
578 0 : move16();
579 0 : config.nbpos[0] = 4;
580 0 : move16();
581 0 : config.nbpos[1] = 6;
582 0 : move16();
583 0 : config.nbpos[2] = 8;
584 0 : move16();
585 0 : config.nbpos[3] = 8;
586 0 : move16();
587 0 : BREAK;
588 :
589 0 : case 62: /* EVS pulse indexing: 62 bits, 16 pulses, 4 tracks */
590 : case 64: /* AMR-WB pulse indexing: 64 bits, 16 pulses, 4 tracks */
591 0 : config.nbiter = 3;
592 0 : move16(); /* 3x36x16=1728 loops */
593 0 : config.alp = 6554; /*.8f in Q13*/
594 0 : move16();
595 0 : config.nb_pulse = 16;
596 0 : move16();
597 0 : config.fixedpulses = 4;
598 0 : move16();
599 0 : config.nbpos[0] = 4;
600 0 : move16();
601 0 : config.nbpos[1] = 4;
602 0 : move16();
603 0 : config.nbpos[2] = 6;
604 0 : move16();
605 0 : config.nbpos[3] = 6;
606 0 : move16();
607 0 : config.nbpos[4] = 8;
608 0 : move16();
609 0 : config.nbpos[5] = 8;
610 0 : move16();
611 0 : BREAK;
612 :
613 0 : case 72: /* AMR-WB pulse indexing: 72 bits, 18 pulses, 4 tracks */
614 0 : config.nbiter = 3;
615 0 : move16(); /* 3x35x16=1680 loops */
616 0 : config.alp = 6144; /*.75f in Q13*/
617 0 : move16();
618 0 : config.nb_pulse = 18;
619 0 : move16();
620 0 : config.fixedpulses = 4;
621 0 : move16();
622 0 : config.nbpos[0] = 2;
623 0 : move16();
624 0 : config.nbpos[1] = 3;
625 0 : move16();
626 0 : config.nbpos[2] = 4;
627 0 : move16();
628 0 : config.nbpos[3] = 5;
629 0 : move16();
630 0 : config.nbpos[4] = 6;
631 0 : move16();
632 0 : config.nbpos[5] = 7;
633 0 : move16();
634 0 : config.nbpos[6] = 8;
635 0 : move16();
636 0 : BREAK;
637 :
638 0 : case 88: /* AMR-WB pulse indexing: 88 bits, 24 pulses, 4 tracks */
639 0 : config.nbiter = 2;
640 0 : move16(); /* 2x53x16=1696 loop */
641 0 : config.alp = 4096; /*.5f in Q13*/
642 0 : move16();
643 0 : config.nb_pulse = 24;
644 0 : move16();
645 0 : config.fixedpulses = 4;
646 0 : move16();
647 0 : config.nbpos[0] = 2;
648 0 : move16();
649 0 : config.nbpos[1] = 2;
650 0 : move16();
651 0 : config.nbpos[2] = 3;
652 0 : move16();
653 0 : config.nbpos[3] = 4;
654 0 : move16();
655 0 : config.nbpos[4] = 5;
656 0 : move16();
657 0 : config.nbpos[5] = 6;
658 0 : move16();
659 0 : config.nbpos[6] = 7;
660 0 : move16();
661 0 : config.nbpos[7] = 8;
662 0 : move16();
663 0 : config.nbpos[8] = 8;
664 0 : move16();
665 0 : config.nbpos[9] = 8;
666 0 : move16();
667 0 : BREAK;
668 :
669 0 : case 87: /* EVS pulse indexing: 87 bits, 26 pulses, 4 tracks */
670 0 : config.nbiter = 1;
671 0 : move16();
672 0 : config.alp = 4096; /*.5f in Q13*/
673 0 : move16();
674 0 : config.nb_pulse = 26;
675 0 : move16();
676 0 : config.fixedpulses = 4;
677 0 : move16();
678 0 : config.nbpos[0] = 4;
679 0 : move16();
680 0 : config.nbpos[1] = 6;
681 0 : move16();
682 0 : config.nbpos[2] = 6;
683 0 : move16();
684 0 : config.nbpos[3] = 8;
685 0 : move16();
686 0 : config.nbpos[4] = 8;
687 0 : move16();
688 0 : config.nbpos[5] = 8;
689 0 : move16();
690 0 : config.nbpos[6] = 8;
691 0 : move16();
692 0 : config.nbpos[7] = 8;
693 0 : move16();
694 0 : config.nbpos[8] = 8;
695 0 : move16();
696 0 : config.nbpos[9] = 8;
697 0 : move16();
698 0 : config.nbpos[10] = 8;
699 0 : move16();
700 0 : BREAK;
701 : }
702 :
703 : /* reduce the number of iterations as a compromise between the performance and complexity */
704 58451 : if ( cmpl_flag > 0 )
705 : {
706 57755 : config.nbiter = cmpl_flag;
707 57755 : move16();
708 : }
709 :
710 58451 : config.codetrackpos = TRACKPOS_FIXED_FIRST;
711 58451 : move32();
712 58451 : config.bits = nbbits;
713 58451 : move16();
714 :
715 58451 : IF( acelpautoc )
716 : {
717 57755 : E_ACELP_4tsearchx_ivas_fx( dn, cn, R, code, &config, ind, element_mode );
718 :
719 : /* Generate weighted code */
720 57755 : E_ACELP_weighted_code( code, H, 12, y );
721 : }
722 : ELSE
723 : {
724 696 : E_ACELP_4tsearch_fx( dn, cn, H, code, &config, ind, y );
725 :
726 45240 : FOR( i = 0; i < L_SUBFR; i++ )
727 : {
728 44544 : y[i] = shr( y[i], 3 );
729 44544 : move16(); /*Q9 */
730 : }
731 : }
732 :
733 : /*-----------------------------------------------------------------*
734 : * Indexing
735 : *-----------------------------------------------------------------*/
736 :
737 58451 : IF( !Opt_AMR_WB )
738 : {
739 58451 : saved_bits = E_ACELP_indexing_fx( code, &config, NB_TRACK_FCB_4T, indexing_indices );
740 :
741 58451 : saved_bits = 0;
742 58451 : move16();
743 :
744 58451 : wordcnt = shr( nbbits, 4 );
745 58451 : bitcnt = s_and( nbbits, 15 );
746 174383 : FOR( i = 0; i < wordcnt; i++ )
747 : {
748 115932 : push_indice( hBstr, IND_ALG_CDBK_4T64, indexing_indices[i], 16 );
749 : }
750 58451 : IF( bitcnt )
751 : {
752 58451 : push_indice( hBstr, IND_ALG_CDBK_4T64, indexing_indices[i], bitcnt );
753 : }
754 : }
755 : ELSE
756 : {
757 : /* AMR-WB pulse indexing */
758 :
759 0 : IF( EQ_16( nbbits, 20 ) )
760 : {
761 0 : FOR( track = 0; track < NB_TRACK_FCB_4T; track++ )
762 : {
763 0 : k = i_mult2( track, NPMAXPT );
764 0 : index = quant_1p_N1_fx( ind[k], 4 );
765 0 : push_indice( hBstr, IND_ALG_CDBK_4T64, index, 5 );
766 : }
767 : }
768 0 : ELSE IF( EQ_16( nbbits, 36 ) )
769 : {
770 0 : FOR( track = 0; track < NB_TRACK_FCB_4T; track++ )
771 : {
772 :
773 0 : k = i_mult2( track, NPMAXPT ); /* k = track * NPMAXPT;*/
774 0 : index = quant_2p_2N1_fx( ind[k], ind[k + 1], 4 );
775 0 : push_indice( hBstr, IND_ALG_CDBK_4T64, index, 9 );
776 : }
777 : }
778 0 : ELSE IF( EQ_16( nbbits, 44 ) ) /* AMR-WB pulse indexing */
779 : {
780 0 : FOR( track = 0; track < ( NB_TRACK_FCB_4T - 2 ); track++ )
781 : {
782 0 : k = i_mult2( track, NPMAXPT );
783 0 : index = quant_3p_3N1_fx( ind[k], ind[k + 1], ind[k + 2], 4 );
784 0 : push_indice( hBstr, IND_ALG_CDBK_4T64, index, 13 );
785 : }
786 :
787 0 : FOR( track = 2; track < NB_TRACK_FCB_4T; track++ )
788 : {
789 0 : k = i_mult2( track, NPMAXPT );
790 0 : index = quant_2p_2N1_fx( ind[k], ind[k + 1], 4 );
791 0 : push_indice( hBstr, IND_ALG_CDBK_4T64, index, 9 );
792 : }
793 : }
794 0 : ELSE IF( EQ_16( nbbits, 52 ) ) /* AMR-WB pulse indexing */
795 : {
796 0 : FOR( track = 0; track < NB_TRACK_FCB_4T; track++ )
797 : {
798 0 : k = i_mult2( track, NPMAXPT );
799 0 : index = quant_3p_3N1_fx( ind[k], ind[k + 1], ind[k + 2], 4 );
800 0 : push_indice( hBstr, IND_ALG_CDBK_4T64, index, 13 );
801 : }
802 : }
803 0 : ELSE IF( EQ_16( nbbits, 64 ) ) /* AMR-WB pulse indexing */
804 : {
805 0 : FOR( track = 0; track < NB_TRACK_FCB_4T; track++ )
806 : {
807 0 : k = i_mult2( track, NPMAXPT );
808 0 : L_index = quant_4p_4N_fx( &ind[k], 4 );
809 0 : index = extract_l( L_shr( L_index, 14 ) & 3 );
810 0 : logic16();
811 0 : push_indice( hBstr, IND_ALG_CDBK_4T64_1, index, 2 );
812 : }
813 :
814 0 : FOR( track = 0; track < NB_TRACK_FCB_4T; track++ )
815 : {
816 0 : k = i_mult2( track, NPMAXPT );
817 0 : L_index = quant_4p_4N_fx( &ind[k], 4 );
818 0 : index = extract_l( L_index & 0x3FFF );
819 0 : logic16();
820 0 : push_indice( hBstr, IND_ALG_CDBK_4T64_2, index, 14 );
821 : }
822 : }
823 0 : ELSE IF( EQ_16( nbbits, 72 ) )
824 : {
825 0 : FOR( track = 0; track < ( NB_TRACK_FCB_4T - 2 ); track++ )
826 : {
827 0 : k = i_mult2( track, NPMAXPT );
828 0 : L_index = quant_5p_5N_fx( &ind[k], 4 );
829 0 : index = extract_l( L_shr( L_index, 10 ) & 0x03FF );
830 0 : logic16();
831 0 : push_indice( hBstr, IND_ALG_CDBK_4T64_1, index, 10 );
832 : }
833 :
834 0 : FOR( track = 2; track < NB_TRACK_FCB_4T; track++ )
835 : {
836 0 : k = i_mult2( track, NPMAXPT );
837 0 : L_index = quant_4p_4N_fx( &ind[k], 4 );
838 0 : index = extract_l( L_shr( L_index, 14 ) & 3 );
839 0 : logic16();
840 0 : push_indice( hBstr, IND_ALG_CDBK_4T64_1, index, 2 );
841 : }
842 :
843 0 : FOR( track = 0; track < ( NB_TRACK_FCB_4T - 2 ); track++ )
844 : {
845 0 : k = i_mult2( track, NPMAXPT );
846 0 : L_index = quant_5p_5N_fx( &ind[k], 4 );
847 0 : index = extract_l( L_index & 0x03FF );
848 0 : logic16();
849 0 : push_indice( hBstr, IND_ALG_CDBK_4T64_2, index, 10 );
850 : }
851 :
852 0 : FOR( track = 2; track < NB_TRACK_FCB_4T; track++ )
853 : {
854 0 : k = i_mult2( track, NPMAXPT );
855 0 : L_index = quant_4p_4N_fx( &ind[k], 4 );
856 0 : index = extract_l( L_index & 0x3FFF );
857 0 : logic16();
858 0 : push_indice( hBstr, IND_ALG_CDBK_4T64_2, index, 14 );
859 : }
860 : }
861 0 : ELSE IF( EQ_16( nbbits, 88 ) )
862 : {
863 0 : FOR( track = 0; track < NB_TRACK_FCB_4T; track++ )
864 : {
865 0 : k = i_mult2( track, NPMAXPT );
866 0 : L_index = quant_6p_6N_2_fx( &ind[k], 4 );
867 0 : index = extract_l( L_shr( L_index, 11 ) & 0x07FF );
868 0 : logic16();
869 0 : push_indice( hBstr, IND_ALG_CDBK_4T64_1, index, 11 );
870 : }
871 :
872 0 : FOR( track = 0; track < NB_TRACK_FCB_4T; track++ )
873 : {
874 0 : k = i_mult2( track, NPMAXPT );
875 0 : L_index = quant_6p_6N_2_fx( &ind[k], 4 );
876 0 : index = extract_l( L_index & 0x07FF );
877 0 : logic16();
878 0 : push_indice( hBstr, IND_ALG_CDBK_4T64_2, index, 11 );
879 : }
880 : }
881 : }
882 :
883 58451 : return saved_bits;
884 : }
885 :
886 : /*---------------------------------------------------------------------*
887 : *encode class for 3p 4p 5p 6p/track *
888 : *---------------------------------------------------------------------*/
889 :
890 7258 : static Word32 fcb_encode_cl_fx( /* o: class index of the pulse on a track */
891 : const Word32 buffer[], /* i: pulses on a track */
892 : const Word32 pulse_num, /* i: pulses number on a track */
893 : const Word32 pos_num /* i: number of the position which have pulse */
894 : )
895 : {
896 : Word32 i, k;
897 : Word32 temp1, temp2;
898 :
899 7258 : temp1 = L_sub( L_add( pos_num, pulse_num ), 1 );
900 7258 : temp2 = L_add( pulse_num, 0 );
901 :
902 7258 : k = L_sub( PI_select_table[temp1][pulse_num], 1 );
903 7258 : temp1 = L_sub( temp1, 1 );
904 :
905 14888 : FOR( i = 0; i < pulse_num; i++ )
906 : {
907 7630 : k = L_sub( k, PI_select_table[temp1 - buffer[i]][temp2--] );
908 7630 : temp1 = L_sub( temp1, 1 );
909 : }
910 :
911 7258 : return k;
912 : }
913 :
914 :
915 : /*---------------------------------------------------------------------*
916 : *encode fcb pulse index *
917 : *---------------------------------------------------------------------*/
918 66960 : static Word32 fcb_encode_PI_fx( /* o: return index of the pulse on a track */
919 : const Word16 v[], /* i: pulse on a track Q9 */
920 : const Word32 pulse_num /* i: number of the pulse on a track */
921 : )
922 : {
923 : Word16 sector_p[7];
924 : Word32 pulse_pos_num;
925 : Word32 sector_p_num[7];
926 : Word32 code_index;
927 : Word32 sign;
928 :
929 : /*order the pulse position*/
930 66960 : sign = pre_process_fx( v, sector_p, sector_p_num, &pulse_pos_num );
931 :
932 : /*encode the position*/
933 66960 : code_index = fcb_encode_position_fx( sector_p, 16, pulse_pos_num, 1 );
934 : /*encode the class and compute class offset*/
935 66960 : code_index = L_add( code_index, fcb_encode_class_fx( sector_p_num, pulse_num, pulse_pos_num ) );
936 :
937 66960 : code_index = L_add( PI_offset[pulse_num][( ( pulse_num + 1L ) - pulse_pos_num )], L_add( L_shl( code_index, extract_l( pulse_pos_num ) ), sign ) );
938 :
939 66960 : return code_index;
940 : }
941 :
942 :
943 : /*---------------------------------------------------------------------*
944 : *encode the class and compute class offset *
945 : *---------------------------------------------------------------------*/
946 66960 : static Word32 fcb_encode_class_fx( /* o: class offset */
947 : const Word32 sector_6p_num[], /* i: position which have pulse on a track */
948 : const Word32 pulse_num, /* i: pulse number on a track */
949 : const Word32 pulse_pos_num /* i: number of position which have pulse on a track */
950 : )
951 : {
952 : Word32 i, j, k;
953 : Word32 mn9_offet;
954 : Word32 vector_class[6];
955 : Word32 *vector_class_ptr;
956 :
957 66960 : mn9_offet = L_deposit_l( 0 );
958 :
959 66960 : IF( LT_32( pulse_pos_num, pulse_num ) )
960 : {
961 7258 : vector_class_ptr = vector_class;
962 21402 : FOR( i = 0; i < pulse_pos_num; i++ )
963 : {
964 21774 : FOR( j = 0; j < ( sector_6p_num[i] - 1 ); j++ )
965 : {
966 :
967 7630 : *vector_class_ptr++ = i;
968 7630 : move32();
969 : }
970 : }
971 7258 : k = fcb_encode_cl_fx( vector_class, L_sub( pulse_num, pulse_pos_num ), pulse_pos_num );
972 10635 : FOR( i = 0; i < k; i++ )
973 : {
974 3377 : mn9_offet = L_add( mn9_offet, PI_factor[pulse_pos_num] );
975 : }
976 : }
977 66960 : return mn9_offet;
978 : }
979 : /*---------------------------------------------------------------------*
980 : *encode the position *
981 : *---------------------------------------------------------------------*/
982 66960 : static Word32 fcb_encode_position_fx( /* o: return index of the positions which have pulse*/
983 : const Word16 pos_vector[], /* i: position of the pulse on a track */
984 : Word32 n,
985 : const Word32 pos_num, /* i: the number of position which have pulse */
986 : const Word32 flag )
987 : {
988 : Word32 i;
989 : Word32 mmm1;
990 : Word32 temp2;
991 66960 : mmm1 = L_sub( PI_select_table[n][pos_num], 1 );
992 66960 : temp2 = pos_num;
993 66960 : move16();
994 :
995 66960 : IF( flag ) /* no decrease */
996 : {
997 66960 : move16(); /*ptr init*/
998 260210 : FOR( i = 0; i < pos_num; i++ )
999 : {
1000 : /*mmm1 -= PI_select_table_fx[sub(n,pos_vector[i]-1)][temp2--];*/
1001 193250 : mmm1 = L_sub( mmm1, PI_select_table[n - ( pos_vector[i] + 1 )][temp2--] );
1002 : }
1003 : }
1004 : ELSE
1005 : {
1006 0 : move16(); /*ptr init*/
1007 0 : FOR( i = 0; i < pos_num; i++ )
1008 : {
1009 : /*mmm1 -= PI_select_table_fx[n-pos_vector[i]-1][temp2--];*/
1010 0 : mmm1 = L_sub( mmm1, PI_select_table[n - ( pos_vector[i] + 1 )][temp2--] );
1011 0 : n = L_sub( n, 1 );
1012 : }
1013 : }
1014 :
1015 66960 : return mmm1;
1016 : }
1017 :
1018 : /*-------------------------------------------------------------------*
1019 : * search_ixiy
1020 : *
1021 : * Find the best positions of 2 pulses in a subframe
1022 : *-------------------------------------------------------------------*/
1023 :
1024 : /*------------------------------------------------------------*
1025 : * quant_1p_N1
1026 : *
1027 : * Quantization of 1 pulse with N+1 bits:
1028 : *-------------------------------------------------------------*/
1029 0 : static Word16 quant_1p_N1_fx( /* o : return N+1 bits */
1030 : const Word16 pos, /* i : position of the pulse */
1031 : const Word16 N /* i : number of bits FOR position */
1032 : )
1033 : {
1034 : Word16 mask;
1035 : Word16 index;
1036 :
1037 :
1038 0 : mask = sub( shl( 1, N ), 1 ); /* mask = ((1<<N)-1) */
1039 :
1040 0 : index = s_and( pos, mask );
1041 0 : IF( s_and( pos, NB_POS_FCB_4T ) != 0 )
1042 : {
1043 0 : index = add( index, shl( 1, N ) ); /* index += 1 << N */
1044 : }
1045 0 : return index;
1046 : }
1047 :
1048 :
1049 : /*------------------------------------------------------------*
1050 : * quant_2p_2N1_fx
1051 : *
1052 : * Quantization of 2 pulses with 2*N+1 bits:
1053 : *-------------------------------------------------------------*/
1054 67914 : Word16 quant_2p_2N1_fx( /* o: return (2*N)+1 bits */
1055 : const Word16 pos1, /* i: position of the pulse 1 */
1056 : const Word16 pos2, /* i: position of the pulse 2 */
1057 : const Word16 N /* i: number of bits FOR position */
1058 : )
1059 : {
1060 : Word16 mask, tmp;
1061 : Word16 index;
1062 :
1063 67914 : mask = sub( shl( 1, N ), 1 ); /* mask = ((1<<N)-1) */
1064 :
1065 : /*----------------------------------------------------------------*
1066 : * sign of 1st pulse == sign of 2th pulse
1067 : *----------------------------------------------------------------*/
1068 :
1069 67914 : logic16();
1070 67914 : logic16();
1071 67914 : IF( ( ( pos2 ^ pos1 ) & NB_POS_FCB_4T ) == 0 )
1072 : {
1073 35495 : IF( LE_16( pos1, pos2 ) ) /* ((pos1 - pos2) <= 0) */
1074 : {
1075 : /* index = ((pos1 & mask) << N) + (pos2 & mask) */
1076 35271 : index = add( shl( s_and( pos1, mask ), N ), s_and( pos2, mask ) );
1077 : }
1078 : ELSE
1079 : {
1080 : /* index = ((pos2 & mask) << N) + (pos1 & mask) */
1081 224 : index = add( shl( s_and( pos2, mask ), N ), s_and( pos1, mask ) );
1082 : }
1083 35495 : logic16();
1084 35495 : IF( ( pos1 & NB_POS_FCB_4T ) != 0 )
1085 : {
1086 17853 : tmp = shl( N, 1 );
1087 17853 : index = add( index, shl( 1, tmp ) ); /* index += 1 << (2*N) */
1088 : }
1089 : }
1090 : /*----------------------------------------------------------------*
1091 : * sign of 1st pulse != sign of 2th pulse
1092 : *----------------------------------------------------------------*/
1093 : ELSE
1094 : {
1095 32419 : IF( LE_16( s_and( pos1, mask ), s_and( pos2, mask ) ) )
1096 : {
1097 : /* index = ((pos2 & mask) << N) + (pos1 & mask); */
1098 32248 : index = add( shl( s_and( pos2, mask ), N ), s_and( pos1, mask ) );
1099 32248 : IF( s_and( pos2, NB_POS_FCB_4T ) != 0 )
1100 : {
1101 15784 : tmp = shl( N, 1 ); /* index += 1 << (2*N); */
1102 15784 : index = add( index, shl( 1, tmp ) );
1103 : }
1104 : }
1105 : ELSE
1106 : {
1107 : /* index = ((pos1 & mask) << N) + (pos2 & mask); */
1108 171 : index = add( shl( s_and( pos1, mask ), N ), s_and( pos2, mask ) );
1109 171 : IF( s_and( pos1, NB_POS_FCB_4T ) != 0 )
1110 : {
1111 69 : tmp = shl( N, 1 );
1112 69 : index = add( index, shl( 1, tmp ) ); /* index += 1 << (2*N) */
1113 : }
1114 : }
1115 : }
1116 :
1117 67914 : return index;
1118 : }
1119 : /*---------------------------------------------------------------------*
1120 : * Quantization of 3 pulses with 3*N+1 bits: *
1121 : *---------------------------------------------------------------------*/
1122 0 : static Word16 quant_3p_3N1_fx( /* o : return (3*N)+1 bits */
1123 : const Word16 pos1, /* i : position of the pulse 1 */
1124 : const Word16 pos2, /* i : position of the pulse 2 */
1125 : const Word16 pos3, /* i : position of the pulse 3 */
1126 : const Word16 N /* i : number of bits for position */
1127 : )
1128 : {
1129 : Word16 nb_pos;
1130 : Word16 index;
1131 :
1132 0 : nb_pos = shl( 1, sub( N, 1 ) ); /* nb_pos = (1<<(N-1)); */
1133 : /*-------------------------------------------------------*
1134 : * Quantization of 3 pulses with 3*N+1 bits: *
1135 : *-------------------------------------------------------*/
1136 0 : logic16();
1137 0 : logic16();
1138 0 : logic16();
1139 0 : logic16();
1140 0 : IF( ( ( pos1 ^ pos2 ) & nb_pos ) == 0 )
1141 : {
1142 0 : index = quant_2p_2N1_fx( pos1, pos2, sub( N, 1 ) ); /* index = quant_2p_2N1_fx(pos1, pos2, (N-1)); */
1143 : /* index += (pos1 & nb_pos) << N; */
1144 0 : index = add( index, shl( (Word16) ( pos1 & nb_pos ), N ) );
1145 0 : logic16();
1146 : /* index += quant_1p_N1_fx(pos3, N) << (2*N); */
1147 0 : index = add( index, shl( quant_1p_N1_fx( pos3, N ), shl( N, 1 ) ) );
1148 : }
1149 0 : ELSE IF( ( ( pos1 ^ pos3 ) & nb_pos ) == 0 )
1150 : {
1151 0 : index = quant_2p_2N1_fx( pos1, pos3, sub( N, 1 ) ); /* index = quant_2p_2N1_fx(pos1, pos3, (N-1)); */
1152 0 : index = add( index, shl( (Word16) ( pos1 & nb_pos ), N ) );
1153 0 : logic16();
1154 : /* index += (pos1 & nb_pos) << N; */
1155 0 : index = add( index, shl( quant_1p_N1_fx( pos2, N ), shl( N, 1 ) ) );
1156 : /* index += quant_1p_N1_fx(pos2, N) <<
1157 : * (2*N); */
1158 : }
1159 : ELSE
1160 : {
1161 0 : index = quant_2p_2N1_fx( pos2, pos3, sub( N, 1 ) ); /* index = quant_2p_2N1_fx(pos2, pos3, (N-1)); */
1162 : /* index += (pos2 & nb_pos) << N; */
1163 0 : index = add( index, shl( (Word16) ( pos2 & nb_pos ), N ) );
1164 0 : logic16();
1165 : /* index += quant_1p_N1_fx(pos1, N) << (2*N); */
1166 0 : index = add( index, shl( quant_1p_N1_fx( pos1, N ), shl( N, 1 ) ) );
1167 : }
1168 0 : return ( index );
1169 : }
1170 : /*---------------------------------------------------------------------*
1171 : * Quantization of 4 pulses with 4*N+1 bits: *
1172 : *---------------------------------------------------------------------*/
1173 0 : static Word32 quant_4p_4N1_fx( /* o : return (4*N)+1 bits */
1174 : const Word16 pos1, /* i : position of the pulse 1 */
1175 : const Word16 pos2, /* i : position of the pulse 2 */
1176 : const Word16 pos3, /* i : position of the pulse 3 */
1177 : const Word16 pos4, /* i : position of the pulse 4 */
1178 : const Word16 N /* i : number of bits for position */
1179 : )
1180 : {
1181 : Word16 nb_pos;
1182 : Word32 index;
1183 :
1184 0 : nb_pos = shl( 1, sub( N, 1 ) ); /* nb_pos = (1<<(N-1)); */
1185 : /*-------------------------------------------------------*
1186 : * Quantization of 4 pulses with 4*N+1 bits: *
1187 : *-------------------------------------------------------*/
1188 0 : logic16();
1189 0 : logic16();
1190 0 : logic16();
1191 0 : logic16();
1192 0 : IF( ( ( pos1 ^ pos2 ) & nb_pos ) == 0 )
1193 : {
1194 0 : index = quant_2p_2N1_fx( pos1, pos2, sub( N, 1 ) ); /* index = quant_2p_2N1_fx(pos1, pos2, (N-1)); */
1195 : /* index += (pos1 & nb_pos) << N; */
1196 0 : index = L_add( index, L_shl( L_deposit_l( (Word16) ( pos1 & nb_pos ) ), N ) );
1197 0 : logic16();
1198 : /* index += quant_2p_2N1_fx(pos3, pos4, N) << (2*N); */
1199 0 : index = L_add( index, L_shl( quant_2p_2N1_fx( pos3, pos4, N ), shl( N, 1 ) ) );
1200 : }
1201 0 : ELSE IF( ( ( pos1 ^ pos3 ) & nb_pos ) == 0 )
1202 : {
1203 0 : index = quant_2p_2N1_fx( pos1, pos3, sub( N, 1 ) );
1204 : /* index += (pos1 & nb_pos) << N; */
1205 0 : index = L_add( index, L_shl( L_deposit_l( (Word16) ( pos1 & nb_pos ) ), N ) );
1206 0 : logic16();
1207 : /* index += quant_2p_2N1_fx(pos2, pos4, N) << (2*N); */
1208 0 : index = L_add( index, L_shl( quant_2p_2N1_fx( pos2, pos4, N ), shl( N, 1 ) ) );
1209 : }
1210 : ELSE
1211 : {
1212 0 : index = quant_2p_2N1_fx( pos2, pos3, sub( N, 1 ) );
1213 : /* index += (pos2 & nb_pos) << N; */
1214 0 : index = L_add( index, L_shl( L_deposit_l( (Word16) ( pos2 & nb_pos ) ), N ) );
1215 0 : logic16();
1216 : /* index += quant_2p_2N1_fx(pos1, pos4, N) << (2*N); */
1217 0 : index = L_add( index, L_shl( quant_2p_2N1_fx( pos1, pos4, N ), shl( N, 1 ) ) );
1218 : }
1219 0 : return ( index );
1220 : }
1221 : /*---------------------------------------------------------------------*
1222 : * Quantization of 4 pulses with 4*N bits: *
1223 : *---------------------------------------------------------------------*/
1224 :
1225 0 : static Word32 quant_4p_4N_fx( /* o : return 4*N bits */
1226 : const Word16 pos[], /* i : position of the pulse 1..4 */
1227 : const Word16 N /* i : number of bits for position */
1228 : )
1229 : {
1230 : Word16 i, j, k, nb_pos, n_1, tmp;
1231 : Word16 posA[4], posB[4];
1232 : Word32 index;
1233 :
1234 0 : n_1 = sub( N, 1 );
1235 0 : move16();
1236 0 : nb_pos = shl( 1, n_1 ); /* nb_pos = (1<<n_1); */
1237 :
1238 0 : i = 0;
1239 0 : move16();
1240 0 : j = 0;
1241 0 : move16();
1242 0 : FOR( k = 0; k < 4; k++ )
1243 : {
1244 0 : logic16();
1245 0 : IF( ( pos[k] & nb_pos ) == 0 )
1246 : {
1247 0 : posA[i++] = pos[k];
1248 0 : move16();
1249 : }
1250 : ELSE
1251 : {
1252 0 : posB[j++] = pos[k];
1253 0 : move16();
1254 : }
1255 : }
1256 :
1257 0 : SWITCH( i )
1258 : {
1259 0 : case 0:
1260 0 : tmp = sub( shl( N, 2 ), 3 ); /* index = 1 << ((4*N)-3); */
1261 0 : index = L_shl( 1L, tmp );
1262 : /* index += quant_4p_4N1_fx(posB[0], posB[1], posB[2], posB[3], n_1); */
1263 0 : index = L_add( index, quant_4p_4N1_fx( posB[0], posB[1], posB[2], posB[3], n_1 ) );
1264 0 : BREAK;
1265 0 : case 1:
1266 : /* index = quant_1p_N1_fx(posA[0], n_1) << ((3*n_1)+1); */
1267 0 : tmp = add( extract_l( L_shr( L_mult( 3, n_1 ), 1 ) ), 1 );
1268 0 : index = L_shl( quant_1p_N1_fx( posA[0], n_1 ), tmp );
1269 : /* index += quant_3p_3N1_fx(posB[0], posB[1], posB[2], n_1); */
1270 0 : index = L_add( index, quant_3p_3N1_fx( posB[0], posB[1], posB[2], n_1 ) );
1271 0 : BREAK;
1272 0 : case 2:
1273 0 : tmp = add( shl( n_1, 1 ), 1 ); /* index = quant_2p_2N1_fx(posA[0], posA[1], n_1) << ((2*n_1)+1); */
1274 0 : index = L_shl( quant_2p_2N1_fx( posA[0], posA[1], n_1 ), tmp );
1275 : /* index += quant_2p_2N1_fx(posB[0], posB[1], n_1); */
1276 0 : index = L_add( index, quant_2p_2N1_fx( posB[0], posB[1], n_1 ) );
1277 0 : BREAK;
1278 0 : case 3:
1279 : /* index = quant_3p_3N1_fx(posA[0], posA[1], posA[2], n_1) << N; */
1280 0 : index = L_shl( quant_3p_3N1_fx( posA[0], posA[1], posA[2], n_1 ), N );
1281 0 : index = L_add( index, quant_1p_N1_fx( posB[0], n_1 ) ); /* index += quant_1p_N1_fx(posB[0], n_1); */
1282 0 : BREAK;
1283 0 : case 4:
1284 0 : index = quant_4p_4N1_fx( posA[0], posA[1], posA[2], posA[3], n_1 );
1285 0 : BREAK;
1286 0 : default:
1287 0 : index = 0;
1288 0 : move32();
1289 0 : fprintf( stderr, "Error in function quant_4p_4N_fx\n" );
1290 : }
1291 0 : tmp = sub( shl( N, 2 ), 2 ); /* index += (i & 3) << ((4*N)-2); */
1292 0 : index = L_add( index, L_shl( ( L_deposit_l( i ) & ( 3L ) ), tmp ) );
1293 0 : logic16();
1294 :
1295 0 : return ( index );
1296 : }
1297 :
1298 :
1299 0 : static Word32 quant_5p_5N_fx( /* o : return 5*N bits */
1300 : const Word16 pos[], /* i : position of the pulse 1..5 */
1301 : const Word16 N ) /* i : number of bits for position */
1302 : {
1303 : Word16 i, j, k, nb_pos, n_1, tmp;
1304 : Word16 posA[5], posB[5];
1305 : Word32 index, tmp2;
1306 :
1307 0 : n_1 = sub( N, 1 );
1308 0 : nb_pos = shl( 1, n_1 ); /* nb_pos = (1<<n_1); */
1309 :
1310 0 : i = 0;
1311 0 : move16();
1312 0 : j = 0;
1313 0 : move16();
1314 0 : FOR( k = 0; k < 5; k++ )
1315 : {
1316 0 : logic16();
1317 0 : IF( ( pos[k] & nb_pos ) == 0 )
1318 : {
1319 0 : posA[i++] = pos[k];
1320 0 : move16();
1321 : }
1322 : ELSE
1323 : {
1324 0 : posB[j++] = pos[k];
1325 0 : move16();
1326 : }
1327 : }
1328 :
1329 0 : SWITCH( i )
1330 : {
1331 0 : case 0:
1332 0 : tmp = sub( extract_l( L_shr( L_mult( 5, N ), 1 ) ), 1 ); /* ((5*N)-1)) */
1333 0 : index = L_shl( 1L, tmp ); /* index = 1 << ((5*N)-1); */
1334 0 : tmp = add( shl( N, 1 ), 1 ); /* index += quant_3p_3N1_fx(posB[0], posB[1], posB[2], n_1) << ((2*N)+1);*/
1335 0 : tmp2 = L_shl( quant_3p_3N1_fx( posB[0], posB[1], posB[2], n_1 ), tmp );
1336 0 : index = L_add( index, tmp2 );
1337 0 : index = L_add( index, quant_2p_2N1_fx( posB[3], posB[4], N ) ); /* index += quant_2p_2N1_fx(posB[3], posB[4], N); */
1338 0 : BREAK;
1339 0 : case 1:
1340 0 : tmp = sub( extract_l( L_shr( L_mult( 5, N ), 1 ) ), 1 ); /* index = 1 << ((5*N)-1); */
1341 0 : index = L_shl( 1L, tmp );
1342 0 : tmp = add( shl( N, 1 ), 1 ); /* index += quant_3p_3N1_fx(posB[0], posB[1], posB[2], n_1) <<((2*N)+1); */
1343 0 : tmp2 = L_shl( quant_3p_3N1_fx( posB[0], posB[1], posB[2], n_1 ), tmp );
1344 0 : index = L_add( index, tmp2 );
1345 0 : index = L_add( index, quant_2p_2N1_fx( posB[3], posA[0], N ) ); /* index += quant_2p_2N1_fx(posB[3], posA[0], N); */
1346 0 : BREAK;
1347 0 : case 2:
1348 0 : tmp = sub( extract_l( L_shr( L_mult( 5, N ), 1 ) ), 1 ); /* ((5*N)-1)) */
1349 0 : index = L_shl( 1L, tmp ); /* index = 1 << ((5*N)-1); */
1350 0 : tmp = add( shl( N, 1 ), 1 ); /* index += quant_3p_3N1_fx(posB[0], posB[1], posB[2], n_1) << ((2*N)+1); */
1351 0 : tmp2 = L_shl( quant_3p_3N1_fx( posB[0], posB[1], posB[2], n_1 ), tmp );
1352 0 : index = L_add( index, tmp2 );
1353 0 : index = L_add( index, quant_2p_2N1_fx( posA[0], posA[1], N ) ); /* index += quant_2p_2N1_fx(posA[0], posA[1], N); */
1354 0 : BREAK;
1355 0 : case 3:
1356 0 : tmp = add( shl( N, 1 ), 1 ); /* index = quant_3p_3N1_fx(posA[0], posA[1], posA[2], n_1) << ((2*N)+1); */
1357 0 : index = L_shl( quant_3p_3N1_fx( posA[0], posA[1], posA[2], n_1 ), tmp );
1358 0 : index = L_add( index, quant_2p_2N1_fx( posB[0], posB[1], N ) ); /* index += quant_2p_2N1_fx(posB[0], posB[1], N); */
1359 0 : BREAK;
1360 0 : case 4:
1361 0 : tmp = add( shl( N, 1 ), 1 ); /* index = quant_3p_3N1_fx(posA[0], posA[1], posA[2], n_1) << ((2*N)+1); */
1362 0 : index = L_shl( quant_3p_3N1_fx( posA[0], posA[1], posA[2], n_1 ), tmp );
1363 0 : index = L_add( index, quant_2p_2N1_fx( posA[3], posB[0], N ) ); /* index += quant_2p_2N1_fx(posA[3], posB[0], N); */
1364 0 : BREAK;
1365 0 : case 5:
1366 0 : tmp = add( shl( N, 1 ), 1 ); /* index = quant_3p_3N1_fx(posA[0], posA[1], posA[2], n_1) << ((2*N)+1); */
1367 0 : index = L_shl( quant_3p_3N1_fx( posA[0], posA[1], posA[2], n_1 ), tmp );
1368 0 : index = L_add( index, quant_2p_2N1_fx( posA[3], posA[4], N ) ); /* index += quant_2p_2N1_fx(posA[3], posA[4], N); */
1369 0 : BREAK;
1370 0 : default:
1371 0 : index = 0;
1372 0 : move32();
1373 0 : fprintf( stderr, "Error in function quant_5p_5N_fx\n" );
1374 : }
1375 :
1376 0 : return ( index );
1377 : }
1378 :
1379 0 : static Word32 quant_6p_6N_2_fx( /* o : return (6*N)-2 bits */
1380 : const Word16 pos[], /* i : position of the pulse 1..6 */
1381 : const Word16 N ) /* i : number of bits for position */
1382 : {
1383 : Word16 i, j, k, nb_pos, n_1;
1384 : Word16 posA[6], posB[6];
1385 : Word32 index;
1386 :
1387 : /* !! N and n_1 are constants -> it doesn't need to be operated by Basic Operators */
1388 :
1389 0 : n_1 = sub( N, 1 );
1390 0 : nb_pos = shl( 1, n_1 ); /* nb_pos = (1<<n_1); */
1391 :
1392 0 : i = 0;
1393 0 : move16();
1394 0 : j = 0;
1395 0 : move16();
1396 0 : FOR( k = 0; k < 6; k++ )
1397 : {
1398 0 : logic16();
1399 0 : IF( ( pos[k] & nb_pos ) == 0 )
1400 : {
1401 0 : posA[i++] = pos[k];
1402 0 : move16();
1403 : }
1404 : ELSE
1405 : {
1406 0 : posB[j++] = pos[k];
1407 0 : move16();
1408 : }
1409 : }
1410 :
1411 0 : SWITCH( i )
1412 : {
1413 0 : case 0:
1414 0 : index = L_shl( 1L, sub( i_mult( 6, N ), 5 ) ); /* index = 1 << ((6*N)-5); */
1415 0 : index = L_add( index, L_shl( quant_5p_5N_fx( posB, n_1 ), N ) ); /* index += quant_5p_5N_fx(posB, n_1) << N; */
1416 0 : index = L_add( index, quant_1p_N1_fx( posB[5], n_1 ) ); /* index += quant_1p_N1_fx(posB[5], n_1); */
1417 0 : BREAK;
1418 0 : case 1:
1419 0 : index = L_shl( 1L, sub( i_mult( 6, N ), 5 ) ); /* index = 1 << ((6*N)-5); */
1420 0 : index = L_add( index, L_shl( quant_5p_5N_fx( posB, n_1 ), N ) ); /* index += quant_5p_5N_fx(posB, n_1) << N; */
1421 0 : index = L_add( index, quant_1p_N1_fx( posA[0], n_1 ) ); /* index += quant_1p_N1_fx(posA[0], n_1); */
1422 0 : BREAK;
1423 0 : case 2:
1424 0 : index = L_shl( 1L, sub( i_mult( 6, N ), 5 ) ); /* index = 1 << ((6*N)-5); */
1425 : /* index += quant_4p_4N_fx(posB, n_1) << ((2*n_1)+1); */
1426 0 : index = L_add( index, L_shl( quant_4p_4N_fx( posB, n_1 ), ( add( shl( n_1, 1 ), 1 ) ) ) );
1427 0 : index = L_add( index, quant_2p_2N1_fx( posA[0], posA[1], n_1 ) ); /* index += quant_2p_2N1_fx(posA[0], posA[1], n_1); */
1428 0 : BREAK;
1429 0 : case 3:
1430 0 : index = L_shl( quant_3p_3N1_fx( posA[0], posA[1], posA[2], n_1 ), ( add( i_mult( 3, n_1 ), 1 ) ) ); /* index = quant_3p_3N1_fx(posA[0], posA[1], posA[2], n_1) << ((3*n_1)+1); */
1431 0 : index = L_add( index, quant_3p_3N1_fx( posB[0], posB[1], posB[2], n_1 ) ); /* index += quant_3p_3N1_fx(posB[0], posB[1], posB[2], n_1); */
1432 0 : BREAK;
1433 0 : case 4:
1434 0 : i = 2;
1435 0 : move16();
1436 0 : index = L_shl( quant_4p_4N_fx( posA, n_1 ), ( add( shl( n_1, 1 ), 1 ) ) ); /* index = quant_4p_4N_fx(posA, n_1) << ((2*n_1)+1); */
1437 0 : index = L_add( index, quant_2p_2N1_fx( posB[0], posB[1], n_1 ) ); /* index += quant_2p_2N1_fx(posB[0], posB[1], n_1); */
1438 0 : BREAK;
1439 0 : case 5:
1440 0 : i = 1;
1441 0 : move16();
1442 0 : index = L_shl( quant_5p_5N_fx( posA, n_1 ), N ); /* index = quant_5p_5N_fx(posA, n_1) << N; */
1443 0 : index = L_add( index, quant_1p_N1_fx( posB[0], n_1 ) ); /* index += quant_1p_N1_fx(posB[0], n_1); */
1444 0 : BREAK;
1445 0 : case 6:
1446 0 : i = 0;
1447 0 : move16();
1448 0 : index = L_shl( quant_5p_5N_fx( posA, n_1 ), N ); /* index = quant_5p_5N_fx(posA, n_1) << N; */
1449 0 : index = L_add( index, quant_1p_N1_fx( posA[5], n_1 ) ); /* index += quant_1p_N1_fx(posA[5], n_1); */
1450 0 : BREAK;
1451 0 : default:
1452 0 : index = 0;
1453 0 : fprintf( stderr, "Error in function quant_6p_6N_2_fx\n" );
1454 : }
1455 0 : index = L_add( index, L_shl( ( L_deposit_l( i ) & 3L ), sub( i_mult( 6, N ), 4 ) ) );
1456 0 : logic16(); /* index += (i & 3) << ((6*N)-4); */
1457 :
1458 0 : return ( index );
1459 : }
1460 :
1461 :
1462 : /*---------------------------------------------------------------------*
1463 : *order the pulse position *
1464 : *---------------------------------------------------------------------*/
1465 66960 : static Word32 pre_process_fx( /* o: return sign value of pulse on a track */
1466 : const Word16 v[], /* i: the pulse vector Q9 */
1467 : Word16 pos_vector[], /* o: position of the pulse on a track */
1468 : Word32 pos_vector_num[], /* o: the pulse number on the position which have pulse Q0 */
1469 : Word32 *pulse_pos_num /* i: the number of position which have pulse */
1470 : )
1471 : {
1472 : Word16 j, k;
1473 : Word32 sign;
1474 :
1475 66960 : sign = L_deposit_l( 0 );
1476 66960 : j = 0;
1477 66960 : move16();
1478 1138320 : FOR( k = 0; k < 64; k += 4 ){
1479 1071360 : IF( v[k] ){
1480 193250 : pos_vector[j] = shr( k, 2 );
1481 193250 : move16();
1482 193250 : pos_vector_num[j] = L_shr( abs_s( v[k] ), 9 ); /* Q9: 512 -> 1, Q0 */
1483 193250 : move32();
1484 193250 : IF( v[k] > 0 )
1485 : {
1486 95856 : sign = L_shl( sign, 1 );
1487 : }
1488 : ELSE
1489 : {
1490 97394 : sign = L_add( L_shl( sign, 1 ), 1 );
1491 : }
1492 193250 : j = add( j, 1 );
1493 : }
1494 : }
1495 66960 : *pulse_pos_num = L_deposit_l( j );
1496 66960 : move32();
1497 :
1498 66960 : return sign;
1499 : }
1500 :
1501 :
1502 : /*--------------------------------------------------------------------------*
1503 : * E_ACELP_code43bit_fx
1504 : *
1505 : * Fixed bit-length arithmetic coding of pulses
1506 : * v - (input) pulse vector
1507 : * s - (output) encoded state
1508 : * n - (output) range of possible states (0...n-1)
1509 : * p - (output) number of pulses found
1510 : * len - (input) length of pulse vector
1511 : * trackstep - (input) step between tracks
1512 : *--------------------------------------------------------------------------*/
1513 :
1514 33480 : Word16 E_ACELP_code43bit_fx(
1515 : const Word16 code[], /*Q9*/
1516 : UWord32 *ps,
1517 : Word16 *p,
1518 : UWord16 idxs[] )
1519 : {
1520 : Word16 i, j, k, track;
1521 : Word16 ind[32];
1522 :
1523 : Word16 tmp;
1524 : Word32 L_tmp;
1525 : Word32 joint_index;
1526 : static const Word32 joint_offset = 3611648; /*offset for 3 pulses per track*/
1527 33480 : move32();
1528 33480 : Word16 saved_bits = 0;
1529 33480 : move16();
1530 100440 : FOR( track = 0; track < 2; track++ )
1531 : {
1532 66960 : ps[track] = fcb_encode_PI_fx( code + track, 3 );
1533 66960 : move32();
1534 66960 : p[track] = 3;
1535 66960 : move16();
1536 : }
1537 :
1538 100440 : FOR( track = 2; track < NB_TRACK_FCB_4T; track++ )
1539 : {
1540 66960 : i = j = i_mult2( track, NPMAXPT );
1541 :
1542 1117891 : FOR( k = track; k < 64; k += 4 )
1543 : {
1544 1053521 : IF( code[k] )
1545 : {
1546 131330 : tmp = shr( k, 2 );
1547 131330 : IF( code[k] < 0 )
1548 : {
1549 65802 : tmp = add( tmp, 16 );
1550 : }
1551 131330 : ind[j] = tmp;
1552 131330 : move16();
1553 131330 : IF( GT_16( abs_s( code[k] ), 512 /*Q9*/ ) )
1554 : {
1555 2590 : ind[j + 1] = tmp;
1556 2590 : move16();
1557 2590 : BREAK;
1558 : }
1559 128740 : j = add( j, 1 );
1560 : }
1561 : }
1562 66960 : ps[track] = quant_2p_2N1_fx( ind[i], ind[i + 1], 4 );
1563 66960 : move32();
1564 66960 : p[track] = 2;
1565 66960 : move16();
1566 : }
1567 : /* joint_index = ps[0]*5472 + ps[1]; */
1568 33480 : L_tmp = L_shl( ps[0], 12 );
1569 33480 : L_tmp = L_add( L_tmp, L_shl( ps[0], 10 ) );
1570 33480 : L_tmp = L_add( L_tmp, L_shl( ps[0], 8 ) );
1571 33480 : L_tmp = L_add( L_tmp, L_shl( ps[0], 6 ) );
1572 33480 : L_tmp = L_add( L_tmp, L_shl( ps[0], 5 ) );
1573 33480 : joint_index = L_add( L_tmp, ps[1] );
1574 33480 : L_tmp = L_sub( joint_index, joint_offset );
1575 33480 : if ( L_tmp >= 0 )
1576 : {
1577 28088 : joint_index = L_add( joint_index, joint_offset );
1578 : }
1579 33480 : if ( L_tmp < 0 )
1580 : {
1581 5392 : saved_bits = add( saved_bits, 1 );
1582 : }
1583 33480 : idxs[0] = extract_l( L_add( L_shl( ps[2], 9 ), ps[3] ) );
1584 33480 : idxs[1] = extract_l( L_add( L_shl( joint_index, 2 ), L_shr( ps[2], 7 ) ) );
1585 33480 : idxs[2] = extract_l( L_shr( joint_index, 14 ) );
1586 33480 : move16();
1587 33480 : move16();
1588 33480 : move16();
1589 33480 : return saved_bits;
1590 : }
|
