Line data Source code
1 : /******************************************************************************
2 : * ETSI TS 103 634 V1.5.1 *
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 : #ifdef ENABLE_HR_MODE
13 0 : void processQuantizeSpec_fx(Word32 x[], Word16 x_e, Word32 gain, Word16 gain_e, Word32 xq[], Word16 nt, Word16 target,
14 : Word16 totalBits, Word16 *nBits, Word16 *nBits2, Word16 fs_idx, Word16 *lastnzout,
15 : Word16 *codingdata, Word16 *lsbMode, Word16 mode, Word16 hrmode)
16 : {
17 :
18 : Word32 a1, b1, a1_i, b1_i;
19 : Word16 t, lev1;
20 : Word16 lastnz, lastnz2;
21 : Word16 rateFlag;
22 : Word32 nbits32, nbits232, target32;
23 : Word16 nt_half;
24 : Word32 c, ab_max, msb, a1_msb, b1_msb;
25 : Word16 levmax;
26 : Word16 s;
27 : Word16 totBits, nbits_lsb;
28 : Counter k, lev;
29 : Word16 maxlevs;
30 : #ifndef FUNCTION_quantizeSpec_func1
31 : Word16 tmp16;
32 : Word32 offs32;
33 : Counter i;
34 : #else
35 : Word32 ARM_params[3];
36 : #endif
37 :
38 : #ifdef DYNMEM_COUNT
39 : Dyn_Mem_In("processQuantizeSpec_fx", sizeof(struct {
40 : Word32 a1, b1, a1_i, b1_i, ab_max, c;
41 : Word16 t, lev1;
42 : Word16 lastnz, lastnz2;
43 : Word16 rateFlag;
44 : Word32 nbits32, nbits232;
45 : Word16 nt_half;
46 : Word16 msb, a1_msb, b1_msb, levmax;
47 : Counter k, lev, i;
48 : Word16 s;
49 : Word16 tmp16;
50 : Word32 offs32, target32;
51 : Word16 totBits, nbits_lsb;
52 : Word16 maxlevs;
53 : }));
54 : #endif
55 :
56 0 : assert(target >= 0);
57 :
58 : /* Quantization */
59 0 : gain = invFixp(gain, &gain_e);
60 :
61 0 : maxlevs = 21;
62 0 : IF (hrmode)
63 : {
64 0 : s = sub(add(x_e, gain_e), 23);
65 0 : s = s_min(s, 31);
66 : #ifdef FUNCTION_quantizeSpec_func1
67 : ARM_params[0] = gain;
68 : ARM_params[1] = s;
69 :
70 : quantizeSpec_func1_hr_ip(xq, x, nt, ARM_params);
71 : #else
72 0 : IF(s > 4)
73 : {
74 0 : s = sub(s, 4); /* Use extra bits of precision for fine calculation */
75 0 : FOR(i = 0; i < nt; i++)
76 : {
77 0 : offs32 = Mpy_32_32_lc3plus(L_shl_pos(x[i], s), gain); /* multiply */
78 0 : xq[i] = L_shr_r_pos(offs32, 4); /* Convert to Q0 with rounding */
79 : /* rounding is the equivalent of adding 0.5, which is the offset in hrmode */
80 :
81 0 : move32();
82 : }
83 : }
84 : ELSE
85 : {
86 0 : FOR(i = 0; i < nt; i++)
87 : {
88 0 : offs32 = Mpy_32_32_lc3plus(x[i], gain); /* multiply */
89 0 : offs32 = L_shl(offs32, s); /* convert to 23Q8 */
90 0 : xq[i] = L_shr_r_pos(offs32, 8); /* Convert to Q0 with rounding */
91 : /* rounding is the equivalent of adding 0.5, which is the offset in hrmode */
92 :
93 0 : move32();
94 : }
95 : }
96 : #endif /* FUNCTION_quantizeSpec_func1 */
97 : }
98 : ELSE
99 : {
100 0 : s = sub(add(x_e, gain_e), 15);
101 0 : s = s_max(s_min(s, 15), -15);
102 : #ifdef FUNCTION_quantizeSpec_func1
103 : ARM_params[0] = gain;
104 : ARM_params[1] = s;
105 : ARM_params[2] = -4096;
106 : quantizeSpec_func1_ip(xq, x, nt, ARM_params);
107 : #else
108 0 : FOR (i = 0; i < nt; i++)
109 : {
110 0 : offs32 = Mpy_32_32_lc3plus(L_abs(x[i]), gain); /* multiply */
111 0 : offs32 = L_shl(offs32, s); /* convert to 15Q16 */
112 0 : tmp16 = mac_r(offs32, -4096, 1); /* add offset and truncate */
113 :
114 0 : if (x[i] < 0)
115 0 : tmp16 = negate(tmp16); /* restore sign */
116 :
117 : /* Normal quantization: xq[i] = x[i] / gg + sign(x[i]) * 0.375
118 : quant_offset is -0.125 in Q15 and round adds 0.5 in Q16. Hence
119 : mac_r results in abs(x[i])/gain - 0.125 + 0.5 = abs(x[i])/gain + 0.375.
120 : Due to the abs and negate combination this achieves the same result
121 : as spec.
122 : */
123 :
124 0 : xq[i] = tmp16;
125 0 : move16();
126 : }
127 : #endif /* FUNCTION_quantizeSpec_func1 */
128 : }
129 : /* Rate flag */
130 0 : rateFlag = 0;
131 0 : move16();
132 0 : if (fs_idx != 5)
133 : {
134 0 : if (sub(totalBits, add(160, DEPR_i_mult(fs_idx, 160))) > 0)
135 : {
136 0 : rateFlag = 2 << NBITS_CONTEXT;
137 0 : move16();
138 : }
139 : }
140 :
141 : /* Init */
142 0 : nt_half = shr_pos(nt, 1);
143 0 : c = 0;
144 0 : move16();
145 0 : t = 0;
146 0 : move16();
147 0 : a1_i = 0;
148 0 : move16();
149 0 : b1_i = 1;
150 0 : move16();
151 0 : target32 = L_shl_pos(L_deposit_l(target), SYM_BITS_Q);
152 0 : nbits32 = L_negate(target32);
153 0 : nbits232 = 0;
154 0 : move32();
155 0 : nbits_lsb = 0;
156 0 : move16();
157 :
158 0 : if (fs_idx != 5)
159 : {
160 0 : IF (mode == 0 && sub(totalBits, add(480, DEPR_i_mult(fs_idx, 160))) >= 0)
161 : {
162 0 : mode = 1;
163 0 : move16();
164 : }
165 : }
166 :
167 : /* Find last non-zero tuple */
168 0 : lastnz = find_last_nz_pair(xq, nt);
169 0 : IF (mode >= 0)
170 : {
171 0 : lastnz2 = 2;
172 : }
173 : ELSE
174 : {
175 0 : lastnz2 = lastnz;
176 : }
177 :
178 0 : IF (mode < 0)
179 : {
180 : /* Main Loop through the 2-tuples */
181 0 : FOR (k = 0; k < lastnz; k += 2)
182 : {
183 :
184 : /* Get context */
185 0 : t = add(c, rateFlag);
186 0 : if (sub(k, nt_half) > 0)
187 : {
188 0 : t = add(t, 1 << NBITS_CONTEXT);
189 : }
190 0 : codingdata[0] = t;
191 0 : move16();
192 :
193 : /* Init current 2-tuple encoding */
194 0 : a1 = L_abs(xq[a1_i]);
195 0 : b1 = L_abs(xq[b1_i]);
196 0 : ab_max = L_max(a1, b1);
197 :
198 0 : IF (ab_max == 0)
199 : {
200 0 : codingdata[1] = -1;
201 0 : move16();
202 0 : codingdata[2] = 0;
203 0 : move16();
204 0 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t]][0]);
205 0 : c = add(shl_pos(s_and(c, 0xf), 4), 1);
206 : }
207 0 : ELSE IF (L_sub(ab_max, A_THRES) < 0)
208 : {
209 0 : codingdata[1] = 0;
210 0 : move16();
211 0 : msb = L_add(a1, L_shl_pos(b1, A_THRES_SHIFT));
212 0 : codingdata[2] = msb;
213 0 : move16();
214 0 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t]][msb]);
215 0 : if (a1 != 0)
216 : {
217 0 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
218 : }
219 0 : if (b1 != 0)
220 : {
221 0 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
222 : }
223 0 : c = L_add(shl_pos(s_and(c, 0xf), 4), L_add(L_add(a1, b1), 1));
224 : }
225 0 : ELSE IF (L_sub(ab_max, 2 * A_THRES) < 0)
226 : {
227 0 : codingdata[1] = 1;
228 0 : move16();
229 0 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t]][VAL_ESC]);
230 0 : nbits32 = L_add(nbits32, 2 << SYM_BITS_Q);
231 0 : a1_msb = L_shr_pos_pos(a1, 1);
232 0 : b1_msb = L_shr_pos_pos(b1, 1);
233 0 : msb = L_add(a1_msb, shl_pos(b1_msb, A_THRES_SHIFT));
234 0 : codingdata[2] = msb;
235 0 : move16();
236 0 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t + Tab_esc_nb[1]]][msb]);
237 0 : if (a1 != 0)
238 : {
239 0 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
240 : }
241 0 : if (b1 != 0)
242 : {
243 0 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
244 : }
245 0 : c = L_add(shl_pos(s_and(c, 0xf), 4), L_add(L_shl_pos(L_add(a1_msb, b1_msb), 1), 1));
246 : }
247 : ELSE
248 : {
249 0 : levmax = sub(maxlevs, sub(norm_l(ab_max), 8));
250 0 : codingdata[1] = levmax;
251 0 : move16();
252 0 : FOR (lev = 0; lev < levmax; lev++)
253 : {
254 0 : lev1 = s_min(lev, 3);
255 0 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t + Tab_esc_nb[lev1]]][VAL_ESC]);
256 : }
257 0 : nbits32 = L_add(nbits32, L_shl_pos(L_deposit_l(levmax), SYM_BITS_Q + 1));
258 0 : a1_msb = L_shr(a1, levmax);
259 0 : b1_msb = L_shr(b1, levmax);
260 0 : msb = L_add(a1_msb, L_shl_pos(b1_msb, A_THRES_SHIFT));
261 0 : codingdata[2] = msb;
262 0 : move16();
263 0 : lev1 = s_min(levmax, 3);
264 0 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t + Tab_esc_nb[lev1]]][msb]);
265 0 : if (a1 != 0)
266 : {
267 0 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
268 : }
269 0 : if (b1 != 0)
270 : {
271 0 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
272 : }
273 0 : c = add(shl_pos(s_and(c, 0xf), 4), add(12, s_min(levmax, 3)));
274 : }
275 :
276 0 : a1_i += 2;
277 0 : b1_i += 2;
278 0 : codingdata += 3;
279 :
280 : } /* end of the 2-tuples loop */
281 : }
282 0 : ELSE IF (mode == 0)
283 : {
284 : /* Main Loop through the 2-tuples */
285 0 : FOR (k = 0; k < lastnz; k += 2)
286 : {
287 :
288 : /* Get context */
289 0 : t = add(c, rateFlag);
290 0 : if (sub(k, nt_half) > 0)
291 : {
292 0 : t = add(t, 1 << NBITS_CONTEXT);
293 : }
294 :
295 0 : codingdata[0] = t;
296 0 : move16();
297 :
298 : /* Init current 2-tuple encoding */
299 0 : a1 = L_abs(xq[a1_i]);
300 0 : b1 = L_abs(xq[b1_i]);
301 0 : ab_max = L_max(a1, b1);
302 :
303 0 : IF (ab_max == 0)
304 : {
305 0 : codingdata[1] = -1;
306 0 : move16();
307 0 : codingdata[2] = 0;
308 0 : move16();
309 0 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t]][0]);
310 0 : c = add(shl_pos(s_and(c, 0xf), 4), 1);
311 : }
312 0 : ELSE IF (L_sub(ab_max, A_THRES) < 0)
313 : {
314 0 : codingdata[1] = 0;
315 0 : move16();
316 0 : msb = L_add(a1, L_shl_pos(b1, A_THRES_SHIFT));
317 0 : codingdata[2] = msb;
318 0 : move16();
319 0 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t]][msb]);
320 0 : if (a1 != 0)
321 : {
322 0 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
323 : }
324 0 : if (b1 != 0)
325 : {
326 0 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
327 : }
328 :
329 0 : if (nbits32 <= 0)
330 : {
331 0 : lastnz2 = add(k, 2);
332 : }
333 0 : if (nbits32 <= 0)
334 : {
335 0 : nbits232 = nbits32;
336 0 : move32();
337 : }
338 :
339 0 : c = L_add(shl_pos(s_and(c, 0xf), 4), L_add(L_add(a1, b1), 1));
340 : }
341 0 : ELSE IF (L_sub(ab_max, 2 * A_THRES) < 0)
342 : {
343 0 : codingdata[1] = 1;
344 0 : move16();
345 0 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t]][VAL_ESC]);
346 0 : nbits32 = L_add(nbits32, 2 << SYM_BITS_Q);
347 0 : a1_msb = L_shr_pos_pos(a1, 1);
348 0 : b1_msb = L_shr_pos_pos(b1, 1);
349 0 : msb = L_add(a1_msb, L_shl_pos(b1_msb, A_THRES_SHIFT));
350 0 : codingdata[2] = msb;
351 0 : move16();
352 0 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t + Tab_esc_nb[1]]][msb]);
353 0 : if (a1 != 0)
354 : {
355 0 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
356 : }
357 0 : if (b1 != 0)
358 : {
359 0 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
360 : }
361 :
362 0 : if (nbits32 <= 0)
363 : {
364 0 : lastnz2 = add(k, 2);
365 : }
366 0 : if (nbits32 <= 0)
367 : {
368 0 : nbits232 = nbits32;
369 0 : move32();
370 : }
371 :
372 0 : c = add(shl_pos(s_and(c, 0xf), 4), L_add(L_shl_pos(L_add(a1_msb, b1_msb), 1), 1));
373 : }
374 : ELSE
375 : {
376 0 : levmax = sub(maxlevs, sub(norm_l(ab_max), 8));
377 0 : codingdata[1] = levmax;
378 0 : move16();
379 0 : FOR (lev = 0; lev < levmax; lev++)
380 : {
381 0 : lev1 = s_min(lev, 3);
382 0 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t + Tab_esc_nb[lev1]]][VAL_ESC]);
383 : }
384 0 : nbits32 = L_add(nbits32, L_shl_pos(L_deposit_l(levmax), SYM_BITS_Q + 1));
385 0 : a1_msb = L_shr(a1, levmax);
386 0 : b1_msb = L_shr(b1, levmax);
387 0 : msb = L_add(a1_msb, L_shl_pos(b1_msb, A_THRES_SHIFT));
388 0 : codingdata[2] = msb;
389 0 : move16();
390 0 : lev1 = s_min(levmax, 3);
391 0 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t + Tab_esc_nb[lev1]]][msb]);
392 0 : if (a1 != 0)
393 : {
394 0 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
395 : }
396 0 : if (b1 != 0)
397 : {
398 0 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
399 : }
400 :
401 0 : if (nbits32 <= 0)
402 : {
403 0 : lastnz2 = add(k, 2);
404 : }
405 0 : if (nbits32 <= 0)
406 : {
407 0 : nbits232 = nbits32;
408 0 : move32();
409 : }
410 :
411 0 : c = add(shl_pos(s_and(c, 0xf), 4), add(12, s_min(levmax, 3)));
412 : }
413 :
414 0 : a1_i += 2;
415 0 : b1_i += 2;
416 0 : codingdata += 3;
417 :
418 : } /* end of the 2-tuples loop */
419 : }
420 : ELSE
421 : {
422 : /* Main Loop through the 2-tuples */
423 0 : FOR (k = 0; k < lastnz; k += 2)
424 : {
425 :
426 : /* Get context */
427 0 : t = add(c, rateFlag);
428 :
429 0 : if (sub(k, nt_half) > 0)
430 : {
431 0 : t = add(t, 1 << NBITS_CONTEXT);
432 : }
433 :
434 0 : codingdata[0] = t;
435 0 : move16();
436 :
437 : /* Init current 2-tuple encoding */
438 0 : a1 = L_abs(xq[a1_i]);
439 0 : b1 = L_abs(xq[b1_i]);
440 0 : ab_max = L_max(a1, b1);
441 :
442 0 : IF (ab_max == 0)
443 : {
444 0 : codingdata[1] = -1;
445 0 : move16();
446 0 : codingdata[2] = 0;
447 0 : move16();
448 0 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t]][0]);
449 0 : c = add(shl_pos(s_and(c, 0xf), 4), 1);
450 : }
451 0 : ELSE IF (L_sub(ab_max, A_THRES) < 0)
452 : {
453 0 : codingdata[1] = 0;
454 0 : move16();
455 0 : msb = L_add(a1, L_shl_pos(b1, A_THRES_SHIFT));
456 0 : codingdata[2] = msb;
457 0 : move16();
458 0 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t]][msb]);
459 0 : if (a1 != 0)
460 : {
461 0 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
462 : }
463 0 : if (b1 != 0)
464 : {
465 0 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
466 : }
467 :
468 0 : if (nbits32 <= 0)
469 : {
470 0 : lastnz2 = add(k, 2);
471 : }
472 0 : if (nbits32 <= 0)
473 : {
474 0 : nbits232 = nbits32;
475 0 : move32();
476 : }
477 :
478 0 : c = add(shl_pos(s_and(c, 0xf), 4), add(add(a1, b1), 1));
479 : }
480 0 : ELSE IF (L_sub(ab_max, 2 * A_THRES) < 0)
481 : {
482 0 : codingdata[1] = 1;
483 0 : move16();
484 0 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t]][VAL_ESC]);
485 0 : a1_msb = L_shr_pos_pos(a1, 1);
486 0 : b1_msb = L_shr_pos_pos(b1, 1);
487 0 : msb = L_add(a1_msb, L_shl_pos(b1_msb, A_THRES_SHIFT));
488 0 : codingdata[2] = msb;
489 0 : move16();
490 0 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t + Tab_esc_nb[1]]][msb]);
491 0 : if (a1_msb != 0)
492 : {
493 0 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
494 : }
495 0 : if (b1_msb != 0)
496 : {
497 0 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
498 : }
499 0 : nbits_lsb = add(nbits_lsb, 2);
500 0 : if (L_sub(a1, 1) == 0)
501 : {
502 0 : nbits_lsb = add(nbits_lsb, 1);
503 : }
504 0 : if (L_sub(b1, 1) == 0)
505 : {
506 0 : nbits_lsb = add(nbits_lsb, 1);
507 : }
508 :
509 0 : if (nbits32 <= 0)
510 : {
511 0 : lastnz2 = add(k, 2);
512 : }
513 0 : if (nbits32 <= 0)
514 : {
515 0 : nbits232 = nbits32;
516 0 : move32();
517 : }
518 :
519 0 : c = add(shl_pos(s_and(c, 0xf), 4), add(shl_pos(add(a1_msb, b1_msb), 1), 1));
520 : }
521 : ELSE
522 : {
523 0 : levmax = sub(maxlevs, sub(norm_l(ab_max), 8));
524 0 : codingdata[1] = levmax;
525 0 : move16();
526 0 : FOR (lev = 0; lev < levmax; lev++)
527 : {
528 0 : lev1 = s_min(lev, 3);
529 0 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t + Tab_esc_nb[lev1]]][VAL_ESC]);
530 : }
531 0 : nbits32 = L_add(nbits32, L_shl_pos(L_deposit_l(sub(levmax, 1)), SYM_BITS_Q + 1));
532 0 : a1_msb = L_shr(a1, levmax);
533 0 : b1_msb = L_shr(b1, levmax);
534 0 : msb = L_add(a1_msb, L_shl_pos(b1_msb, A_THRES_SHIFT));
535 0 : codingdata[2] = msb;
536 0 : move16();
537 0 : lev1 = s_min(levmax, 3);
538 0 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t + Tab_esc_nb[lev1]]][msb]);
539 0 : a1_msb = L_shr_pos(a1, 1);
540 0 : b1_msb = L_shr_pos(b1, 1);
541 0 : if (a1_msb != 0)
542 : {
543 0 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
544 : }
545 0 : if (b1_msb != 0)
546 : {
547 0 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
548 : }
549 0 : nbits_lsb = add(nbits_lsb, 2);
550 0 : if (L_sub(a1, 1) == 0)
551 : {
552 0 : nbits_lsb = add(nbits_lsb, 1);
553 : }
554 0 : if (L_sub(b1, 1) == 0)
555 : {
556 0 : nbits_lsb = add(nbits_lsb, 1);
557 : }
558 :
559 0 : if (nbits32 <= 0)
560 : {
561 0 : lastnz2 = add(k, 2);
562 : }
563 0 : if (nbits32 <= 0)
564 : {
565 0 : nbits232 = nbits32;
566 0 : move32();
567 : }
568 :
569 0 : c = add(shl_pos(s_and(c, 0xf), 4), add(12, s_min(levmax, 3)));
570 : }
571 :
572 0 : a1_i += 2;
573 0 : b1_i += 2;
574 0 : codingdata += 3;
575 :
576 : } /* end of the 2-tuples loop */
577 : }
578 :
579 : /* Number of consumed bits */
580 0 : nbits32 = L_add(nbits32, target32);
581 0 : totBits = add(extract_l(L_shr_pos_pos(L_sub(nbits32, 1), SYM_BITS_Q)), 1);
582 0 : IF (mode > 0)
583 : {
584 0 : totBits = add(totBits, nbits_lsb);
585 : }
586 0 : IF (nBits != NULL)
587 : {
588 0 : *nBits = totBits;
589 : }
590 0 : IF (mode >= 0)
591 : {
592 0 : nbits232 = L_add(nbits232, target32);
593 0 : *nBits2 = add(extract_l(L_shr_pos(L_sub(nbits232, 1), SYM_BITS_Q)), 1);
594 : }
595 : ELSE
596 : {
597 0 : *nBits2 = *nBits;
598 0 : move16();
599 : }
600 0 : IF (mode > 0)
601 : {
602 0 : *nBits2 = add(*nBits2, nbits_lsb);
603 : }
604 0 : *lastnzout = lastnz2;
605 :
606 : /* Truncation of high frequency coefficients */
607 0 : IF (lastnz > lastnz2)
608 : {
609 0 : basop_memset(&xq[lastnz2], 0, (lastnz - lastnz2) * sizeof(*xq));
610 : }
611 :
612 : /* Truncation of LSBs */
613 0 : test();
614 0 : IF (mode > 0 && sub(totBits, target) > 0)
615 : {
616 0 : *lsbMode = 1;
617 0 : move16();
618 : }
619 : ELSE
620 : {
621 0 : *lsbMode = 0;
622 0 : move16();
623 : }
624 :
625 : #ifdef DYNMEM_COUNT
626 : Dyn_Mem_Out();
627 : #endif
628 0 : }
629 :
630 : #else /* ENABLE_HR_MODE */
631 :
632 : void processQuantizeSpec_fx(Word32 x[], Word16 x_e, Word16 gain, Word16 gain_e, Word16 xq[], Word16 nt, Word16 target,
633 : Word16 totalBits, Word16 *nBits, Word16 *nBits2, Word16 fs_idx, Word16 *lastnzout,
634 : Word16 *codingdata, Word16 *lsbMode, Word16 mode
635 : )
636 : {
637 :
638 : Word16 a1, b1, a1_i, b1_i;
639 : Word16 t, lev1;
640 : Word16 lastnz, lastnz2;
641 : Word16 rateFlag;
642 : Word32 nbits32, nbits232, target32;
643 : Word16 nt_half;
644 : Word16 c, ab_max, msb, a1_msb, b1_msb, levmax;
645 : Word16 s;
646 : Word16 totBits, nbits_lsb;
647 : Counter k, lev;
648 : Word16 tmp16;
649 : Word32 offs32;
650 : Counter i;
651 :
652 : #ifdef DYNMEM_COUNT
653 : Dyn_Mem_In("processQuantizeSpec_fx", sizeof(struct {
654 : Word16 a1, b1, a1_i, b1_i;
655 : Word16 t, lev1;
656 : Word16 lastnz, lastnz2;
657 : Word16 rateFlag;
658 : Word32 nbits32, nbits232;
659 : Word16 nt_half;
660 : Word16 c, ab_max, msb, a1_msb, b1_msb, levmax;
661 : Counter k, lev, i;
662 : Word16 s;
663 : Word16 tmp16;
664 : Word32 offs32, target32;
665 : Word16 totBits, nbits_lsb;
666 : }));
667 : #endif
668 :
669 : /* Quantization */
670 : gain = Inv16_lc3plus(gain, &gain_e);
671 : s = sub(add(x_e, gain_e), 15);
672 : s = s_max(s_min(s, 15), -15);
673 :
674 : FOR (i = 0; i < nt; i++)
675 : {
676 : offs32 = Mpy_32_16_lc3plus(L_abs(x[i]), gain); /* multiply */
677 : offs32 = L_shl(offs32, s); /* convert to 15Q16 */
678 : tmp16 = extract_h(L_add(offs32, 0x00006000)); /* add offset and truncate */
679 : Word16 x_sign = (Word16) L_shr(x[i], 31);
680 : xq[i] = sub(s_xor(tmp16, x_sign), x_sign);
681 : move16();
682 : /*
683 : Normal quantization: xq[i] = x[i] / gg + sign(x[i]) * 0.375
684 : -> 0.375 = 0x00006000 in 15Q16
685 : */
686 : }
687 :
688 : /* Rate flag */
689 : rateFlag = 0;
690 : move16();
691 : if (sub(totalBits, add(160, DEPR_i_mult(fs_idx, 160))) > 0)
692 : {
693 : rateFlag = 2 << NBITS_CONTEXT;
694 : move16();
695 : }
696 :
697 : /* Init */
698 : nt_half = shr_pos(nt, 1);
699 : c = 0;
700 : move16();
701 : t = 0;
702 : move16();
703 : a1_i = 0;
704 : move16();
705 : b1_i = 1;
706 : move16();
707 : target32 = L_shl_pos(L_deposit_l(target), SYM_BITS_Q);
708 : nbits32 = L_negate(target32);
709 : nbits232 = 0;
710 : move32();
711 : nbits_lsb = 0;
712 : move16();
713 : IF (mode == 0 && sub(totalBits, add(480, DEPR_i_mult(fs_idx, 160))) >= 0)
714 : {
715 : mode = 1;
716 : move16();
717 : }
718 :
719 : /* Find last non-zero tuple */
720 : lastnz = find_last_nz_pair(xq, nt);
721 : IF (mode >= 0)
722 : {
723 : lastnz2 = 2;
724 : }
725 : ELSE
726 : {
727 : lastnz2 = lastnz;
728 : }
729 :
730 : IF (mode < 0)
731 : {
732 : /* Main Loop through the 2-tuples */
733 : FOR (k = 0; k < lastnz; k += 2)
734 : {
735 :
736 : /* Get context */
737 : t = add(c, rateFlag);
738 : if (sub(k, nt_half) > 0)
739 : {
740 : t = add(t, 1 << NBITS_CONTEXT);
741 : }
742 : codingdata[0] = t;
743 : move16();
744 :
745 : /* Init current 2-tuple encoding */
746 : a1 = abs_s(xq[a1_i]);
747 : b1 = abs_s(xq[b1_i]);
748 : ab_max = s_max(a1, b1);
749 :
750 : IF (ab_max == 0)
751 : {
752 : codingdata[1] = -1;
753 : move16();
754 : codingdata[2] = 0;
755 : move16();
756 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t]][0]);
757 : c = add(shl_pos(s_and(c, 0xf), 4), 1);
758 : }
759 : ELSE IF (sub(ab_max, A_THRES) < 0)
760 : {
761 : codingdata[1] = 0;
762 : move16();
763 : msb = add(a1, shl_pos(b1, A_THRES_SHIFT));
764 : codingdata[2] = msb;
765 : move16();
766 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t]][msb]);
767 : if (a1 != 0)
768 : {
769 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
770 : }
771 : if (b1 != 0)
772 : {
773 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
774 : }
775 : c = add(shl_pos(s_and(c, 0xf), 4), add(add(a1, b1), 1));
776 : }
777 : ELSE IF (sub(ab_max, 2 * A_THRES) < 0)
778 : {
779 : codingdata[1] = 1;
780 : move16();
781 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t]][VAL_ESC]);
782 : nbits32 = L_add(nbits32, 2 << SYM_BITS_Q);
783 : a1_msb = shr_pos_pos(a1, 1);
784 : b1_msb = shr_pos_pos(b1, 1);
785 : msb = add(a1_msb, shl_pos(b1_msb, A_THRES_SHIFT));
786 : codingdata[2] = msb;
787 : move16();
788 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t + Tab_esc_nb[1]]][msb]);
789 : if (a1 != 0)
790 : {
791 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
792 : }
793 : if (b1 != 0)
794 : {
795 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
796 : }
797 : c = add(shl_pos(s_and(c, 0xf), 4), add(shl_pos(add(a1_msb, b1_msb), 1), 1));
798 : }
799 : ELSE
800 : {
801 : levmax = sub(13, norm_s(ab_max));
802 : codingdata[1] = levmax;
803 : move16();
804 : FOR (lev = 0; lev < levmax; lev++)
805 : {
806 : lev1 = s_min(lev, 3);
807 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t + Tab_esc_nb[lev1]]][VAL_ESC]);
808 : }
809 : nbits32 = L_add(nbits32, L_shl_pos(L_deposit_l(levmax), SYM_BITS_Q + 1));
810 : a1_msb = shr(a1, levmax);
811 : b1_msb = shr(b1, levmax);
812 : msb = add(a1_msb, shl_pos(b1_msb, A_THRES_SHIFT));
813 : codingdata[2] = msb;
814 : move16();
815 : lev1 = s_min(levmax, 3);
816 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t + Tab_esc_nb[lev1]]][msb]);
817 : if (a1 != 0)
818 : {
819 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
820 : }
821 : if (b1 != 0)
822 : {
823 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
824 : }
825 : c = add(shl_pos(s_and(c, 0xf), 4), add(12, s_min(levmax, 3)));
826 : }
827 :
828 : a1_i += 2;
829 : b1_i += 2;
830 : codingdata += 3;
831 :
832 : } /* end of the 2-tuples loop */
833 : }
834 : ELSE IF (mode == 0)
835 : {
836 : /* Main Loop through the 2-tuples */
837 : FOR (k = 0; k < lastnz; k += 2)
838 : {
839 :
840 : /* Get context */
841 : t = add(c, rateFlag);
842 : if (sub(k, nt_half) > 0)
843 : {
844 : t = add(t, 1 << NBITS_CONTEXT);
845 : }
846 : codingdata[0] = t;
847 : move16();
848 :
849 : /* Init current 2-tuple encoding */
850 : a1 = abs_s(xq[a1_i]);
851 : b1 = abs_s(xq[b1_i]);
852 : ab_max = s_max(a1, b1);
853 :
854 : IF (ab_max == 0)
855 : {
856 : codingdata[1] = -1;
857 : move16();
858 : codingdata[2] = 0;
859 : move16();
860 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t]][0]);
861 : c = add(shl_pos(s_and(c, 0xf), 4), 1);
862 : }
863 : ELSE IF (sub(ab_max, A_THRES) < 0)
864 : {
865 : codingdata[1] = 0;
866 : move16();
867 : msb = add(a1, shl_pos(b1, A_THRES_SHIFT));
868 : codingdata[2] = msb;
869 : move16();
870 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t]][msb]);
871 : if (a1 != 0)
872 : {
873 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
874 : }
875 : if (b1 != 0)
876 : {
877 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
878 : }
879 : if (nbits32 <= 0)
880 : {
881 : lastnz2 = add(k, 2);
882 : }
883 : if (nbits32 <= 0)
884 : {
885 : nbits232 = nbits32;
886 : move32();
887 : }
888 : c = add(shl_pos(s_and(c, 0xf), 4), add(add(a1, b1), 1));
889 : }
890 : ELSE IF (sub(ab_max, 2 * A_THRES) < 0)
891 : {
892 : codingdata[1] = 1;
893 : move16();
894 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t]][VAL_ESC]);
895 : nbits32 = L_add(nbits32, 2 << SYM_BITS_Q);
896 : a1_msb = shr_pos_pos(a1, 1);
897 : b1_msb = shr_pos_pos(b1, 1);
898 : msb = add(a1_msb, shl_pos(b1_msb, A_THRES_SHIFT));
899 : codingdata[2] = msb;
900 : move16();
901 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t + Tab_esc_nb[1]]][msb]);
902 : if (a1 != 0)
903 : {
904 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
905 : }
906 : if (b1 != 0)
907 : {
908 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
909 : }
910 : if (nbits32 <= 0)
911 : {
912 : lastnz2 = add(k, 2);
913 : }
914 : if (nbits32 <= 0)
915 : {
916 : nbits232 = nbits32;
917 : move32();
918 : }
919 : c = add(shl_pos(s_and(c, 0xf), 4), add(shl_pos(add(a1_msb, b1_msb), 1), 1));
920 : }
921 : ELSE
922 : {
923 : levmax = sub(13, norm_s(ab_max));
924 : codingdata[1] = levmax;
925 : move16();
926 : FOR (lev = 0; lev < levmax; lev++)
927 : {
928 : lev1 = s_min(lev, 3);
929 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t + Tab_esc_nb[lev1]]][VAL_ESC]);
930 : }
931 : nbits32 = L_add(nbits32, L_shl_pos(L_deposit_l(levmax), SYM_BITS_Q + 1));
932 : a1_msb = shr(a1, levmax);
933 : b1_msb = shr(b1, levmax);
934 : msb = add(a1_msb, shl_pos(b1_msb, A_THRES_SHIFT));
935 : codingdata[2] = msb;
936 : move16();
937 : lev1 = s_min(levmax, 3);
938 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t + Tab_esc_nb[lev1]]][msb]);
939 : if (a1 != 0)
940 : {
941 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
942 : }
943 : if (b1 != 0)
944 : {
945 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
946 : }
947 : if (nbits32 <= 0)
948 : {
949 : lastnz2 = add(k, 2);
950 : }
951 : if (nbits32 <= 0)
952 : {
953 : nbits232 = nbits32;
954 : move32();
955 : }
956 : c = add(shl_pos(s_and(c, 0xf), 4), add(12, s_min(levmax, 3)));
957 : }
958 :
959 : a1_i += 2;
960 : b1_i += 2;
961 : codingdata += 3;
962 :
963 : } /* end of the 2-tuples loop */
964 : }
965 : ELSE
966 : {
967 : /* Main Loop through the 2-tuples */
968 : FOR (k = 0; k < lastnz; k += 2)
969 : {
970 :
971 : /* Get context */
972 : t = add(c, rateFlag);
973 : if (sub(k, nt_half) > 0)
974 : {
975 : t = add(t, 1 << NBITS_CONTEXT);
976 : }
977 : codingdata[0] = t;
978 : move16();
979 :
980 : /* Init current 2-tuple encoding */
981 : a1 = abs_s(xq[a1_i]);
982 : b1 = abs_s(xq[b1_i]);
983 : ab_max = s_max(a1, b1);
984 :
985 : IF (ab_max == 0)
986 : {
987 : codingdata[1] = -1;
988 : move16();
989 : codingdata[2] = 0;
990 : move16();
991 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t]][0]);
992 : c = add(shl_pos(s_and(c, 0xf), 4), 1);
993 : }
994 : ELSE IF (sub(ab_max, A_THRES) < 0)
995 : {
996 : codingdata[1] = 0;
997 : move16();
998 : msb = add(a1, shl_pos(b1, A_THRES_SHIFT));
999 : codingdata[2] = msb;
1000 : move16();
1001 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t]][msb]);
1002 : if (a1 != 0)
1003 : {
1004 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
1005 : }
1006 : if (b1 != 0)
1007 : {
1008 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
1009 : }
1010 : if (nbits32 <= 0)
1011 : {
1012 : lastnz2 = add(k, 2);
1013 : }
1014 : if (nbits32 <= 0)
1015 : {
1016 : nbits232 = nbits32;
1017 : move32();
1018 : }
1019 : c = add(shl_pos(s_and(c, 0xf), 4), add(add(a1, b1), 1));
1020 : }
1021 : ELSE IF (sub(ab_max, 2 * A_THRES) < 0)
1022 : {
1023 : codingdata[1] = 1;
1024 : move16();
1025 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t]][VAL_ESC]);
1026 : a1_msb = shr_pos_pos(a1, 1);
1027 : b1_msb = shr_pos_pos(b1, 1);
1028 : msb = add(a1_msb, shl_pos(b1_msb, A_THRES_SHIFT));
1029 : codingdata[2] = msb;
1030 : move16();
1031 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t + Tab_esc_nb[1]]][msb]);
1032 : if (a1_msb != 0)
1033 : {
1034 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
1035 : }
1036 : if (b1_msb != 0)
1037 : {
1038 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
1039 : }
1040 : nbits_lsb = add(nbits_lsb, 2);
1041 : if (sub(a1, 1) == 0)
1042 : {
1043 : nbits_lsb = add(nbits_lsb, 1);
1044 : }
1045 : if (sub(b1, 1) == 0)
1046 : {
1047 : nbits_lsb = add(nbits_lsb, 1);
1048 : }
1049 : if (nbits32 <= 0)
1050 : {
1051 : lastnz2 = add(k, 2);
1052 : }
1053 : if (nbits32 <= 0)
1054 : {
1055 : nbits232 = nbits32;
1056 : move32();
1057 : }
1058 : c = add(shl_pos(s_and(c, 0xf), 4), add(shl_pos(add(a1_msb, b1_msb), 1), 1));
1059 : }
1060 : ELSE
1061 : {
1062 : levmax = sub(13, norm_s(ab_max));
1063 : codingdata[1] = levmax;
1064 : move16();
1065 : FOR (lev = 0; lev < levmax; lev++)
1066 : {
1067 : lev1 = s_min(lev, 3);
1068 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t + Tab_esc_nb[lev1]]][VAL_ESC]);
1069 : }
1070 : nbits32 = L_add(nbits32, L_shl_pos(L_deposit_l(sub(levmax, 1)), SYM_BITS_Q + 1));
1071 : a1_msb = shr(a1, levmax);
1072 : b1_msb = shr(b1, levmax);
1073 : msb = add(a1_msb, shl_pos(b1_msb, A_THRES_SHIFT));
1074 : codingdata[2] = msb;
1075 : move16();
1076 : lev1 = s_min(levmax, 3);
1077 : nbits32 = L_add(nbits32, ari_spec_bits[ari_spec_lookup[t + Tab_esc_nb[lev1]]][msb]);
1078 : a1_msb = shr_pos(a1, 1);
1079 : b1_msb = shr_pos(b1, 1);
1080 : if (a1_msb != 0)
1081 : {
1082 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
1083 : }
1084 : if (b1_msb != 0)
1085 : {
1086 : nbits32 = L_add(nbits32, 1 << SYM_BITS_Q);
1087 : }
1088 : nbits_lsb = add(nbits_lsb, 2);
1089 : if (sub(a1, 1) == 0)
1090 : {
1091 : nbits_lsb = add(nbits_lsb, 1);
1092 : }
1093 : if (sub(b1, 1) == 0)
1094 : {
1095 : nbits_lsb = add(nbits_lsb, 1);
1096 : }
1097 : if (nbits32 <= 0)
1098 : {
1099 : lastnz2 = add(k, 2);
1100 : }
1101 : if (nbits32 <= 0)
1102 : {
1103 : nbits232 = nbits32;
1104 : move32();
1105 : }
1106 : c = add(shl_pos(s_and(c, 0xf), 4), add(12, s_min(levmax, 3)));
1107 : }
1108 :
1109 : a1_i += 2;
1110 : b1_i += 2;
1111 : codingdata += 3;
1112 :
1113 : } /* end of the 2-tuples loop */
1114 : }
1115 :
1116 : /* Number of consumed bits */
1117 : nbits32 = L_add(nbits32, target32);
1118 : totBits = add(extract_l(L_shr_pos_pos(L_sub(nbits32, 1), SYM_BITS_Q)), 1);
1119 : IF (mode > 0)
1120 : {
1121 : totBits = add(totBits, nbits_lsb);
1122 : }
1123 : IF (nBits != NULL)
1124 : {
1125 : *nBits = totBits;
1126 : }
1127 : IF (mode >= 0)
1128 : {
1129 : nbits232 = L_add(nbits232, target32);
1130 : *nBits2 = add(extract_l(L_shr_pos(L_sub(nbits232, 1), SYM_BITS_Q)), 1);
1131 : }
1132 : ELSE
1133 : {
1134 : *nBits2 = *nBits;
1135 : move16();
1136 : }
1137 : IF (mode > 0)
1138 : {
1139 : *nBits2 = add(*nBits2, nbits_lsb);
1140 : }
1141 : *lastnzout = lastnz2;
1142 :
1143 : /* Truncation of high frequency coefficients */
1144 : IF (lastnz > lastnz2)
1145 : {
1146 : basop_memset(&xq[lastnz2], 0, (lastnz - lastnz2) * sizeof(*xq));
1147 : }
1148 :
1149 : /* Truncation of LSBs */
1150 : test();
1151 : IF (mode > 0 && sub(totBits, target) > 0)
1152 : {
1153 : *lsbMode = 1;
1154 : move16();
1155 : }
1156 : ELSE
1157 : {
1158 : *lsbMode = 0;
1159 : move16();
1160 : }
1161 :
1162 : #ifdef DYNMEM_COUNT
1163 : Dyn_Mem_Out();
1164 : #endif
1165 : }
1166 :
1167 : #endif /* ENABLE_HR_MODE */
|
