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