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 1160429 : void findNonZero(LC3_INT* in, LC3_INT len, LC3_INT* outLen)
33 : {
34 1160429 : LC3_INT i = 0, j = 0;
35 :
36 243094549 : for (i = 0; i < len; i++) {
37 241934120 : if (in[i] != 0) {
38 198453547 : j++;
39 : }
40 : }
41 :
42 1160429 : *outLen = j;
43 1160429 : }
44 :
45 1178242 : void calculate_nfseed(LC3_INT *x, LC3_INT L_spec, LC3_INT *nf_seed)
46 : {
47 : LC3_INT k;
48 :
49 1178242 : *nf_seed = 0;
50 :
51 246806962 : for (k = 0; k < L_spec; k++) {
52 245628720 : *nf_seed = *nf_seed + (abs(x[k]) & 32767) * k;
53 : }
54 1178242 : *nf_seed = *nf_seed & 65535;
55 :
56 1178242 : if (*nf_seed >= 32768) {
57 501819 : *nf_seed = *nf_seed - 65536;
58 : }
59 1178242 : }
60 :
61 737509711 : 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 737509711 : 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 737509711 : return 0;
158 : }
159 :
160 : #ifdef CR13_B_FIX_PC_BINS
161 337981884 : 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 337981884 : 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 337981884 : return 0;
204 : }
205 : #endif
206 :
207 1178242 : 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 1178242 : if (!st_fl->pc_enc)
212 : {
213 1178242 : *bp = *bp + st_fl->pc_bytes;
214 : }
215 :
216 1178242 : st_fl->ac_low_fl = 0;
217 :
218 1178242 : st_fl->ac_range_fl = (LC3_UINT32) 16777215; /* 2^24 -1 */
219 4712968 : for (i = 0; i < 3; i++) {
220 3534726 : if(pc_check_bytes(bp, st_fl, from_left, mask_side, bp_side, 0) != 0)
221 : {
222 0 : return;
223 : }
224 :
225 3534726 : st_fl->ac_low_fl = (st_fl->ac_low_fl << 8) + (LC3_UINT32)ptr[*bp];
226 3534726 : *bp = *bp + 1;
227 : }
228 :
229 1178242 : st_fl->BER_detect = 0;
230 : }
231 :
232 : /* Returns val */
233 337981884 : 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 337981884 : 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 337981884 : tmp = st->ac_range_fl >> 10;
249 :
250 337981884 : if (st->ac_low_fl >= (LC3_UINT32)(tmp << 10))
251 : {
252 0 : st->BER_detect = 1;
253 : }
254 :
255 337981884 : val = num_sym - 1;
256 :
257 1457345238 : while (st->ac_low_fl < (LC3_UINT32)(tmp * freq[val]))
258 : {
259 1119363354 : val--;
260 : }
261 :
262 337981884 : symfreq_loc = freq[val + 1] - freq[val];
263 :
264 337981884 : st->ac_low_fl = st->ac_low_fl - tmp * freq[val];
265 337981884 : st->ac_range_fl = tmp * symfreq_loc;
266 :
267 419745117 : while (st->ac_range_fl < 65536)
268 : {
269 81763233 : st->ac_low_fl = ((LC3_INT32)st->ac_low_fl) & ((LC3_INT32)(16777215));
270 :
271 81763233 : 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 81763233 : st->ac_low_fl = st->ac_low_fl << 8;
278 81763233 : st->ac_low_fl = st->ac_low_fl + ptr[*bp];
279 81763233 : *bp = *bp + 1;
280 81763233 : st->ac_range_fl = st->ac_range_fl << 8;
281 : }
282 :
283 : #ifdef WMOPS
284 : pop_wmops();
285 : #endif
286 337981884 : return val;
287 : }
288 :
289 652211752 : void read_bit_fl(LC3_UINT8* ptr, LC3_INT* mask_side, LC3_INT* bp_side, LC3_INT* bit)
290 : {
291 652211752 : if (ptr[*bp_side] & *mask_side) {
292 314355521 : *bit = 1;
293 : } else {
294 337856231 : *bit = 0;
295 : }
296 :
297 652211752 : if (*mask_side == 128) {
298 81370862 : *mask_side = 1;
299 81370862 : *bp_side = *bp_side - 1;
300 : } else {
301 570840890 : *mask_side = *mask_side * 2;
302 : }
303 652211752 : }
304 :
305 1178242 : 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 1178242 : total_bits = 8 * numbytes;
327 1178242 : rateFlag = 0;
328 :
329 1178242 : memset(&st, 0, sizeof(st));
330 :
331 1178242 : st.pc_bytes = (n_pc + 1) >> 1;
332 1178242 : st.pc_b_left = numbytes + 1;
333 1178242 : st.pc_b_right = -1;
334 1178242 : st.pc_enc = enc;
335 1178242 : st.pc_bfi = *bfi;
336 1178242 : st.pc_be_bp_left = floor(be_bp_left / 8);
337 1178242 : st.pc_be_bp_right = floor(be_bp_right / 8) - 1;
338 1178242 : *spec_inv_idx = L_spec + 1;
339 1178242 : assert(st.pc_be_bp_right < st.pc_bytes || st.pc_bytes == 0);
340 :
341 : /* Rate flag */
342 1178242 : if (fs_idx != 5)
343 : {
344 1178242 : if (total_bits > (160 + fs_idx * 160)) {
345 927539 : rateFlag = 512;
346 : }
347 : }
348 :
349 : /* Init */
350 1178242 : c = 0;
351 1178242 : t = 0;
352 1178242 : bp = 0;
353 :
354 1178242 : *b_left = -1;
355 :
356 1178242 : ptr = bytes;
357 :
358 : /* Start Decoding */
359 1178242 : ac_dec_init_fl(ptr, &bp, &st, 1, mask_side, &bp_side);
360 :
361 : /* Decode TNS data */
362 1178242 : tmp = MAXLAG;
363 :
364 :
365 1178242 : if (frame_dms <= LC3PLUS_FRAME_DURATION_5MS)
366 : {
367 1128326 : tmp /= 2;
368 : }
369 :
370 : /* Decode TNS data */
371 3519036 : for (n = 0; n < tns_numfilters; n++) {
372 :
373 2340794 : if (tns_order[n] > 0) {
374 266472 : 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 266472 : tns_order[n] = tns_order[n] + 1;
377 :
378 266472 : if (tns_order[n] > tmp || st.BER_detect > 0)
379 : {
380 0 : goto ber_detect;
381 : }
382 :
383 1281391 : for (k = 0; k < tns_order[n]; k++) {
384 1014919 : if (bp_side < bp)
385 : {
386 0 : *bfi = 1;
387 0 : return;
388 : }
389 :
390 1014919 : 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 1014919 : if (st.BER_detect > 0)
393 : {
394 0 : goto ber_detect;
395 : }
396 : }
397 : }
398 : }
399 :
400 : /* Spectral data */
401 122059456 : for (k = 0; k < lastnz; k = k + 2)
402 : {
403 : /* Context */
404 120881214 : t = c + rateFlag;
405 :
406 120881214 : if (k > (L_spec >> 1))
407 : {
408 58875272 : t = t + 256;
409 : }
410 :
411 : /* Decode amplitude */
412 120881214 : x[k] = 0;
413 120881214 : x[k + 1] = 0;
414 :
415 120881214 : if (hrmode == 1)
416 : {
417 0 : max_lev = 13 + 8;
418 : }
419 : else
420 : {
421 120881214 : max_lev = 13;
422 : }
423 :
424 336700493 : for (lev = 0; lev <= max_lev; lev++)
425 : {
426 336700493 : lev1 = MIN(lev, 3);
427 336700493 : pki = ari_spec_lookup_fl[t + lev1 * 1024];
428 :
429 336700493 : sym = ac_decode_fl(&st, &ari_spec_cumfreq_fl[pki][0], 17, ptr, &bp, 1, mask_side, &bp_side, k);
430 :
431 336700493 : if (sym < 16)
432 : {
433 120881214 : break;
434 : }
435 :
436 215819279 : if (lsbMode == 0 || lev > 0)
437 : {
438 214387019 : if(pc_check_bytes(&bp, &st, 0, mask_side, &bp_side, k) != 0)
439 : {
440 0 : goto ber_detect;
441 : }
442 214387019 : read_bit_fl(ptr, &mask_side, &bp_side, &bit);
443 :
444 214387019 : x[k] = x[k] + (bit << lev);
445 214387019 : if(pc_check_bytes(&bp, &st, 0, mask_side, &bp_side, k) != 0)
446 : {
447 0 : goto ber_detect;
448 : }
449 214387019 : read_bit_fl(ptr, &mask_side, &bp_side, &bit);
450 :
451 214387019 : x[k + 1] = x[k + 1] + (bit << lev);
452 : }
453 : }
454 :
455 120881214 : if ((lev - 1) == 13 && sym == 16)
456 : {
457 0 : goto ber_detect;
458 : }
459 :
460 120881214 : if (hrmode == 0) {
461 120881214 : lev = MIN(lev, 13);
462 : }
463 :
464 120881214 : if (lsbMode == 1) {
465 1843642 : save_lev[k] = lev;
466 : }
467 :
468 120881214 : a = sym & 3;
469 120881214 : b = sym >> 2;
470 :
471 120881214 : x[k] = x[k] + (a << lev);
472 120881214 : x[k + 1] = x[k + 1] + (b << lev);
473 :
474 : /* Decode signs */
475 120881214 : if (x[k] > 0) {
476 100894084 : if(pc_check_bytes(&bp, &st, 0, mask_side, &bp_side, k) != 0)
477 : {
478 0 : goto ber_detect;
479 : }
480 100894084 : read_bit_fl(ptr, &mask_side, &bp_side, &bit);
481 :
482 100894084 : if (bit == 1) {
483 50412310 : x[k] = -x[k];
484 : }
485 : }
486 :
487 120881214 : if (x[k + 1] > 0) {
488 100750759 : if(pc_check_bytes(&bp, &st, 0, mask_side, &bp_side, k) != 0)
489 : {
490 0 : goto ber_detect;
491 : }
492 100750759 : read_bit_fl(ptr, &mask_side, &bp_side, &bit);
493 :
494 100750759 : if (bit == 1) {
495 50344680 : x[k + 1] = -x[k + 1];
496 : }
497 : }
498 :
499 : /* Context */
500 120881214 : lev1 = MIN(lev, 3);
501 120881214 : if (lev1 <= 1) {
502 64201714 : t = 1 + (a + b) * (lev1 + 1);
503 : } else {
504 56679500 : t = 12 + lev1;
505 : }
506 :
507 120881214 : c = (c & 15) * 16 + t;
508 :
509 120881214 : 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 120881214 : if (st.BER_detect > 0)
523 : {
524 0 : goto ber_detect;
525 : }
526 : }
527 :
528 : /* Residual bits */
529 1178242 : nbits_side = total_bits - (8 * bp_side + 8 - (31 - clz_func(mask_side)));
530 1178242 : nbits_ari = (bp - 3) * 8;
531 1178242 : extra_bits = 25 - (31 - clz_func(st.ac_range_fl));
532 :
533 1178242 : if (enc == 0)
534 : {
535 1178242 : if (st.pc_c_bp == 0)
536 : {
537 1178242 : 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 1178242 : 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 1178242 : *nbits_residual = total_bits - (nbits_side + nbits_ari + extra_bits);
550 :
551 1178242 : 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 1178242 : if (lsbMode == 0) {
564 1160429 : findNonZero(x, L_spec, &idx_len);
565 :
566 1160429 : if (hrmode)
567 : {
568 0 : idx_len *= EXT_RES_ITER_MAX;
569 : }
570 : #ifdef CR9_C_ADD_1p25MS
571 1160429 : if (frame_dms == LC3PLUS_FRAME_DURATION_1p25MS) {
572 0 : idx_len *= 3;
573 : }
574 : #endif
575 :
576 1160429 : *nbits_residual = MIN(*nbits_residual, idx_len);
577 1160429 : *residualPresent = 1;
578 :
579 1160429 : memset(resBits, 0, MAX_RESBITS_LEN);
580 :
581 20075247 : for (k = 0; k < *nbits_residual; k++) {
582 18914818 : if(pc_check_bytes(&bp, &st, 0, mask_side, &bp_side, k) != 0)
583 : {
584 0 : goto ber_detect_res;
585 : }
586 18914818 : read_bit_fl(ptr, &mask_side, &bp_side, &tmp);
587 :
588 18914818 : resBits[k >> 3] |= tmp << (k & 7);
589 : }
590 : } else {
591 1743886 : for (k = 0; k < lastnz; k = k + 2) {
592 1741611 : if (save_lev[k] > 0) {
593 1390928 : if (*nbits_residual == 0) {
594 6896 : break;
595 : }
596 :
597 1384032 : if(pc_check_bytes(&bp, &st, 0, mask_side, &bp_side, k) != 0)
598 : {
599 0 : goto ber_detect_res;
600 : }
601 1384032 : read_bit_fl(ptr, &mask_side, &bp_side, &bit);
602 :
603 1384032 : *nbits_residual = *nbits_residual - 1;
604 :
605 1384032 : if (bit == 1) {
606 677165 : if (x[k] > 0) {
607 309170 : x[k] = x[k] + 1;
608 367995 : } else if (x[k] < 0) {
609 307802 : x[k] = x[k] - 1;
610 : } else {
611 60193 : if (*nbits_residual == 0) {
612 423 : break;
613 : }
614 :
615 59770 : if(pc_check_bytes(&bp, &st, 0, mask_side, &bp_side, k) != 0)
616 : {
617 0 : goto ber_detect_res;
618 : }
619 59770 : read_bit_fl(ptr, &mask_side, &bp_side, &bit);
620 :
621 59770 : *nbits_residual = *nbits_residual - 1;
622 :
623 59770 : if (bit == 0) {
624 29934 : x[k] = 1;
625 : } else {
626 29836 : x[k] = -1;
627 : }
628 : }
629 : }
630 :
631 1383609 : if (*nbits_residual == 0) {
632 7643 : break;
633 : }
634 :
635 1375966 : if(pc_check_bytes(&bp, &st, 0, mask_side, &bp_side, k) != 0)
636 : {
637 0 : goto ber_detect_res;
638 : }
639 1375966 : read_bit_fl(ptr, &mask_side, &bp_side, &bit);
640 :
641 1375966 : *nbits_residual = *nbits_residual - 1;
642 :
643 1375966 : if (bit == 1) {
644 670011 : if (x[k + 1] > 0) {
645 303821 : x[k + 1] = x[k + 1] + 1;
646 366190 : } else if (x[k + 1] < 0) {
647 307329 : x[k + 1] = x[k + 1] - 1;
648 : } else {
649 58861 : if (*nbits_residual == 0) {
650 576 : break;
651 : }
652 :
653 58285 : if(pc_check_bytes(&bp, &st, 0, mask_side, &bp_side, k) != 0)
654 : {
655 0 : goto ber_detect_res;
656 : }
657 58285 : read_bit_fl(ptr, &mask_side, &bp_side, &bit);
658 :
659 58285 : *nbits_residual = *nbits_residual - 1;
660 :
661 58285 : if (bit == 0) {
662 29147 : x[k + 1] = 1;
663 : } else {
664 29138 : x[k + 1] = -1;
665 : }
666 : }
667 : }
668 : }
669 : }
670 : }
671 :
672 : /* Noise-filling seed */
673 1178242 : calculate_nfseed(x, L_spec, nf_seed);
674 :
675 : /* Zero frame flag */
676 1178242 : if (lastnz == 2 && x[0] == 0 && x[1] == 0 && gg_idx == 0 && fac_ns_idx == 7) {
677 11512 : *zero_frame = 1;
678 : } else {
679 1166730 : *zero_frame = 0;
680 : }
681 :
682 1178242 : 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 1178242 : 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 1178242 : if ((*bfi == 2) && (*spec_inv_idx == (L_spec + 1)))
702 : {
703 0 : *bfi = 0;
704 : }
705 :
706 1178242 : *spec_inv_idx = *spec_inv_idx - 1;
707 :
708 1178242 : 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 1178242 : 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 341013816 : void ac_encode_fl(Encoder_State_fl* st, LC3_INT sym_freq, LC3_INT cum_freq)
747 : {
748 : LC3_INT r;
749 :
750 341013816 : r = st->range >> 10;
751 341013816 : st->low += r * cum_freq;
752 :
753 341013816 : if ((st->low >> 24) == 1) {
754 19675767 : st->carry = 1;
755 : }
756 :
757 341013816 : st->low &= (16777215); /* 2^24 -1 */
758 341013816 : st->range = r * sym_freq;
759 :
760 423480765 : while (st->range < 65536) { /* 2^16 */
761 82466949 : st->range <<= 8;
762 82466949 : ac_shift_fl(st);
763 : }
764 341013816 : }
765 :
766 83737437 : void ac_shift_fl(Encoder_State_fl* st)
767 : {
768 83737437 : if (st->low < 16711680 || st->carry == 1) {
769 83134163 : if (st->cache >= 0) {
770 81944852 : st->ptr[st->bp] = st->cache + st->carry;
771 81944852 : st->bp = st->bp + 1;
772 : }
773 :
774 83736786 : while (st->carry_count > 0) {
775 602623 : st->ptr[st->bp] = (st->carry + 255) & 255;
776 602623 : st->bp = st->bp + 1;
777 602623 : st->carry_count = st->carry_count - 1;
778 : }
779 :
780 83134163 : st->cache = st->low >> 16;
781 83134163 : st->carry = 0;
782 : } else {
783 603274 : st->carry_count = st->carry_count + 1;
784 : }
785 :
786 83737437 : st->low = (LC3_INT)((LC3_UINT32)st->low << 8);
787 83737437 : st->low = (st->low) & (16777215); /* 2^24 - 1 */
788 83737437 : }
789 :
790 :
791 1189311 : void ac_finalize_fl(Encoder_State_fl* st)
792 : {
793 1189311 : LC3_INT bits = 0, mask = 0, val = 0, over1 = 0, high = 0, over2 = 0, c = 0, b = 0;
794 :
795 1189311 : bits = 24 - (31 - clz_func(st->range));
796 1189311 : mask = 16777215 >> bits;
797 1189311 : val = st->low + mask;
798 1189311 : over1 = val >> 24;
799 :
800 1189311 : val = (val) & 16777215;
801 1189311 : high = st->low + st->range;
802 1189311 : over2 = high >> 24;
803 1189311 : high = high & 16777215;
804 1189311 : val = val & (16777215 - mask);
805 :
806 1189311 : if (over1 == over2) {
807 1124555 : if (val + mask >= high) {
808 653612 : bits = bits + 1;
809 653612 : mask = mask >> 1;
810 653612 : val = ((st->low + mask) & (16777215)) & (16777215 - mask);
811 : }
812 :
813 1124555 : if (val < st->low) {
814 87271 : st->carry = 1;
815 : }
816 : }
817 :
818 1189311 : st->low = val;
819 :
820 1189311 : b = bits;
821 :
822 1189311 : if (bits > 8) {
823 243531 : for (; b >= 1; b = b - 8) {
824 162354 : ac_shift_fl(st);
825 : }
826 : } else {
827 1108134 : ac_shift_fl(st);
828 : }
829 :
830 1189311 : bits = b;
831 1189311 : if (bits < 0) {
832 81177 : bits += 8;
833 : }
834 :
835 1189311 : if (st->carry_count > 0) {
836 649 : st->ptr[st->bp] = st->cache;
837 649 : st->bp = st->bp + 1;
838 :
839 651 : for (c = st->carry_count; c >= 2; c--) {
840 2 : st->ptr[st->bp] = 255;
841 2 : st->bp = st->bp + 1;
842 : }
843 :
844 649 : write_uint_forward_fl(st, 255 << (bits - 8), bits);
845 : } else {
846 1188662 : write_uint_forward_fl(st, st->cache, bits);
847 : }
848 1189311 : }
849 :
850 1189311 : void write_uint_forward_fl(Encoder_State_fl* st, LC3_INT val, LC3_INT numbits)
851 : {
852 1189311 : LC3_INT k, bit, mask = 128;
853 :
854 6509014 : for (k = 0; k < numbits; k++) {
855 5319703 : bit = val & mask;
856 :
857 5319703 : if (bit == 0) {
858 2530862 : st->ptr[st->bp] = st->ptr[st->bp] & (255 - mask);
859 : } else {
860 2788841 : st->ptr[st->bp] = st->ptr[st->bp] | mask;
861 : }
862 :
863 5319703 : mask = mask >> 1;
864 : }
865 1189311 : }
866 :
867 1189311 : void ari_enc_init(Encoder_State_fl* st, LC3_UINT8* bytes, LC3_INT* bp_side, LC3_INT* mask_side)
868 : {
869 1189311 : st->ptr = bytes;
870 1189311 : st->bp_side = bp_side;
871 1189311 : st->mask_side = mask_side;
872 1189311 : st->bp = 0;
873 1189311 : st->low = 0;
874 1189311 : st->range = 16777215;
875 1189311 : st->cache = -1;
876 1189311 : st->carry = 0;
877 1189311 : st->carry_count = 0;
878 1189311 : }
879 :
880 305151722 : LC3_INT sign(LC3_INT x)
881 : {
882 305151722 : if (x > 0)
883 101806886 : return 1;
884 :
885 203344836 : if (x < 0)
886 203344836 : return -1;
887 :
888 0 : return 0;
889 : }
890 :
891 1189311 : 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 1189311 : 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 1189311 : ari_enc_init(&st, bytes, &bp_side, &mask_side);
906 :
907 1189311 : total_bits = nbbits;
908 :
909 : /* TNS data */
910 3551743 : for (i = 0; i < tns_numfilters; i++) {
911 2362432 : if (tns_order[i] > 0) {
912 270609 : symfreq = tns_freq_cf[enable_lpc_weighting][tns_order[i]] - tns_freq_cf[enable_lpc_weighting][tns_order[i] - 1];
913 270609 : cumfreq = tns_freq_cf[enable_lpc_weighting][tns_order[i] - 1];
914 270609 : ac_encode_fl(&st, symfreq, cumfreq);
915 :
916 1300968 : for (j = 0; j < tns_order[i]; j++) {
917 1030359 : symfreq = tns_cf[j][tns_idx[i * 8 + j] + 1] - tns_cf[j][tns_idx[i * 8 + j]];
918 1030359 : cumfreq = tns_cf[j][tns_idx[i * 8 + j]];
919 1030359 : ac_encode_fl(&st, symfreq, cumfreq);
920 : }
921 : }
922 : }
923 :
924 : /* Spectral data */
925 123064007 : for (k = 0; k < lastnz; k = k + 2) {
926 121874696 : abs_x_k = abs(x[k]);
927 121874696 : abs_x_kp1 = abs(x[k + 1]);
928 339712848 : for (lev = 0; lev < codingdata[1]; lev++) {
929 217838152 : lev1 = MIN(lev, 3);
930 217838152 : pki = ari_spec_lookup_fl[codingdata[0] + lev1 * 1024];
931 217838152 : symfreq = ari_spec_cumfreq_fl[pki][17] - ari_spec_cumfreq_fl[pki][16];
932 217838152 : cumfreq = ari_spec_cumfreq_fl[pki][16];
933 :
934 217838152 : ac_encode_fl(&st, symfreq, cumfreq);
935 217838152 : bit1 = (abs_x_k >> lev) & 1;
936 217838152 : bit2 = (abs_x_kp1 >> lev) & 1;
937 :
938 :
939 217838152 : if (lsbMode == 1 && lev == 0) {
940 1444375 : lsb1 = bit1;
941 1444375 : lsb2 = bit2;
942 : } else {
943 216393777 : write_bit_backward_fl(st.ptr, st.bp_side, st.mask_side, bit1);
944 216393777 : write_bit_backward_fl(st.ptr, st.bp_side, st.mask_side, bit2);
945 : }
946 : }
947 :
948 121874696 : lev1 = MIN(MAX(codingdata[1], 0), 3);
949 121874696 : pki = ari_spec_lookup_fl[codingdata[0] + lev1 * 1024];
950 :
951 121874696 : symfreq = ari_spec_cumfreq_fl[pki][codingdata[2] + 1] - ari_spec_cumfreq_fl[pki][codingdata[2]];
952 121874696 : cumfreq = ari_spec_cumfreq_fl[pki][codingdata[2]];
953 121874696 : ac_encode_fl(&st, symfreq, cumfreq);
954 :
955 121874696 : a = abs_x_k;
956 121874696 : b = abs_x_kp1;
957 :
958 121874696 : if (lsbMode == 1 && codingdata[1] > 0) {
959 1444375 : a = a >> 1;
960 1444375 : lsbs[lsbsLen] = lsb1;
961 1444375 : lsbsLen++;
962 :
963 1444375 : if (a == 0 && x[k] != 0) {
964 62476 : bit = MAX(0, -sign(x[k]));
965 62476 : lsbs[lsbsLen] = bit;
966 62476 : lsbsLen++;
967 : }
968 :
969 1444375 : b = b >> 1;
970 1444375 : lsbs[lsbsLen] = lsb2;
971 1444375 : lsbsLen++;
972 :
973 1444375 : if (b == 0 && x[k + 1] != 0) {
974 62198 : bit = MAX(0, -sign(x[k + 1]));
975 62198 : lsbs[lsbsLen] = bit;
976 62198 : lsbsLen++;
977 : }
978 : }
979 :
980 121874696 : if (a != 0) {
981 101749030 : bit = MAX(0, -sign(x[k]));
982 101749030 : write_bit_backward_fl(st.ptr, st.bp_side, st.mask_side, bit);
983 : }
984 :
985 121874696 : if (b != 0) {
986 101605600 : bit = MAX(0, -sign(x[k + 1]));
987 101605600 : write_bit_backward_fl(st.ptr, st.bp_side, st.mask_side, bit);
988 : }
989 :
990 121874696 : codingdata += 3;
991 : }
992 :
993 : /* Residual bits */
994 1189311 : nbits_side = total_bits - (8 * (*(st.bp_side) + 1) + 8 - (31 - clz_func(*(st.mask_side))));
995 1189311 : nbits_ari = 8 * (st.bp + 1) + 25 - (31 - clz_func(st.range )) ;
996 :
997 1189311 : if (st.cache >= 0) {
998 1187081 : nbits_ari = nbits_ari + 8;
999 : }
1000 :
1001 1189311 : if (st.carry_count > 0) {
1002 4447 : nbits_ari = nbits_ari + st.carry_count * 8;
1003 : }
1004 :
1005 1189311 : 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 1189311 : if (lsbMode == 0) {
1013 1171359 : nbits_residual_enc = MIN(nbits_residual_enc, resBitsLen);
1014 20254286 : for (k = 0; k < nbits_residual_enc; k++) {
1015 19082927 : if (res_bits[k >> 3] & (1 << (k & 7)))
1016 : {
1017 9541924 : write_bit_backward_fl(st.ptr, st.bp_side, st.mask_side, 1);
1018 : }
1019 : else
1020 : {
1021 9541003 : write_bit_backward_fl(st.ptr, st.bp_side, st.mask_side, 0);
1022 : }
1023 : }
1024 : } else {
1025 17952 : nbits_residual_enc = MIN(nbits_residual_enc, lsbsLen);
1026 :
1027 2920387 : for (k = 0; k < nbits_residual_enc; k++) {
1028 2902435 : write_bit_backward_fl(st.ptr, st.bp_side, st.mask_side, lsbs[k]);
1029 : }
1030 : }
1031 :
1032 1189311 : ac_finalize_fl(&st);
1033 : #ifdef WMOPS
1034 : pop_wmops();
1035 : #endif
1036 1189311 : }
1037 :
|
