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 "options.h"
8 : #include <assert.h>
9 : #include "prot_fx.h"
10 : /* Constants */
11 :
12 : #define M 16 /* length of LPC */
13 : #define BFI_FAC 29491 /*0.9f Q15*/
14 :
15 : /***********************************************/
16 : /* Variable bit-rate multiple LPC un-quantizer */
17 : /***********************************************/
18 :
19 101170 : Word16 dlpc_avq_fx(
20 : Word16 *index, /* i : Quantization indices */
21 : Word16 *LSF_Q, /* o : Quantized LSF vectors */
22 : Word16 numlpc, /* i : Number of sets of lpc */
23 : Word32 sr_core /* i : Core sampling rate */
24 : )
25 : {
26 : Word16 i, nbi, last;
27 : Word16 *p_index, q_type;
28 :
29 :
30 : /* Last LPC index */
31 :
32 101170 : move16();
33 101170 : last = 0;
34 101170 : IF( NE_16( numlpc, 1 ) )
35 : {
36 1942 : move16();
37 1942 : last = M;
38 : }
39 :
40 101170 : move16();
41 101170 : p_index = index;
42 :
43 : /* Decode last LPC */
44 :
45 1719890 : FOR( i = 0; i < M; i++ )
46 : {
47 1618720 : move16();
48 1618720 : LSF_Q[last + i] = 0;
49 : }
50 101170 : vlpc_1st_dec( p_index[0], &LSF_Q[last] ); // LSF_Q[last] -> Q2.56
51 101170 : p_index++;
52 101170 : vlpc_2st_dec( &LSF_Q[last], &p_index[0], 0, sr_core ); // Q2.56
53 101170 : nbi = add( 2, add( p_index[0], p_index[1] ) );
54 101170 : p_index += nbi;
55 :
56 : /* Decode intermediate LPC (512 framing) */
57 :
58 101170 : IF( EQ_16( numlpc, 2 ) )
59 : {
60 1942 : move16();
61 1942 : q_type = p_index[0];
62 1942 : p_index++;
63 :
64 1942 : IF( q_type == 0 )
65 : {
66 :
67 18275 : FOR( i = 0; i < M; i++ )
68 : {
69 17200 : move16();
70 17200 : LSF_Q[i] = 0;
71 : }
72 1075 : vlpc_1st_dec( p_index[0], &LSF_Q[0] ); ////Q2.56
73 1075 : p_index++;
74 1075 : vlpc_2st_dec( &LSF_Q[0], &p_index[0], 0, sr_core );
75 : }
76 867 : ELSE IF( EQ_16( q_type, 1 ) )
77 : {
78 :
79 14739 : FOR( i = 0; i < M; i++ )
80 : {
81 13872 : move16();
82 13872 : LSF_Q[i] = LSF_Q[M + i];
83 : }
84 867 : vlpc_2st_dec( &LSF_Q[0], &p_index[0], 3, sr_core ); ////Q2.56
85 : }
86 1942 : nbi = add( 2, add( p_index[0], p_index[1] ) );
87 1942 : p_index += nbi;
88 : }
89 :
90 101170 : return (Word16) ( p_index - index );
91 : }
92 :
93 156174 : static Word16 unary_decode_fx(
94 : Decoder_State *st,
95 : Word16 *ind )
96 : {
97 :
98 : Word16 start_bit_pos;
99 :
100 :
101 156174 : move16();
102 156174 : start_bit_pos = st->next_bit_pos;
103 :
104 : /* Index bits */
105 :
106 156174 : move16();
107 156174 : *ind = 0;
108 156174 : test();
109 350411 : WHILE( ( get_next_indice_1_fx( st ) != 0 ) && !st->BER_detect )
110 : {
111 194237 : move16();
112 194237 : *ind = add( *ind, 1 );
113 : }
114 :
115 156174 : if ( *ind != 0 )
116 : {
117 111264 : move16();
118 111264 : *ind = add( *ind, 1 );
119 : }
120 :
121 156174 : return sub( st->next_bit_pos, start_bit_pos );
122 : }
123 :
124 1133296 : static Word16 pack4bits_fx(
125 : Word16 nbits,
126 : Decoder_State *st,
127 : Word16 *prm )
128 : {
129 : Word16 i;
130 :
131 :
132 1133296 : move16();
133 1133296 : i = 0;
134 :
135 3252693 : FOR( ; nbits > 4; nbits -= 4 )
136 : {
137 2119397 : move16();
138 2119397 : prm[i] = get_next_indice_fx( st, 4 );
139 2119397 : i = add( i, 1 );
140 : }
141 1133296 : prm[i] = get_next_indice_fx( st, nbits );
142 1133296 : move16();
143 1133296 : i = add( i, 1 );
144 :
145 1133296 : return ( i );
146 : }
147 :
148 0 : Word16 decode_lpc_avq_fx(
149 : Decoder_State *st, /* i/o: decoder state structure */
150 : const Word16 numlpc, /* i : Number of sets of lpc */
151 : Word16 *param_lpc /* o : lpc parameters */
152 : #ifdef IVAS_CODE_AVQ_LPC
153 : ,
154 : const Word16 ch, /* i : channel */
155 : const Word16 element_mode, /* i : element mode */
156 : const Word16 sns_low_br_mode /* i : SNS low-bitrate mode */
157 : #endif
158 : )
159 : {
160 : Word16 k, j;
161 : Word16 nb, qn1, qn2, avqBits, q_type;
162 : Word16 start_bit_pos;
163 : #ifdef IVAS_CODE_AVQ_LPC
164 : Word16 stereo_mode = 0;
165 : #endif
166 0 : move16();
167 0 : move16();
168 0 : move16();
169 0 : j = 0;
170 0 : start_bit_pos = st->next_bit_pos;
171 :
172 0 : FOR( k = 0; k < numlpc; k++ )
173 : {
174 : /* Decode quantizer type */
175 :
176 0 : IF( k == 0 )
177 : {
178 0 : move16();
179 0 : move16();
180 0 : q_type = 0;
181 0 : nb = 0;
182 : }
183 : ELSE
184 : {
185 0 : move16();
186 0 : nb = 1;
187 0 : q_type = get_next_indice_fx( st, nb );
188 0 : move16();
189 0 : param_lpc[j] = q_type;
190 0 : j = add( j, 1 );
191 : }
192 : #ifdef IVAS_CODE_AVQ_LPC
193 : test();
194 : IF( EQ_16( element_mode, IVAS_CPE_MDCT ) && k == 0 )
195 : {
196 : stereo_mode = ch;
197 : move16();
198 : if ( ch == 0 )
199 : {
200 : stereo_mode = param_lpc[j];
201 : move16();
202 : }
203 : param_lpc[j++] = stereo_mode;
204 : move16();
205 : }
206 : #endif
207 : /* Decode quantization indices */
208 :
209 0 : IF( q_type == 0 )
210 : {
211 : /* Absolute quantizer with 1st stage stochastic codebook */
212 : #ifdef IVAS_CODE_AVQ_LPC
213 : IF( EQ_16( element_mode, IVAS_CPE_MDCT ) )
214 : {
215 : IF( NE_16( stereo_mode, 3 ) )
216 : {
217 : param_lpc[j] = get_next_indice_fx( st, SNS_ABS_QUANT_BITS );
218 : }
219 : ELSE
220 : {
221 : param_lpc[j] = sub( get_next_indice_fx( st, 1 ), 2 );
222 : }
223 : move16();
224 : }
225 : ELSE
226 : #endif
227 : {
228 0 : move16();
229 0 : param_lpc[j] = get_next_indice_fx( st, 8 );
230 : }
231 0 : j = add( j, 1 );
232 : }
233 : /*
234 : * 2nd stage decoding is skipped if:
235 : * - we are in low bitrate mode and no joint SNS coding is used
236 : * - OR the side-SNS-is-zero flag is set for joint SNS
237 : */
238 : #ifdef IVAS_CODE_AVQ_LPC
239 : IF( NE_16( element_mode, IVAS_CPE_MDCT ) || ( !( sns_low_br_mode && ( EQ_16( stereo_mode, 0 ) || EQ_16( stereo_mode, 1 ) ) && !( EQ_16( q_type, 0 ) && EQ_16( param_lpc[j - 1], -2 ) ) ) ) )
240 : #endif
241 : {
242 : /* 2 bits to specify Q2,Q3,Q4,ext */
243 0 : qn1 = add( 2, get_next_indice_fx( st, 2 ) );
244 0 : qn2 = add( 2, get_next_indice_fx( st, 2 ) );
245 :
246 : /* Unary code */
247 : /* Q5 = 0, Q6=10, Q0=110, Q7=1110, ... */
248 :
249 0 : IF( GT_16( qn1, 4 ) )
250 : {
251 0 : nb = unary_decode_fx( st, &qn1 );
252 :
253 0 : if ( EQ_16( nb, 1 ) )
254 : {
255 0 : qn1 = add( qn1, 5 );
256 : }
257 0 : if ( EQ_16( nb, 2 ) )
258 : {
259 0 : qn1 = add( qn1, 4 );
260 : }
261 0 : if ( EQ_16( nb, 3 ) )
262 : {
263 0 : move16();
264 0 : qn1 = 0;
265 : }
266 0 : if ( GT_16( nb, 3 ) )
267 : {
268 0 : qn1 = add( qn1, 3 );
269 : }
270 : }
271 :
272 0 : IF( GT_16( qn2, 4 ) )
273 : {
274 0 : nb = unary_decode_fx( st, &qn2 );
275 :
276 0 : if ( EQ_16( nb, 1 ) )
277 : {
278 0 : qn2 = add( qn2, 5 );
279 : }
280 0 : if ( EQ_16( nb, 2 ) )
281 : {
282 0 : qn2 = add( qn2, 4 );
283 : }
284 0 : if ( EQ_16( nb, 3 ) )
285 : {
286 0 : move16();
287 0 : qn2 = 0;
288 : }
289 0 : if ( GT_16( nb, 3 ) )
290 : {
291 0 : qn2 = add( qn2, 3 );
292 : }
293 : }
294 :
295 : /* check for potential bit errors */
296 0 : test();
297 0 : IF( ( GT_16( qn1, NB_SPHERE ) ) || ( GT_16( qn2, NB_SPHERE ) ) )
298 : {
299 0 : qn1 = 0;
300 0 : move16();
301 0 : qn2 = 0;
302 0 : move16();
303 0 : st->BER_detect = 1;
304 0 : move16();
305 : }
306 :
307 0 : move16();
308 0 : param_lpc[j] = qn1;
309 0 : j = add( j, 1 );
310 0 : move16();
311 0 : param_lpc[j] = qn2;
312 0 : j = add( j, 1 );
313 :
314 : /* Decode Split-by-2 algebraic VQ */
315 0 : avqBits = shl( qn1, 2 );
316 :
317 0 : pack4bits_fx( avqBits, st, ¶m_lpc[j] );
318 0 : j = add( j, qn1 );
319 :
320 0 : avqBits = shl( qn2, 2 );
321 0 : pack4bits_fx( avqBits, st, ¶m_lpc[j] );
322 0 : j = add( j, qn2 );
323 : }
324 : #ifdef IVAS_CODE_AVQ_LPC
325 : ELSE
326 : {
327 : param_lpc[j] = 0;
328 : j = add( j, 1 );
329 : param_lpc[j] = 0;
330 : j = add( j, 1 );
331 : move16();
332 : move16();
333 : }
334 : #endif
335 : }
336 :
337 0 : return sub( st->next_bit_pos, start_bit_pos );
338 : }
339 573176 : Word16 decode_lpc_avq_ivas_fx(
340 : Decoder_State *st, /* i/o: decoder state structure */
341 : const Word16 numlpc, /* i : Number of sets of lpc */
342 : Word16 *param_lpc /* o : lpc parameters */
343 : ,
344 : const Word16 ch, /* i : channel */
345 : const Word16 element_mode, /* i : element mode */
346 : const Word16 sns_low_br_mode /* i : SNS low-bitrate mode */
347 : )
348 : {
349 : Word16 k, j;
350 : Word16 nb, qn1, qn2, avqBits, q_type;
351 : Word16 start_bit_pos;
352 573176 : Word16 stereo_mode = 0;
353 :
354 573176 : move16();
355 573176 : move16();
356 573176 : move16();
357 573176 : j = 0;
358 573176 : start_bit_pos = st->next_bit_pos;
359 :
360 1158763 : FOR( k = 0; k < numlpc; k++ )
361 : {
362 : /* Decode quantizer type */
363 :
364 585587 : IF( k == 0 )
365 : {
366 573176 : move16();
367 573176 : move16();
368 573176 : q_type = 0;
369 573176 : nb = 0;
370 : }
371 : ELSE
372 : {
373 12411 : move16();
374 12411 : nb = 1;
375 12411 : q_type = get_next_indice_fx( st, nb );
376 12411 : move16();
377 12411 : param_lpc[j] = q_type;
378 12411 : j = add( j, 1 );
379 : }
380 585587 : test();
381 585587 : IF( EQ_16( element_mode, IVAS_CPE_MDCT ) && k == 0 )
382 : {
383 472006 : stereo_mode = ch;
384 472006 : move16();
385 472006 : if ( ch == 0 )
386 : {
387 262512 : stereo_mode = param_lpc[j];
388 262512 : move16();
389 : }
390 472006 : param_lpc[j] = stereo_mode;
391 472006 : j = add( j, 1 );
392 472006 : move16();
393 : }
394 : /* Decode quantization indices */
395 :
396 585587 : IF( q_type == 0 )
397 : {
398 : /* Absolute quantizer with 1st stage stochastic codebook */
399 578178 : IF( EQ_16( element_mode, IVAS_CPE_MDCT ) )
400 : {
401 475933 : IF( NE_16( stereo_mode, 3 ) )
402 : {
403 304877 : param_lpc[j] = get_next_indice_fx( st, SNS_ABS_QUANT_BITS );
404 : }
405 : ELSE
406 : {
407 171056 : param_lpc[j] = sub( get_next_indice_fx( st, 1 ), 2 );
408 : }
409 475933 : move16();
410 : }
411 : ELSE
412 : {
413 102245 : move16();
414 102245 : param_lpc[j] = get_next_indice_fx( st, LPC_ABS_QUANT_BITS );
415 : }
416 578178 : j = add( j, 1 );
417 : }
418 : /*
419 : * 2nd stage decoding is skipped if:
420 : * - we are in low bitrate mode and no joint SNS coding is used
421 : * - OR the side-SNS-is-zero flag is set for joint SNS
422 : */
423 585587 : test();
424 585587 : test();
425 585587 : test();
426 585587 : test();
427 585587 : test();
428 585587 : IF( NE_16( element_mode, IVAS_CPE_MDCT ) || ( !( sns_low_br_mode && ( ( stereo_mode == 0 ) || EQ_16( stereo_mode, 1 ) ) ) && !( ( q_type == 0 ) && EQ_16( param_lpc[j - 1], -2 ) ) ) )
429 : {
430 : /* 2 bits to specify Q2,Q3,Q4,ext */
431 566648 : qn1 = add( 2, get_next_indice_fx( st, 2 ) );
432 566648 : qn2 = add( 2, get_next_indice_fx( st, 2 ) );
433 : /* Unary code */
434 : /* Q5 = 0, Q6=10, Q0=110, Q7=1110, ... */
435 :
436 566648 : IF( GT_16( qn1, 4 ) )
437 : {
438 72241 : nb = unary_decode_fx( st, &qn1 );
439 :
440 72241 : if ( EQ_16( nb, 1 ) )
441 : {
442 35839 : qn1 = add( qn1, 5 );
443 : }
444 72241 : if ( EQ_16( nb, 2 ) )
445 : {
446 24777 : qn1 = add( qn1, 4 );
447 : }
448 72241 : if ( EQ_16( nb, 3 ) )
449 : {
450 10702 : move16();
451 10702 : qn1 = 0;
452 : }
453 72241 : if ( GT_16( nb, 3 ) )
454 : {
455 923 : qn1 = add( qn1, 3 );
456 : }
457 : }
458 :
459 566648 : IF( GT_16( qn2, 4 ) )
460 : {
461 83933 : nb = unary_decode_fx( st, &qn2 );
462 :
463 83933 : if ( EQ_16( nb, 1 ) )
464 : {
465 9071 : qn2 = add( qn2, 5 );
466 : }
467 83933 : if ( EQ_16( nb, 2 ) )
468 : {
469 4618 : qn2 = add( qn2, 4 );
470 : }
471 83933 : if ( EQ_16( nb, 3 ) )
472 : {
473 70103 : move16();
474 70103 : qn2 = 0;
475 : }
476 83933 : if ( GT_16( nb, 3 ) )
477 : {
478 141 : qn2 = add( qn2, 3 );
479 : }
480 : }
481 :
482 : /* check for potential bit errors */
483 566648 : test();
484 566648 : IF( ( GT_16( qn1, NB_SPHERE ) ) || ( GT_16( qn2, NB_SPHERE ) ) )
485 : {
486 0 : qn1 = 0;
487 0 : move16();
488 0 : qn2 = 0;
489 0 : move16();
490 0 : st->BER_detect = 1;
491 0 : move16();
492 : }
493 :
494 566648 : move16();
495 566648 : param_lpc[j] = qn1;
496 566648 : j = add( j, 1 );
497 566648 : move16();
498 566648 : param_lpc[j] = qn2;
499 566648 : j = add( j, 1 );
500 :
501 : /* Decode Split-by-2 algebraic VQ */
502 566648 : avqBits = shl( qn1, 2 );
503 :
504 566648 : pack4bits_fx( avqBits, st, ¶m_lpc[j] );
505 566648 : j = add( j, qn1 );
506 :
507 566648 : avqBits = shl( qn2, 2 );
508 566648 : pack4bits_fx( avqBits, st, ¶m_lpc[j] );
509 566648 : j = add( j, qn2 );
510 : }
511 : ELSE
512 : {
513 18939 : param_lpc[j] = 0;
514 18939 : j = add( j, 1 );
515 18939 : param_lpc[j] = 0;
516 18939 : j = add( j, 1 );
517 18939 : move16();
518 18939 : move16();
519 : }
520 : }
521 :
522 573176 : return sub( st->next_bit_pos, start_bit_pos );
523 : }
|
