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 101553 : 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 101553 : move16();
33 101553 : last = 0;
34 101553 : IF( NE_16( numlpc, 1 ) )
35 : {
36 1956 : move16();
37 1956 : last = M;
38 : }
39 :
40 101553 : move16();
41 101553 : p_index = index;
42 :
43 : /* Decode last LPC */
44 :
45 1726401 : FOR( i = 0; i < M; i++ )
46 : {
47 1624848 : move16();
48 1624848 : LSF_Q[last + i] = 0;
49 : }
50 101553 : vlpc_1st_dec( p_index[0], &LSF_Q[last] ); // LSF_Q[last] -> Q2.56
51 101553 : p_index++;
52 101553 : vlpc_2st_dec( &LSF_Q[last], &p_index[0], 0, sr_core ); // Q2.56
53 101553 : nbi = add( 2, add( p_index[0], p_index[1] ) );
54 101553 : p_index += nbi;
55 :
56 : /* Decode intermediate LPC (512 framing) */
57 :
58 101553 : IF( EQ_16( numlpc, 2 ) )
59 : {
60 1956 : move16();
61 1956 : q_type = p_index[0];
62 1956 : p_index++;
63 :
64 1956 : IF( q_type == 0 )
65 : {
66 :
67 18445 : FOR( i = 0; i < M; i++ )
68 : {
69 17360 : move16();
70 17360 : LSF_Q[i] = 0;
71 : }
72 1085 : vlpc_1st_dec( p_index[0], &LSF_Q[0] ); ////Q2.56
73 1085 : p_index++;
74 1085 : vlpc_2st_dec( &LSF_Q[0], &p_index[0], 0, sr_core );
75 : }
76 871 : ELSE IF( EQ_16( q_type, 1 ) )
77 : {
78 :
79 14807 : FOR( i = 0; i < M; i++ )
80 : {
81 13936 : move16();
82 13936 : LSF_Q[i] = LSF_Q[M + i];
83 : }
84 871 : vlpc_2st_dec( &LSF_Q[0], &p_index[0], 3, sr_core ); ////Q2.56
85 : }
86 1956 : nbi = add( 2, add( p_index[0], p_index[1] ) );
87 1956 : p_index += nbi;
88 : }
89 :
90 101553 : return (Word16) ( p_index - index );
91 : }
92 :
93 167150 : static Word16 unary_decode_fx(
94 : Decoder_State *st,
95 : Word16 *ind )
96 : {
97 :
98 : Word16 start_bit_pos;
99 :
100 :
101 167150 : move16();
102 167150 : start_bit_pos = st->next_bit_pos;
103 :
104 : /* Index bits */
105 :
106 167150 : move16();
107 167150 : *ind = 0;
108 167150 : test();
109 376386 : WHILE( ( get_next_indice_1_fx( st ) != 0 ) && !st->BER_detect )
110 : {
111 209236 : move16();
112 209236 : *ind = add( *ind, 1 );
113 : }
114 :
115 167150 : if ( *ind != 0 )
116 : {
117 119344 : move16();
118 119344 : *ind = add( *ind, 1 );
119 : }
120 :
121 167150 : return sub( st->next_bit_pos, start_bit_pos );
122 : }
123 :
124 1221728 : static Word16 pack4bits_fx(
125 : Word16 nbits,
126 : Decoder_State *st,
127 : Word16 *prm )
128 : {
129 : Word16 i;
130 :
131 :
132 1221728 : move16();
133 1221728 : i = 0;
134 :
135 3500396 : FOR( ; nbits > 4; nbits -= 4 )
136 : {
137 2278668 : move16();
138 2278668 : prm[i] = get_next_indice_fx( st, 4 );
139 2278668 : i = add( i, 1 );
140 : }
141 1221728 : prm[i] = get_next_indice_fx( st, nbits );
142 1221728 : move16();
143 1221728 : i = add( i, 1 );
144 :
145 1221728 : 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 : )
153 : {
154 : Word16 k, j;
155 : Word16 nb, qn1, qn2, avqBits, q_type;
156 : Word16 start_bit_pos;
157 0 : move16();
158 0 : move16();
159 0 : move16();
160 0 : j = 0;
161 0 : start_bit_pos = st->next_bit_pos;
162 :
163 0 : FOR( k = 0; k < numlpc; k++ )
164 : {
165 : /* Decode quantizer type */
166 :
167 0 : IF( k == 0 )
168 : {
169 0 : move16();
170 0 : move16();
171 0 : q_type = 0;
172 0 : nb = 0;
173 : }
174 : ELSE
175 : {
176 0 : move16();
177 0 : nb = 1;
178 0 : q_type = get_next_indice_fx( st, nb );
179 0 : move16();
180 0 : param_lpc[j] = q_type;
181 0 : j = add( j, 1 );
182 : }
183 : /* Decode quantization indices */
184 :
185 0 : IF( q_type == 0 )
186 : {
187 : /* Absolute quantizer with 1st stage stochastic codebook */
188 : {
189 0 : move16();
190 0 : param_lpc[j] = get_next_indice_fx( st, 8 );
191 : }
192 0 : j = add( j, 1 );
193 : }
194 : /*
195 : * 2nd stage decoding is skipped if:
196 : * - we are in low bitrate mode and no joint SNS coding is used
197 : * - OR the side-SNS-is-zero flag is set for joint SNS
198 : */
199 : {
200 : /* 2 bits to specify Q2,Q3,Q4,ext */
201 0 : qn1 = add( 2, get_next_indice_fx( st, 2 ) );
202 0 : qn2 = add( 2, get_next_indice_fx( st, 2 ) );
203 :
204 : /* Unary code */
205 : /* Q5 = 0, Q6=10, Q0=110, Q7=1110, ... */
206 :
207 0 : IF( GT_16( qn1, 4 ) )
208 : {
209 0 : nb = unary_decode_fx( st, &qn1 );
210 :
211 0 : if ( EQ_16( nb, 1 ) )
212 : {
213 0 : qn1 = add( qn1, 5 );
214 : }
215 0 : if ( EQ_16( nb, 2 ) )
216 : {
217 0 : qn1 = add( qn1, 4 );
218 : }
219 0 : if ( EQ_16( nb, 3 ) )
220 : {
221 0 : move16();
222 0 : qn1 = 0;
223 : }
224 0 : if ( GT_16( nb, 3 ) )
225 : {
226 0 : qn1 = add( qn1, 3 );
227 : }
228 : }
229 :
230 0 : IF( GT_16( qn2, 4 ) )
231 : {
232 0 : nb = unary_decode_fx( st, &qn2 );
233 :
234 0 : if ( EQ_16( nb, 1 ) )
235 : {
236 0 : qn2 = add( qn2, 5 );
237 : }
238 0 : if ( EQ_16( nb, 2 ) )
239 : {
240 0 : qn2 = add( qn2, 4 );
241 : }
242 0 : if ( EQ_16( nb, 3 ) )
243 : {
244 0 : move16();
245 0 : qn2 = 0;
246 : }
247 0 : if ( GT_16( nb, 3 ) )
248 : {
249 0 : qn2 = add( qn2, 3 );
250 : }
251 : }
252 :
253 : /* check for potential bit errors */
254 0 : test();
255 0 : IF( ( GT_16( qn1, NB_SPHERE ) ) || ( GT_16( qn2, NB_SPHERE ) ) )
256 : {
257 0 : qn1 = 0;
258 0 : move16();
259 0 : qn2 = 0;
260 0 : move16();
261 0 : st->BER_detect = 1;
262 0 : move16();
263 : }
264 :
265 0 : move16();
266 0 : param_lpc[j] = qn1;
267 0 : j = add( j, 1 );
268 0 : move16();
269 0 : param_lpc[j] = qn2;
270 0 : j = add( j, 1 );
271 :
272 : /* Decode Split-by-2 algebraic VQ */
273 0 : avqBits = shl( qn1, 2 );
274 :
275 0 : pack4bits_fx( avqBits, st, ¶m_lpc[j] );
276 0 : j = add( j, qn1 );
277 :
278 0 : avqBits = shl( qn2, 2 );
279 0 : pack4bits_fx( avqBits, st, ¶m_lpc[j] );
280 0 : j = add( j, qn2 );
281 : }
282 : }
283 :
284 0 : return sub( st->next_bit_pos, start_bit_pos );
285 : }
286 :
287 617216 : Word16 decode_lpc_avq_ivas_fx(
288 : Decoder_State *st, /* i/o: decoder state structure */
289 : const Word16 numlpc, /* i : Number of sets of lpc */
290 : Word16 *param_lpc /* o : lpc parameters */
291 : ,
292 : const Word16 ch, /* i : channel */
293 : const Word16 element_mode, /* i : element mode */
294 : const Word16 sns_low_br_mode /* i : SNS low-bitrate mode */
295 : )
296 : {
297 : Word16 k, j;
298 : Word16 nb, qn1, qn2, avqBits, q_type;
299 : Word16 start_bit_pos;
300 617216 : Word16 stereo_mode = 0;
301 :
302 617216 : move16();
303 617216 : move16();
304 617216 : move16();
305 617216 : j = 0;
306 617216 : start_bit_pos = st->next_bit_pos;
307 :
308 1248245 : FOR( k = 0; k < numlpc; k++ )
309 : {
310 : /* Decode quantizer type */
311 :
312 631029 : IF( k == 0 )
313 : {
314 617216 : move16();
315 617216 : move16();
316 617216 : q_type = 0;
317 617216 : nb = 0;
318 : }
319 : ELSE
320 : {
321 13813 : move16();
322 13813 : nb = 1;
323 13813 : q_type = get_next_indice_fx( st, nb );
324 13813 : move16();
325 13813 : param_lpc[j] = q_type;
326 13813 : j = add( j, 1 );
327 : }
328 631029 : test();
329 631029 : IF( EQ_16( element_mode, IVAS_CPE_MDCT ) && k == 0 )
330 : {
331 515663 : stereo_mode = ch;
332 515663 : move16();
333 515663 : if ( ch == 0 )
334 : {
335 286746 : stereo_mode = param_lpc[j];
336 286746 : move16();
337 : }
338 515663 : param_lpc[j] = stereo_mode;
339 515663 : j = add( j, 1 );
340 515663 : move16();
341 : }
342 : /* Decode quantization indices */
343 :
344 631029 : IF( q_type == 0 )
345 : {
346 : /* Absolute quantizer with 1st stage stochastic codebook */
347 622689 : IF( EQ_16( element_mode, IVAS_CPE_MDCT ) )
348 : {
349 520051 : IF( NE_16( stereo_mode, 3 ) )
350 : {
351 340127 : param_lpc[j] = get_next_indice_fx( st, SNS_ABS_QUANT_BITS );
352 : }
353 : ELSE
354 : {
355 179924 : param_lpc[j] = sub( get_next_indice_fx( st, 1 ), 2 );
356 : }
357 520051 : move16();
358 : }
359 : ELSE
360 : {
361 102638 : move16();
362 102638 : param_lpc[j] = get_next_indice_fx( st, LPC_ABS_QUANT_BITS );
363 : }
364 622689 : j = add( j, 1 );
365 : }
366 : /*
367 : * 2nd stage decoding is skipped if:
368 : * - we are in low bitrate mode and no joint SNS coding is used
369 : * - OR the side-SNS-is-zero flag is set for joint SNS
370 : */
371 631029 : test();
372 631029 : test();
373 631029 : test();
374 631029 : test();
375 631029 : test();
376 631029 : 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 ) ) ) )
377 : {
378 : /* 2 bits to specify Q2,Q3,Q4,ext */
379 610864 : qn1 = add( 2, get_next_indice_fx( st, 2 ) );
380 610864 : qn2 = add( 2, get_next_indice_fx( st, 2 ) );
381 : /* Unary code */
382 : /* Q5 = 0, Q6=10, Q0=110, Q7=1110, ... */
383 :
384 610864 : IF( GT_16( qn1, 4 ) )
385 : {
386 76248 : nb = unary_decode_fx( st, &qn1 );
387 :
388 76248 : if ( EQ_16( nb, 1 ) )
389 : {
390 38357 : qn1 = add( qn1, 5 );
391 : }
392 76248 : if ( EQ_16( nb, 2 ) )
393 : {
394 25793 : qn1 = add( qn1, 4 );
395 : }
396 76248 : if ( EQ_16( nb, 3 ) )
397 : {
398 11166 : move16();
399 11166 : qn1 = 0;
400 : }
401 76248 : if ( GT_16( nb, 3 ) )
402 : {
403 932 : qn1 = add( qn1, 3 );
404 : }
405 : }
406 :
407 610864 : IF( GT_16( qn2, 4 ) )
408 : {
409 90902 : nb = unary_decode_fx( st, &qn2 );
410 :
411 90902 : if ( EQ_16( nb, 1 ) )
412 : {
413 9449 : qn2 = add( qn2, 5 );
414 : }
415 90902 : if ( EQ_16( nb, 2 ) )
416 : {
417 4772 : qn2 = add( qn2, 4 );
418 : }
419 90902 : if ( EQ_16( nb, 3 ) )
420 : {
421 76540 : move16();
422 76540 : qn2 = 0;
423 : }
424 90902 : if ( GT_16( nb, 3 ) )
425 : {
426 141 : qn2 = add( qn2, 3 );
427 : }
428 : }
429 :
430 : /* check for potential bit errors */
431 610864 : test();
432 610864 : IF( ( GT_16( qn1, NB_SPHERE ) ) || ( GT_16( qn2, NB_SPHERE ) ) )
433 : {
434 0 : qn1 = 0;
435 0 : move16();
436 0 : qn2 = 0;
437 0 : move16();
438 0 : st->BER_detect = 1;
439 0 : move16();
440 : }
441 :
442 610864 : move16();
443 610864 : param_lpc[j] = qn1;
444 610864 : j = add( j, 1 );
445 610864 : move16();
446 610864 : param_lpc[j] = qn2;
447 610864 : j = add( j, 1 );
448 :
449 : /* Decode Split-by-2 algebraic VQ */
450 610864 : avqBits = shl( qn1, 2 );
451 :
452 610864 : pack4bits_fx( avqBits, st, ¶m_lpc[j] );
453 610864 : j = add( j, qn1 );
454 :
455 610864 : avqBits = shl( qn2, 2 );
456 610864 : pack4bits_fx( avqBits, st, ¶m_lpc[j] );
457 610864 : j = add( j, qn2 );
458 : }
459 : ELSE
460 : {
461 20165 : param_lpc[j] = 0;
462 20165 : j = add( j, 1 );
463 20165 : param_lpc[j] = 0;
464 20165 : j = add( j, 1 );
465 20165 : move16();
466 20165 : move16();
467 : }
468 : }
469 :
470 617216 : return sub( st->next_bit_pos, start_bit_pos );
471 : }
|
