Line data Source code
1 : /*====================================================================================
2 : EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
3 : ====================================================================================*/
4 :
5 :
6 : #include <stdint.h>
7 : #include <assert.h>
8 : #include "options.h"
9 : #include "cnst.h"
10 : //#include "prot_fx.h"
11 : #include "rom_com.h"
12 : #include "prot_fx.h" /* Function prototypes */
13 : #include "prot_fx_enc.h" /* Function prototypes */
14 :
15 :
16 : /*-------------------------------------------------------------------*
17 : * qlpc_avq_fx()
18 : *
19 : *
20 : * --------------------------------------------------------------------*/
21 106874 : void qlpc_avq_fx(
22 : const Word16 *lsf, /* i : Input LSF vectors (14Q1*1.28) */
23 : const Word16 *lsfmid, /* i : Input LSF vectors (14Q1*1.28) */
24 : Word16 *lsf_q, /* o : Quantized LFS vectors (14Q1*1.28) */
25 : Word16 *lsfmid_q, /* o : Quantized LFS vectors (14Q1*1.28) */
26 : Word16 *index, /* o : Quantization indices Q0 */
27 : Word16 *nb_indices, /* o : Number of quantization indices Q0 */
28 : Word16 *nbbits, /* o : Number of quantization bits Q0 */
29 : const Word16 core, /* i : TCX10 or TCX20 Q0 */
30 : const Word32 sr_core /* i : internal sampling rate Q0 */
31 : )
32 : {
33 : Word16 i;
34 : Word16 lsfmid_q0[M];
35 : Word16 *tmp_index, indxt[256], nit, nbits, nbt;
36 : Word16 dummy[M];
37 :
38 :
39 : /* Init */
40 106874 : tmp_index = &index[0]; // Q0
41 106874 : *nb_indices = 0;
42 106874 : move16();
43 :
44 106874 : tmp_index[0] = vlpc_1st_cod_fx( lsf, lsf_q, dummy, 0 ); // Q0
45 :
46 106874 : nbt = vlpc_2st_cod_fx( lsf, lsf_q, &tmp_index[1], 0, sr_core ); // Q0
47 :
48 : /*nit = 1 + 2 + index[1] + index[2]; nit < NPRM_LPC_NEW(=50) */
49 106874 : nit = add( add( 3, index[1] ), index[2] ); // Q0
50 106874 : assert( nit < NPRM_LPC_NEW );
51 :
52 : /*tmp_index += nit;*/
53 106874 : tmp_index = tmp_index + nit;
54 : /**nb_indices += nit;*/
55 106874 : *nb_indices = add( *nb_indices, nit ); // Q0
56 106874 : move16();
57 : /*nbbits[0] = 8 + nbt;*/
58 106874 : nbbits[0] = add( 8, nbt ); // Q0
59 106874 : move16();
60 :
61 106874 : *tmp_index = 0;
62 106874 : move16();
63 :
64 106874 : IF( EQ_16( core, TCX_20_CORE ) )
65 : {
66 :
67 104815 : return;
68 : }
69 :
70 : /* Quantize intermediate LPC (512 framing) */
71 2059 : tmp_index++;
72 : /**nb_indices +=1;*/
73 2059 : *nb_indices = add( *nb_indices, 1 ); // Q0
74 2059 : move16();
75 :
76 : /* LPC2: Abs? */
77 2059 : tmp_index[0] = vlpc_1st_cod_fx( lsfmid, lsfmid_q, dummy, 0 ); // Q0
78 :
79 2059 : nbits = vlpc_2st_cod_fx( lsfmid, lsfmid_q, &tmp_index[1], 0, sr_core ); // Q0
80 : /*nbt = 8 + nbits;*/
81 2059 : nbt = add( 8, nbits );
82 : /*nit = 1 + 2 + tmp_index[1] + tmp_index[2];*/
83 2059 : nit = add( add( 3, tmp_index[1] ), tmp_index[2] ); // Q0
84 :
85 : /* LPC2: RelR? */
86 35003 : FOR( i = 0; i < M; i++ )
87 : {
88 32944 : lsfmid_q0[i] = lsf_q[i]; /* 14Q1*1.28 */
89 32944 : move16();
90 : }
91 2059 : nbits = vlpc_2st_cod_fx( lsfmid, lsfmid_q0, indxt, 3, sr_core ); // Q0
92 :
93 2059 : IF( LT_16( nbits, nbt ) )
94 : {
95 1689 : nbt = nbits; // Q0
96 1689 : move16();
97 : /*nit = 2 + indxt[0] + indxt[1];*/
98 1689 : nit = add( add( 2, indxt[0] ), indxt[1] ); // Q0
99 1689 : tmp_index[-1] = 1;
100 1689 : move16();
101 :
102 28713 : FOR( i = 0; i < M; i++ )
103 : {
104 27024 : lsfmid_q[i] = lsfmid_q0[i]; /* 14Q1*1.28 */
105 27024 : move16();
106 : }
107 :
108 20994 : FOR( i = 0; i < nit; i++ )
109 : {
110 19305 : tmp_index[i] = indxt[i]; // Q0
111 19305 : move16();
112 : }
113 : }
114 :
115 2059 : tmp_index += nit;
116 : /**nb_indices += nit;*/
117 2059 : *nb_indices = add( *nb_indices, nit ); // Q0
118 2059 : move16();
119 : /*nbbits[1] = 1 + nbt;*/
120 2059 : nbbits[1] = add( 1, nbt );
121 2059 : move16();
122 :
123 :
124 2059 : return;
125 : }
126 : /*-------------------------------------------------------------------*
127 : * unary_code()
128 : *
129 : *
130 : *--------------------------------------------------------------------*/
131 :
132 0 : static Word16 unary_code(
133 : Word16 ind, /* Q0 */
134 : BSTR_ENC_HANDLE hBstr )
135 : {
136 : Word16 nb_bits;
137 :
138 0 : move16();
139 0 : nb_bits = 1;
140 :
141 : /* Index bits */
142 0 : ind = sub( ind, 1 );
143 :
144 0 : FOR( ; ind > 0; ind-- )
145 : {
146 0 : push_next_indice( hBstr, 1, 1 );
147 0 : nb_bits = add( nb_bits, 1 ); // Q0
148 : }
149 :
150 : /* Stop bit */
151 0 : push_next_indice( hBstr, 0, 1 );
152 :
153 0 : return ( nb_bits );
154 : }
155 271518 : static Word16 unary_code_ivas_fx(
156 : Word16 ind, /* Q0 */
157 : BSTR_ENC_HANDLE hBstr )
158 : {
159 : Word16 nb_bits;
160 :
161 271518 : move16();
162 271518 : nb_bits = 1;
163 :
164 : /* Index bits */
165 271518 : ind = sub( ind, 1 ); // Q0
166 :
167 271518 : WHILE( ind >= 16 )
168 : {
169 0 : push_next_indice( hBstr, 0xffffU, 16 );
170 0 : nb_bits = add( nb_bits, 16 ); // Q0
171 0 : ind = sub( ind, 16 );
172 : }
173 271518 : IF( ind > 0 )
174 : {
175 215227 : push_next_indice( hBstr, ( 1U << ind ) - 1, ind );
176 215227 : nb_bits = add( nb_bits, ind ); // Q0
177 : }
178 :
179 : /* Stop bit */
180 271518 : push_next_indice( hBstr, 0, 1 );
181 :
182 271518 : return ( nb_bits );
183 : }
184 : /*-------------------------------------------------------------------*
185 : * unpack4bits()
186 : *
187 : *
188 : *--------------------------------------------------------------------*/
189 0 : static Word16 unpack4bits(
190 : Word16 nbits, /* Q0 */
191 : const Word16 *prm, /* Q0 */
192 : BSTR_ENC_HANDLE hBstr )
193 : {
194 : Word16 i;
195 :
196 0 : IF( nbits == 0 )
197 : {
198 0 : push_next_indice( hBstr, 0, 0 );
199 0 : i = 1;
200 0 : move16();
201 : }
202 : ELSE
203 : {
204 0 : move16();
205 0 : i = 0;
206 :
207 0 : FOR( ; nbits > 4; nbits -= 4 )
208 : {
209 0 : push_next_indice( hBstr, prm[i], 4 );
210 0 : i = add( i, 1 );
211 : }
212 0 : push_next_indice( hBstr, prm[i], nbits );
213 0 : i = add( i, 1 );
214 : }
215 :
216 0 : return ( i );
217 : }
218 1227970 : static Word16 unpack4bits_ivas_fx(
219 : Word16 nbits, /* Q0 */
220 : const Word16 *prm, /* Q0 */
221 : BSTR_ENC_HANDLE hBstr )
222 : {
223 : Word16 i;
224 :
225 1227970 : IF( nbits == 0 )
226 : {
227 73198 : push_next_indice( hBstr, 0, 0 );
228 73198 : i = 1;
229 73198 : move16();
230 : }
231 : ELSE
232 : {
233 1154772 : move16();
234 1154772 : i = 0;
235 :
236 3925813 : FOR( ; nbits > 4; nbits -= 4 )
237 : {
238 2771041 : push_next_indice( hBstr, prm[i], 4 );
239 2771041 : i = add( i, 1 );
240 : }
241 1154772 : push_next_indice( hBstr, prm[i], nbits );
242 1154772 : i = add( i, 1 );
243 : }
244 :
245 1227970 : return ( i );
246 : }
247 : /*-------------------------------------------------------------------*
248 : * encode_lpc_avq_fx()
249 : *
250 : *
251 : *--------------------------------------------------------------------*/
252 :
253 0 : Word16 encode_lpc_avq_fx(
254 : BSTR_ENC_HANDLE hBstr, /* i/o: bitstream handle */
255 : const Word16 numlpc, /* i : Number of sets of lpc Q0*/
256 : const Word16 *param_lpc, /* i : lpc parameters Q0*/
257 : const Word16 core, /* i : core Q0*/
258 : const Word16 element_mode /* i : element mode - decides between SNS and LPC coding Q0*/
259 : )
260 : {
261 : Word16 k, j;
262 : Word16 q_type, nb_ind;
263 : Word16 i, qn1, qn2, nb, avqBits, st1;
264 : Word16 nb_bits;
265 : Word16 stereo_mode, bits_for_abs_quant;
266 :
267 0 : stereo_mode = 0;
268 0 : move16();
269 0 : bits_for_abs_quant = LPC_ABS_QUANT_BITS;
270 0 : move16();
271 0 : if ( EQ_16( element_mode, IVAS_CPE_MDCT ) )
272 : {
273 0 : bits_for_abs_quant = SNS_ABS_QUANT_BITS;
274 0 : move16();
275 : }
276 :
277 0 : move16();
278 0 : move16();
279 0 : move16();
280 0 : st1 = 0;
281 0 : j = 0;
282 0 : nb_bits = 0;
283 :
284 0 : FOR( k = 0; k < numlpc; k++ )
285 : {
286 : /* Retrieve quantizer type */
287 :
288 :
289 0 : move16();
290 0 : q_type = 0;
291 0 : if ( k != 0 )
292 : {
293 0 : move16();
294 0 : q_type = param_lpc[j]; // Q0
295 0 : j = add( j, 1 );
296 : }
297 0 : test();
298 0 : if ( EQ_16( element_mode, IVAS_CPE_MDCT ) && k == 0 )
299 : {
300 0 : stereo_mode = param_lpc[j]; // Q0
301 0 : move16();
302 0 : j = add( j, 1 );
303 : }
304 : /* Determine number of AVQ indices */
305 0 : move16();
306 0 : nb_ind = 0;
307 :
308 0 : if ( q_type == 0 )
309 : {
310 0 : move16();
311 0 : st1 = param_lpc[j++]; // Q0
312 : }
313 0 : move16();
314 0 : move16();
315 0 : qn1 = param_lpc[j++]; // Q0
316 0 : qn2 = param_lpc[j++]; // Q0
317 0 : IF( EQ_16( qn1, SNS_LOW_BR_MODE ) )
318 : {
319 0 : nb_ind = add( qn1, qn2 );
320 : }
321 :
322 0 : test();
323 0 : test();
324 0 : IF( k == 0 || ( EQ_16( k, 1 ) && NE_16( core, TCX_20_CORE ) ) )
325 : {
326 : /* Encode quantizer type */
327 0 : move16();
328 0 : nb = 0;
329 0 : IF( k != 0 )
330 : {
331 0 : nb = 1;
332 0 : move16();
333 0 : push_next_indice( hBstr, q_type, nb );
334 : }
335 0 : nb_bits = add( nb_bits, nb ); // Q0
336 :
337 : /* Encode quantizer data */
338 0 : test();
339 0 : test();
340 0 : test();
341 0 : test();
342 0 : IF( ( ( q_type == 0 ) && NE_16( element_mode, IVAS_CPE_MDCT ) ) || ( ( q_type == 0 ) && ( GE_16( st1, 0 ) ) && EQ_16( element_mode, IVAS_CPE_MDCT ) ) )
343 : {
344 : /* Absolute quantizer with 1st stage stochastic codebook */
345 0 : push_next_indice( hBstr, st1, bits_for_abs_quant );
346 0 : nb_bits = add( nb_bits, bits_for_abs_quant ); // Q0
347 : }
348 :
349 0 : test();
350 0 : test();
351 0 : IF( EQ_16( element_mode, IVAS_CPE_MDCT ) && EQ_16( stereo_mode, 3 ) && st1 < 0 )
352 : {
353 0 : push_next_indice( hBstr, add( st1, 2 ), 1 );
354 0 : nb_bits = add( nb_bits, 1 ); // Q0
355 : }
356 :
357 0 : test();
358 0 : test();
359 0 : IF( NE_16( element_mode, IVAS_CPE_MDCT ) || ( NE_16( st1, -2 ) && NE_16( qn1, SNS_LOW_BR_MODE ) ) )
360 : {
361 :
362 : /* 2 bits to specify Q2,Q3,Q4,ext */
363 0 : nb_bits = add( nb_bits, 4 ); // Q0
364 0 : i = sub( qn1, 2 );
365 :
366 0 : if ( s_or( i < 0, (Word16) GT_16( i, 3 ) ) )
367 : {
368 0 : move16();
369 0 : i = 3;
370 : }
371 0 : push_next_indice( hBstr, i, 2 );
372 :
373 0 : i = sub( qn2, 2 );
374 :
375 0 : if ( s_or( i < 0, (Word16) GT_16( i, 3 ) ) )
376 : {
377 0 : move16();
378 0 : i = 3;
379 : }
380 0 : push_next_indice( hBstr, i, 2 );
381 :
382 : /* Unary code for abs and rel LPC0/LPC2 */
383 : /* Q5 = 0, Q6=10, Q0=110, Q7=1110, ... */
384 0 : move16();
385 0 : nb = qn1;
386 :
387 0 : IF( GT_16( nb, 6 ) )
388 : {
389 0 : nb = sub( nb, 3 );
390 : }
391 0 : ELSE IF( GT_16( nb, 4 ) )
392 : {
393 0 : nb = sub( nb, 4 );
394 : }
395 0 : ELSE IF( nb == 0 )
396 : {
397 0 : move16();
398 0 : nb = 3;
399 : }
400 : ELSE
401 : {
402 0 : move16();
403 0 : nb = 0;
404 : }
405 :
406 0 : IF( nb > 0 )
407 : {
408 0 : unary_code( nb, hBstr );
409 : }
410 0 : nb_bits = add( nb_bits, nb ); // Q0
411 :
412 0 : move16();
413 0 : nb = qn2;
414 :
415 0 : IF( GT_16( nb, 6 ) )
416 : {
417 0 : nb = sub( nb, 3 ); // Q0
418 : }
419 0 : ELSE IF( GT_16( nb, 4 ) )
420 : {
421 0 : nb = sub( nb, 4 ); // Q0
422 : }
423 0 : ELSE IF( nb == 0 )
424 : {
425 0 : move16();
426 0 : nb = 3;
427 : }
428 : ELSE
429 : {
430 0 : move16();
431 0 : nb = 0;
432 : }
433 :
434 0 : IF( nb > 0 )
435 : {
436 0 : unary_code( nb, hBstr );
437 : }
438 0 : nb_bits = add( nb_bits, nb ); // Q0
439 :
440 0 : avqBits = shl( qn1, 2 );
441 0 : unpack4bits( avqBits, ¶m_lpc[j], hBstr );
442 0 : j = add( j, qn1 );
443 0 : nb_bits = add( nb_bits, avqBits ); // Q0
444 :
445 0 : avqBits = shl( qn2, 2 );
446 0 : unpack4bits( avqBits, ¶m_lpc[j], hBstr );
447 0 : j = add( j, qn2 );
448 0 : nb_bits = add( nb_bits, avqBits ); // Q0
449 : }
450 : }
451 : ELSE
452 : {
453 0 : j = add( j, nb_ind );
454 : }
455 : }
456 :
457 0 : return ( nb_bits );
458 : }
459 :
460 620636 : Word16 encode_lpc_avq_ivas_fx(
461 : BSTR_ENC_HANDLE hBstr, /* i/o: bitstream handle */
462 : const Word16 numlpc, /* i : Number of sets of lpc Q0*/
463 : const Word16 *param_lpc, /* i : lpc parameters Q0*/
464 : const Word16 core, /* i : core Q0*/
465 : const Word16 element_mode /* i : element mode - decides between SNS and LPC coding Q0*/
466 : )
467 : {
468 : Word16 k, j;
469 : Word16 q_type, nb_ind;
470 : Word16 i, qn1, qn2, nb, avqBits, st1;
471 : Word16 nb_bits;
472 : Word16 stereo_mode, bits_for_abs_quant;
473 :
474 620636 : stereo_mode = 0;
475 620636 : move16();
476 620636 : bits_for_abs_quant = LPC_ABS_QUANT_BITS;
477 620636 : move16();
478 620636 : if ( EQ_16( element_mode, IVAS_CPE_MDCT ) )
479 : {
480 513762 : bits_for_abs_quant = SNS_ABS_QUANT_BITS;
481 513762 : move16();
482 : }
483 :
484 620636 : move16();
485 620636 : move16();
486 620636 : move16();
487 620636 : st1 = 0;
488 620636 : j = 0;
489 620636 : nb_bits = 0;
490 :
491 1254725 : FOR( k = 0; k < numlpc; k++ )
492 : {
493 : /* Retrieve quantizer type */
494 :
495 :
496 634089 : move16();
497 634089 : q_type = 0;
498 634089 : IF( k != 0 )
499 : {
500 13453 : move16();
501 13453 : q_type = param_lpc[j]; // Q0
502 13453 : j = add( j, 1 );
503 : }
504 634089 : test();
505 634089 : IF( EQ_16( element_mode, IVAS_CPE_MDCT ) && k == 0 )
506 : {
507 513762 : stereo_mode = param_lpc[j]; // Q0
508 513762 : move16();
509 513762 : j = add( j, 1 );
510 : }
511 : /* Determine number of AVQ indices */
512 634089 : move16();
513 634089 : nb_ind = 0;
514 :
515 634089 : IF( q_type == 0 )
516 : {
517 625222 : move16();
518 625222 : st1 = param_lpc[j]; // Q0
519 625222 : j = add( j, 1 );
520 : }
521 634089 : move16();
522 634089 : move16();
523 634089 : qn1 = param_lpc[j]; // Q0
524 634089 : j = add( j, 1 );
525 634089 : qn2 = param_lpc[j]; // Q0
526 634089 : j = add( j, 1 );
527 634089 : IF( NE_16( qn1, SNS_LOW_BR_MODE ) )
528 : {
529 633794 : nb_ind = add( nb_ind, add( qn1, qn2 ) ); // Q0
530 : }
531 :
532 634089 : test();
533 634089 : test();
534 634089 : IF( k == 0 || ( EQ_16( k, 1 ) && NE_16( core, TCX_20_CORE ) ) )
535 : {
536 : /* Encode quantizer type */
537 634089 : move16();
538 634089 : nb = 0;
539 634089 : IF( k != 0 )
540 : {
541 13453 : nb = 1;
542 13453 : move16();
543 13453 : push_next_indice( hBstr, q_type, nb );
544 : }
545 634089 : nb_bits = add( nb_bits, nb ); // Q0
546 :
547 : /* Encode quantizer data */
548 634089 : test();
549 634089 : test();
550 634089 : test();
551 634089 : test();
552 634089 : IF( ( ( q_type == 0 ) && NE_16( element_mode, IVAS_CPE_MDCT ) ) || ( ( q_type == 0 ) && ( st1 >= 0 ) && EQ_16( element_mode, IVAS_CPE_MDCT ) ) )
553 : {
554 : /* Absolute quantizer with 1st stage stochastic codebook */
555 441167 : push_next_indice( hBstr, st1, bits_for_abs_quant );
556 441167 : nb_bits = add( nb_bits, bits_for_abs_quant ); // Q0
557 : }
558 :
559 634089 : test();
560 634089 : test();
561 634089 : IF( EQ_16( element_mode, IVAS_CPE_MDCT ) && EQ_16( stereo_mode, 3 ) && st1 < 0 )
562 : {
563 184055 : push_next_indice( hBstr, add( st1, 2 ), 1 );
564 184055 : nb_bits = add( nb_bits, 1 ); // Q0
565 : }
566 :
567 634089 : test();
568 634089 : test();
569 634089 : IF( NE_16( element_mode, IVAS_CPE_MDCT ) || ( NE_16( st1, -2 ) && NE_16( qn1, SNS_LOW_BR_MODE ) ) )
570 : {
571 :
572 : /* 2 bits to specify Q2,Q3,Q4,ext */
573 613985 : nb_bits = add( nb_bits, 4 );
574 613985 : i = sub( qn1, 2 );
575 :
576 613985 : if ( s_or( i < 0, (Word16) GT_16( i, 3 ) ) )
577 : {
578 108753 : move16();
579 108753 : i = 3;
580 : }
581 613985 : push_next_indice( hBstr, i, 2 );
582 :
583 613985 : i = sub( qn2, 2 );
584 :
585 613985 : if ( s_or( i < 0, (Word16) GT_16( i, 3 ) ) )
586 : {
587 106474 : move16();
588 106474 : i = 3;
589 : }
590 613985 : push_next_indice( hBstr, i, 2 );
591 :
592 : /* Unary code for abs and rel LPC0/LPC2 */
593 : /* Q5 = 0, Q6=10, Q0=110, Q7=1110, ... */
594 613985 : move16();
595 613985 : nb = qn1;
596 :
597 613985 : IF( GT_16( nb, 6 ) )
598 : {
599 60421 : nb = sub( nb, 3 );
600 : }
601 553564 : ELSE IF( GT_16( nb, 4 ) )
602 : {
603 67826 : nb = sub( nb, 4 );
604 : }
605 485738 : ELSE IF( nb == 0 )
606 : {
607 8159 : move16();
608 8159 : nb = 3;
609 : }
610 : ELSE
611 : {
612 477579 : move16();
613 477579 : nb = 0;
614 : }
615 :
616 613985 : IF( nb > 0 )
617 : {
618 136406 : unary_code_ivas_fx( nb, hBstr );
619 : }
620 613985 : nb_bits = add( nb_bits, nb );
621 :
622 613985 : move16();
623 613985 : nb = qn2;
624 :
625 613985 : IF( GT_16( nb, 6 ) )
626 : {
627 11083 : nb = sub( nb, 3 );
628 : }
629 602902 : ELSE IF( GT_16( nb, 4 ) )
630 : {
631 58990 : nb = sub( nb, 4 );
632 : }
633 543912 : ELSE IF( nb == 0 )
634 : {
635 65039 : move16();
636 65039 : nb = 3;
637 : }
638 : ELSE
639 : {
640 478873 : move16();
641 478873 : nb = 0;
642 : }
643 :
644 613985 : IF( nb > 0 )
645 : {
646 135112 : unary_code_ivas_fx( nb, hBstr );
647 : }
648 613985 : nb_bits = add( nb_bits, nb );
649 :
650 613985 : avqBits = shl( qn1, 2 );
651 613985 : unpack4bits_ivas_fx( avqBits, ¶m_lpc[j], hBstr );
652 613985 : j = add( j, qn1 );
653 613985 : nb_bits = add( nb_bits, avqBits ); // Q0
654 :
655 613985 : avqBits = shl( qn2, 2 );
656 613985 : unpack4bits_ivas_fx( avqBits, ¶m_lpc[j], hBstr );
657 613985 : j = add( j, qn2 );
658 613985 : nb_bits = add( nb_bits, avqBits ); // Q0
659 : }
660 : }
661 : ELSE
662 : {
663 0 : j = add( j, nb_ind );
664 : }
665 : }
666 :
667 620636 : return ( nb_bits );
668 : }
|
