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 : )
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 573176 : 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 573176 : Word16 stereo_mode = 0;
301 :
302 573176 : move16();
303 573176 : move16();
304 573176 : move16();
305 573176 : j = 0;
306 573176 : start_bit_pos = st->next_bit_pos;
307 :
308 1158763 : FOR( k = 0; k < numlpc; k++ )
309 : {
310 : /* Decode quantizer type */
311 :
312 585587 : IF( k == 0 )
313 : {
314 573176 : move16();
315 573176 : move16();
316 573176 : q_type = 0;
317 573176 : nb = 0;
318 : }
319 : ELSE
320 : {
321 12411 : move16();
322 12411 : nb = 1;
323 12411 : q_type = get_next_indice_fx( st, nb );
324 12411 : move16();
325 12411 : param_lpc[j] = q_type;
326 12411 : j = add( j, 1 );
327 : }
328 585587 : test();
329 585587 : IF( EQ_16( element_mode, IVAS_CPE_MDCT ) && k == 0 )
330 : {
331 472006 : stereo_mode = ch;
332 472006 : move16();
333 472006 : if ( ch == 0 )
334 : {
335 262512 : stereo_mode = param_lpc[j];
336 262512 : move16();
337 : }
338 472006 : param_lpc[j] = stereo_mode;
339 472006 : j = add( j, 1 );
340 472006 : move16();
341 : }
342 : /* Decode quantization indices */
343 :
344 585587 : IF( q_type == 0 )
345 : {
346 : /* Absolute quantizer with 1st stage stochastic codebook */
347 578178 : IF( EQ_16( element_mode, IVAS_CPE_MDCT ) )
348 : {
349 475933 : IF( NE_16( stereo_mode, 3 ) )
350 : {
351 304877 : param_lpc[j] = get_next_indice_fx( st, SNS_ABS_QUANT_BITS );
352 : }
353 : ELSE
354 : {
355 171056 : param_lpc[j] = sub( get_next_indice_fx( st, 1 ), 2 );
356 : }
357 475933 : move16();
358 : }
359 : ELSE
360 : {
361 102245 : move16();
362 102245 : param_lpc[j] = get_next_indice_fx( st, LPC_ABS_QUANT_BITS );
363 : }
364 578178 : 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 585587 : test();
372 585587 : test();
373 585587 : test();
374 585587 : test();
375 585587 : test();
376 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 ) ) ) )
377 : {
378 : /* 2 bits to specify Q2,Q3,Q4,ext */
379 566648 : qn1 = add( 2, get_next_indice_fx( st, 2 ) );
380 566648 : qn2 = add( 2, get_next_indice_fx( st, 2 ) );
381 : /* Unary code */
382 : /* Q5 = 0, Q6=10, Q0=110, Q7=1110, ... */
383 :
384 566648 : IF( GT_16( qn1, 4 ) )
385 : {
386 72241 : nb = unary_decode_fx( st, &qn1 );
387 :
388 72241 : if ( EQ_16( nb, 1 ) )
389 : {
390 35839 : qn1 = add( qn1, 5 );
391 : }
392 72241 : if ( EQ_16( nb, 2 ) )
393 : {
394 24777 : qn1 = add( qn1, 4 );
395 : }
396 72241 : if ( EQ_16( nb, 3 ) )
397 : {
398 10702 : move16();
399 10702 : qn1 = 0;
400 : }
401 72241 : if ( GT_16( nb, 3 ) )
402 : {
403 923 : qn1 = add( qn1, 3 );
404 : }
405 : }
406 :
407 566648 : IF( GT_16( qn2, 4 ) )
408 : {
409 83933 : nb = unary_decode_fx( st, &qn2 );
410 :
411 83933 : if ( EQ_16( nb, 1 ) )
412 : {
413 9071 : qn2 = add( qn2, 5 );
414 : }
415 83933 : if ( EQ_16( nb, 2 ) )
416 : {
417 4618 : qn2 = add( qn2, 4 );
418 : }
419 83933 : if ( EQ_16( nb, 3 ) )
420 : {
421 70103 : move16();
422 70103 : qn2 = 0;
423 : }
424 83933 : if ( GT_16( nb, 3 ) )
425 : {
426 141 : qn2 = add( qn2, 3 );
427 : }
428 : }
429 :
430 : /* check for potential bit errors */
431 566648 : test();
432 566648 : 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 566648 : move16();
443 566648 : param_lpc[j] = qn1;
444 566648 : j = add( j, 1 );
445 566648 : move16();
446 566648 : param_lpc[j] = qn2;
447 566648 : j = add( j, 1 );
448 :
449 : /* Decode Split-by-2 algebraic VQ */
450 566648 : avqBits = shl( qn1, 2 );
451 :
452 566648 : pack4bits_fx( avqBits, st, ¶m_lpc[j] );
453 566648 : j = add( j, qn1 );
454 :
455 566648 : avqBits = shl( qn2, 2 );
456 566648 : pack4bits_fx( avqBits, st, ¶m_lpc[j] );
457 566648 : j = add( j, qn2 );
458 : }
459 : ELSE
460 : {
461 18939 : param_lpc[j] = 0;
462 18939 : j = add( j, 1 );
463 18939 : param_lpc[j] = 0;
464 18939 : j = add( j, 1 );
465 18939 : move16();
466 18939 : move16();
467 : }
468 : }
469 :
470 573176 : return sub( st->next_bit_pos, start_bit_pos );
471 : }
|
