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 64093 : 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 64093 : kv = xriq; /* reuse vector to save memory */
46 64093 : bits = *nb_bits;
47 64093 : move16();
48 64093 : bitsMod = 0;
49 64093 : move16();
50 64093 : underflow = 0;
51 64093 : move16();
52 64093 : unusedbitsFlag = 0;
53 64093 : move16();
54 64093 : nullVec = 0;
55 64093 : move16();
56 64093 : dummy_bits = 0;
57 64093 : move16();
58 64093 : svOrder[Nsv - 1] = trgtSvPos;
59 64093 : move16();
60 64093 : svOrder[0] = 0;
61 64093 : move16();
62 64093 : svOrder[1] = 1;
63 64093 : move16();
64 64093 : i = 2;
65 64093 : move16();
66 64093 : j = i;
67 64093 : move16();
68 64093 : IF( EQ_16( avq_bit_sFlag, 2 ) )
69 : {
70 16742 : j = i + 1;
71 : }
72 :
73 392958 : WHILE( LT_16( i, sub( Nsv, 1 ) ) )
74 : {
75 328865 : move16();
76 328865 : svOrder[i] = j;
77 328865 : i = 1 + i;
78 328865 : j = 1 + j;
79 : }
80 :
81 2243255 : FOR( i = 0; i < NSV_MAX; i++ )
82 : {
83 2179162 : I[i] = (UWord16) -1;
84 2179162 : move16();
85 : }
86 :
87 546129 : FOR( i = 0; i < Nsv; i++ )
88 : {
89 520996 : k = svOrder[i];
90 520996 : move16();
91 520996 : test();
92 520996 : test();
93 520996 : test();
94 520996 : test();
95 520996 : test();
96 520996 : 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 2501 : ordr_esti( sub( Nsv, i ), &trgtSvPos, &svOrder[i], Nsv );
99 2501 : k = svOrder[i];
100 2501 : move16();
101 2501 : avq_bit_sFlag = 1;
102 2501 : move16();
103 : }
104 520996 : test();
105 520996 : IF( EQ_16( k, trgtSvPos ) && avq_bit_sFlag > 0 )
106 : {
107 59295 : test();
108 59295 : test();
109 59295 : IF( EQ_16( sub( *nb_bits, bits ), 7 ) || LT_16( bits, BIT_SAVING_LOW_THR ) || GE_16( bits, BIT_SAVING_HIGH_THR ) )
110 : {
111 20335 : avq_bit_sFlag = 0;
112 20335 : move16();
113 : }
114 : ELSE
115 : {
116 : BREAK;
117 : }
118 : }
119 :
120 482036 : nq[k] = 0;
121 482036 : move16(); /* initialization and also forced if the budget is exceeded */
122 :
123 482036 : IF( GT_16( bits, 8 ) )
124 : {
125 : /* read the unary code including the stop bit for nq[i] */
126 457924 : nq[k] = -1;
127 457924 : move16();
128 : DO
129 : {
130 952550 : nq[k] = add( nq[k], 1 );
131 952550 : move16();
132 :
133 : // IF ( 5 * nq[k] + 4 == bits )
134 952550 : IF( EQ_16( add( add( shl( nq[k], 2 ), nq[k] ), 4 ), bits ) )
135 : {
136 5442 : BREAK;
137 : }
138 : }
139 947108 : WHILE( get_next_indice_1_fx( st ) );
140 :
141 457924 : if ( EQ_16( add( add( shl( nq[k], 2 ), nq[k] ), 4 ), bits ) ) /* check the overflow */
142 : {
143 5442 : bits = add( bits, 1 ); /* overflow stop bit */
144 : }
145 :
146 : /* check for potential bit errors */
147 457924 : 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 457924 : bits = sub( bits, nq[k] );
160 457924 : bits = sub( bits, 1 ); /* count the stop bit */
161 :
162 457924 : IF( GT_16( nq[k], 0 ) )
163 : {
164 337777 : nq[k] = add( nq[k], 1 );
165 337777 : move16();
166 : }
167 :
168 : /* read codebook indices (rank I and event. Voronoi index kv) */
169 457924 : read_cv_fx( st, &I[k], &kv[k * 8], nq[k], &bits );
170 : }
171 : } /* for */
172 :
173 : /* Bit Saving Solution */
174 64093 : IF( ( avq_bit_sFlag > 0 ) && GT_16( bits, 8 ) )
175 : {
176 38960 : i = svOrder[Nsv - 1];
177 38960 : nq[i] = 0;
178 38960 : move16();
179 38960 : bitsMod = bits % 5;
180 38960 : IF( NE_16( i, sub( Nsv, 1 ) ) )
181 : {
182 13013 : nullVec = 0;
183 13013 : move16();
184 78078 : FOR( j = i; j < Nsv - 1; j++ )
185 : {
186 65065 : if ( nq[svOrder[j]] == 0 )
187 : {
188 8937 : nullVec = add( nullVec, 1 );
189 : }
190 : }
191 13013 : nq_est = idiv1616( bits, 5 );
192 13013 : test();
193 13013 : test();
194 13013 : test();
195 13013 : test();
196 13013 : test();
197 13013 : test();
198 13013 : test();
199 13013 : test();
200 13013 : test();
201 13013 : test();
202 13013 : test();
203 13013 : test();
204 13013 : 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 93 : dummy_bits = sub( 5, bitsMod );
207 93 : bits = add( bits, dummy_bits ); /* add dummy bits */
208 93 : bitsMod = 0;
209 93 : move16();
210 : }
211 12920 : 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 4 : underflow = 0;
214 4 : move16();
215 4 : IF( NE_16( ( add( bitsMod, nullVec ) % 5 ), 0 ) )
216 : {
217 4 : underflow = 1;
218 4 : move16();
219 : }
220 4 : dummy_bits = add( nullVec, underflow );
221 4 : bits = add( bits, dummy_bits ); /* add dummy bits */
222 4 : bitsMod = 0;
223 4 : move16();
224 : }
225 : }
226 38960 : underflow = 1;
227 38960 : move16();
228 38960 : IF( NE_16( bitsMod, 4 ) )
229 : {
230 32635 : underflow = 0;
231 32635 : move16();
232 32635 : bits = sub( bits, bitsMod );
233 : }
234 38960 : bits = add( bits, underflow );
235 :
236 : /* read the unary code for unused bit*/
237 38960 : unused_bits_idx = -1;
238 38960 : move16();
239 : DO
240 : {
241 52753 : unused_bits_idx = add( unused_bits_idx, 1 );
242 52753 : IF( EQ_16( add( add( shl( unused_bits_idx, 2 ), unused_bits_idx ), 4 ), sub( bits, 1 ) ) )
243 : {
244 210 : BREAK;
245 : }
246 : }
247 52543 : WHILE( get_next_indice_1_fx( st ) );
248 :
249 38960 : unusedbitsFlag = 0;
250 38960 : move16();
251 :
252 38960 : IF( ( dummy_bits == 0 ) )
253 : {
254 38863 : test();
255 38863 : test();
256 38863 : test();
257 38863 : test();
258 38863 : IF( ( unused_bits_idx == 0 ) && GT_16( bits, BIT_SAVING_LOW_THR ) )
259 : {
260 17716 : unusedbitsFlag = 1;
261 17716 : move16();
262 : }
263 21147 : ELSE IF( EQ_16( unused_bits_idx, 1 ) && GT_16( bits, BIT_SAVING_LOW_THR ) )
264 : {
265 7424 : unusedbitsFlag = -1;
266 7424 : move16();
267 : }
268 : }
269 :
270 : /*Compute AVQ code book number from unused Bits */
271 38960 : tmp = (Word16) ( sub( bits, add( add( shl( add( unusedbitsFlag, unused_bits_idx ), 2 ), unusedbitsFlag ), unused_bits_idx ) ) );
272 38960 : nq_est = idiv1616( tmp, 5 );
273 38960 : IF( ( ( tmp % 5 ) != 0 ) )
274 : {
275 0 : nq_est = add( nq_est, 1 );
276 : }
277 38960 : if ( EQ_16( nq_est, 1 ) )
278 : {
279 210 : nq_est = 0;
280 210 : move16();
281 : }
282 38960 : bits = sub( bits, underflow );
283 :
284 38960 : bits = sub( bits, unused_bits_idx );
285 :
286 38960 : if ( ( nq_est != 0 ) )
287 : {
288 38750 : bits = sub( bits, 1 );
289 : }
290 :
291 38960 : nq[i] = nq_est;
292 38960 : move16();
293 : /* read codebook indices (rank I and event. Voronoi index kv) */
294 38960 : read_cv_fx( st, &I[i], &kv[i * 8], nq[i], &bits );
295 :
296 38960 : bits = sub( bits, dummy_bits );
297 :
298 38960 : if ( NE_16( bitsMod, 4 ) )
299 : {
300 32635 : bits = add( bits, bitsMod );
301 : }
302 : }
303 :
304 : /* decode all subvectors */
305 585089 : FOR( i = 0; i < Nsv; i++ )
306 : {
307 : /* multi-rate RE8 decoder */
308 520996 : re8_dec_fx( nq[i], I[i], &kv[8 * i], code );
309 :
310 : /* write decoded RE8 vector to decoded subvector #i */
311 4688964 : FOR( j = 0; j < 8; j++ )
312 : {
313 4167968 : xriq[i * 8 + j] = code[j];
314 4167968 : move16();
315 : }
316 : }
317 64093 : move16();
318 64093 : *nb_bits = bits;
319 :
320 64093 : 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 611163 : 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 611163 : pos = sub( Nsv, 1 );
343 :
344 1833489 : FOR( l = 0; l < Nsv; l++ )
345 : {
346 1222326 : pos = add( pos, indx[l] );
347 : }
348 :
349 : /* decode all subvectors */
350 :
351 1833489 : FOR( l = Nsv - 1; l >= 0; l-- )
352 : {
353 1222326 : nq = indx[l]; /* quantizer number (0,2,3..n) */
354 1222326 : move16();
355 :
356 1222326 : nk = 0;
357 1222326 : move16();
358 1222326 : n = nq;
359 1222326 : move16();
360 :
361 1222326 : IF( GT_16( nq, 4 ) )
362 : {
363 79444 : nk = shr( sub( nq, 3 ), 1 );
364 79444 : n = sub( nq, shl( nk, 1 ) );
365 : }
366 :
367 : /* read n groups of 4-bit for Voronoi index (k[]) */
368 :
369 11000934 : FOR( i = 0; i < 8; i++ )
370 : {
371 9778608 : kv[i] = 0;
372 9778608 : move16();
373 : }
374 :
375 1302843 : FOR( ; nk > 0; nk-- )
376 : {
377 80517 : ival = s_and( indx[pos--], 0x0F );
378 80517 : ival = shl( ival, 4 );
379 80517 : ival = add( ival, s_and( indx[pos--], 0x0F ) );
380 :
381 724653 : FOR( i = 7; i >= 0; i-- )
382 : {
383 644136 : kv[i] = add( shl( kv[i], 1 ), s_and( ival, 0x01 ) );
384 644136 : move16();
385 644136 : ival = shr( ival, 1 );
386 : }
387 : }
388 :
389 : /* read n groups of 4-bit for base codebook index (I) */
390 1222326 : I = L_deposit_l( 0 );
391 4473982 : FOR( ; n > 0; n-- )
392 : {
393 3251656 : I = L_shl( I, 4 );
394 3251656 : I = L_add( I, (Word32) s_and( indx[pos--], 0x0F ) );
395 : }
396 :
397 : /* multi-rate RE8 decoder */
398 1222326 : I16 = (UWord16) extract_l( I );
399 1222326 : cast16();
400 1222326 : re8_dec_fx( nq, I16, kv, c );
401 :
402 : /* write decoded RE8 vector */
403 11000934 : FOR( i = 0; i < 8; i++ )
404 : {
405 9778608 : nvecq[( l * 8 ) + i] = c[i];
406 9778608 : move16();
407 : }
408 : }
409 :
410 611163 : return;
411 : }
412 :
413 : /*-----------------------------------------------------------------*
414 : * read_cv_fx()
415 : *
416 : * read codebook indices (rank I and event. Voronoi index kv)
417 : *-----------------------------------------------------------------*/
418 :
419 496884 : 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 496884 : bits = *nbits;
431 496884 : move16();
432 : /* read codebook indices (rank I and event. Voronoi index kv) */
433 496884 : IF( ( nq == 0 ) ) /* Q0 */
434 : {
435 : /* nothing to read */
436 : }
437 376527 : ELSE IF( LT_16( nq, 5 ) ) /* Q2, Q3, Q4 */
438 : {
439 372143 : *I = get_next_indice_fx( st, shl( nq, 2 ) );
440 372143 : move32();
441 372143 : bits = sub( bits, shl( nq, 2 ) );
442 : }
443 4384 : ELSE IF( ( s_and( nq, 1 ) == 0 ) ) /* Q4 + Voronoi extensions r=1,2,3,... */
444 : {
445 1571 : *I = get_next_indice_fx( st, 16 );
446 1571 : move32();
447 1571 : bits = sub( bits, 16 );
448 1571 : order_v = (Word16) sub( shr( nq, 1 ), 2 );
449 1571 : move32();
450 :
451 14139 : FOR( j = 0; j < 8; j++ )
452 : {
453 12568 : kv[j] = get_next_indice_fx( st, order_v );
454 12568 : move16();
455 : }
456 1571 : bits = sub( bits, ( shl( order_v, 3 ) ) );
457 : }
458 : ELSE /* Q3 + Voronoi extensions r=1,2,3,... */
459 : {
460 2813 : *I = get_next_indice_fx( st, 12 );
461 2813 : move32();
462 2813 : bits = sub( bits, 12 );
463 2813 : order_v = (Word16) sub( shr( nq, 1 ), 1 );
464 :
465 25317 : FOR( j = 0; j < 8; j++ )
466 : {
467 22504 : kv[j] = get_next_indice_fx( st, order_v );
468 22504 : move32();
469 : }
470 2813 : bits = sub( bits, shl( order_v, 3 ) );
471 : }
472 496884 : *nbits = bits;
473 496884 : move16();
474 :
475 496884 : return;
476 : }
|
