Line data Source code
1 : /******************************************************************************
2 : * ETSI TS 103 634 V1.4.5 *
3 : * Low Complexity Communication Codec Plus (LC3plus) *
4 : * *
5 : * Copyright licence is solely granted through ETSI Intellectual Property *
6 : * Rights Policy, 3rd April 2019. No patent licence is granted by implication, *
7 : * estoppel or otherwise. *
8 : ******************************************************************************/
9 :
10 : #include "functions.h"
11 :
12 :
13 : typedef struct
14 : {
15 : Word16 inv_bin;
16 : Word16 numbytes;
17 : Word16 c_bp;
18 : Word16 c_bp_side;
19 : Word16 bytes;
20 : Word16 b_left;
21 : Word16 b_right;
22 : Word16 enc;
23 : Word16 sim_dec;
24 : Word16 bfi;
25 : Word16 be_bp_left;
26 : Word16 be_bp_right;
27 : } Pc_State_fx;
28 :
29 : typedef struct
30 : {
31 : UWord32 ac_low_fx;
32 : UWord32 ac_range_fx;
33 : Word16 ac_cache_fx;
34 : Word16 ac_carry_fx;
35 : Word16 ac_carry_count_fx;
36 : } Encoder_State_fx;
37 :
38 : typedef struct
39 : {
40 : UWord32 ac_low_fx;
41 : UWord32 ac_range_fx;
42 : UWord32 ac_help_fx;
43 : Word16 BER_detect;
44 : Pc_State_fx pc;
45 : } Decoder_State_fx;
46 :
47 : static void ac_dec_init_fx(UWord8 *ptr, Word16 *bp, Word16 *bp_side, Word16 *mask_side,
48 : Decoder_State_fx *st_fx /* i/o: Decoder State */
49 : );
50 :
51 : static __forceinline void pc_init_fx(Word16 n_pc, Word16 numbytes, Word16 be_bp_left, Word16 be_bp_right, Word16 L_spec,
52 : Word16 enc, Word16 sim_dec, Word16 bfi, Pc_State_fx *pc /* i/o: Pc State */
53 : );
54 : static __forceinline Word16 check_pc_bytes(Word16 *bp, Word16 *bp_side, Word16 *mask_side, Word16 cur_bin,
55 : Word16 from_left, Pc_State_fx *pc /* i/o: Pc State */
56 : );
57 :
58 : static void ac_enc_init_fx(Encoder_State_fx *st_fx /* i/o: Encoder state */
59 : );
60 :
61 : static void ac_enc_shift_fx(UWord8 *ptr, Word16 *bp, Encoder_State_fx *st_fx /* i/o: Encoder state */
62 : );
63 :
64 : static void write_indice_forward(UWord8 *ptr, Word16 bp, Word16 indice, Word16 numbits);
65 :
66 : static void ac_encode_fx(UWord8 *ptr, Word16 *bp, Encoder_State_fx *st_fx, /* i/o: Encoder state */
67 : UWord32 cum_freq, /* i : Cumulative frequency up to symbol */
68 : UWord32 sym_freq /* i : Symbol probability */
69 : );
70 :
71 : static Word16 ac_enc_finish_fx(UWord8 *ptr, Word16 *bp, Encoder_State_fx *st_fx /* i/o: Encoder state */
72 : );
73 :
74 : static Word16 ac_decode_fx( /* o : Decoded cumulative frequency */
75 : Decoder_State_fx *st_fx, /* i/o: Decoder State */
76 : Word16 pki);
77 : static Word16 ac_decode_tns_order( /* o : Decoded cumulative frequency */
78 : Decoder_State_fx *st_fx, /* i/o: Decoder State */
79 : Word16 enable_lpc_weighting);
80 : static Word16 ac_decode_tns_coef( /* o : Decoded cumulative frequency */
81 : Decoder_State_fx *st_fx, /* i/o: Decoder State */
82 : Word16 pki);
83 : static Word16 ac_dec_update_fx(UWord8 *ptr, Word16 *bp, Word16 *bp_side, Word16 *mask_side, Word16 cur_bin,
84 : Decoder_State_fx *st_fx, /* i/o: Decoder State */
85 : UWord32 cum_freq, /* i : Cumulative frequency */
86 : UWord32 sym_freq /* i : Symbol frequency */
87 : );
88 :
89 : /*************************************************************************/
90 :
91 : #ifdef ENABLE_HR_MODE
92 :
93 0 : Word16 processAriEncoder_fx(UWord8 *bytes, Word16 bp_side_in, Word16 mask_side_in, Word16 nbbits, Word32 xq[],
94 : Word16 *tns_order, Word16 tns_numfilters, Word16 *tns_idx, Word16 lastnz,
95 : Word16 *codingdata, UWord8 *resBits, Word16 numResBits, Word16 lsbMode,
96 : Word16 enable_lpc_weighting, Word8 *scratchBuffer)
97 : {
98 : Word16 resbit, i1, i2;
99 :
100 : Dyn_Mem_Deluxe_In(Encoder_State_fx st; Word16 bp, bp_side, mask_side, extra_bits;
101 : Word32 a1, b1, a1_i, b1_i, a1_msb, b1_msb; Word16 lev1; Word16 nbits_side; Word16 tmp;
102 : Word16 fill_bits; UWord8 * ptr; Word16 numResBitsEnc; Word16 * lsb, nlsbs; Word32 i, n, k, lev;);
103 :
104 0 : lsb = (Word16 *)scratchAlign(scratchBuffer, 0); /* size = 2 * lastnz */
105 :
106 : /* Init */
107 0 : a1_i = 0;
108 0 : move16();
109 0 : b1_i = 1;
110 0 : move16();
111 0 : bp = 0;
112 0 : move16();
113 0 : numResBitsEnc = 0;
114 0 : move16();
115 0 : nlsbs = 0;
116 0 : move16();
117 0 : ptr = bytes;
118 0 : bp_side = bp_side_in;
119 0 : move16();
120 0 : mask_side = mask_side_in;
121 0 : move16();
122 :
123 : /*Start Encoding*/
124 0 : ac_enc_init_fx(&st);
125 :
126 : /* TNS data */
127 0 : FOR (n = 0; n < tns_numfilters; n++)
128 : {
129 0 : IF (tns_order[n] > 0)
130 : {
131 0 : ac_encode_fx(ptr, &bp, &st, ac_tns_order_cumfreq[enable_lpc_weighting][tns_order[n] - 1],
132 0 : ac_tns_order_freq[enable_lpc_weighting][tns_order[n] - 1]);
133 0 : FOR (k = 0; k < tns_order[n]; k++)
134 : {
135 0 : ac_encode_fx(ptr, &bp, &st, ac_tns_coef_cumfreq[k][tns_idx[MAXLAG * n + k]],
136 0 : ac_tns_coef_freq[k][tns_idx[MAXLAG * n + k]]);
137 : }
138 : }
139 : }
140 :
141 0 : IF (lsbMode == 0)
142 : {
143 :
144 : /*Main Loop through the 2-tuples*/
145 0 : FOR (k = 0; k < lastnz; k += 2)
146 : {
147 0 : IF (codingdata[1] < 0)
148 : {
149 0 : ac_encode_fx(ptr, &bp, &st, 0,
150 0 : ari_spec_freq[ari_spec_lookup[codingdata[0]]][0]);
151 : }
152 0 : ELSE IF (codingdata[1] == 0)
153 : {
154 0 : ac_encode_fx(ptr, &bp, &st, ari_spec_cumfreq[ari_spec_lookup[codingdata[0]]][codingdata[2]],
155 0 : ari_spec_freq[ari_spec_lookup[codingdata[0]]][codingdata[2]]);
156 0 : IF (xq[a1_i] != 0)
157 : {
158 0 : write_bit_backward(ptr, &bp_side, &mask_side, L_lshr(xq[a1_i], 31));
159 : }
160 0 : IF (xq[b1_i] != 0)
161 : {
162 0 : write_bit_backward(ptr, &bp_side, &mask_side, L_lshr(xq[b1_i], 31));
163 : }
164 : }
165 0 : ELSE IF (sub(codingdata[1], 1) == 0)
166 : {
167 0 : ac_encode_fx(ptr, &bp, &st, ari_spec_cumfreq[ari_spec_lookup[codingdata[0]]][VAL_ESC],
168 0 : ari_spec_freq[ari_spec_lookup[codingdata[0]]][VAL_ESC]);
169 0 : ac_encode_fx(ptr, &bp, &st,
170 0 : ari_spec_cumfreq[ari_spec_lookup[codingdata[0] + Tab_esc_nb[1]]][codingdata[2]],
171 0 : ari_spec_freq[ari_spec_lookup[codingdata[0] + Tab_esc_nb[1]]][codingdata[2]]);
172 0 : write_bit_backward(ptr, &bp_side, &mask_side, L_and(xq[a1_i], 1));
173 0 : write_bit_backward(ptr, &bp_side, &mask_side, L_and(xq[b1_i], 1));
174 0 : IF (xq[a1_i] != 0)
175 : {
176 0 : write_bit_backward(ptr, &bp_side, &mask_side, L_lshr(xq[a1_i], 31));
177 : }
178 0 : IF (xq[b1_i] != 0)
179 : {
180 0 : write_bit_backward(ptr, &bp_side, &mask_side, L_lshr(xq[b1_i], 31));
181 : }
182 : }
183 : ELSE
184 : {
185 0 : a1 = L_abs(xq[a1_i]);
186 0 : b1 = L_abs(xq[b1_i]);
187 0 : FOR (lev = 0; lev < codingdata[1]; lev++)
188 : {
189 0 : lev1 = s_min(lev, 3);
190 0 : ac_encode_fx(ptr, &bp, &st,
191 0 : ari_spec_cumfreq[ari_spec_lookup[codingdata[0] + Tab_esc_nb[lev1]]][VAL_ESC],
192 0 : ari_spec_freq[ari_spec_lookup[codingdata[0] + Tab_esc_nb[lev1]]][VAL_ESC]);
193 0 : write_bit_backward(ptr, &bp_side, &mask_side, s_and(L_shr_pos(a1, lev), 1));
194 0 : write_bit_backward(ptr, &bp_side, &mask_side, s_and(L_shr_pos(b1, lev), 1));
195 : }
196 0 : lev1 = s_min(codingdata[1], 3);
197 0 : ac_encode_fx(ptr, &bp, &st,
198 0 : ari_spec_cumfreq[ari_spec_lookup[codingdata[0] + Tab_esc_nb[lev1]]][codingdata[2]],
199 0 : ari_spec_freq[ari_spec_lookup[codingdata[0] + Tab_esc_nb[lev1]]][codingdata[2]]);
200 0 : IF (xq[a1_i] != 0)
201 : {
202 0 : write_bit_backward(ptr, &bp_side, &mask_side, L_lshr(xq[a1_i], 31));
203 : }
204 0 : IF (xq[b1_i] != 0)
205 : {
206 0 : write_bit_backward(ptr, &bp_side, &mask_side, L_lshr(xq[b1_i], 31));
207 : }
208 : }
209 :
210 0 : a1_i += 2;
211 0 : b1_i += 2;
212 0 : codingdata += 3;
213 :
214 : } /*end of the 2-tuples loop*/
215 : }
216 : ELSE
217 : {
218 : /*Main Loop through the 2-tuples*/
219 0 : FOR (k = 0; k < lastnz; k += 2)
220 : {
221 0 : IF (codingdata[1] < 0)
222 : {
223 0 : ac_encode_fx(ptr, &bp, &st, 0,
224 0 : ari_spec_freq[ari_spec_lookup[codingdata[0]]][0]);
225 : }
226 0 : ELSE IF (codingdata[1] == 0)
227 : {
228 0 : ac_encode_fx(ptr, &bp, &st, ari_spec_cumfreq[ari_spec_lookup[codingdata[0]]][codingdata[2]],
229 0 : ari_spec_freq[ari_spec_lookup[codingdata[0]]][codingdata[2]]);
230 0 : IF (xq[a1_i] != 0)
231 : {
232 0 : write_bit_backward(ptr, &bp_side, &mask_side, L_lshr(xq[a1_i], 31));
233 : }
234 0 : IF (xq[b1_i] != 0)
235 : {
236 0 : write_bit_backward(ptr, &bp_side, &mask_side, L_lshr(xq[b1_i], 31));
237 : }
238 : }
239 0 : ELSE IF (sub(codingdata[1], 1) == 0)
240 : {
241 0 : ac_encode_fx(ptr, &bp, &st, ari_spec_cumfreq[ari_spec_lookup[codingdata[0]]][VAL_ESC],
242 0 : ari_spec_freq[ari_spec_lookup[codingdata[0]]][VAL_ESC]);
243 0 : ac_encode_fx(ptr, &bp, &st,
244 0 : ari_spec_cumfreq[ari_spec_lookup[codingdata[0] + Tab_esc_nb[1]]][codingdata[2]],
245 0 : ari_spec_freq[ari_spec_lookup[codingdata[0] + Tab_esc_nb[1]]][codingdata[2]]);
246 0 : a1_msb = s_and(codingdata[2], 0x3);
247 0 : tmp = L_and(xq[a1_i], 1);
248 0 : lsb[nlsbs++] = tmp;
249 0 : move16();
250 0 : test();
251 0 : IF (a1_msb == 0 && tmp > 0)
252 : {
253 0 : if (xq[a1_i] > 0)
254 : {
255 0 : lsb[nlsbs++] = 0;
256 0 : move16();
257 : }
258 0 : if (xq[a1_i] < 0)
259 : {
260 0 : lsb[nlsbs++] = 1;
261 0 : move16();
262 : }
263 : }
264 0 : IF (a1_msb != 0)
265 : {
266 0 : write_bit_backward(ptr, &bp_side, &mask_side, L_lshr(xq[a1_i], 31));
267 : }
268 0 : b1_msb = shr_pos(codingdata[2], 2);
269 0 : tmp = L_and(xq[b1_i], 1);
270 0 : lsb[nlsbs++] = tmp;
271 0 : move16();
272 0 : test();
273 0 : IF (b1_msb == 0 && tmp > 0)
274 : {
275 0 : if (xq[b1_i] > 0)
276 : {
277 0 : lsb[nlsbs++] = 0;
278 0 : move16();
279 : }
280 0 : if (xq[b1_i] < 0)
281 : {
282 0 : lsb[nlsbs++] = 1;
283 0 : move16();
284 : }
285 : }
286 0 : IF (b1_msb != 0)
287 : {
288 0 : write_bit_backward(ptr, &bp_side, &mask_side, L_lshr(xq[b1_i], 31));
289 : }
290 : }
291 : ELSE
292 : {
293 0 : a1 = L_abs(xq[a1_i]);
294 0 : b1 = L_abs(xq[b1_i]);
295 0 : a1_msb = L_shr_pos(a1, 1);
296 0 : tmp = L_and(a1, 1);
297 0 : lsb[nlsbs++] = tmp;
298 0 : move16();
299 0 : test();
300 0 : IF (a1_msb == 0 && tmp > 0)
301 : {
302 0 : if (xq[a1_i] > 0)
303 : {
304 0 : lsb[nlsbs++] = 0;
305 0 : move16();
306 : }
307 0 : if (xq[a1_i] < 0)
308 : {
309 0 : lsb[nlsbs++] = 1;
310 0 : move16();
311 : }
312 : }
313 0 : b1_msb = L_shr_pos(b1, 1);
314 0 : tmp = s_and(b1, 1);
315 0 : lsb[nlsbs++] = tmp;
316 0 : move16();
317 0 : test();
318 0 : IF (b1_msb == 0 && tmp > 0)
319 : {
320 0 : if (xq[b1_i] > 0)
321 : {
322 0 : lsb[nlsbs++] = 0;
323 0 : move16();
324 : }
325 0 : if (xq[b1_i] < 0)
326 : {
327 0 : lsb[nlsbs++] = 1;
328 0 : move16();
329 : }
330 : }
331 0 : ac_encode_fx(ptr, &bp, &st, ari_spec_cumfreq[ari_spec_lookup[codingdata[0] + Tab_esc_nb[0]]][VAL_ESC],
332 0 : ari_spec_freq[ari_spec_lookup[codingdata[0] + Tab_esc_nb[0]]][VAL_ESC]);
333 0 : FOR (lev = 1; lev < codingdata[1]; lev++)
334 : {
335 0 : lev1 = s_min(lev, 3);
336 0 : ac_encode_fx(ptr, &bp, &st,
337 0 : ari_spec_cumfreq[ari_spec_lookup[codingdata[0] + Tab_esc_nb[lev1]]][VAL_ESC],
338 0 : ari_spec_freq[ari_spec_lookup[codingdata[0] + Tab_esc_nb[lev1]]][VAL_ESC]);
339 0 : write_bit_backward(ptr, &bp_side, &mask_side, s_and(L_shr_pos(a1, lev), 1));
340 0 : write_bit_backward(ptr, &bp_side, &mask_side, s_and(L_shr_pos(b1, lev), 1));
341 : }
342 0 : lev1 = s_min(codingdata[1], 3);
343 0 : ac_encode_fx(ptr, &bp, &st,
344 0 : ari_spec_cumfreq[ari_spec_lookup[codingdata[0] + Tab_esc_nb[lev1]]][codingdata[2]],
345 0 : ari_spec_freq[ari_spec_lookup[codingdata[0] + Tab_esc_nb[lev1]]][codingdata[2]]);
346 0 : IF (a1_msb != 0)
347 : {
348 0 : write_bit_backward(ptr, &bp_side, &mask_side, L_lshr(xq[a1_i], 31));
349 : }
350 0 : IF (b1_msb != 0)
351 : {
352 0 : write_bit_backward(ptr, &bp_side, &mask_side, L_lshr(xq[b1_i], 31));
353 : }
354 : }
355 :
356 0 : a1_i += 2;
357 0 : b1_i += 2;
358 0 : codingdata += 3;
359 :
360 : } /*end of the 2-tuples loop*/
361 : }
362 :
363 : /* Side bits (in sync with the decoder) */
364 0 : nbits_side = sub(nbbits, add(shl_pos(bp_side, 3), sub(norm_s(mask_side), 6)));
365 :
366 : /* Residual bits (in sync with the decoder) */
367 0 : extra_bits = sub(norm_ul(st.ac_range_fx), 6);
368 0 : if (st.ac_cache_fx >= 0)
369 : {
370 0 : extra_bits = add(extra_bits, 8);
371 : }
372 0 : if (st.ac_carry_count_fx > 0)
373 : {
374 0 : extra_bits = add(extra_bits, shl_pos(st.ac_carry_count_fx, 3));
375 : }
376 :
377 0 : n = s_max(sub(nbbits, add(shl_pos(bp, 3), add(extra_bits, nbits_side))), 0);
378 0 : move16();
379 :
380 0 : IF (lsbMode == 0)
381 : {
382 0 : numResBitsEnc = s_min(numResBits, n);
383 0 : FOR (i = 0; i < numResBitsEnc; i++)
384 : {
385 0 : resbit = 0; move16();
386 0 : i1 = shr(i, RESBITS_PACK_SHIFT);
387 0 : i2 = s_and(i, RESBITS_PACK_MASK);
388 0 : if (s_and(resBits[i1], shl(1, i2)))
389 : {
390 0 : resbit = 1;
391 : }
392 0 : write_bit_backward(ptr, &bp_side, &mask_side, resbit);
393 : }
394 : }
395 : ELSE
396 : {
397 0 : nlsbs = s_min(nlsbs, n);
398 0 : FOR (k = 0; k < nlsbs; k++)
399 : {
400 0 : write_bit_backward(ptr, &bp_side, &mask_side, lsb[k]);
401 : }
402 : }
403 :
404 : /* End arithmetic coder, overflow management */
405 0 : extra_bits = ac_enc_finish_fx(ptr, &bp, &st);
406 :
407 : /* Fill bits (for debugging, the exact number of fill bits cannot be computed in the decoder)*/
408 0 : fill_bits = nbbits - (bp * 8 + extra_bits + nbits_side + nlsbs + numResBitsEnc);
409 :
410 : Dyn_Mem_Deluxe_Out();
411 :
412 0 : return fill_bits;
413 : }
414 :
415 : #else /* ENABLE_HR_MODE */
416 :
417 : Word16 processAriEncoder_fx(UWord8 *bytes, Word16 bp_side_in, Word16 mask_side_in, Word16 nbbits, Word16 xq[],
418 : Word16 *tns_order, Word16 tns_numfilters, Word16 *tns_idx, Word16 lastnz,
419 : Word16 *codingdata, UWord8 *resBits, Word16 numResBits, Word16 lsbMode,
420 : Word16 enable_lpc_weighting, Word8 *scratchBuffer)
421 : {
422 : #ifdef ENABLE_HR_MODE
423 : Dyn_Mem_Deluxe_In(Encoder_State_fx st; Word16 bp, bp_side, mask_side, extra_bits;
424 : Word16 a1, b1, a1_i, b1_i, a1_msb, b1_msb; Word16 lev1; Word16 nbits_side; Word16 tmp;
425 : Word16 fill_bits; UWord8 * ptr; Word16 numResBitsEnc; Word16 * lsb, nlsbs; Counter i, n, k, lev;
426 : );
427 : #else
428 : Dyn_Mem_Deluxe_In(Encoder_State_fx st; Word16 bp, bp_side, mask_side, extra_bits;
429 : Word16 a1, b1, a1_i, b1_i, a1_msb, b1_msb; Word16 lev1; Word16 nbits_side; Word16 tmp;
430 : Word16 fill_bits; UWord8 * ptr; Word16 numResBitsEnc; Word16 * lsb, nlsbs; Counter i, n, k, lev;
431 : );
432 : #endif
433 :
434 :
435 : lsb = (Word16 *)scratchAlign(scratchBuffer, 0); /* Size = 2 * MAX_LEN * 2 bytes */
436 :
437 : /* Init */
438 : a1_i = 0;
439 : move16();
440 : b1_i = 1;
441 : move16();
442 : bp = 0;
443 : move16();
444 : numResBitsEnc = 0;
445 : move16();
446 : nlsbs = 0;
447 : move16();
448 : ptr = bytes;
449 : bp_side = bp_side_in;
450 : move16();
451 : mask_side = mask_side_in;
452 : move16();
453 :
454 : /*Start Encoding*/
455 : ac_enc_init_fx(&st);
456 :
457 : /* TNS data */
458 : FOR (n = 0; n < tns_numfilters; n++)
459 : {
460 : IF (tns_order[n] > 0)
461 : {
462 : ac_encode_fx(ptr, &bp, &st, ac_tns_order_cumfreq[enable_lpc_weighting][tns_order[n] - 1],
463 : ac_tns_order_freq[enable_lpc_weighting][tns_order[n] - 1]);
464 : FOR (k = 0; k < tns_order[n]; k++)
465 : {
466 : ac_encode_fx(ptr, &bp, &st, ac_tns_coef_cumfreq[k][tns_idx[MAXLAG * n + k]],
467 : ac_tns_coef_freq[k][tns_idx[MAXLAG * n + k]]);
468 : }
469 : }
470 : }
471 :
472 : IF (lsbMode == 0)
473 : {
474 :
475 : /*Main Loop through the 2-tuples*/
476 : FOR (k = 0; k < lastnz; k += 2)
477 : {
478 : IF (codingdata[1] < 0)
479 : {
480 : ac_encode_fx(ptr, &bp, &st, ari_spec_cumfreq[ari_spec_lookup[codingdata[0]]][0],
481 : ari_spec_freq[ari_spec_lookup[codingdata[0]]][0]);
482 : }
483 : ELSE IF (codingdata[1] == 0)
484 : {
485 : ac_encode_fx(ptr, &bp, &st, ari_spec_cumfreq[ari_spec_lookup[codingdata[0]]][codingdata[2]],
486 : ari_spec_freq[ari_spec_lookup[codingdata[0]]][codingdata[2]]);
487 : IF (xq[a1_i] != 0)
488 : {
489 : write_bit_backward(ptr, &bp_side, &mask_side, lshr(xq[a1_i], 15));
490 : }
491 : IF (xq[b1_i] != 0)
492 : {
493 : write_bit_backward(ptr, &bp_side, &mask_side, lshr(xq[b1_i], 15));
494 : }
495 : }
496 : ELSE IF (sub(codingdata[1], 1) == 0)
497 : {
498 : ac_encode_fx(ptr, &bp, &st, ari_spec_cumfreq[ari_spec_lookup[codingdata[0]]][VAL_ESC],
499 : ari_spec_freq[ari_spec_lookup[codingdata[0]]][VAL_ESC]);
500 : ac_encode_fx(ptr, &bp, &st,
501 : ari_spec_cumfreq[ari_spec_lookup[codingdata[0] + Tab_esc_nb[1]]][codingdata[2]],
502 : ari_spec_freq[ari_spec_lookup[codingdata[0] + Tab_esc_nb[1]]][codingdata[2]]);
503 : write_bit_backward(ptr, &bp_side, &mask_side, s_and(xq[a1_i], 1));
504 : write_bit_backward(ptr, &bp_side, &mask_side, s_and(xq[b1_i], 1));
505 : IF (xq[a1_i] != 0)
506 : {
507 : write_bit_backward(ptr, &bp_side, &mask_side, lshr(xq[a1_i], 15));
508 : }
509 : IF (xq[b1_i] != 0)
510 : {
511 : write_bit_backward(ptr, &bp_side, &mask_side, lshr(xq[b1_i], 15));
512 : }
513 : }
514 : ELSE
515 : {
516 : a1 = abs_s(xq[a1_i]);
517 : b1 = abs_s(xq[b1_i]);
518 : FOR (lev = 0; lev < codingdata[1]; lev++)
519 : {
520 : lev1 = s_min(lev, 3);
521 : ac_encode_fx(ptr, &bp, &st,
522 : ari_spec_cumfreq[ari_spec_lookup[codingdata[0] + Tab_esc_nb[lev1]]][VAL_ESC],
523 : ari_spec_freq[ari_spec_lookup[codingdata[0] + Tab_esc_nb[lev1]]][VAL_ESC]);
524 : write_bit_backward(ptr, &bp_side, &mask_side, s_and(shr_pos(a1, lev), 1));
525 : write_bit_backward(ptr, &bp_side, &mask_side, s_and(shr_pos(b1, lev), 1));
526 : }
527 : lev1 = s_min(codingdata[1], 3);
528 : ac_encode_fx(ptr, &bp, &st,
529 : ari_spec_cumfreq[ari_spec_lookup[codingdata[0] + Tab_esc_nb[lev1]]][codingdata[2]],
530 : ari_spec_freq[ari_spec_lookup[codingdata[0] + Tab_esc_nb[lev1]]][codingdata[2]]);
531 : IF (xq[a1_i] != 0)
532 : {
533 : write_bit_backward(ptr, &bp_side, &mask_side, lshr(xq[a1_i], 15));
534 : }
535 : IF (xq[b1_i] != 0)
536 : {
537 : write_bit_backward(ptr, &bp_side, &mask_side, lshr(xq[b1_i], 15));
538 : }
539 : }
540 :
541 : a1_i += 2;
542 : b1_i += 2;
543 : codingdata += 3;
544 :
545 : } /*end of the 2-tuples loop*/
546 : }
547 : ELSE
548 : {
549 : /*Main Loop through the 2-tuples*/
550 : FOR (k = 0; k < lastnz; k += 2)
551 : {
552 : IF (codingdata[1] < 0)
553 : {
554 : ac_encode_fx(ptr, &bp, &st, ari_spec_cumfreq[ari_spec_lookup[codingdata[0]]][0],
555 : ari_spec_freq[ari_spec_lookup[codingdata[0]]][0]);
556 : }
557 : ELSE IF (codingdata[1] == 0)
558 : {
559 : ac_encode_fx(ptr, &bp, &st, ari_spec_cumfreq[ari_spec_lookup[codingdata[0]]][codingdata[2]],
560 : ari_spec_freq[ari_spec_lookup[codingdata[0]]][codingdata[2]]);
561 : IF (xq[a1_i] != 0)
562 : {
563 : write_bit_backward(ptr, &bp_side, &mask_side, lshr(xq[a1_i], 15));
564 : }
565 : IF (xq[b1_i] != 0)
566 : {
567 : write_bit_backward(ptr, &bp_side, &mask_side, lshr(xq[b1_i], 15));
568 : }
569 : }
570 : ELSE IF (sub(codingdata[1], 1) == 0)
571 : {
572 : ac_encode_fx(ptr, &bp, &st, ari_spec_cumfreq[ari_spec_lookup[codingdata[0]]][VAL_ESC],
573 : ari_spec_freq[ari_spec_lookup[codingdata[0]]][VAL_ESC]);
574 : ac_encode_fx(ptr, &bp, &st,
575 : ari_spec_cumfreq[ari_spec_lookup[codingdata[0] + Tab_esc_nb[1]]][codingdata[2]],
576 : ari_spec_freq[ari_spec_lookup[codingdata[0] + Tab_esc_nb[1]]][codingdata[2]]);
577 : a1_msb = s_and(codingdata[2], 0x3);
578 : tmp = s_and(xq[a1_i], 1);
579 : lsb[nlsbs++] = tmp;
580 : move16();
581 : test();
582 : IF (a1_msb == 0 && tmp > 0)
583 : {
584 : if (xq[a1_i] > 0)
585 : {
586 : lsb[nlsbs++] = 0;
587 : move16();
588 : }
589 : if (xq[a1_i] < 0)
590 : {
591 : lsb[nlsbs++] = 1;
592 : move16();
593 : }
594 : }
595 : IF (a1_msb != 0)
596 : {
597 : write_bit_backward(ptr, &bp_side, &mask_side, lshr(xq[a1_i], 15));
598 : }
599 : b1_msb = shr_pos(codingdata[2], 2);
600 : tmp = s_and(xq[b1_i], 1);
601 : lsb[nlsbs++] = tmp;
602 : move16();
603 : test();
604 : IF (b1_msb == 0 && tmp > 0)
605 : {
606 : if (xq[b1_i] > 0)
607 : {
608 : lsb[nlsbs++] = 0;
609 : move16();
610 : }
611 : if (xq[b1_i] < 0)
612 : {
613 : lsb[nlsbs++] = 1;
614 : move16();
615 : }
616 : }
617 : IF (b1_msb != 0)
618 : {
619 : write_bit_backward(ptr, &bp_side, &mask_side, lshr(xq[b1_i], 15));
620 : }
621 : }
622 : ELSE
623 : {
624 : a1 = abs_s(xq[a1_i]);
625 : b1 = abs_s(xq[b1_i]);
626 : a1_msb = shr_pos(a1, 1);
627 : tmp = s_and(a1, 1);
628 : lsb[nlsbs++] = tmp;
629 : move16();
630 : test();
631 : IF (a1_msb == 0 && tmp > 0)
632 : {
633 : if (xq[a1_i] > 0)
634 : {
635 : lsb[nlsbs++] = 0;
636 : move16();
637 : }
638 : if (xq[a1_i] < 0)
639 : {
640 : lsb[nlsbs++] = 1;
641 : move16();
642 : }
643 : }
644 : b1_msb = shr_pos(b1, 1);
645 : tmp = s_and(b1, 1);
646 : lsb[nlsbs++] = tmp;
647 : move16();
648 : test();
649 : IF (b1_msb == 0 && tmp > 0)
650 : {
651 : if (xq[b1_i] > 0)
652 : {
653 : lsb[nlsbs++] = 0;
654 : move16();
655 : }
656 : if (xq[b1_i] < 0)
657 : {
658 : lsb[nlsbs++] = 1;
659 : move16();
660 : }
661 : }
662 : ac_encode_fx(ptr, &bp, &st, ari_spec_cumfreq[ari_spec_lookup[codingdata[0] + Tab_esc_nb[0]]][VAL_ESC],
663 : ari_spec_freq[ari_spec_lookup[codingdata[0] + Tab_esc_nb[0]]][VAL_ESC]);
664 : FOR (lev = 1; lev < codingdata[1]; lev++)
665 : {
666 : lev1 = s_min(lev, 3);
667 : ac_encode_fx(ptr, &bp, &st,
668 : ari_spec_cumfreq[ari_spec_lookup[codingdata[0] + Tab_esc_nb[lev1]]][VAL_ESC],
669 : ari_spec_freq[ari_spec_lookup[codingdata[0] + Tab_esc_nb[lev1]]][VAL_ESC]);
670 : write_bit_backward(ptr, &bp_side, &mask_side, s_and(shr_pos(a1, lev), 1));
671 : write_bit_backward(ptr, &bp_side, &mask_side, s_and(shr_pos(b1, lev), 1));
672 : }
673 : lev1 = s_min(codingdata[1], 3);
674 : ac_encode_fx(ptr, &bp, &st,
675 : ari_spec_cumfreq[ari_spec_lookup[codingdata[0] + Tab_esc_nb[lev1]]][codingdata[2]],
676 : ari_spec_freq[ari_spec_lookup[codingdata[0] + Tab_esc_nb[lev1]]][codingdata[2]]);
677 : IF (a1_msb != 0)
678 : {
679 : write_bit_backward(ptr, &bp_side, &mask_side, lshr(xq[a1_i], 15));
680 : }
681 : IF (b1_msb != 0)
682 : {
683 : write_bit_backward(ptr, &bp_side, &mask_side, lshr(xq[b1_i], 15));
684 : }
685 : }
686 :
687 : a1_i += 2;
688 : b1_i += 2;
689 : codingdata += 3;
690 :
691 : } /*end of the 2-tuples loop*/
692 : }
693 :
694 : /* Side bits (in sync with the decoder) */
695 : nbits_side = sub(nbbits, add(shl_pos(bp_side, 3), sub(norm_s(mask_side), 6)));
696 :
697 : /* Residual bits (in sync with the decoder) */
698 : extra_bits = sub(norm_ul(st.ac_range_fx), 6);
699 : if (st.ac_cache_fx >= 0)
700 : {
701 : extra_bits = add(extra_bits, 8);
702 : }
703 : if (st.ac_carry_count_fx > 0)
704 : {
705 : extra_bits = add(extra_bits, shl_pos(st.ac_carry_count_fx, 3));
706 : }
707 :
708 : n = s_max(sub(nbbits, add(shl_pos(bp, 3), add(extra_bits, nbits_side))), 0);
709 : move16();
710 :
711 : IF (lsbMode == 0)
712 : {
713 : numResBitsEnc = s_min(numResBits, n);
714 : FOR (i = 0; i < numResBitsEnc; i++)
715 : {
716 : FOR (i = 0; i < numResBitsEnc; i++)
717 : {
718 : write_bit_backward(ptr, &bp_side, &mask_side, resBits[i]);
719 : }
720 : }
721 : }
722 : ELSE
723 : {
724 : nlsbs = s_min(nlsbs, n);
725 : FOR (k = 0; k < nlsbs; k++)
726 : {
727 : write_bit_backward(ptr, &bp_side, &mask_side, lsb[k]);
728 : }
729 : }
730 :
731 : /* End arithmetic coder, overflow management */
732 : extra_bits = ac_enc_finish_fx(ptr, &bp, &st);
733 :
734 : /* Fill bits (for debugging, the exact number of fill bits cannot be computed in the decoder)*/
735 : fill_bits = nbbits - (bp * 8 + extra_bits + nbits_side + nlsbs + numResBitsEnc);
736 :
737 : Dyn_Mem_Deluxe_Out();
738 : return fill_bits;
739 : }
740 :
741 : #endif /* ENABLE_HR_MODE */
742 :
743 0 : void processAriDecoder_fx(UWord8 *bytes, Word16 *bp_side, Word16 *mask_side, Word16 nbbits, Word16 L_spec,
744 : Word16 fs_idx, Word16 enable_lpc_weighting, Word16 tns_numfilters, Word16 lsbMode,
745 : Word16 lastnz, Word16 *bfi, Word16 *tns_order, Word16 fac_ns_idx, Word16 gg_idx,
746 : Word16 frame_dms,
747 : Word16 n_pc, Word16 be_bp_left, Word16 be_bp_right, Word16 mode, Word16 *spec_inv_idx,
748 : Word16 *b_left,
749 : Word16 *resBits,
750 : #ifdef ENABLE_HR_MODE
751 : Word32 *x,
752 : #else
753 : Word16 *x,
754 : #endif
755 : Word16 *nf_seed, UWord8 *resQdata, Word16 *tns_idx, Word16 *zero_frame, Word8 *scratchBuffer
756 : #ifdef ENABLE_HR_MODE
757 : , Word16 hrmode
758 : #endif
759 : )
760 : {
761 : Decoder_State_fx st;
762 : #ifdef ENABLE_HR_MODE
763 : Word16 resbit, i1, i2;
764 : Word32 a, b;
765 : #else
766 : Word16 a, b;
767 : #endif
768 : Word16 t, a1, b1, a1_i, b1_i, bp;
769 : Word16 esc_nb;
770 : Word16 rateFlag;
771 : Word16 r;
772 : Word16 nt_half;
773 : Word16 c;
774 : Word16 nbits_side, extra_bits, nbits_ari;
775 : UWord8 * ptr;
776 : Word32 tmp32;
777 : Word16 lsb_ind_c;
778 : Word16 * lsb_ind;
779 : Word16 tmp;
780 : Word32 n, k, lev;
781 : Word32 i;
782 0 : Word16 max_lev = 14;
783 :
784 : #ifdef DYNMEM_COUNT
785 : struct _dynmem
786 : {
787 : Decoder_State_fx st;
788 : Pc_State_fx pc;
789 : Word16 resbit, i1, i2;
790 : #ifdef ENABLE_HR_MODE
791 : Word32 a, b;
792 : #else
793 : Word16 a, b;
794 : #endif
795 : Word16 t, a1, b1, a1_i, b1_i, bp;
796 : Word16 esc_nb;
797 : Word16 rateFlag;
798 : Word16 r;
799 : Word16 nt_half;
800 : Word16 c;
801 : Word16 nbits_side, extra_bits, nbits_ari;
802 : UWord8 * ptr;
803 : Word32 tmp32;
804 : Word16 lsb_ind_c;
805 : Word16 * lsb_ind;
806 : Word16 tmp;
807 : Counter i, n, k, lev;
808 : };
809 : Dyn_Mem_In("processAriDecoder_fx", sizeof(struct _dynmem));
810 : #endif
811 :
812 : #ifdef ENABLE_HR_MODE
813 0 : if (hrmode == 1)
814 : {
815 0 : max_lev = max_lev + 8;
816 : }
817 : #endif
818 :
819 0 : lsb_ind = (Word16 *)scratchAlign(scratchBuffer, 0); /* Size 2 * MAX_LEN bytes */
820 :
821 : /* Rate flag */
822 0 : rateFlag = 0;
823 0 : move16();
824 : #ifdef ENABLE_HR_MODE
825 0 : if (fs_idx != 5) /* Don't update rateFlag for 96000 Hz */
826 : #endif
827 : {
828 0 : if (sub(nbbits, add(160, DEPR_i_mult(fs_idx, 160))) > 0)
829 : {
830 0 : rateFlag = 2 << NBITS_CONTEXT;
831 0 : move16();
832 : }
833 : }
834 :
835 0 : pc_init_fx(n_pc, shr_pos(nbbits, 3), be_bp_left, be_bp_right, L_spec, mode==1, mode==2, *bfi, &st.pc);
836 :
837 : /* Init */
838 0 : nt_half = shr_pos(L_spec, 1);
839 0 : c = 0;
840 0 : move16();
841 0 : t = 0;
842 0 : move16();
843 0 : a1_i = 0;
844 0 : move16();
845 0 : b1_i = 1;
846 0 : move16();
847 0 : bp = 0;
848 0 : move16();
849 0 : if (mode != 1)
850 : {
851 0 : bp = add(bp, st.pc.bytes);
852 0 : move16();
853 : }
854 0 : *spec_inv_idx = L_spec;
855 0 : move16();
856 0 : *b_left = -1;
857 0 : move16();
858 0 : lsb_ind_c = 0;
859 0 : move16();
860 :
861 0 : ptr = bytes;
862 :
863 : /* Start Decoding */
864 0 : ac_dec_init_fx(ptr, &bp, bp_side, mask_side, &st);
865 :
866 : /* Decode TNS data */
867 0 : tmp = MAXLAG;
868 0 : IF (sub(frame_dms, 25) == 0)
869 : {
870 0 : tmp = shr_pos(tmp, 1);
871 : }
872 0 : IF (sub(frame_dms, 50) == 0)
873 : {
874 0 : tmp = shr_pos(tmp, 1);
875 : }
876 :
877 0 : FOR (n = 0; n < tns_numfilters; n++)
878 : {
879 0 : IF (tns_order[n] > 0)
880 : {
881 0 : tns_order[n] = ac_decode_tns_order(&st, enable_lpc_weighting);
882 0 : move16();
883 0 : tns_order[n] = add(tns_order[n], 1);
884 0 : move16();
885 0 : IF (tns_order[n] > tmp)
886 : {
887 0 : GOTO ber_detect;
888 : }
889 0 : if (ac_dec_update_fx(ptr, &bp, bp_side, mask_side, 0, &st,
890 0 : ac_tns_order_cumfreq[enable_lpc_weighting][tns_order[n] - 1],
891 0 : ac_tns_order_freq[enable_lpc_weighting][tns_order[n] - 1]) != 0)
892 : {
893 0 : GOTO ber_detect;
894 : }
895 0 : FOR (k = 0; k < tns_order[n]; k++)
896 : {
897 0 : IF (sub(*bp_side, bp) < 0)
898 : {
899 0 : GOTO ber_detect;
900 : }
901 0 : tns_idx[MAXLAG * n + k] = ac_decode_tns_coef(&st, k);
902 0 : move16();
903 0 : if (ac_dec_update_fx(ptr, &bp, bp_side, mask_side, 0, &st,
904 0 : ac_tns_coef_cumfreq[k][tns_idx[MAXLAG * n + k]],
905 0 : ac_tns_coef_freq[k][tns_idx[MAXLAG * n + k]]) != 0)
906 : {
907 0 : GOTO ber_detect;
908 : }
909 : }
910 : }
911 : }
912 0 : IF (st.BER_detect > 0)
913 : {
914 0 : GOTO ber_detect;
915 : }
916 :
917 0 : IF (lsbMode == 0)
918 : {
919 :
920 : /*Main Loop through the 2-tuples*/
921 0 : FOR (k = 0; k < lastnz; k += 2)
922 : {
923 :
924 : /* Get context */
925 0 : t = add(c, rateFlag);
926 0 : if (sub(k, nt_half) > 0)
927 : {
928 0 : t = add(t, 1 << NBITS_CONTEXT);
929 : }
930 :
931 0 : r = ac_decode_fx(&st, ari_spec_lookup[t]);
932 0 : if (ac_dec_update_fx(ptr, &bp, bp_side, mask_side, k, &st, ari_spec_cumfreq[ari_spec_lookup[t]][r],
933 0 : ari_spec_freq[ari_spec_lookup[t]][r]) != 0)
934 : {
935 0 : GOTO ber_detect;
936 : }
937 :
938 0 : IF (r == 0)
939 : {
940 0 : x[a1_i] = 0;
941 0 : move16();
942 0 : x[b1_i] = 0;
943 0 : move16();
944 0 : c = add(shl_pos(s_and(c, 0xf), 4), 1);
945 : }
946 0 : ELSE IF (sub(r, VAL_ESC) < 0)
947 : {
948 0 : a = s_and(r, 0x3);
949 0 : b = shr_pos(r, 2);
950 0 : c = add(shl_pos(s_and(c, 0xf), 4), add(add(a, b), 1));
951 0 : IF (a > 0)
952 : {
953 0 : if (check_pc_bytes(&bp, bp_side, mask_side, a1_i, 0, &st.pc) != 0)
954 : {
955 0 : GOTO ber_detect;
956 : }
957 0 : if (read_bit(ptr, bp_side, mask_side) != 0)
958 : {
959 0 : a = negate(a);
960 : }
961 : }
962 0 : x[a1_i] = a;
963 0 : move16();
964 0 : IF (b > 0)
965 : {
966 0 : if (check_pc_bytes(&bp, bp_side, mask_side, b1_i, 0, &st.pc) != 0)
967 : {
968 0 : GOTO ber_detect;
969 : }
970 0 : if (read_bit(ptr, bp_side, mask_side) != 0)
971 : {
972 0 : b = negate(b);
973 : }
974 : }
975 0 : x[b1_i] = b;
976 0 : move16();
977 : }
978 : ELSE
979 : {
980 0 : if (check_pc_bytes(&bp, bp_side, mask_side, a1_i, 0, &st.pc) != 0)
981 : {
982 0 : GOTO ber_detect;
983 : }
984 0 : a = read_bit(ptr, bp_side, mask_side);
985 0 : if (check_pc_bytes(&bp, bp_side, mask_side, a1_i, 0, &st.pc) != 0)
986 : {
987 0 : GOTO ber_detect;
988 : }
989 0 : b = read_bit(ptr, bp_side, mask_side);
990 0 : r = ac_decode_fx(&st, ari_spec_lookup[t + Tab_esc_nb[1]]);
991 0 : if (ac_dec_update_fx(ptr, &bp, bp_side, mask_side, k, &st,
992 0 : ari_spec_cumfreq[ari_spec_lookup[t + Tab_esc_nb[1]]][r],
993 0 : ari_spec_freq[ari_spec_lookup[t + Tab_esc_nb[1]]][r]) != 0)
994 : {
995 0 : GOTO ber_detect;
996 : }
997 0 : IF (sub(r, VAL_ESC) < 0)
998 : {
999 0 : a1 = s_and(r, 0x3);
1000 0 : b1 = shr_pos(r, 2);
1001 0 : a = add(shl_pos(a1, 1), a);
1002 0 : b = add(shl_pos(b1, 1), b);
1003 0 : IF (a > 0)
1004 : {
1005 0 : if (check_pc_bytes(&bp, bp_side, mask_side, a1_i, 0, &st.pc) != 0)
1006 : {
1007 0 : GOTO ber_detect;
1008 : }
1009 0 : if (read_bit(ptr, bp_side, mask_side) != 0)
1010 : {
1011 0 : a = negate(a);
1012 : }
1013 : }
1014 0 : x[a1_i] = a;
1015 0 : move16();
1016 0 : IF (b > 0)
1017 : {
1018 0 : if (check_pc_bytes(&bp, bp_side, mask_side, b1_i, 0, &st.pc) != 0)
1019 : {
1020 0 : GOTO ber_detect;
1021 : }
1022 0 : if (read_bit(ptr, bp_side, mask_side) != 0)
1023 : {
1024 0 : b = negate(b);
1025 : }
1026 : }
1027 0 : x[b1_i] = b;
1028 0 : move16();
1029 0 : c = add(shl_pos(s_and(c, 0xf), 4), add(shl_pos(add(a1, b1), 1), 1));
1030 : }
1031 : ELSE
1032 : {
1033 0 : if (check_pc_bytes(&bp, bp_side, mask_side, a1_i, 0, &st.pc) != 0)
1034 : {
1035 0 : GOTO ber_detect;
1036 : }
1037 0 : a = add(shl_pos(read_bit(ptr, bp_side, mask_side), 1), a);
1038 0 : if (check_pc_bytes(&bp, bp_side, mask_side, a1_i, 0, &st.pc) != 0)
1039 : {
1040 0 : GOTO ber_detect;
1041 : }
1042 0 : b = add(shl_pos(read_bit(ptr, bp_side, mask_side), 1), b);
1043 0 : FOR (lev = 2; lev < max_lev; lev++)
1044 : {
1045 0 : esc_nb = s_min(lev, 3);
1046 0 : r = ac_decode_fx(&st, ari_spec_lookup[t + Tab_esc_nb[esc_nb]]);
1047 0 : if (ac_dec_update_fx(ptr, &bp, bp_side, mask_side, k, &st,
1048 0 : ari_spec_cumfreq[ari_spec_lookup[t + Tab_esc_nb[esc_nb]]][r],
1049 0 : ari_spec_freq[ari_spec_lookup[t + Tab_esc_nb[esc_nb]]][r]) != 0)
1050 : {
1051 0 : GOTO ber_detect;
1052 : }
1053 0 : IF (sub(r, VAL_ESC) < 0)
1054 : {
1055 0 : BREAK;
1056 : }
1057 0 : if (check_pc_bytes(&bp, bp_side, mask_side, a1_i, 0, &st.pc) != 0)
1058 : {
1059 0 : GOTO ber_detect;
1060 : }
1061 :
1062 : #ifdef ENABLE_HR_MODE
1063 0 : a = L_add(L_shl(read_bit(ptr, bp_side, mask_side), lev), a);
1064 : #else
1065 : a = add(shl(read_bit(ptr, bp_side, mask_side), lev), a);
1066 : #endif
1067 :
1068 0 : if (check_pc_bytes(&bp, bp_side, mask_side, a1_i, 0, &st.pc) != 0)
1069 : {
1070 0 : GOTO ber_detect;
1071 : }
1072 : #ifdef ENABLE_HR_MODE
1073 0 : b = L_add(L_shl(read_bit(ptr, bp_side, mask_side), lev), b);
1074 : #else
1075 : b = add(shl(read_bit(ptr, bp_side, mask_side), lev), b);
1076 : #endif
1077 : }
1078 : /* check for bitflip */
1079 0 : IF (sub(lev, max_lev) == 0)
1080 : {
1081 0 : GOTO ber_detect;
1082 : }
1083 :
1084 0 : b1 = shr_pos(r, 2);
1085 0 : a1 = s_and(r, 0x3);
1086 :
1087 : #ifdef ENABLE_HR_MODE
1088 0 : a = L_add(L_shl(a1, lev), a);
1089 0 : b = L_add(L_shl(b1, lev), b);
1090 : #else
1091 : a = add(shl(a1, lev), a);
1092 : b = add(shl(b1, lev), b);
1093 : #endif
1094 0 : IF (a > 0)
1095 : {
1096 0 : if (check_pc_bytes(&bp, bp_side, mask_side, a1_i, 0, &st.pc) != 0)
1097 : {
1098 0 : GOTO ber_detect;
1099 : }
1100 0 : if (read_bit(ptr, bp_side, mask_side) != 0)
1101 : {
1102 : #ifdef ENABLE_HR_MODE
1103 0 : a = L_negate(a);
1104 : #else
1105 : a = negate(a);
1106 : #endif
1107 : }
1108 : }
1109 0 : x[a1_i] = a;
1110 0 : move16();
1111 0 : IF (b > 0)
1112 : {
1113 0 : if (check_pc_bytes(&bp, bp_side, mask_side, b1_i, 0, &st.pc) != 0)
1114 : {
1115 0 : GOTO ber_detect;
1116 : }
1117 0 : if (read_bit(ptr, bp_side, mask_side) != 0)
1118 : {
1119 : #ifdef ENABLE_HR_MODE
1120 0 : b = L_negate(b);
1121 : #else
1122 : b = negate(b);
1123 : #endif
1124 : }
1125 : }
1126 0 : x[b1_i] = b;
1127 0 : move16();
1128 0 : c = add(shl_pos(s_and(c, 0xf), 4), add(esc_nb, 12));
1129 : }
1130 : }
1131 :
1132 0 : test();
1133 0 : test();
1134 0 : IF ((sub(sub(bp, *bp_side), 3) > 0 && sub(st.pc.c_bp, st.pc.c_bp_side) == 0) || st.BER_detect > 0)
1135 : {
1136 0 : GOTO ber_detect;
1137 : }
1138 :
1139 0 : a1_i += 2;
1140 0 : b1_i += 2;
1141 : }
1142 : }
1143 : ELSE
1144 : {
1145 : /*Main Loop through the 2-tuples*/
1146 0 : FOR (k = 0; k < lastnz; k += 2)
1147 : {
1148 :
1149 : /* Get context */
1150 0 : t = add(c, rateFlag);
1151 0 : if (sub(k, nt_half) > 0)
1152 : {
1153 0 : t = add(t, 1 << NBITS_CONTEXT);
1154 : }
1155 :
1156 0 : r = ac_decode_fx(&st, ari_spec_lookup[t]);
1157 0 : if (ac_dec_update_fx(ptr, &bp, bp_side, mask_side, k, &st, ari_spec_cumfreq[ari_spec_lookup[t]][r],
1158 0 : ari_spec_freq[ari_spec_lookup[t]][r]) != 0)
1159 : {
1160 0 : GOTO ber_detect;
1161 : }
1162 :
1163 0 : IF (r == 0)
1164 : {
1165 0 : x[a1_i] = 0;
1166 0 : move16();
1167 0 : x[b1_i] = 0;
1168 0 : move16();
1169 0 : c = add(shl_pos(s_and(c, 0xf), 4), 1);
1170 : }
1171 0 : ELSE IF (sub(r, VAL_ESC) < 0)
1172 : {
1173 0 : a = s_and(r, 0x3);
1174 0 : b = shr_pos(r, 2);
1175 0 : c = add(shl_pos(s_and(c, 0xf), 4), add(add(a, b), 1));
1176 0 : IF (a > 0)
1177 : {
1178 0 : if (check_pc_bytes(&bp, bp_side, mask_side, a1_i, 0, &st.pc) != 0)
1179 : {
1180 0 : GOTO ber_detect;
1181 : }
1182 0 : if (read_bit(ptr, bp_side, mask_side) != 0)
1183 : {
1184 0 : a = negate(a);
1185 : }
1186 : }
1187 0 : x[a1_i] = a;
1188 0 : move16();
1189 0 : IF (b > 0)
1190 : {
1191 0 : if (check_pc_bytes(&bp, bp_side, mask_side, b1_i, 0, &st.pc) != 0)
1192 : {
1193 0 : GOTO ber_detect;
1194 : }
1195 0 : if (read_bit(ptr, bp_side, mask_side) != 0)
1196 : {
1197 0 : b = negate(b);
1198 : }
1199 : }
1200 0 : x[b1_i] = b;
1201 0 : move16();
1202 : }
1203 : ELSE
1204 : {
1205 0 : r = ac_decode_fx(&st, ari_spec_lookup[t + Tab_esc_nb[1]]);
1206 0 : if (ac_dec_update_fx(ptr, &bp, bp_side, mask_side, k, &st,
1207 0 : ari_spec_cumfreq[ari_spec_lookup[t + Tab_esc_nb[1]]][r],
1208 0 : ari_spec_freq[ari_spec_lookup[t + Tab_esc_nb[1]]][r]) != 0)
1209 : {
1210 0 : GOTO ber_detect;
1211 : }
1212 0 : IF (sub(r, VAL_ESC) < 0)
1213 : {
1214 0 : a1 = s_and(r, 0x3);
1215 0 : b1 = shr_pos(r, 2);
1216 0 : a = shl_pos(a1, 1);
1217 0 : b = shl_pos(b1, 1);
1218 0 : IF (a > 0)
1219 : {
1220 0 : if (check_pc_bytes(&bp, bp_side, mask_side, a1_i, 0, &st.pc) != 0)
1221 : {
1222 0 : GOTO ber_detect;
1223 : }
1224 0 : if (read_bit(ptr, bp_side, mask_side) != 0)
1225 : {
1226 0 : a = negate(a);
1227 : }
1228 : }
1229 0 : x[a1_i] = a;
1230 0 : move16();
1231 0 : IF (b > 0)
1232 : {
1233 0 : if (check_pc_bytes(&bp, bp_side, mask_side, b1_i, 0, &st.pc) != 0)
1234 : {
1235 0 : GOTO ber_detect;
1236 : }
1237 0 : if (read_bit(ptr, bp_side, mask_side) != 0)
1238 : {
1239 0 : b = negate(b);
1240 : }
1241 : }
1242 0 : x[b1_i] = b;
1243 0 : move16();
1244 0 : c = add(shl_pos(s_and(c, 0xf), 4), add(shl_pos(add(a1, b1), 1), 1));
1245 0 : lsb_ind[lsb_ind_c++] = k;
1246 0 : move16();
1247 : }
1248 : ELSE
1249 : {
1250 0 : if (check_pc_bytes(&bp, bp_side, mask_side, a1_i, 0, &st.pc) != 0)
1251 : {
1252 0 : GOTO ber_detect;
1253 : }
1254 0 : a = shl_pos(read_bit(ptr, bp_side, mask_side), 1);
1255 0 : if (check_pc_bytes(&bp, bp_side, mask_side, a1_i, 0, &st.pc) != 0)
1256 : {
1257 0 : GOTO ber_detect;
1258 : }
1259 0 : b = shl_pos(read_bit(ptr, bp_side, mask_side), 1);
1260 0 : FOR (lev = 2; lev < max_lev; lev++)
1261 : {
1262 0 : esc_nb = s_min(lev, 3);
1263 0 : r = ac_decode_fx(&st, ari_spec_lookup[t + Tab_esc_nb[esc_nb]]);
1264 0 : if (ac_dec_update_fx(ptr, &bp, bp_side, mask_side, k, &st,
1265 0 : ari_spec_cumfreq[ari_spec_lookup[t + Tab_esc_nb[esc_nb]]][r],
1266 0 : ari_spec_freq[ari_spec_lookup[t + Tab_esc_nb[esc_nb]]][r]) != 0)
1267 : {
1268 0 : GOTO ber_detect;
1269 : }
1270 0 : IF (sub(r, VAL_ESC) < 0)
1271 : {
1272 0 : BREAK;
1273 : }
1274 0 : if (check_pc_bytes(&bp, bp_side, mask_side, a1_i, 0, &st.pc) != 0)
1275 : {
1276 0 : GOTO ber_detect;
1277 : }
1278 : #ifdef ENABLE_HR_MODE
1279 0 : a = L_add(L_shl(read_bit(ptr, bp_side, mask_side), lev), a);
1280 : #else
1281 : a = add(shl(read_bit(ptr, bp_side, mask_side), lev), a);
1282 : #endif
1283 0 : if (check_pc_bytes(&bp, bp_side, mask_side, a1_i, 0, &st.pc) != 0)
1284 : {
1285 0 : GOTO ber_detect;
1286 : }
1287 : #ifdef ENABLE_HR_MODE
1288 0 : b = L_add(L_shl(read_bit(ptr, bp_side, mask_side), lev), b);
1289 : #else
1290 : b = add(shl(read_bit(ptr, bp_side, mask_side), lev), b);
1291 : #endif
1292 : }
1293 : /* check for bitflip */
1294 0 : IF (sub(lev, max_lev) == 0)
1295 : {
1296 0 : GOTO ber_detect;
1297 : }
1298 :
1299 0 : b1 = shr_pos(r, 2);
1300 0 : a1 = s_and(r, 0x3);
1301 : #ifdef ENABLE_HR_MODE
1302 0 : a = L_add(L_shl(a1, lev), a);
1303 0 : b = L_add(L_shl(b1, lev), b);
1304 : #else
1305 : a = add(shl(a1, lev), a);
1306 : b = add(shl(b1, lev), b);
1307 : #endif
1308 0 : IF (a > 0)
1309 : {
1310 0 : if (check_pc_bytes(&bp, bp_side, mask_side, a1_i, 0, &st.pc) != 0)
1311 : {
1312 0 : GOTO ber_detect;
1313 : }
1314 0 : if (read_bit(ptr, bp_side, mask_side) != 0)
1315 : {
1316 : #ifdef ENABLE_HR_MODE
1317 0 : a = L_negate(a);
1318 : #else
1319 : a = negate(a);
1320 : #endif
1321 : }
1322 : }
1323 0 : x[a1_i] = a;
1324 0 : move16();
1325 0 : IF (b > 0)
1326 : {
1327 0 : if (check_pc_bytes(&bp, bp_side, mask_side, b1_i, 0, &st.pc) != 0)
1328 : {
1329 0 : GOTO ber_detect;
1330 : }
1331 0 : if (read_bit(ptr, bp_side, mask_side) != 0)
1332 : {
1333 : #ifdef ENABLE_HR_MODE
1334 0 : b = L_negate(b);
1335 : #else
1336 : b = negate(b);
1337 : #endif
1338 : }
1339 : }
1340 0 : x[b1_i] = b;
1341 0 : move16();
1342 0 : c = add(shl_pos(s_and(c, 0xf), 4), add(esc_nb, 12));
1343 0 : lsb_ind[lsb_ind_c++] = k;
1344 0 : move16();
1345 : }
1346 : }
1347 :
1348 0 : test();
1349 0 : test();
1350 0 : IF ((sub(sub(bp, *bp_side), 3) > 0 && sub(st.pc.c_bp, st.pc.c_bp_side) == 0) || st.BER_detect > 0)
1351 : {
1352 0 : GOTO ber_detect;
1353 : }
1354 :
1355 0 : a1_i += 2;
1356 0 : b1_i += 2;
1357 : }
1358 : }
1359 :
1360 0 : IF (L_spec > k)
1361 : {
1362 0 : basop_memset(&x[k], 0, (L_spec - k) * sizeof(*x));
1363 : }
1364 :
1365 0 : nbits_side = sub(nbbits, add(shl_pos(*bp_side, 3), sub(norm_s(*mask_side), 6)));
1366 0 : extra_bits = sub(norm_ul(st.ac_range_fx), 6);
1367 0 : nbits_ari = shl_pos(sub(bp, 3), 3);
1368 0 : IF (mode != 1)
1369 : {
1370 0 : IF (st.pc.c_bp == 0)
1371 : {
1372 0 : nbits_ari = shl_pos(sub(sub(bp, st.pc.bytes), 3), 3);
1373 : }
1374 : ELSE
1375 : {
1376 0 : nbits_ari = shl_pos(add(bp, sub(sub(st.pc.b_left, st.pc.bytes), 3)), 3);
1377 : }
1378 :
1379 0 : IF (st.pc.c_bp_side != 0)
1380 : {
1381 0 : nbits_side = sub(add(sub(nbbits, shl_pos(st.pc.b_left, 3)), shl_pos(sub(st.pc.bytes, *bp_side), 3)),
1382 0 : sub(norm_s(*mask_side), 6));
1383 : }
1384 : }
1385 :
1386 0 : n = sub(nbbits, add(nbits_ari, add(extra_bits, nbits_side)));
1387 0 : move16();
1388 :
1389 0 : IF (n < 0)
1390 : {
1391 0 : GOTO ber_detect;
1392 : }
1393 :
1394 0 : IF (lsbMode == 0)
1395 : {
1396 0 : *resBits = n;
1397 0 : move16();
1398 0 : i=0;
1399 :
1400 : #ifdef ENABLE_HR_MODE
1401 0 : FOR (k = 0; k < L_spec; k++)
1402 : {
1403 0 : IF (x[k] != 0)
1404 : {
1405 0 : IF (n == 0)
1406 : {
1407 0 : BREAK;
1408 : }
1409 0 : if (check_pc_bytes(&bp, bp_side, mask_side, st.pc.inv_bin, 0, &st.pc) != 0)
1410 : {
1411 0 : GOTO ber_detect_res;
1412 : }
1413 0 : i1 = shr(i, RESBITS_PACK_SHIFT);
1414 0 : i2 = s_and(i, RESBITS_PACK_MASK);
1415 0 : resbit = read_bit(ptr, bp_side, mask_side);
1416 0 : if (resbit)
1417 : {
1418 0 : resQdata[i1] = (UWord8) s_or(resQdata[i1], shl(1, i2));
1419 : }
1420 0 : i = add(i, 1);
1421 0 : move16();
1422 0 : n = sub(n, 1);
1423 : }
1424 : }
1425 : #else
1426 : FOR (k = 0; k < L_spec; k++)
1427 : {
1428 : IF (x[k] != 0)
1429 : {
1430 : IF (n == 0)
1431 : {
1432 : BREAK;
1433 : }
1434 :
1435 : if (check_pc_bytes(&bp, bp_side, mask_side, st.pc.inv_bin, 0, &st.pc) != 0)
1436 : {
1437 : GOTO ber_detect_res;
1438 : }
1439 :
1440 : *resQdata++ = (UWord8) read_bit(ptr, bp_side, mask_side);
1441 : move16();
1442 : n = sub(n, 1);
1443 : }
1444 : }
1445 : #endif
1446 :
1447 : #ifdef ENABLE_HR_MODE
1448 0 : if (hrmode)
1449 : {
1450 0 : Word16 idx_len = sub(*resBits, n); /* Number of nonzero bits */
1451 0 : Word16 idx_len_lim = idx_len * EXT_RES_ITER_MAX;
1452 :
1453 0 : Word16 res_bits_hrmode = s_min(idx_len_lim, *resBits) - idx_len;
1454 : /* idx_len bits have been read in the previous loop */
1455 :
1456 0 : for (k = 0; k < res_bits_hrmode; k++)
1457 : {
1458 0 : if (check_pc_bytes(&bp, bp_side, mask_side, st.pc.inv_bin, 0, &st.pc) != 0)
1459 : {
1460 0 : GOTO ber_detect_res;
1461 : }
1462 0 : i1 = shr(i, RESBITS_PACK_SHIFT);
1463 0 : i2 = s_and(i, RESBITS_PACK_MASK);
1464 0 : resbit = read_bit(ptr, bp_side, mask_side);
1465 0 : if (resbit)
1466 : {
1467 0 : resQdata[i1] = (UWord8) s_or(resQdata[i1], shl(1, i2));
1468 : }
1469 0 : i = add(i, 1);
1470 0 : move16();
1471 0 : n = sub(n, 1);
1472 : }
1473 : }
1474 : #endif
1475 :
1476 0 : *resBits = sub(*resBits, n);
1477 : }
1478 : ELSE
1479 : {
1480 0 : *resBits = 0;
1481 0 : FOR (k = 0; k < lsb_ind_c; k++)
1482 : {
1483 0 : a = x[lsb_ind[k]];
1484 0 : move16();
1485 0 : IF (n == 0)
1486 : {
1487 0 : BREAK;
1488 : }
1489 0 : if (check_pc_bytes(&bp, bp_side, mask_side, st.pc.inv_bin, 0, &st.pc) != 0)
1490 : {
1491 0 : GOTO ber_detect_res;
1492 : }
1493 0 : tmp = read_bit(ptr, bp_side, mask_side);
1494 0 : n = sub(n, 1);
1495 0 : IF (tmp > 0)
1496 : {
1497 : #ifdef ENABLE_HR_MODE
1498 0 : if (a > 0)
1499 : {
1500 0 : a = L_add(a, 1);
1501 : }
1502 0 : if (a < 0)
1503 : {
1504 0 : a = L_sub(a, 1);
1505 : }
1506 : #else
1507 : if (a > 0)
1508 : {
1509 : a = add(a, 1);
1510 : }
1511 : if (a < 0)
1512 : {
1513 : a = sub(a, 1);
1514 : }
1515 : #endif
1516 0 : IF (a == 0)
1517 : {
1518 0 : IF (n == 0)
1519 : {
1520 0 : BREAK;
1521 : }
1522 0 : a = 1;
1523 0 : if (check_pc_bytes(&bp, bp_side, mask_side, st.pc.inv_bin, 0, &st.pc) != 0)
1524 : {
1525 0 : GOTO ber_detect_res;
1526 : }
1527 0 : if (read_bit(ptr, bp_side, mask_side) != 0)
1528 : {
1529 0 : a = negate(a);
1530 : }
1531 0 : n = sub(n, 1);
1532 : }
1533 : }
1534 :
1535 0 : x[lsb_ind[k]] = a;
1536 0 : move16();
1537 0 : b = x[lsb_ind[k] + 1];
1538 0 : move16();
1539 0 : IF (n == 0)
1540 : {
1541 0 : BREAK;
1542 : }
1543 0 : if (check_pc_bytes(&bp, bp_side, mask_side, st.pc.inv_bin, 0, &st.pc) != 0)
1544 : {
1545 0 : GOTO ber_detect_res;
1546 : }
1547 0 : tmp = read_bit(ptr, bp_side, mask_side);
1548 0 : n = sub(n, 1);
1549 0 : IF (tmp > 0)
1550 : {
1551 : #ifdef ENABLE_HR_MODE
1552 0 : if (b > 0)
1553 : {
1554 0 : b = L_add(b, 1);
1555 : }
1556 0 : if (b < 0)
1557 : {
1558 0 : b = L_sub(b, 1);
1559 : }
1560 : #else
1561 : if (b > 0)
1562 : {
1563 : b = add(b, 1);
1564 : }
1565 : if (b < 0)
1566 : {
1567 : b = sub(b, 1);
1568 : }
1569 : #endif
1570 0 : IF (b == 0)
1571 : {
1572 0 : IF (n == 0)
1573 : {
1574 0 : BREAK;
1575 : }
1576 0 : b = 1;
1577 0 : if (check_pc_bytes(&bp, bp_side, mask_side, st.pc.inv_bin, 0, &st.pc) != 0)
1578 : {
1579 0 : GOTO ber_detect_res;
1580 : }
1581 0 : if (read_bit(ptr, bp_side, mask_side) != 0)
1582 : {
1583 0 : b = negate(b);
1584 : }
1585 0 : n = sub(n, 1);
1586 : }
1587 : }
1588 0 : x[lsb_ind[k] + 1] = b;
1589 0 : move16();
1590 : }
1591 : }
1592 :
1593 : /* Noise Filling seed */
1594 0 : tmp32 = L_deposit_l(0);
1595 0 : FOR (i = 0; i < L_spec; i++)
1596 : {
1597 : #ifdef ENABLE_HR_MODE
1598 0 : tmp32 = L_mac0(tmp32, L_and(L_abs(x[i]), 32767), i);
1599 : #else
1600 : tmp32 = L_mac0(tmp32, abs_s(x[i]), i);
1601 : #endif
1602 : }
1603 0 : *nf_seed = extract_l(tmp32);
1604 0 : move16();
1605 :
1606 : /* Detect zero frame */
1607 0 : test();
1608 0 : test();
1609 0 : test();
1610 0 : test();
1611 0 : IF (sub(lastnz, 2) == 0 && sub(x[0], 0) == 0 && sub(x[1], 0) == 0 && sub(gg_idx, 0) == 0 && sub(fac_ns_idx, 7) == 0)
1612 : {
1613 0 : *zero_frame = 1;
1614 0 : move16();
1615 : }
1616 : ELSE
1617 : {
1618 0 : *zero_frame = 0;
1619 0 : move16();
1620 : }
1621 :
1622 0 : IF (mode == 1)
1623 : {
1624 0 : IF (st.pc.bytes > 0)
1625 : {
1626 0 : IF (sub(st.pc.b_left, shr_pos(nbbits, 3)) > 0)
1627 : {
1628 0 : *b_left = sub(*bp_side, st.pc.bytes);
1629 : }
1630 : }
1631 : }
1632 0 : IF (mode == 2)
1633 : {
1634 0 : IF (st.pc.bytes > 0)
1635 : {
1636 0 : IF (sub(st.pc.b_left, shr_pos(nbbits,3)) > 0)
1637 : {
1638 0 : *b_left = *bp_side;
1639 : }
1640 : }
1641 : }
1642 :
1643 0 : IF (sub(*bfi, 2) == 0)
1644 : {
1645 0 : IF (sub(*spec_inv_idx, L_spec) == 0)
1646 : {
1647 0 : *bfi = 0;
1648 : }
1649 : }
1650 0 : GOTO bail;
1651 :
1652 : /* goto for bit error handling */
1653 0 : ber_detect:
1654 0 : *bfi = 1;
1655 0 : move16();
1656 0 : *b_left = st.pc.b_left;
1657 0 : move16();
1658 0 : test();
1659 0 : IF (st.pc.inv_bin > 0 && sub(st.pc.inv_bin, L_spec) <= 0)
1660 : {
1661 0 : *spec_inv_idx = st.pc.inv_bin;
1662 0 : move16();
1663 0 : *bfi = 2;
1664 0 : move16();
1665 0 : *resBits = 0;
1666 0 : move16();
1667 0 : *zero_frame = 0;
1668 0 : move16();
1669 : /* Noise Filling seed */
1670 0 : tmp32 = L_deposit_l(0);
1671 0 : FOR (i = 0; i < *spec_inv_idx; i++)
1672 : {
1673 0 : tmp32 = L_mac0(tmp32, abs_s(x[i]), i);
1674 : }
1675 0 : *nf_seed = extract_l(tmp32);
1676 0 : move16();
1677 : }
1678 0 : GOTO bail;
1679 :
1680 : /* goto for bit error handling in residual signal */
1681 0 : ber_detect_res:
1682 0 : *b_left = st.pc.b_left;
1683 0 : move16();
1684 0 : *resBits = 0;
1685 0 : move16();
1686 0 : *bfi = 0;
1687 0 : move16();
1688 0 : *zero_frame = 0;
1689 0 : move16();
1690 : /* Noise Filling seed */
1691 0 : tmp32 = L_deposit_l(0);
1692 0 : FOR (i = 0; i < *spec_inv_idx; i++)
1693 : {
1694 0 : tmp32 = L_mac0(tmp32, abs_s(x[i]), i);
1695 : }
1696 0 : *nf_seed = extract_l(tmp32);
1697 0 : move16();
1698 0 : GOTO bail;
1699 :
1700 : /* goto, because of dynmem out */
1701 0 : bail:
1702 : Dyn_Mem_Deluxe_Out();
1703 0 : }
1704 :
1705 :
1706 0 : void processAriDecoderScaling_fx(
1707 : #ifdef ENABLE_HR_MODE
1708 : Word32 *datain,
1709 : #else
1710 : Word16 *data16,
1711 : #endif
1712 : Word16 dataLen, Word32 *data32, Word16 *data_e)
1713 : {
1714 : Word32 i;
1715 :
1716 : #ifdef ENABLE_HR_MODE
1717 : Dyn_Mem_Deluxe_In(Word16 shift; Word32 tmp, x_min, x_max;);
1718 : #else
1719 : Dyn_Mem_Deluxe_In(Word16 shift; Word16 tmp, x_min, x_max;);
1720 : #endif
1721 :
1722 :
1723 : #ifdef ENABLE_HR_MODE
1724 0 : x_max = 0;
1725 0 : move32();
1726 0 : x_min = 0;
1727 0 : move32();
1728 : #else
1729 : x_max = 0;
1730 : move16();
1731 : x_min = 0;
1732 : move16();
1733 : #endif
1734 :
1735 0 : FOR (i = 0; i < dataLen; i++)
1736 : {
1737 : #ifdef ENABLE_HR_MODE
1738 0 : if (datain[i] > 0)
1739 0 : x_max = L_max(x_max, datain[i]);
1740 0 : if (datain[i] < 0)
1741 0 : x_min = L_min(x_min, datain[i]);
1742 : #else
1743 : if (data16[i] > 0)
1744 : x_max = s_max(x_max, data16[i]);
1745 : if (data16[i] < 0)
1746 : x_min = s_min(x_min, data16[i]);
1747 : #endif
1748 : }
1749 :
1750 : #ifdef ENABLE_HR_MODE
1751 0 : tmp = L_max(x_max, L_negate(x_min));
1752 0 : shift = norm_l(tmp);
1753 0 : if (tmp == 0)
1754 : {
1755 0 : shift = 31;
1756 0 : move32();
1757 : }
1758 : #else
1759 : tmp = s_max(x_max, negate(x_min));
1760 : shift = norm_s(tmp);
1761 : if (tmp == 0)
1762 : {
1763 : shift = 15;
1764 : move16();
1765 : }
1766 : #endif
1767 :
1768 0 : FOR (i = 0; i < dataLen; i++)
1769 : {
1770 : #ifdef ENABLE_HR_MODE
1771 0 : data32[i] = L_shl_pos(datain[i], shift);
1772 : #else
1773 : data32[i] = L_shl_pos(L_deposit_h(data16[i]), shift);
1774 : #endif
1775 : }
1776 :
1777 : #ifdef ENABLE_HR_MODE
1778 0 : *data_e = sub(31, shift);
1779 0 : move16();
1780 : #else
1781 : *data_e = sub(15, shift);
1782 : move16();
1783 : #endif
1784 :
1785 : Dyn_Mem_Deluxe_Out();
1786 0 : }
1787 :
1788 :
1789 : /*************************************************************************/
1790 : /*************************************************************************/
1791 : /*************************************************************************/
1792 :
1793 : /*************************************************************************/
1794 :
1795 0 : static __forceinline UWord32 UL_addNs24(UWord32 UL_var1, UWord32 UL_var2, UWord16 *wrap)
1796 : {
1797 0 : return UL_lshr(UL_addNs(UL_lshl(UL_var1, 8), UL_lshl(UL_var2, 8), wrap), 8);
1798 : }
1799 : #ifdef ENABLE_HR_MODE
1800 0 : Word16 find_last_nz_pair(const Word32 x[], Word16 length)
1801 : #else
1802 : Word16 find_last_nz_pair(const Word16 x[], Word16 length)
1803 : #endif
1804 : {
1805 : Dyn_Mem_Deluxe_In(Word16 last_nz, lobs[4]; Word32 stage, i;);
1806 :
1807 0 : lobs[0] = 4;
1808 0 : move16();
1809 0 : lobs[1] = shr_pos(length, 1); /* length/2 */
1810 0 : move16();
1811 0 : lobs[2] = add(lobs[1], shr_pos(length, 2));
1812 0 : move16();
1813 0 : lobs[3] = add(lobs[2], shr_pos(length, 3));
1814 0 : move16();
1815 :
1816 0 : last_nz = 0;
1817 0 : move16();
1818 0 : i = length;
1819 0 : move16();
1820 0 : FOR (stage = 3; stage >= 0; --stage)
1821 : {
1822 : /* unmapped kernel */
1823 0 : FOR (; i >= lobs[stage]; i -= 2)
1824 : {
1825 0 : if (x[i - 2] != 0)
1826 : {
1827 0 : last_nz = s_max(last_nz, i);
1828 : }
1829 0 : if (x[i - 1] != 0)
1830 : {
1831 0 : last_nz = s_max(last_nz, i);
1832 : }
1833 : }
1834 0 : IF (last_nz > 0)
1835 : {
1836 0 : BREAK;
1837 : }
1838 : }
1839 :
1840 : Dyn_Mem_Deluxe_Out();
1841 0 : return s_max(last_nz, 2);
1842 : }
1843 :
1844 :
1845 0 : void write_bit_backward(UWord8 *ptr, Word16 *bp, Word16 *mask, Word16 bit)
1846 : {
1847 0 : if (bit > 0)
1848 : {
1849 0 : ptr[*bp] = (UWord8)s_or((Word16)ptr[*bp], *mask);
1850 0 : move16();
1851 : }
1852 0 : *mask = lshl_pos(*mask, 1);
1853 0 : move16();
1854 0 : if (sub(*mask, 0x100) == 0)
1855 : {
1856 0 : *mask = 1;
1857 0 : move16();
1858 : }
1859 0 : if (sub(*mask, 1) == 0)
1860 : {
1861 0 : *bp = sub(*bp, 1);
1862 0 : move16();
1863 : }
1864 0 : }
1865 :
1866 :
1867 0 : void write_indice_backward(UWord8 *ptr, Word16 *bp, Word16 *mask, Word16 indice, Word16 numbits)
1868 : {
1869 : Dyn_Mem_Deluxe_In(Word32 k; Word16 bit;);
1870 :
1871 0 : FOR (k = 0; k < numbits; k++)
1872 : {
1873 0 : bit = s_and(indice, 1);
1874 0 : write_bit_backward(ptr, bp, mask, bit);
1875 0 : indice = lshr(indice, 1);
1876 : }
1877 :
1878 : Dyn_Mem_Deluxe_Out();
1879 0 : }
1880 :
1881 :
1882 0 : static __forceinline void write_indice_forward(UWord8 *ptr, Word16 bp, Word16 indice, Word16 numbits)
1883 : {
1884 : Dyn_Mem_Deluxe_In(Word32 k; Word16 bit, mask, tmp;);
1885 :
1886 0 : tmp = (Word16)ptr[bp];
1887 0 : move16();
1888 0 : mask = 0x80;
1889 0 : move16();
1890 0 : FOR (k = 0; k < numbits; k++)
1891 : {
1892 0 : bit = s_and(indice, mask);
1893 0 : tmp = s_or(tmp, mask);
1894 0 : if (bit == 0)
1895 : {
1896 0 : tmp = sub(tmp, mask);
1897 : }
1898 0 : mask = lshr(mask, 1);
1899 : }
1900 0 : ptr[bp] = (UWord8)tmp;
1901 0 : move16();
1902 :
1903 : Dyn_Mem_Deluxe_Out();
1904 0 : }
1905 :
1906 0 : static __forceinline void ac_enc_init_fx(Encoder_State_fx *st_fx) /* i/o: Encoder state */
1907 : {
1908 0 : st_fx->ac_low_fx = L_deposit_l(0);
1909 0 : move32();
1910 0 : st_fx->ac_range_fx = 0x00ffffff;
1911 0 : move32();
1912 0 : st_fx->ac_cache_fx = -1;
1913 0 : move16();
1914 0 : st_fx->ac_carry_fx = 0;
1915 0 : move16();
1916 0 : st_fx->ac_carry_count_fx = 0;
1917 0 : move16();
1918 0 : }
1919 :
1920 0 : static __forceinline void ac_enc_shift_fx(UWord8 *ptr, Word16 *bp, Encoder_State_fx *st_fx) /* i/o: Encoder state */
1921 : {
1922 0 : test();
1923 0 : L_sub(0, 0); /* For comparision in if */
1924 0 : IF (st_fx->ac_low_fx < (0x00ff0000UL) || sub(st_fx->ac_carry_fx, 1) == 0)
1925 : {
1926 0 : IF (st_fx->ac_cache_fx >= 0)
1927 : {
1928 0 : ptr[(*bp)++] = (UWord8)add(st_fx->ac_cache_fx, st_fx->ac_carry_fx);
1929 0 : move16();
1930 : }
1931 :
1932 0 : WHILE (st_fx->ac_carry_count_fx > 0)
1933 : {
1934 0 : ptr[(*bp)++] = (UWord8)s_and(add(st_fx->ac_carry_fx, 0xff), 255);
1935 0 : move16();
1936 0 : st_fx->ac_carry_count_fx = sub(st_fx->ac_carry_count_fx, 1);
1937 0 : move16();
1938 : }
1939 :
1940 0 : st_fx->ac_cache_fx = u_extract_l(UL_lshr_pos(st_fx->ac_low_fx, 16));
1941 0 : move16();
1942 0 : st_fx->ac_carry_fx = 0;
1943 0 : move16();
1944 : }
1945 : ELSE
1946 : {
1947 0 : st_fx->ac_carry_count_fx = add(st_fx->ac_carry_count_fx, 1);
1948 0 : move16();
1949 : }
1950 0 : st_fx->ac_low_fx = UL_and(UL_lshl_pos(st_fx->ac_low_fx, 8), 0x00ffffff);
1951 0 : move32();
1952 0 : }
1953 :
1954 0 : static __forceinline void ac_encode_fx(UWord8 *ptr, Word16 *bp, Encoder_State_fx *st_fx, /* i/o: Encoder state */
1955 : UWord32 cum_freq, /* i : Cumulative frequency up to symbol */
1956 : UWord32 sym_freq) /* i : Symbol probability */
1957 : {
1958 : Dyn_Mem_Deluxe_In(UWord32 r, tmp; UWord16 carry;);
1959 :
1960 0 : r = UL_lshr_pos(st_fx->ac_range_fx, 10);
1961 0 : tmp = UL_Mpy_32_32(r, cum_freq);
1962 :
1963 0 : assert(r < (1U << 24));
1964 0 : assert(cum_freq < (1U << 24));
1965 0 : assert(tmp < (1U << 24));
1966 0 : assert(st_fx->ac_low_fx < (1U << 24));
1967 0 : st_fx->ac_low_fx = UL_addNs24(st_fx->ac_low_fx, tmp, &carry);
1968 0 : move32();
1969 :
1970 0 : if (carry != 0)
1971 : {
1972 0 : st_fx->ac_carry_fx = carry;
1973 0 : move16();
1974 : }
1975 :
1976 0 : st_fx->ac_range_fx = UL_Mpy_32_32(r, sym_freq);
1977 0 : move32();
1978 :
1979 0 : assert(cum_freq < (1U << 24));
1980 0 : assert(st_fx->ac_range_fx < (1U << 24));
1981 0 : WHILE (st_fx->ac_range_fx < (1U << 16))
1982 : {
1983 0 : L_sub(0, 0); /* Comparison in while */
1984 0 : st_fx->ac_range_fx = UL_lshl_pos(st_fx->ac_range_fx, 8);
1985 0 : move32();
1986 :
1987 0 : assert(st_fx->ac_range_fx < (1U << 24));
1988 :
1989 0 : ac_enc_shift_fx(ptr, bp, st_fx);
1990 : }
1991 :
1992 : Dyn_Mem_Deluxe_Out();
1993 0 : }
1994 :
1995 0 : static __forceinline Word16 ac_enc_finish_fx(UWord8 *ptr, Word16 *bp, Encoder_State_fx *st_fx) /* i/o: Encoder state */
1996 : {
1997 : Dyn_Mem_Deluxe_In(UWord32 val, mask, high; Word16 bits; UWord16 over1, over2;);
1998 :
1999 : /*bits = 24 - log2_i(st->ac_range); */
2000 0 : bits = sub(norm_ul(st_fx->ac_range_fx), 7);
2001 :
2002 0 : mask = UL_lshr(0x00ffffff, bits);
2003 :
2004 0 : val = UL_addNs24(st_fx->ac_low_fx, mask, &over1);
2005 0 : high = UL_addNs24(st_fx->ac_low_fx, st_fx->ac_range_fx, &over2);
2006 :
2007 0 : L_xor(0, 0); /* For bit not */
2008 0 : UL_and(1U, 1U); /* added counters */
2009 0 : val = L_and(val, (~mask) & 0x00ffffff);
2010 :
2011 0 : L_xor(0, 0); /* For bit not */
2012 0 : IF ((L_xor(over1, over2)) == 0)
2013 : {
2014 0 : L_sub(0, 0); /* For comparision in if */
2015 0 : IF (UL_addNsD(val, mask) >= high)
2016 : {
2017 0 : bits = add(bits, 1);
2018 0 : mask = UL_lshr_pos(mask, 1);
2019 0 : val = UL_and(UL_addNsD(st_fx->ac_low_fx, mask), (~mask) & 0x00ffffff);
2020 0 : L_xor(0, 0);
2021 0 : UL_and(1, 1); /* For bit not , mask */
2022 : }
2023 :
2024 0 : if (val < st_fx->ac_low_fx)
2025 : {
2026 0 : st_fx->ac_carry_fx = 1;
2027 0 : move16();
2028 : }
2029 : }
2030 :
2031 0 : st_fx->ac_low_fx = val;
2032 0 : move32();
2033 :
2034 0 : FOR (; bits > 0; bits -= 8)
2035 : {
2036 0 : ac_enc_shift_fx(ptr, bp, st_fx);
2037 : }
2038 0 : bits = add(bits, 8);
2039 :
2040 0 : assert(st_fx->ac_carry_fx == 0);
2041 :
2042 0 : IF (st_fx->ac_carry_count_fx > 0)
2043 : {
2044 0 : ptr[(*bp)++] = (UWord8)st_fx->ac_cache_fx;
2045 0 : move16();
2046 :
2047 0 : FOR (; st_fx->ac_carry_count_fx > 1; st_fx->ac_carry_count_fx--)
2048 : {
2049 0 : ptr[(*bp)++] = 0xff;
2050 0 : move16();
2051 : }
2052 0 : write_indice_forward(ptr, *bp, lshr(0xff, sub(8, bits)), bits);
2053 : }
2054 : ELSE
2055 : {
2056 0 : write_indice_forward(ptr, *bp, st_fx->ac_cache_fx, bits);
2057 : }
2058 :
2059 : Dyn_Mem_Deluxe_Out();
2060 0 : return bits;
2061 : }
2062 :
2063 :
2064 0 : __forceinline Word16 read_bit(UWord8 *ptr, Word16 *bp, Word16 *mask)
2065 : {
2066 : Dyn_Mem_Deluxe_In(Word16 bit;);
2067 :
2068 0 : bit = 0;
2069 0 : move16();
2070 0 : if (s_and((Word16)ptr[*bp], *mask) > 0)
2071 : {
2072 0 : bit = 1;
2073 0 : move16();
2074 : }
2075 0 : *mask = lshl_pos(*mask, 1);
2076 0 : move16();
2077 0 : if (sub(*mask, 0x100) == 0)
2078 : {
2079 0 : *mask = 1;
2080 0 : move16();
2081 : }
2082 0 : if (sub(*mask, 1) == 0)
2083 : {
2084 0 : *bp = sub(*bp, 1);
2085 0 : move16();
2086 : }
2087 :
2088 : Dyn_Mem_Deluxe_Out();
2089 0 : return bit;
2090 : }
2091 :
2092 :
2093 0 : static __forceinline void ac_dec_init_fx(UWord8 *ptr, Word16 *bp, Word16 *bp_side, Word16 *mask_side,
2094 : Decoder_State_fx *st_fx) /* i/o: Decoder State */
2095 : {
2096 : Dyn_Mem_Deluxe_In(Word32 i;);
2097 :
2098 :
2099 0 : st_fx->ac_low_fx = L_deposit_l(0);
2100 0 : move32();
2101 :
2102 0 : st_fx->ac_range_fx = 0x00ffffff;
2103 0 : move32();
2104 0 : FOR (i = 0; i < 3; i++)
2105 : {
2106 0 : if (check_pc_bytes(bp, bp_side, mask_side, 0, 1, &st_fx->pc) != 0)
2107 : {
2108 : Dyn_Mem_Deluxe_Out();
2109 0 : return;
2110 : }
2111 0 : st_fx->ac_low_fx = UL_addNsD(UL_lshl_pos(st_fx->ac_low_fx, 8), UL_deposit_l((Word16)ptr[(*bp)++]));
2112 0 : move32();
2113 0 : assert(st_fx->ac_low_fx < (1U << 24));
2114 : }
2115 :
2116 0 : st_fx->BER_detect = 0;
2117 0 : move16();
2118 :
2119 : Dyn_Mem_Deluxe_Out();
2120 : }
2121 :
2122 : /* o : Decoded cumulative frequency */
2123 0 : static __forceinline Word16 ac_decode_fx(Decoder_State_fx *st_fx, /* i/o: Decoder State */
2124 : Word16 pki)
2125 : {
2126 : Dyn_Mem_Deluxe_In(UWord16 sgn; Word16 val, r;);
2127 :
2128 0 : st_fx->ac_help_fx = UL_lshr_pos(st_fx->ac_range_fx, 10);
2129 0 : move32();
2130 0 : val = 0;
2131 0 : move16();
2132 :
2133 0 : r = add(val, 8);
2134 0 : UL_subNs(st_fx->ac_low_fx, UL_Mpy_32_32(st_fx->ac_help_fx, ari_spec_cumfreq[pki][r]), &sgn);
2135 0 : if (sgn == 0)
2136 : {
2137 0 : val = r;
2138 0 : move16();
2139 : }
2140 :
2141 0 : r = add(val, 4);
2142 0 : UL_subNs(st_fx->ac_low_fx, UL_Mpy_32_32(st_fx->ac_help_fx, ari_spec_cumfreq[pki][r]), &sgn);
2143 0 : if (sgn == 0)
2144 : {
2145 0 : val = r;
2146 0 : move16();
2147 : }
2148 :
2149 0 : r = add(val, 2);
2150 0 : UL_subNs(st_fx->ac_low_fx, UL_Mpy_32_32(st_fx->ac_help_fx, ari_spec_cumfreq[pki][r]), &sgn);
2151 0 : if (sgn == 0)
2152 : {
2153 0 : val = r;
2154 0 : move16();
2155 : }
2156 :
2157 0 : r = add(val, 1);
2158 0 : UL_subNs(st_fx->ac_low_fx, UL_Mpy_32_32(st_fx->ac_help_fx, ari_spec_cumfreq[pki][r]), &sgn);
2159 0 : IF (sgn == 0)
2160 : {
2161 0 : val = r;
2162 0 : move16();
2163 0 : IF (sub(val, 15) == 0)
2164 : {
2165 0 : UL_subNs(st_fx->ac_low_fx, UL_Mpy_32_32(st_fx->ac_help_fx, ari_spec_cumfreq[pki][16]), &sgn);
2166 0 : if (sgn == 0)
2167 : {
2168 0 : val = 16;
2169 0 : move16();
2170 : }
2171 0 : UL_subNs(st_fx->ac_low_fx, UL_lshl(st_fx->ac_help_fx, 10), &sgn);
2172 0 : if (sgn == 0)
2173 : {
2174 0 : st_fx->BER_detect = 1;
2175 0 : move16();
2176 : }
2177 : }
2178 : }
2179 :
2180 : Dyn_Mem_Deluxe_Out();
2181 0 : return val;
2182 : }
2183 :
2184 : /* o : Decoded cumulative frequency */
2185 0 : static __forceinline Word16 ac_decode_tns_order(Decoder_State_fx *st_fx, /* i/o: Decoder State */
2186 : Word16 enable_lpc_weighting)
2187 : {
2188 : Dyn_Mem_Deluxe_In(UWord16 sgn; Word16 val, r;);
2189 :
2190 0 : st_fx->ac_help_fx = UL_lshr_pos(st_fx->ac_range_fx, 10);
2191 0 : move32();
2192 0 : val = 0;
2193 0 : move16();
2194 :
2195 0 : r = add(val, 4);
2196 0 : UL_subNs(st_fx->ac_low_fx, UL_Mpy_32_32(st_fx->ac_help_fx, ac_tns_order_cumfreq[enable_lpc_weighting][r]), &sgn);
2197 0 : if (sgn == 0)
2198 : {
2199 0 : val = r;
2200 0 : move16();
2201 : }
2202 :
2203 0 : r = add(val, 2);
2204 0 : UL_subNs(st_fx->ac_low_fx, UL_Mpy_32_32(st_fx->ac_help_fx, ac_tns_order_cumfreq[enable_lpc_weighting][r]), &sgn);
2205 0 : if (sgn == 0)
2206 : {
2207 0 : val = r;
2208 0 : move16();
2209 : }
2210 :
2211 0 : r = add(val, 1);
2212 0 : UL_subNs(st_fx->ac_low_fx, UL_Mpy_32_32(st_fx->ac_help_fx, ac_tns_order_cumfreq[enable_lpc_weighting][r]), &sgn);
2213 0 : if (sgn == 0)
2214 : {
2215 0 : val = r;
2216 0 : move16();
2217 : }
2218 :
2219 0 : UL_subNs(st_fx->ac_low_fx, UL_lshl(st_fx->ac_help_fx, 10), &sgn);
2220 0 : if (sgn == 0)
2221 : {
2222 0 : st_fx->BER_detect = 1;
2223 0 : move16();
2224 : }
2225 :
2226 : Dyn_Mem_Deluxe_Out();
2227 0 : return val;
2228 : }
2229 :
2230 : /* o : Decoded cumulative frequency */
2231 0 : static __forceinline Word16 ac_decode_tns_coef(Decoder_State_fx *st_fx, /* i/o: Decoder State */
2232 : Word16 pki)
2233 : {
2234 : Dyn_Mem_Deluxe_In(UWord16 sgn; Word16 val, r;);
2235 :
2236 0 : st_fx->ac_help_fx = UL_lshr_pos(st_fx->ac_range_fx, 10);
2237 0 : move32();
2238 0 : val = 0;
2239 0 : move16();
2240 :
2241 0 : r = add(val, 8);
2242 0 : UL_subNs(st_fx->ac_low_fx, UL_Mpy_32_32(st_fx->ac_help_fx, ac_tns_coef_cumfreq[pki][r]), &sgn);
2243 0 : if (sgn == 0)
2244 : {
2245 0 : val = r;
2246 0 : move16();
2247 : }
2248 :
2249 0 : r = add(val, 4);
2250 0 : UL_subNs(st_fx->ac_low_fx, UL_Mpy_32_32(st_fx->ac_help_fx, ac_tns_coef_cumfreq[pki][r]), &sgn);
2251 0 : if (sgn == 0)
2252 : {
2253 0 : val = r;
2254 0 : move16();
2255 : }
2256 :
2257 0 : r = add(val, 2);
2258 0 : UL_subNs(st_fx->ac_low_fx, UL_Mpy_32_32(st_fx->ac_help_fx, ac_tns_coef_cumfreq[pki][r]), &sgn);
2259 0 : if (sgn == 0)
2260 : {
2261 0 : val = r;
2262 0 : move16();
2263 : }
2264 :
2265 0 : r = add(val, 1);
2266 0 : UL_subNs(st_fx->ac_low_fx, UL_Mpy_32_32(st_fx->ac_help_fx, ac_tns_coef_cumfreq[pki][r]), &sgn);
2267 0 : if (sgn == 0)
2268 : {
2269 0 : val = r;
2270 0 : move16();
2271 0 : IF (sub(val, 15) == 0)
2272 : {
2273 0 : UL_subNs(st_fx->ac_low_fx, UL_Mpy_32_32(st_fx->ac_help_fx, ac_tns_coef_cumfreq[pki][16]), &sgn);
2274 0 : if (sgn == 0)
2275 : {
2276 0 : val = 16;
2277 0 : move16();
2278 : }
2279 0 : UL_subNs(st_fx->ac_low_fx, UL_lshl(st_fx->ac_help_fx, 10), &sgn);
2280 0 : if (sgn == 0)
2281 : {
2282 0 : st_fx->BER_detect = 1;
2283 0 : move16();
2284 : }
2285 : }
2286 : }
2287 :
2288 : Dyn_Mem_Deluxe_Out();
2289 0 : return val;
2290 : }
2291 :
2292 0 : static __forceinline Word16 ac_dec_update_fx(UWord8 *ptr, Word16 *bp, Word16 *bp_side, Word16 *mask_side,
2293 : Word16 cur_bin, Decoder_State_fx *st_fx, /* i/o: Decoder State */
2294 : UWord32 cum_freq, /* i : Cumulative frequency */
2295 : UWord32 sym_freq /* i : Symbol frequency */
2296 : )
2297 : {
2298 : UWord32 UL_tmp;
2299 :
2300 :
2301 0 : assert(st_fx->ac_help_fx < (1U << 24));
2302 0 : assert(cum_freq < (1U << 24));
2303 :
2304 0 : UL_tmp = UL_Mpy_32_32(cum_freq, st_fx->ac_help_fx);
2305 0 : assert(UL_tmp < (1U << 24));
2306 :
2307 0 : st_fx->ac_low_fx = UL_subNsD(st_fx->ac_low_fx, UL_tmp);
2308 0 : move32(); /*0+0*/
2309 0 : assert(st_fx->ac_low_fx < (1U << 24));
2310 :
2311 0 : st_fx->ac_range_fx = UL_Mpy_32_32(st_fx->ac_help_fx, sym_freq);
2312 0 : move32();
2313 :
2314 0 : assert(st_fx->ac_range_fx < (1U << 24));
2315 : /* updated to 16 from 24 */
2316 0 : WHILE (st_fx->ac_range_fx < (1U << 16))
2317 : {
2318 0 : L_sub(0, 0); /* For comparision in while*/
2319 :
2320 0 : st_fx->ac_low_fx =
2321 0 : UL_and(st_fx->ac_low_fx, 0x0000ffFF); /* make sure upshift doe not lead to more than 24 bits */
2322 0 : assert(st_fx->ac_low_fx < 1U << 16);
2323 :
2324 0 : if (check_pc_bytes(bp, bp_side, mask_side, cur_bin, 1, &st_fx->pc) != 0)
2325 0 : return 1;
2326 :
2327 : /*shift in 8 bits */
2328 0 : st_fx->ac_low_fx = UL_addNsD(UL_lshl_pos(st_fx->ac_low_fx, 8), UL_deposit_l((Word16)ptr[(*bp)++]));
2329 0 : move32();
2330 :
2331 0 : assert(st_fx->ac_low_fx < (1U << 24));
2332 0 : st_fx->ac_range_fx = UL_lshl_pos(st_fx->ac_range_fx, 8);
2333 0 : move32();
2334 0 : assert(st_fx->ac_range_fx < (1U << 24));
2335 : }
2336 0 : return 0;
2337 : }
2338 :
2339 0 : static __forceinline void pc_init_fx(Word16 n_pc, Word16 numbytes, Word16 be_bp_left, Word16 be_bp_right, Word16 L_spec,
2340 : Word16 enc, Word16 sim_dec, Word16 bfi, Pc_State_fx *pc /* i/o: Pc State */
2341 : )
2342 : {
2343 0 : pc->inv_bin = add(L_spec, 1); move16();
2344 0 : pc->numbytes = numbytes; move16();
2345 0 : pc->c_bp = 0; move16();
2346 0 : pc->c_bp_side = 0; move16();
2347 0 : pc->bytes = shr(add(n_pc, 1),1); move16();
2348 0 : pc->b_left = add(numbytes,1); move16();
2349 0 : pc->b_right = -1; move16();
2350 0 : pc->enc = enc; move16();
2351 0 : pc->sim_dec = sim_dec; move16();
2352 0 : pc->bfi = bfi; move16();
2353 0 : pc->be_bp_left = shr(be_bp_left, 3); move16();
2354 0 : pc->be_bp_right = shr(be_bp_right, 3); move16();
2355 0 : assert(pc->be_bp_right < pc->bytes || pc->bytes == 0);
2356 0 : }
2357 :
2358 0 : static __forceinline Word16 check_pc_bytes(Word16 *bp, Word16 *bp_side, Word16 *mask_side, Word16 cur_bin,
2359 : Word16 from_left, Pc_State_fx *pc /* i/o: Pc State */)
2360 : {
2361 : Dyn_Mem_Deluxe_In(Word16 bp_local, bp_side_local, offset;);
2362 :
2363 0 : IF (pc->bytes > 0)
2364 : {
2365 0 : test();
2366 0 : IF (from_left == 0 && sub(*mask_side, 1) != 0)
2367 : {
2368 : Dyn_Mem_Deluxe_Out();
2369 0 : return 0;
2370 : }
2371 0 : test();
2372 0 : IF (pc->c_bp_side > 0 && *bp_side < 0)
2373 : {
2374 0 : assert(*mask_side == 1);
2375 0 : assert(pc->b_right != -1);
2376 0 : *bp_side = pc->b_right;
2377 : Dyn_Mem_Deluxe_Out();
2378 0 : return 0;
2379 : }
2380 0 : bp_local = *bp;
2381 0 : bp_side_local = *bp_side;
2382 :
2383 0 : IF (from_left != 0)
2384 : {
2385 0 : if (sub(*mask_side, 1) == 0)
2386 : {
2387 0 : bp_side_local = add(bp_side_local, 1);
2388 : }
2389 : }
2390 : ELSE
2391 : {
2392 0 : bp_local = sub(bp_local, 1);
2393 : }
2394 :
2395 0 : IF (pc->b_right < 0)
2396 : {
2397 0 : offset = -1;
2398 0 : move16();
2399 0 : if (pc->enc == 0)
2400 : {
2401 0 : offset = add(offset, pc->bytes);
2402 : }
2403 :
2404 0 : IF (add(bp_side_local, sub(offset, bp_local)) == pc->bytes)
2405 : {
2406 0 : pc->b_left = add(bp_local, 1);
2407 0 : pc->b_right = sub(bp_side_local, 1);
2408 0 : IF (pc->enc != 0)
2409 : {
2410 0 : assert(pc->b_right - pc->b_left + 1 == pc->bytes);
2411 : Dyn_Mem_Deluxe_Out();
2412 0 : return 1;
2413 : }
2414 : }
2415 : }
2416 :
2417 0 : test();
2418 0 : IF (pc->enc == 0 && pc->b_right >= 0)
2419 : {
2420 0 : test();
2421 0 : IF (from_left != 0 && sub(*bp, pc->b_left) == 0)
2422 : {
2423 0 : IF (pc->sim_dec == 1)
2424 : {
2425 0 : pc->b_left = *bp;
2426 : Dyn_Mem_Deluxe_Out();
2427 0 : return 1;
2428 : }
2429 0 : *bp = 0; move16();
2430 0 : pc->c_bp = 1; move16();
2431 : }
2432 0 : test();
2433 0 : IF (from_left == 0 && sub(bp_side_local, pc->b_right) == 0)
2434 : {
2435 0 : *bp_side = sub(pc->bytes, 1);
2436 0 : move16();
2437 0 : pc->c_bp_side = 1;
2438 0 : move16();
2439 : }
2440 0 : IF (sub(pc->bfi, 2) == 0)
2441 : {
2442 0 : test();
2443 0 : test();
2444 0 : IF ((pc->c_bp != 0 && sub(*bp, pc->be_bp_left) >= 0) ||
2445 : (pc->c_bp_side != 0 && sub(*bp_side, pc->be_bp_right) <= 0))
2446 : {
2447 0 : pc->inv_bin = cur_bin;
2448 0 : move16();
2449 : Dyn_Mem_Deluxe_Out();
2450 0 : return 1;
2451 : }
2452 0 : ELSE IF ((pc->c_bp != 0 && *bp >= 0) || (pc->c_bp_side != 0 && sub(*bp_side, sub(pc->bytes, 1)) <= 0))
2453 : {
2454 0 : pc->inv_bin = s_min(pc->inv_bin, cur_bin);
2455 : Dyn_Mem_Deluxe_Out();
2456 0 : return 0;
2457 : }
2458 : }
2459 : }
2460 : }
2461 :
2462 : Dyn_Mem_Deluxe_Out();
2463 0 : return 0;
2464 : }
2465 :
|
