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