Line data Source code
1 : /******************************************************************************
2 : * ETSI TS 103 634 V1.6.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 "options.h"
11 : #include "wmc_auto.h"
12 : #include "functions.h"
13 :
14 : static void ac_shift_fl(Encoder_State_fl* st);
15 : static void ac_encode_fl(Encoder_State_fl* st, LC3_INT sym_freq, LC3_INT cum_freq);
16 : static void ac_finalize_fl(Encoder_State_fl* st);
17 : static void write_uint_forward_fl(Encoder_State_fl* st, LC3_INT val, LC3_INT numbits);
18 : static void ari_enc_init(Encoder_State_fl* st, LC3_UINT8* bytes, LC3_INT* bp_side, LC3_INT* mask_side);
19 : static LC3_INT sign(LC3_INT x);
20 :
21 : static void read_bit_fl(LC3_UINT8* ptr, LC3_INT* mask_side, LC3_INT* bp_side, LC3_INT* bit);
22 :
23 : static void ac_dec_init_fl(LC3_UINT8* ptr, LC3_INT* bp, Decoder_State_fl* st_fl, LC3_INT from_left, LC3_INT mask_side, LC3_INT *bp_side);
24 :
25 : static LC3_INT32 ac_decode_fl(Decoder_State_fl* st, const LC3_INT16* sym_freq, LC3_INT32 num_sym, LC3_UINT8* ptr, LC3_INT32* bp, LC3_INT32 from_left, LC3_INT32 mask_side, LC3_INT32 *bp_side, LC3_INT16 cur_bin);
26 :
27 : static LC3_INT16 pc_check_bytes(LC3_INT32* bp, Decoder_State_fl* st_fl, LC3_INT32 from_left, LC3_INT32 mask_side, LC3_INT32 *bp_side, LC3_INT16 cur_bin);
28 :
29 : static void calculate_nfseed(LC3_INT *x, LC3_INT L_spec, LC3_INT *nf_seed);
30 : static void findNonZero(LC3_INT* in, LC3_INT len, LC3_INT* outLen);
31 :
32 586911 : void findNonZero(LC3_INT* in, LC3_INT len, LC3_INT* outLen)
33 : {
34 586911 : LC3_INT i = 0, j = 0;
35 :
36 124363911 : for (i = 0; i < len; i++) {
37 123777000 : if (in[i] != 0) {
38 102719498 : j++;
39 : }
40 : }
41 :
42 586911 : *outLen = j;
43 586911 : }
44 :
45 590506 : void calculate_nfseed(LC3_INT *x, LC3_INT L_spec, LC3_INT *nf_seed)
46 : {
47 : LC3_INT k;
48 :
49 590506 : *nf_seed = 0;
50 :
51 125130106 : for (k = 0; k < L_spec; k++) {
52 124539600 : *nf_seed = *nf_seed + (abs(x[k]) & 32767) * k;
53 : }
54 590506 : *nf_seed = *nf_seed & 65535;
55 :
56 590506 : if (*nf_seed >= 32768) {
57 233765 : *nf_seed = *nf_seed - 65536;
58 : }
59 590506 : }
60 :
61 372931694 : static LC3_INT16 pc_check_bytes(LC3_INT32* bp, Decoder_State_fl* st_fl, LC3_INT32 from_left, LC3_INT32 mask_side, LC3_INT32 *bp_side, LC3_INT16 cur_bin)
62 : {
63 : LC3_INT32 bp_local, bp_side_local, offset;
64 : #ifdef WMOPS
65 : push_wmops("pc_check_bytes");
66 : #endif
67 :
68 372931694 : if (st_fl->pc_bytes > 0)
69 : {
70 0 : if (!from_left && mask_side != 1)
71 : {
72 0 : return 0;
73 : }
74 :
75 0 : if (st_fl->pc_c_bp_side > 0 && *bp_side < 0)
76 : {
77 0 : assert(mask_side == 1);
78 0 : assert(st_fl->pc_b_right != -1);
79 0 : *bp_side = st_fl->pc_b_right;
80 :
81 0 : return 0;
82 : }
83 :
84 0 : bp_local = *bp;
85 0 : bp_side_local = *bp_side;
86 :
87 0 : if (from_left)
88 : {
89 0 : if (mask_side == 1)
90 : {
91 0 : bp_side_local = bp_side_local + 1;
92 : }
93 : }
94 : else
95 : {
96 0 : bp_local = bp_local - 1;
97 : }
98 :
99 0 : if (st_fl->pc_b_right == -1)
100 : {
101 0 : offset = -1;
102 0 : if (!st_fl->pc_enc)
103 : {
104 0 : offset = offset + st_fl->pc_bytes;
105 : }
106 :
107 0 : if ((bp_side_local + offset - bp_local) == st_fl->pc_bytes)
108 : {
109 0 : st_fl->pc_b_left = bp_local + 1;
110 0 : st_fl->pc_b_right = bp_side_local - 1;
111 :
112 0 : if (st_fl->pc_enc)
113 : {
114 0 : assert(st_fl->pc_b_right - st_fl->pc_b_left + 1 == st_fl->pc_bytes);
115 0 : return 1;
116 : }
117 : }
118 : }
119 :
120 0 : if (!st_fl->pc_enc && st_fl->pc_b_right > -1)
121 : {
122 0 : if (from_left && *bp == st_fl->pc_b_left)
123 : {
124 0 : *bp = 0;
125 0 : st_fl->pc_c_bp = 1;
126 : }
127 :
128 0 : if (!from_left && bp_side_local == st_fl->pc_b_right)
129 : {
130 0 : *bp_side = st_fl->pc_bytes - 1;
131 0 : st_fl->pc_c_bp_side = 1;
132 : }
133 :
134 0 : if (st_fl->pc_bfi == 2)
135 : {
136 : #ifdef CR13_B_FIX_PC_BINS
137 0 : if (st_fl->pc_c_bp_side && (*bp_side + 1) <= st_fl->pc_be_bp_right)
138 : #else
139 : if ((st_fl->pc_c_bp && (*bp + 1) >= st_fl->pc_be_bp_left) || (st_fl->pc_c_bp_side && (*bp_side + 1) <= st_fl->pc_be_bp_right))
140 : #endif
141 : {
142 0 : st_fl->pc_inv_bin = cur_bin;
143 0 : return 1;
144 : }
145 0 : else if ((st_fl->pc_c_bp && *bp >= 0) || (st_fl->pc_c_bp_side && *bp_side <= (st_fl->pc_bytes - 1)))
146 : {
147 0 : st_fl->pc_inv_bin = MIN(st_fl->pc_inv_bin, cur_bin);
148 0 : return 0;
149 : }
150 : }
151 : }
152 : }
153 :
154 : #ifdef WMOPS
155 : pop_wmops();
156 : #endif
157 372931694 : return 0;
158 : }
159 :
160 : #ifdef CR13_B_FIX_PC_BINS
161 170388127 : static LC3_INT16 pc_check_bytes_ac_decode(LC3_INT32* bp, Decoder_State_fl* st_fl, LC3_INT32 from_left, LC3_INT32 mask_side, LC3_INT32* bp_side, LC3_INT16 cur_bin)
162 : {
163 : LC3_INT32 bp_local, bp_side_local;
164 : #ifdef WMOPS
165 : push_wmops("pc_check_bytes");
166 : #endif
167 :
168 170388127 : if (st_fl->pc_bytes > 0)
169 : {
170 0 : bp_local = *bp;
171 0 : bp_side_local = *bp_side;
172 :
173 0 : if (from_left)
174 : {
175 0 : if (mask_side == 1)
176 : {
177 0 : bp_side_local = bp_side_local + 1;
178 : }
179 : }
180 : else
181 : {
182 0 : bp_local = bp_local - 1;
183 : }
184 :
185 :
186 0 : if (!st_fl->pc_enc && st_fl->pc_b_right > -1)
187 : {
188 :
189 0 : if (st_fl->pc_bfi == 2)
190 : {
191 0 : if ((st_fl->pc_c_bp && (*bp) > st_fl->pc_be_bp_left))
192 : {
193 0 : st_fl->pc_inv_bin = cur_bin;
194 0 : return 1;
195 : }
196 : }
197 : }
198 : }
199 :
200 : #ifdef WMOPS
201 : pop_wmops();
202 : #endif
203 170388127 : return 0;
204 : }
205 : #endif
206 :
207 590506 : void ac_dec_init_fl(LC3_UINT8* ptr, LC3_INT* bp, Decoder_State_fl* st_fl, LC3_INT from_left, LC3_INT mask_side, LC3_INT *bp_side)
208 : {
209 : LC3_INT i;
210 :
211 590506 : if (!st_fl->pc_enc)
212 : {
213 590506 : *bp = *bp + st_fl->pc_bytes;
214 : }
215 :
216 590506 : st_fl->ac_low_fl = 0;
217 :
218 590506 : st_fl->ac_range_fl = (LC3_UINT32) 16777215; /* 2^24 -1 */
219 2362024 : for (i = 0; i < 3; i++) {
220 1771518 : if(pc_check_bytes(bp, st_fl, from_left, mask_side, bp_side, 0) != 0)
221 : {
222 0 : return;
223 : }
224 :
225 1771518 : st_fl->ac_low_fl = (st_fl->ac_low_fl << 8) + (LC3_UINT32)ptr[*bp];
226 1771518 : *bp = *bp + 1;
227 : }
228 :
229 590506 : st_fl->BER_detect = 0;
230 : }
231 :
232 : /* Returns val */
233 170388127 : LC3_INT32 ac_decode_fl(Decoder_State_fl* st, const LC3_INT16* freq, LC3_INT32 num_sym, LC3_UINT8* ptr, LC3_INT32* bp, LC3_INT32 from_left, LC3_INT32 mask_side, LC3_INT32 *bp_side, LC3_INT16 cur_bin)
234 : {
235 : LC3_INT val, tmp, symfreq_loc;
236 : #ifdef WMOPS
237 : push_wmops("ac_decode_fl");
238 : #endif
239 :
240 : #ifdef CR13_B_FIX_PC_BINS
241 170388127 : if (pc_check_bytes_ac_decode(bp, st, from_left, mask_side, bp_side, cur_bin) != 0)
242 : {
243 0 : st->BER_detect = 1;
244 0 : return 0;
245 : }
246 : #endif
247 :
248 170388127 : tmp = st->ac_range_fl >> 10;
249 :
250 170388127 : if (st->ac_low_fl >= (LC3_UINT32)(tmp << 10))
251 : {
252 0 : st->BER_detect = 1;
253 : }
254 :
255 170388127 : val = num_sym - 1;
256 :
257 738753994 : while (st->ac_low_fl < (LC3_UINT32)(tmp * freq[val]))
258 : {
259 568365867 : val--;
260 : }
261 :
262 170388127 : symfreq_loc = freq[val + 1] - freq[val];
263 :
264 170388127 : st->ac_low_fl = st->ac_low_fl - tmp * freq[val];
265 170388127 : st->ac_range_fl = tmp * symfreq_loc;
266 :
267 211256089 : while (st->ac_range_fl < 65536)
268 : {
269 40867962 : st->ac_low_fl = ((LC3_INT32)st->ac_low_fl) & ((LC3_INT32)(16777215));
270 :
271 40867962 : if(pc_check_bytes(bp, st, from_left, mask_side, bp_side, cur_bin) != 0)
272 : {
273 0 : st->BER_detect = 1;
274 0 : return 1;
275 : }
276 :
277 40867962 : st->ac_low_fl = st->ac_low_fl << 8;
278 40867962 : st->ac_low_fl = st->ac_low_fl + ptr[*bp];
279 40867962 : *bp = *bp + 1;
280 40867962 : st->ac_range_fl = st->ac_range_fl << 8;
281 : }
282 :
283 : #ifdef WMOPS
284 : pop_wmops();
285 : #endif
286 170388127 : return val;
287 : }
288 :
289 330292214 : void read_bit_fl(LC3_UINT8* ptr, LC3_INT* mask_side, LC3_INT* bp_side, LC3_INT* bit)
290 : {
291 330292214 : if (ptr[*bp_side] & *mask_side) {
292 159238743 : *bit = 1;
293 : } else {
294 171053471 : *bit = 0;
295 : }
296 :
297 330292214 : if (*mask_side == 128) {
298 41176269 : *mask_side = 1;
299 41176269 : *bp_side = *bp_side - 1;
300 : } else {
301 289115945 : *mask_side = *mask_side * 2;
302 : }
303 330292214 : }
304 :
305 590506 : void processAriDecoder_fl(LC3_UINT8* bytes, LC3_INT bp_side, LC3_INT mask_side, LC3_INT L_spec, LC3_INT fs_idx, LC3_INT enable_lpc_weighting,
306 : LC3_INT tns_numfilters, LC3_INT lsbMode, LC3_INT lastnz, LC3_INT* bfi, LC3_INT* tns_order, LC3_INT fac_ns_idx,
307 : LC3_INT gg_idx, uint8_t * resBits, LC3_INT* x, LC3_INT* nf_seed, LC3_INT* tns_idx, LC3_INT* zero_frame, LC3_INT numbytes,
308 : LC3_INT* nbits_residual, LC3_INT* residualPresent, LC3PLUS_FrameDuration frame_dms,
309 : LC3_INT32 n_pc, LC3_INT32 be_bp_left, LC3_INT32 be_bp_right, LC3_INT32 enc, LC3_INT32 *b_left, LC3_INT32 *spec_inv_idx,
310 : LC3_INT hrmode
311 : )
312 : {
313 : Decoder_State_fl st;
314 : LC3_INT a, b, t, bp;
315 : LC3_INT c;
316 : LC3_INT nbits_side, extra_bits;
317 : LC3_UINT8* ptr;
318 : LC3_INT n, k, lev;
319 : LC3_INT max_lev, tmp;
320 : LC3_INT bit, lev1, pki, sym, save_lev[MAX_LEN], idx_len, total_bits, nbits_ari, rateFlag;
321 :
322 : #ifdef WMOPS
323 : push_wmops("processAriDecoder_fl");
324 : #endif
325 :
326 590506 : total_bits = 8 * numbytes;
327 590506 : rateFlag = 0;
328 :
329 590506 : memset(&st, 0, sizeof(st));
330 :
331 590506 : st.pc_bytes = (n_pc + 1) >> 1;
332 590506 : st.pc_b_left = numbytes + 1;
333 590506 : st.pc_b_right = -1;
334 590506 : st.pc_enc = enc;
335 590506 : st.pc_bfi = *bfi;
336 590506 : st.pc_be_bp_left = floor(be_bp_left / 8);
337 590506 : st.pc_be_bp_right = floor(be_bp_right / 8) - 1;
338 590506 : *spec_inv_idx = L_spec + 1;
339 590506 : assert(st.pc_be_bp_right < st.pc_bytes || st.pc_bytes == 0);
340 :
341 : /* Rate flag */
342 590506 : if (fs_idx != 5)
343 : {
344 590506 : if (total_bits > (160 + fs_idx * 160)) {
345 457376 : rateFlag = 512;
346 : }
347 : }
348 :
349 : /* Init */
350 590506 : c = 0;
351 590506 : t = 0;
352 590506 : bp = 0;
353 :
354 590506 : *b_left = -1;
355 :
356 590506 : ptr = bytes;
357 :
358 : /* Start Decoding */
359 590506 : ac_dec_init_fl(ptr, &bp, &st, 1, mask_side, &bp_side);
360 :
361 : /* Decode TNS data */
362 590506 : tmp = MAXLAG;
363 :
364 :
365 590506 : if (frame_dms <= LC3PLUS_FRAME_DURATION_5MS)
366 : {
367 558314 : tmp /= 2;
368 : }
369 :
370 : /* Decode TNS data */
371 1769020 : for (n = 0; n < tns_numfilters; n++) {
372 :
373 1178514 : if (tns_order[n] > 0) {
374 13810 : tns_order[n] = ac_decode_fl(&st, &ari_tns_order_cf[enable_lpc_weighting][0], 8, ptr, &bp, 1, mask_side, &bp_side, 0);
375 :
376 13810 : tns_order[n] = tns_order[n] + 1;
377 :
378 13810 : if (tns_order[n] > tmp || st.BER_detect > 0)
379 : {
380 0 : goto ber_detect;
381 : }
382 :
383 63730 : for (k = 0; k < tns_order[n]; k++) {
384 49920 : if (bp_side < bp)
385 : {
386 0 : *bfi = 1;
387 0 : return;
388 : }
389 :
390 49920 : tns_idx[n * 8 + k] = ac_decode_fl(&st, &ari_tns_freq_cf[k][0], 17, ptr, &bp, 1, mask_side, &bp_side, 0);
391 :
392 49920 : if (st.BER_detect > 0)
393 : {
394 0 : goto ber_detect;
395 : }
396 : }
397 : }
398 : }
399 :
400 : /* Spectral data */
401 62301570 : for (k = 0; k < lastnz; k = k + 2)
402 : {
403 : /* Context */
404 61711064 : t = c + rateFlag;
405 :
406 61711064 : if (k > (L_spec >> 1))
407 : {
408 30035458 : t = t + 256;
409 : }
410 :
411 : /* Decode amplitude */
412 61711064 : x[k] = 0;
413 61711064 : x[k + 1] = 0;
414 :
415 61711064 : if (hrmode == 1)
416 : {
417 0 : max_lev = 13 + 8;
418 : }
419 : else
420 : {
421 61711064 : max_lev = 13;
422 : }
423 :
424 170324397 : for (lev = 0; lev <= max_lev; lev++)
425 : {
426 170324397 : lev1 = MIN(lev, 3);
427 170324397 : pki = ari_spec_lookup_fl[t + lev1 * 1024];
428 :
429 170324397 : sym = ac_decode_fl(&st, &ari_spec_cumfreq_fl[pki][0], 17, ptr, &bp, 1, mask_side, &bp_side, k);
430 :
431 170324397 : if (sym < 16)
432 : {
433 61711064 : break;
434 : }
435 :
436 108613333 : if (lsbMode == 0 || lev > 0)
437 : {
438 108308188 : if(pc_check_bytes(&bp, &st, 0, mask_side, &bp_side, k) != 0)
439 : {
440 0 : goto ber_detect;
441 : }
442 108308188 : read_bit_fl(ptr, &mask_side, &bp_side, &bit);
443 :
444 108308188 : x[k] = x[k] + (bit << lev);
445 108308188 : if(pc_check_bytes(&bp, &st, 0, mask_side, &bp_side, k) != 0)
446 : {
447 0 : goto ber_detect;
448 : }
449 108308188 : read_bit_fl(ptr, &mask_side, &bp_side, &bit);
450 :
451 108308188 : x[k + 1] = x[k + 1] + (bit << lev);
452 : }
453 : }
454 :
455 61711064 : if ((lev - 1) == 13 && sym == 16)
456 : {
457 0 : goto ber_detect;
458 : }
459 :
460 61711064 : if (hrmode == 0) {
461 61711064 : lev = MIN(lev, 13);
462 : }
463 :
464 61711064 : if (lsbMode == 1) {
465 381061 : save_lev[k] = lev;
466 : }
467 :
468 61711064 : a = sym & 3;
469 61711064 : b = sym >> 2;
470 :
471 61711064 : x[k] = x[k] + (a << lev);
472 61711064 : x[k + 1] = x[k + 1] + (b << lev);
473 :
474 : /* Decode signs */
475 61711064 : if (x[k] > 0) {
476 51741731 : if(pc_check_bytes(&bp, &st, 0, mask_side, &bp_side, k) != 0)
477 : {
478 0 : goto ber_detect;
479 : }
480 51741731 : read_bit_fl(ptr, &mask_side, &bp_side, &bit);
481 :
482 51741731 : if (bit == 1) {
483 25895350 : x[k] = -x[k];
484 : }
485 : }
486 :
487 61711064 : if (x[k + 1] > 0) {
488 51652032 : if(pc_check_bytes(&bp, &st, 0, mask_side, &bp_side, k) != 0)
489 : {
490 0 : goto ber_detect;
491 : }
492 51652032 : read_bit_fl(ptr, &mask_side, &bp_side, &bit);
493 :
494 51652032 : if (bit == 1) {
495 25811231 : x[k + 1] = -x[k + 1];
496 : }
497 : }
498 :
499 : /* Context */
500 61711064 : lev1 = MIN(lev, 3);
501 61711064 : if (lev1 <= 1) {
502 33091588 : t = 1 + (a + b) * (lev1 + 1);
503 : } else {
504 28619476 : t = 12 + lev1;
505 : }
506 :
507 61711064 : c = (c & 15) * 16 + t;
508 :
509 61711064 : if (((bp - bp_side) > 3 && (st.pc_c_bp == st.pc_c_bp_side))) {
510 :
511 0 : if ((0 < *spec_inv_idx) && (*spec_inv_idx < (L_spec + 1)))
512 : {
513 0 : *bfi = 2;
514 0 : calculate_nfseed(x, k, nf_seed);
515 0 : return;
516 : }
517 :
518 0 : *bfi = 1;
519 0 : return;
520 : }
521 :
522 61711064 : if (st.BER_detect > 0)
523 : {
524 0 : goto ber_detect;
525 : }
526 : }
527 :
528 : /* Residual bits */
529 590506 : nbits_side = total_bits - (8 * bp_side + 8 - (31 - clz_func(mask_side)));
530 590506 : nbits_ari = (bp - 3) * 8;
531 590506 : extra_bits = 25 - (31 - clz_func(st.ac_range_fl));
532 :
533 590506 : if (enc == 0)
534 : {
535 590506 : if (st.pc_c_bp == 0)
536 : {
537 590506 : nbits_ari = (bp - st.pc_bytes - 3) * 8;
538 : } else {
539 0 : nbits_ari = (bp + st.pc_b_left - st.pc_bytes - 3) * 8;
540 : }
541 :
542 590506 : if (st.pc_c_bp_side != 0)
543 : {
544 0 : nbits_side = total_bits - 8 * (st.pc_b_left) + 8 * (st.pc_bytes - bp_side) - (8 - LC3_LOGTWO(mask_side));
545 : }
546 : }
547 :
548 :
549 590506 : *nbits_residual = total_bits - (nbits_side + nbits_ari + extra_bits);
550 :
551 590506 : if (*nbits_residual < 0) {
552 0 : if ((0 < *spec_inv_idx) && (*spec_inv_idx < (L_spec + 1)))
553 : {
554 0 : *bfi = 2;
555 0 : calculate_nfseed(x, k, nf_seed);
556 0 : return;
557 : }
558 :
559 0 : *bfi = 1;
560 0 : return;
561 : }
562 :
563 590506 : if (lsbMode == 0) {
564 586911 : findNonZero(x, L_spec, &idx_len);
565 :
566 586911 : if (hrmode)
567 : {
568 0 : idx_len *= EXT_RES_ITER_MAX;
569 : }
570 : #ifdef CR9_C_ADD_1p25MS
571 586911 : if (frame_dms == LC3PLUS_FRAME_DURATION_1p25MS) {
572 0 : idx_len *= 3;
573 : }
574 : #endif
575 :
576 586911 : *nbits_residual = MIN(*nbits_residual, idx_len);
577 586911 : *residualPresent = 1;
578 :
579 586911 : memset(resBits, 0, MAX_RESBITS_LEN);
580 :
581 10247571 : for (k = 0; k < *nbits_residual; k++) {
582 9660660 : if(pc_check_bytes(&bp, &st, 0, mask_side, &bp_side, k) != 0)
583 : {
584 0 : goto ber_detect_res;
585 : }
586 9660660 : read_bit_fl(ptr, &mask_side, &bp_side, &tmp);
587 :
588 9660660 : resBits[k >> 3] |= tmp << (k & 7);
589 : }
590 : } else {
591 347889 : for (k = 0; k < lastnz; k = k + 2) {
592 347303 : if (save_lev[k] > 0) {
593 299762 : if (*nbits_residual == 0) {
594 1221 : break;
595 : }
596 :
597 298541 : if(pc_check_bytes(&bp, &st, 0, mask_side, &bp_side, k) != 0)
598 : {
599 0 : goto ber_detect_res;
600 : }
601 298541 : read_bit_fl(ptr, &mask_side, &bp_side, &bit);
602 :
603 298541 : *nbits_residual = *nbits_residual - 1;
604 :
605 298541 : if (bit == 1) {
606 145228 : if (x[k] > 0) {
607 66495 : x[k] = x[k] + 1;
608 78733 : } else if (x[k] < 0) {
609 65415 : x[k] = x[k] - 1;
610 : } else {
611 13318 : if (*nbits_residual == 0) {
612 121 : break;
613 : }
614 :
615 13197 : if(pc_check_bytes(&bp, &st, 0, mask_side, &bp_side, k) != 0)
616 : {
617 0 : goto ber_detect_res;
618 : }
619 13197 : read_bit_fl(ptr, &mask_side, &bp_side, &bit);
620 :
621 13197 : *nbits_residual = *nbits_residual - 1;
622 :
623 13197 : if (bit == 0) {
624 6566 : x[k] = 1;
625 : } else {
626 6631 : x[k] = -1;
627 : }
628 : }
629 : }
630 :
631 298420 : if (*nbits_residual == 0) {
632 1517 : break;
633 : }
634 :
635 296903 : if(pc_check_bytes(&bp, &st, 0, mask_side, &bp_side, k) != 0)
636 : {
637 0 : goto ber_detect_res;
638 : }
639 296903 : read_bit_fl(ptr, &mask_side, &bp_side, &bit);
640 :
641 296903 : *nbits_residual = *nbits_residual - 1;
642 :
643 296903 : if (bit == 1) {
644 145115 : if (x[k + 1] > 0) {
645 65626 : x[k + 1] = x[k + 1] + 1;
646 79489 : } else if (x[k + 1] < 0) {
647 66565 : x[k + 1] = x[k + 1] - 1;
648 : } else {
649 12924 : if (*nbits_residual == 0) {
650 150 : break;
651 : }
652 :
653 12774 : if(pc_check_bytes(&bp, &st, 0, mask_side, &bp_side, k) != 0)
654 : {
655 0 : goto ber_detect_res;
656 : }
657 12774 : read_bit_fl(ptr, &mask_side, &bp_side, &bit);
658 :
659 12774 : *nbits_residual = *nbits_residual - 1;
660 :
661 12774 : if (bit == 0) {
662 6324 : x[k + 1] = 1;
663 : } else {
664 6450 : x[k + 1] = -1;
665 : }
666 : }
667 : }
668 : }
669 : }
670 : }
671 :
672 : /* Noise-filling seed */
673 590506 : calculate_nfseed(x, L_spec, nf_seed);
674 :
675 : /* Zero frame flag */
676 590506 : if (lastnz == 2 && x[0] == 0 && x[1] == 0 && gg_idx == 0 && fac_ns_idx == 7) {
677 964 : *zero_frame = 1;
678 : } else {
679 589542 : *zero_frame = 0;
680 : }
681 :
682 590506 : if (enc)
683 : {
684 0 : if (st.pc_bytes > 0)
685 : {
686 0 : if (st.pc_b_left > numbytes)
687 : {
688 0 : *b_left = bp_side - st.pc_bytes;
689 : }
690 : }
691 : } else {
692 590506 : if (st.pc_bytes > 0)
693 : {
694 0 : if (st.pc_b_left > numbytes)
695 : {
696 0 : *b_left = bp_side;
697 : }
698 : }
699 : }
700 :
701 590506 : if ((*bfi == 2) && (*spec_inv_idx == (L_spec + 1)))
702 : {
703 0 : *bfi = 0;
704 : }
705 :
706 590506 : *spec_inv_idx = *spec_inv_idx - 1;
707 :
708 590506 : goto bail;
709 :
710 : /* goto for bit error handling */
711 0 : ber_detect:
712 0 : *bfi = 1;
713 0 : *b_left = st.pc_b_left;
714 :
715 0 : if (st.pc_inv_bin > 0 && (st.pc_inv_bin - L_spec) <= 0)
716 : {
717 0 : *spec_inv_idx = st.pc_inv_bin;
718 0 : *bfi = 2;
719 0 : *resBits = 0;
720 0 : *zero_frame = 0;
721 : /* Noise Filling seed */
722 0 : calculate_nfseed(x, *spec_inv_idx, nf_seed);
723 : }
724 0 : goto bail;
725 :
726 : /* goto for bit error handling in residual signal */
727 0 : ber_detect_res:
728 0 : *b_left = st.pc_b_left;
729 0 : *resBits = 0;
730 0 : *bfi = 0;
731 0 : *zero_frame = 0;
732 : /* Noise Filling seed */
733 0 : calculate_nfseed(x, *spec_inv_idx, nf_seed);
734 0 : goto bail;
735 :
736 : /* goto, because of dynmem out */
737 590506 : bail:
738 :
739 : #ifdef WMOPS
740 : pop_wmops();
741 : #endif
742 : /* Avoid warning "label at end of compound statement" when WMOPS is inactive */
743 : (void)0;
744 : }
745 :
746 170388127 : void ac_encode_fl(Encoder_State_fl* st, LC3_INT sym_freq, LC3_INT cum_freq)
747 : {
748 : LC3_INT r;
749 :
750 170388127 : r = st->range >> 10;
751 170388127 : st->low += r * cum_freq;
752 :
753 170388127 : if ((st->low >> 24) == 1) {
754 9643468 : st->carry = 1;
755 : }
756 :
757 170388127 : st->low &= (16777215); /* 2^24 -1 */
758 170388127 : st->range = r * sym_freq;
759 :
760 211256089 : while (st->range < 65536) { /* 2^16 */
761 40867962 : st->range <<= 8;
762 40867962 : ac_shift_fl(st);
763 : }
764 170388127 : }
765 :
766 41499069 : void ac_shift_fl(Encoder_State_fl* st)
767 : {
768 41499069 : if (st->low < 16711680 || st->carry == 1) {
769 41157165 : if (st->cache >= 0) {
770 40566659 : st->ptr[st->bp] = st->cache + st->carry;
771 40566659 : st->bp = st->bp + 1;
772 : }
773 :
774 41498762 : while (st->carry_count > 0) {
775 341597 : st->ptr[st->bp] = (st->carry + 255) & 255;
776 341597 : st->bp = st->bp + 1;
777 341597 : st->carry_count = st->carry_count - 1;
778 : }
779 :
780 41157165 : st->cache = st->low >> 16;
781 41157165 : st->carry = 0;
782 : } else {
783 341904 : st->carry_count = st->carry_count + 1;
784 : }
785 :
786 41499069 : st->low = (LC3_INT)((LC3_UINT32)st->low << 8);
787 41499069 : st->low = (st->low) & (16777215); /* 2^24 - 1 */
788 41499069 : }
789 :
790 :
791 590506 : void ac_finalize_fl(Encoder_State_fl* st)
792 : {
793 590506 : LC3_INT bits = 0, mask = 0, val = 0, over1 = 0, high = 0, over2 = 0, c = 0, b = 0;
794 :
795 590506 : bits = 24 - (31 - clz_func(st->range));
796 590506 : mask = 16777215 >> bits;
797 590506 : val = st->low + mask;
798 590506 : over1 = val >> 24;
799 :
800 590506 : val = (val) & 16777215;
801 590506 : high = st->low + st->range;
802 590506 : over2 = high >> 24;
803 590506 : high = high & 16777215;
804 590506 : val = val & (16777215 - mask);
805 :
806 590506 : if (over1 == over2) {
807 557987 : if (val + mask >= high) {
808 327757 : bits = bits + 1;
809 327757 : mask = mask >> 1;
810 327757 : val = ((st->low + mask) & (16777215)) & (16777215 - mask);
811 : }
812 :
813 557987 : if (val < st->low) {
814 43607 : st->carry = 1;
815 : }
816 : }
817 :
818 590506 : st->low = val;
819 :
820 590506 : b = bits;
821 :
822 590506 : if (bits > 8) {
823 121803 : for (; b >= 1; b = b - 8) {
824 81202 : ac_shift_fl(st);
825 : }
826 : } else {
827 549905 : ac_shift_fl(st);
828 : }
829 :
830 590506 : bits = b;
831 590506 : if (bits < 0) {
832 40601 : bits += 8;
833 : }
834 :
835 590506 : if (st->carry_count > 0) {
836 306 : st->ptr[st->bp] = st->cache;
837 306 : st->bp = st->bp + 1;
838 :
839 307 : for (c = st->carry_count; c >= 2; c--) {
840 1 : st->ptr[st->bp] = 255;
841 1 : st->bp = st->bp + 1;
842 : }
843 :
844 306 : write_uint_forward_fl(st, 255 << (bits - 8), bits);
845 : } else {
846 590200 : write_uint_forward_fl(st, st->cache, bits);
847 : }
848 590506 : }
849 :
850 590506 : void write_uint_forward_fl(Encoder_State_fl* st, LC3_INT val, LC3_INT numbits)
851 : {
852 590506 : LC3_INT k, bit, mask = 128;
853 :
854 3247789 : for (k = 0; k < numbits; k++) {
855 2657283 : bit = val & mask;
856 :
857 2657283 : if (bit == 0) {
858 1258121 : st->ptr[st->bp] = st->ptr[st->bp] & (255 - mask);
859 : } else {
860 1399162 : st->ptr[st->bp] = st->ptr[st->bp] | mask;
861 : }
862 :
863 2657283 : mask = mask >> 1;
864 : }
865 590506 : }
866 :
867 590506 : void ari_enc_init(Encoder_State_fl* st, LC3_UINT8* bytes, LC3_INT* bp_side, LC3_INT* mask_side)
868 : {
869 590506 : st->ptr = bytes;
870 590506 : st->bp_side = bp_side;
871 590506 : st->mask_side = mask_side;
872 590506 : st->bp = 0;
873 590506 : st->low = 0;
874 590506 : st->range = 16777215;
875 590506 : st->cache = -1;
876 590506 : st->carry = 0;
877 590506 : st->carry_count = 0;
878 590506 : }
879 :
880 155141538 : LC3_INT sign(LC3_INT x)
881 : {
882 155141538 : if (x > 0)
883 51700782 : return 1;
884 :
885 103440756 : if (x < 0)
886 103440756 : return -1;
887 :
888 0 : return 0;
889 : }
890 :
891 590506 : void processAriEncoder_fl(LC3_UINT8* bytes, LC3_INT bp_side, LC3_INT mask_side, LC3_INT* x, LC3_INT* tns_order, LC3_INT tns_numfilters,
892 : LC3_INT* tns_idx, LC3_INT lastnz, LC3_INT* codingdata, uint8_t* res_bits, LC3_INT resBitsLen, LC3_INT lsbMode,
893 : LC3_INT nbbits, LC3_INT enable_lpc_weighting)
894 : {
895 : LC3_INT total_bits, cumfreq, symfreq, k, i, j, lev, lev1;
896 : LC3_INT bit1, bit2, lsb1, lsb2, a, b, bit, pki, nbits_side;
897 590506 : LC3_INT nbits_residual_enc, nbits_ari, lsbs[MAX_LEN], lsbsLen = 0;
898 : LC3_INT abs_x_k, abs_x_kp1;
899 : Encoder_State_fl st;
900 :
901 : #ifdef WMOPS
902 : push_wmops("processAriEncoder_fl");
903 : #endif
904 :
905 590506 : ari_enc_init(&st, bytes, &bp_side, &mask_side);
906 :
907 590506 : total_bits = nbbits;
908 :
909 : /* TNS data */
910 1769020 : for (i = 0; i < tns_numfilters; i++) {
911 1178514 : if (tns_order[i] > 0) {
912 13810 : symfreq = tns_freq_cf[enable_lpc_weighting][tns_order[i]] - tns_freq_cf[enable_lpc_weighting][tns_order[i] - 1];
913 13810 : cumfreq = tns_freq_cf[enable_lpc_weighting][tns_order[i] - 1];
914 13810 : ac_encode_fl(&st, symfreq, cumfreq);
915 :
916 63730 : for (j = 0; j < tns_order[i]; j++) {
917 49920 : symfreq = tns_cf[j][tns_idx[i * 8 + j] + 1] - tns_cf[j][tns_idx[i * 8 + j]];
918 49920 : cumfreq = tns_cf[j][tns_idx[i * 8 + j]];
919 49920 : ac_encode_fl(&st, symfreq, cumfreq);
920 : }
921 : }
922 : }
923 :
924 : /* Spectral data */
925 62301570 : for (k = 0; k < lastnz; k = k + 2) {
926 61711064 : abs_x_k = abs(x[k]);
927 61711064 : abs_x_kp1 = abs(x[k + 1]);
928 170324397 : for (lev = 0; lev < codingdata[1]; lev++) {
929 108613333 : lev1 = MIN(lev, 3);
930 108613333 : pki = ari_spec_lookup_fl[codingdata[0] + lev1 * 1024];
931 108613333 : symfreq = ari_spec_cumfreq_fl[pki][17] - ari_spec_cumfreq_fl[pki][16];
932 108613333 : cumfreq = ari_spec_cumfreq_fl[pki][16];
933 :
934 108613333 : ac_encode_fl(&st, symfreq, cumfreq);
935 108613333 : bit1 = (abs_x_k >> lev) & 1;
936 108613333 : bit2 = (abs_x_kp1 >> lev) & 1;
937 :
938 :
939 108613333 : if (lsbMode == 1 && lev == 0) {
940 305145 : lsb1 = bit1;
941 305145 : lsb2 = bit2;
942 : } else {
943 108308188 : write_bit_backward_fl(st.ptr, st.bp_side, st.mask_side, bit1);
944 108308188 : write_bit_backward_fl(st.ptr, st.bp_side, st.mask_side, bit2);
945 : }
946 : }
947 :
948 61711064 : lev1 = MIN(MAX(codingdata[1], 0), 3);
949 61711064 : pki = ari_spec_lookup_fl[codingdata[0] + lev1 * 1024];
950 :
951 61711064 : symfreq = ari_spec_cumfreq_fl[pki][codingdata[2] + 1] - ari_spec_cumfreq_fl[pki][codingdata[2]];
952 61711064 : cumfreq = ari_spec_cumfreq_fl[pki][codingdata[2]];
953 61711064 : ac_encode_fl(&st, symfreq, cumfreq);
954 :
955 61711064 : a = abs_x_k;
956 61711064 : b = abs_x_kp1;
957 :
958 61711064 : if (lsbMode == 1 && codingdata[1] > 0) {
959 305145 : a = a >> 1;
960 305145 : lsbs[lsbsLen] = lsb1;
961 305145 : lsbsLen++;
962 :
963 305145 : if (a == 0 && x[k] != 0) {
964 13790 : bit = MAX(0, -sign(x[k]));
965 13790 : lsbs[lsbsLen] = bit;
966 13790 : lsbsLen++;
967 : }
968 :
969 305145 : b = b >> 1;
970 305145 : lsbs[lsbsLen] = lsb2;
971 305145 : lsbsLen++;
972 :
973 305145 : if (b == 0 && x[k + 1] != 0) {
974 13607 : bit = MAX(0, -sign(x[k + 1]));
975 13607 : lsbs[lsbsLen] = bit;
976 13607 : lsbsLen++;
977 : }
978 : }
979 :
980 61711064 : if (a != 0) {
981 51741731 : bit = MAX(0, -sign(x[k]));
982 51741731 : write_bit_backward_fl(st.ptr, st.bp_side, st.mask_side, bit);
983 : }
984 :
985 61711064 : if (b != 0) {
986 51652032 : bit = MAX(0, -sign(x[k + 1]));
987 51652032 : write_bit_backward_fl(st.ptr, st.bp_side, st.mask_side, bit);
988 : }
989 :
990 61711064 : codingdata += 3;
991 : }
992 :
993 : /* Residual bits */
994 590506 : nbits_side = total_bits - (8 * (*(st.bp_side) + 1) + 8 - (31 - clz_func(*(st.mask_side))));
995 590506 : nbits_ari = 8 * (st.bp + 1) + 25 - (31 - clz_func(st.range )) ;
996 :
997 590506 : if (st.cache >= 0) {
998 590254 : nbits_ari = nbits_ari + 8;
999 : }
1000 :
1001 590506 : if (st.carry_count > 0) {
1002 2244 : nbits_ari = nbits_ari + st.carry_count * 8;
1003 : }
1004 :
1005 590506 : nbits_residual_enc = MAX(total_bits - (nbits_side + nbits_ari), 0);
1006 : /* the max operation avoids in very rare cases, that
1007 : * nbits_residual_enc becomes negative; having overwritten
1008 : * the last bit(s) of the side information is in this case
1009 : * assumed to be not critical, since no spectral data bits
1010 : * were written */
1011 :
1012 590506 : if (lsbMode == 0) {
1013 586911 : nbits_residual_enc = MIN(nbits_residual_enc, resBitsLen);
1014 10247571 : for (k = 0; k < nbits_residual_enc; k++) {
1015 9660660 : if (res_bits[k >> 3] & (1 << (k & 7)))
1016 : {
1017 4829818 : write_bit_backward_fl(st.ptr, st.bp_side, st.mask_side, 1);
1018 : }
1019 : else
1020 : {
1021 4830842 : write_bit_backward_fl(st.ptr, st.bp_side, st.mask_side, 0);
1022 : }
1023 : }
1024 : } else {
1025 3595 : nbits_residual_enc = MIN(nbits_residual_enc, lsbsLen);
1026 :
1027 625010 : for (k = 0; k < nbits_residual_enc; k++) {
1028 621415 : write_bit_backward_fl(st.ptr, st.bp_side, st.mask_side, lsbs[k]);
1029 : }
1030 : }
1031 :
1032 590506 : ac_finalize_fl(&st);
1033 : #ifdef WMOPS
1034 : pop_wmops();
1035 : #endif
1036 590506 : }
1037 :
|
