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" /* Compilation switches */
8 : #include "cnst.h" /* Common constants */
9 : #include "rom_com.h" /* Static table prototypes */
10 : #include "prot_fx.h" /* Function prototypes */
11 :
12 : /*-------------------------------------------------------------------*
13 : * Local prototypes
14 : *-------------------------------------------------------------------*/
15 :
16 : static void read_cv_fx( Decoder_State *st, UWord16 *I, Word16 *kv, Word16 nq, Word16 *nbits );
17 :
18 : /*-----------------------------------------------------------------*
19 : * AVQ_demuxdec()
20 : *
21 : * Demultiplex and decode subvectors using
22 : * split algebraic vector dequantizer based on RE8 latice.
23 : *-----------------------------------------------------------------*/
24 :
25 64155 : void AVQ_demuxdec_fx(
26 : Decoder_State *st, /* i/o: decoder state structure */
27 : Word16 xriq[], /* o : decoded subvectors [0..8*Nsv-1] Q0*/
28 : Word16 *nb_bits, /* i/o: number of allocated bits Q0*/
29 : const Word16 Nsv, /* i : number of subvectors Q0*/
30 : Word16 nq[], /* i/o: AVQ nq index Q0*/
31 : Word16 avq_bit_sFlag, /* i : flag for AVQ bit saving solution Q0*/
32 : Word16 trgtSvPos /* i : target SV for AVQ bit savings Q0*/
33 : )
34 : {
35 : Word16 i, j, bits, tmp;
36 : UWord16 I[NSV_MAX];
37 : Word16 code[8];
38 : Word16 *kv;
39 : Word16 nq_est, unused_bits_idx;
40 : Word16 bitsMod;
41 : Word16 underflow;
42 : Word16 unusedbitsFlag;
43 : Word16 svOrder[NSV_MAX], k, nullVec, dummy_bits;
44 :
45 64155 : kv = xriq; /* reuse vector to save memory */
46 64155 : bits = *nb_bits;
47 64155 : move16();
48 64155 : bitsMod = 0;
49 64155 : move16();
50 64155 : underflow = 0;
51 64155 : move16();
52 64155 : unusedbitsFlag = 0;
53 64155 : move16();
54 64155 : nullVec = 0;
55 64155 : move16();
56 64155 : dummy_bits = 0;
57 64155 : move16();
58 64155 : svOrder[Nsv - 1] = trgtSvPos;
59 64155 : move16();
60 64155 : svOrder[0] = 0;
61 64155 : move16();
62 64155 : svOrder[1] = 1;
63 64155 : move16();
64 64155 : i = 2;
65 64155 : move16();
66 64155 : j = i;
67 64155 : move16();
68 64155 : IF( EQ_16( avq_bit_sFlag, 2 ) )
69 : {
70 16552 : j = i + 1;
71 : }
72 :
73 393349 : WHILE( LT_16( i, sub( Nsv, 1 ) ) )
74 : {
75 329194 : move16();
76 329194 : svOrder[i] = j;
77 329194 : i = 1 + i;
78 329194 : j = 1 + j;
79 : }
80 :
81 2245425 : FOR( i = 0; i < NSV_MAX; i++ )
82 : {
83 2181270 : I[i] = (UWord16) -1;
84 2181270 : move16();
85 : }
86 :
87 548113 : FOR( i = 0; i < Nsv; i++ )
88 : {
89 521495 : k = svOrder[i];
90 521495 : move16();
91 521495 : test();
92 521495 : test();
93 521495 : test();
94 521495 : test();
95 521495 : test();
96 521495 : IF( EQ_16( avq_bit_sFlag, 2 ) && EQ_16( ( bits % 5 ), 4 ) && GT_16( bits, 8 ) && LT_16( bits, 30 ) && GE_16( k, trgtSvPos ) && LT_16( i, sub( Nsv, 1 ) ) )
97 : {
98 2449 : ordr_esti( sub( Nsv, i ), &trgtSvPos, &svOrder[i], Nsv );
99 2449 : k = svOrder[i];
100 2449 : move16();
101 2449 : avq_bit_sFlag = 1;
102 2449 : move16();
103 : }
104 521495 : test();
105 521495 : IF( EQ_16( k, trgtSvPos ) && avq_bit_sFlag > 0 )
106 : {
107 59315 : test();
108 59315 : test();
109 59315 : IF( EQ_16( sub( *nb_bits, bits ), 7 ) || LT_16( bits, BIT_SAVING_LOW_THR ) || GE_16( bits, BIT_SAVING_HIGH_THR ) )
110 : {
111 21778 : avq_bit_sFlag = 0;
112 21778 : move16();
113 : }
114 : ELSE
115 : {
116 : BREAK;
117 : }
118 : }
119 :
120 483958 : nq[k] = 0;
121 483958 : move16(); /* initialization and also forced if the budget is exceeded */
122 :
123 483958 : IF( GT_16( bits, 8 ) )
124 : {
125 : /* read the unary code including the stop bit for nq[i] */
126 457099 : nq[k] = -1;
127 457099 : move16();
128 : DO
129 : {
130 956498 : nq[k] = add( nq[k], 1 );
131 956498 : move16();
132 :
133 : // IF ( 5 * nq[k] + 4 == bits )
134 956498 : IF( EQ_16( add( add( shl( nq[k], 2 ), nq[k] ), 4 ), bits ) )
135 : {
136 5642 : BREAK;
137 : }
138 : }
139 950856 : WHILE( get_next_indice_1_fx( st ) );
140 :
141 457099 : if ( EQ_16( add( add( shl( nq[k], 2 ), nq[k] ), 4 ), bits ) ) /* check the overflow */
142 : {
143 5642 : bits = add( bits, 1 ); /* overflow stop bit */
144 : }
145 :
146 : /* check for potential bit errors */
147 457099 : IF( GT_16( nq[k], NB_SPHERE ) )
148 : {
149 0 : st->BER_detect = 1;
150 0 : move16();
151 0 : set16_fx( xriq, 0, shl( Nsv, 3 ) );
152 0 : set16_fx( nq, 0, Nsv );
153 0 : *nb_bits = 0;
154 0 : move16();
155 :
156 0 : return;
157 : }
158 :
159 457099 : bits = sub( bits, nq[k] );
160 457099 : bits = sub( bits, 1 ); /* count the stop bit */
161 :
162 457099 : IF( GT_16( nq[k], 0 ) )
163 : {
164 338082 : nq[k] = add( nq[k], 1 );
165 338082 : move16();
166 : }
167 :
168 : /* read codebook indices (rank I and event. Voronoi index kv) */
169 457099 : read_cv_fx( st, &I[k], &kv[k * 8], nq[k], &bits );
170 : }
171 : } /* for */
172 :
173 : /* Bit Saving Solution */
174 64155 : IF( ( avq_bit_sFlag > 0 ) && GT_16( bits, 8 ) )
175 : {
176 37537 : i = svOrder[Nsv - 1];
177 37537 : nq[i] = 0;
178 37537 : move16();
179 37537 : bitsMod = bits % 5;
180 37537 : IF( NE_16( i, sub( Nsv, 1 ) ) )
181 : {
182 12820 : nullVec = 0;
183 12820 : move16();
184 76920 : FOR( j = i; j < Nsv - 1; j++ )
185 : {
186 64100 : if ( nq[svOrder[j]] == 0 )
187 : {
188 9071 : nullVec = add( nullVec, 1 );
189 : }
190 : }
191 12820 : nq_est = idiv1616( bits, 5 );
192 12820 : test();
193 12820 : test();
194 12820 : test();
195 12820 : test();
196 12820 : test();
197 12820 : test();
198 12820 : test();
199 12820 : test();
200 12820 : test();
201 12820 : test();
202 12820 : test();
203 12820 : test();
204 12820 : IF( ( ( bitsMod > 0 ) || ( EQ_16( nullVec, 4 ) && EQ_16( nq_est, 5 ) ) ) && NE_16( bitsMod, 4 ) && GE_16( add( bits, nullVec ), ( add( add( shl( nq_est, 2 ), nq_est ), 4 ) ) ) && ( nq[svOrder[Nsv - 2]] == 0 ) ) /* dummy bits */
205 : {
206 100 : dummy_bits = sub( 5, bitsMod );
207 100 : bits = add( bits, dummy_bits ); /* add dummy bits */
208 100 : bitsMod = 0;
209 100 : move16();
210 : }
211 12720 : ELSE IF( GT_16( nq_est, 4 ) && ( ( ( bitsMod == 0 ) && GT_16( nullVec, 3 ) && LT_16( nullVec, 6 ) ) || ( EQ_16( bitsMod, 4 ) && EQ_16( nullVec, 5 ) ) ) && ( nq[svOrder[Nsv - 2]] == 0 ) ) /* wasted bits 4, 5 for nq 6,7..*/
212 : {
213 3 : underflow = 0;
214 3 : move16();
215 3 : IF( NE_16( ( add( bitsMod, nullVec ) % 5 ), 0 ) )
216 : {
217 3 : underflow = 1;
218 3 : move16();
219 : }
220 3 : dummy_bits = add( nullVec, underflow );
221 3 : bits = add( bits, dummy_bits ); /* add dummy bits */
222 3 : bitsMod = 0;
223 3 : move16();
224 : }
225 : }
226 37537 : underflow = 1;
227 37537 : move16();
228 37537 : IF( NE_16( bitsMod, 4 ) )
229 : {
230 31531 : underflow = 0;
231 31531 : move16();
232 31531 : bits = sub( bits, bitsMod );
233 : }
234 37537 : bits = add( bits, underflow );
235 :
236 : /* read the unary code for unused bit*/
237 37537 : unused_bits_idx = -1;
238 37537 : move16();
239 : DO
240 : {
241 49453 : unused_bits_idx = add( unused_bits_idx, 1 );
242 49453 : IF( EQ_16( add( add( shl( unused_bits_idx, 2 ), unused_bits_idx ), 4 ), sub( bits, 1 ) ) )
243 : {
244 225 : BREAK;
245 : }
246 : }
247 49228 : WHILE( get_next_indice_1_fx( st ) );
248 :
249 37537 : unusedbitsFlag = 0;
250 37537 : move16();
251 :
252 37537 : IF( ( dummy_bits == 0 ) )
253 : {
254 37434 : test();
255 37434 : test();
256 37434 : test();
257 37434 : test();
258 37434 : IF( ( unused_bits_idx == 0 ) && GT_16( bits, BIT_SAVING_LOW_THR ) )
259 : {
260 16977 : unusedbitsFlag = 1;
261 16977 : move16();
262 : }
263 20457 : ELSE IF( EQ_16( unused_bits_idx, 1 ) && GT_16( bits, BIT_SAVING_LOW_THR ) )
264 : {
265 7248 : unusedbitsFlag = -1;
266 7248 : move16();
267 : }
268 : }
269 :
270 : /*Compute AVQ code book number from unused Bits */
271 37537 : tmp = (Word16) ( sub( bits, add( add( shl( add( unusedbitsFlag, unused_bits_idx ), 2 ), unusedbitsFlag ), unused_bits_idx ) ) );
272 37537 : nq_est = idiv1616( tmp, 5 );
273 37537 : IF( ( ( tmp % 5 ) != 0 ) )
274 : {
275 0 : nq_est = add( nq_est, 1 );
276 : }
277 37537 : if ( EQ_16( nq_est, 1 ) )
278 : {
279 225 : nq_est = 0;
280 225 : move16();
281 : }
282 37537 : bits = sub( bits, underflow );
283 :
284 37537 : bits = sub( bits, unused_bits_idx );
285 :
286 37537 : if ( ( nq_est != 0 ) )
287 : {
288 37312 : bits = sub( bits, 1 );
289 : }
290 :
291 37537 : nq[i] = nq_est;
292 37537 : move16();
293 : /* read codebook indices (rank I and event. Voronoi index kv) */
294 37537 : read_cv_fx( st, &I[i], &kv[i * 8], nq[i], &bits );
295 :
296 37537 : bits = sub( bits, dummy_bits );
297 :
298 37537 : if ( NE_16( bitsMod, 4 ) )
299 : {
300 31531 : bits = add( bits, bitsMod );
301 : }
302 : }
303 :
304 : /* decode all subvectors */
305 585650 : FOR( i = 0; i < Nsv; i++ )
306 : {
307 : /* multi-rate RE8 decoder */
308 521495 : re8_dec_fx( nq[i], I[i], &kv[8 * i], code );
309 :
310 : /* write decoded RE8 vector to decoded subvector #i */
311 4693455 : FOR( j = 0; j < 8; j++ )
312 : {
313 4171960 : xriq[i * 8 + j] = code[j];
314 4171960 : move16();
315 : }
316 : }
317 64155 : move16();
318 64155 : *nb_bits = bits;
319 :
320 64155 : return;
321 : }
322 :
323 :
324 : /*-----------------------------------------------------------------*
325 : * AVQ_dec_lpc()
326 : *
327 : * Demultiplex and decode subvectors for LPC dequantization
328 : * using split algebraic vector dequantizer
329 : *-----------------------------------------------------------------*/
330 :
331 614123 : void AVQ_dec_lpc(
332 : Word16 *indx, /* input: index[] (4 bits per words) Q0*/
333 : Word16 *nvecq, /* output: vector quantized Q0*/
334 : Word16 Nsv /* input: number of subvectors (lg=Nsv*8) Q0*/
335 : )
336 : {
337 : Word16 i, l, n, nq, nk, pos, ival, c[8], kv[8];
338 : Word32 I;
339 : UWord16 I16;
340 :
341 : /* last index word */
342 614123 : pos = sub( Nsv, 1 );
343 :
344 1842369 : FOR( l = 0; l < Nsv; l++ )
345 : {
346 1228246 : pos = add( pos, indx[l] );
347 : }
348 :
349 : /* decode all subvectors */
350 :
351 1842369 : FOR( l = Nsv - 1; l >= 0; l-- )
352 : {
353 1228246 : nq = indx[l]; /* quantizer number (0,2,3..n) */
354 1228246 : move16();
355 :
356 1228246 : nk = 0;
357 1228246 : move16();
358 1228246 : n = nq;
359 1228246 : move16();
360 :
361 1228246 : IF( GT_16( nq, 4 ) )
362 : {
363 191563 : nk = shr( sub( nq, 3 ), 1 );
364 191563 : n = sub( nq, shl( nk, 1 ) );
365 : }
366 :
367 : /* read n groups of 4-bit for Voronoi index (k[]) */
368 :
369 11054214 : FOR( i = 0; i < 8; i++ )
370 : {
371 9825968 : kv[i] = 0;
372 9825968 : move16();
373 : }
374 :
375 1494206 : FOR( ; nk > 0; nk-- )
376 : {
377 265960 : ival = s_and( indx[pos--], 0x0F );
378 265960 : ival = shl( ival, 4 );
379 265960 : ival = add( ival, s_and( indx[pos--], 0x0F ) );
380 :
381 2393640 : FOR( i = 7; i >= 0; i-- )
382 : {
383 2127680 : kv[i] = add( shl( kv[i], 1 ), s_and( ival, 0x01 ) );
384 2127680 : move16();
385 2127680 : ival = shr( ival, 1 );
386 : }
387 : }
388 :
389 : /* read n groups of 4-bit for base codebook index (I) */
390 1228246 : I = L_deposit_l( 0 );
391 4592208 : FOR( ; n > 0; n-- )
392 : {
393 3363962 : I = L_shl( I, 4 );
394 3363962 : I = L_add( I, (Word32) s_and( indx[pos--], 0x0F ) );
395 : }
396 :
397 : /* multi-rate RE8 decoder */
398 1228246 : I16 = (UWord16) extract_l( I );
399 1228246 : cast16();
400 1228246 : re8_dec_fx( nq, I16, kv, c );
401 :
402 : /* write decoded RE8 vector */
403 11054214 : FOR( i = 0; i < 8; i++ )
404 : {
405 9825968 : nvecq[( l * 8 ) + i] = c[i];
406 9825968 : move16();
407 : }
408 : }
409 :
410 614123 : return;
411 : }
412 :
413 : /*-----------------------------------------------------------------*
414 : * read_cv_fx()
415 : *
416 : * read codebook indices (rank I and event. Voronoi index kv)
417 : *-----------------------------------------------------------------*/
418 :
419 494636 : static void read_cv_fx(
420 : Decoder_State *st, /* i/o: decoder state structure */
421 : UWord16 *I, /* o : rank I code book index Q0*/
422 : Word16 *kv, /* o : Voronoi index kv Q0*/
423 : Word16 nq, /* i : AVQ nq index Q0*/
424 : Word16 *nbits /* i/o: bits available Q0*/
425 : )
426 :
427 : {
428 : Word16 j, bits, order_v;
429 :
430 494636 : bits = *nbits;
431 494636 : move16();
432 : /* read codebook indices (rank I and event. Voronoi index kv) */
433 494636 : IF( ( nq == 0 ) ) /* Q0 */
434 : {
435 : /* nothing to read */
436 : }
437 375394 : ELSE IF( LT_16( nq, 5 ) ) /* Q2, Q3, Q4 */
438 : {
439 370488 : *I = get_next_indice_fx( st, shl( nq, 2 ) );
440 370488 : move32();
441 370488 : bits = sub( bits, shl( nq, 2 ) );
442 : }
443 4906 : ELSE IF( ( s_and( nq, 1 ) == 0 ) ) /* Q4 + Voronoi extensions r=1,2,3,... */
444 : {
445 1880 : *I = get_next_indice_fx( st, 16 );
446 1880 : move32();
447 1880 : bits = sub( bits, 16 );
448 1880 : order_v = (Word16) sub( shr( nq, 1 ), 2 );
449 1880 : move32();
450 :
451 16920 : FOR( j = 0; j < 8; j++ )
452 : {
453 15040 : kv[j] = get_next_indice_fx( st, order_v );
454 15040 : move16();
455 : }
456 1880 : bits = sub( bits, ( shl( order_v, 3 ) ) );
457 : }
458 : ELSE /* Q3 + Voronoi extensions r=1,2,3,... */
459 : {
460 3026 : *I = get_next_indice_fx( st, 12 );
461 3026 : move32();
462 3026 : bits = sub( bits, 12 );
463 3026 : order_v = (Word16) sub( shr( nq, 1 ), 1 );
464 :
465 27234 : FOR( j = 0; j < 8; j++ )
466 : {
467 24208 : kv[j] = get_next_indice_fx( st, order_v );
468 24208 : move32();
469 : }
470 3026 : bits = sub( bits, shl( order_v, 3 ) );
471 : }
472 494636 : *nbits = bits;
473 494636 : move16();
474 :
475 494636 : return;
476 : }
|
