Line data Source code
1 : /*====================================================================================
2 : EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
3 : ====================================================================================*/
4 : #include <stdint.h>
5 : #include "options.h" /* Compilation switches */
6 : #include "prot_fx.h"
7 : #include "rom_dec.h"
8 : /*--------------------------------------------------------------------------*/
9 : /* Function hdecnrm_fx */
10 : /* ~~~~~~~~~~~~~~~~~~~~ */
11 : /* */
12 : /* Huffman decoding for indices of quantized norms */
13 : /*--------------------------------------------------------------------------*/
14 934 : void hdecnrm_fx(
15 : Decoder_State *st_fx, /* i/o: decoder state structure */
16 : const Word16 numNorms, /* i : number of norms Q0*/
17 : Word16 *index ) /* o : indices of quantized norms Q0*/
18 : {
19 : Word16 i, j, k, n, m;
20 : Word16 temp;
21 : Word16 *pidx;
22 :
23 :
24 934 : pidx = index; /* Q0 */
25 :
26 934 : m = sub( numNorms, 1 ); /* Q0 */
27 26415 : FOR( i = 0; i < m; i++ )
28 : {
29 25481 : j = (Word16) 0;
30 25481 : move16();
31 25481 : k = (Word16) 0;
32 25481 : move16();
33 :
34 25481 : if ( get_next_indice_1_fx( st_fx ) != 0 )
35 : {
36 12424 : j = (Word16) 1; /* Q0 */
37 12424 : move16();
38 : }
39 25481 : if ( get_next_indice_1_fx( st_fx ) != 0 )
40 : {
41 12884 : k = (Word16) 1; /* Q0 */
42 12884 : move16();
43 : }
44 25481 : n = add( shl( j, 1 ), k ); /* Q0 */
45 25481 : j = shl( j, 2 ); /* Q0 */
46 25481 : temp = sub( add( 16, n ), j ); /* Q0 */
47 25481 : IF( get_next_indice_1_fx( st_fx ) != 0 )
48 : {
49 14289 : temp = add( add( 12, n ), j ); /* Q0 */
50 14289 : IF( get_next_indice_1_fx( st_fx ) != 0 )
51 : {
52 6461 : j = (Word16) 0;
53 6461 : move16();
54 6461 : if ( get_next_indice_1_fx( st_fx ) != 0 )
55 : {
56 2840 : j = 1; /* Q0 */
57 2840 : move16();
58 : }
59 6461 : temp = add( 8, n ); /* Q0 */
60 6461 : if ( j != 0 )
61 : {
62 2840 : temp = add( temp, 12 ); /* Q0 */
63 : }
64 6461 : IF( get_next_indice_1_fx( st_fx ) != 0 )
65 : {
66 1118 : temp = n; /* Q0 */
67 1118 : move16();
68 :
69 1118 : if ( get_next_indice_1_fx( st_fx ) != 0 )
70 : {
71 488 : temp = add( 4, n ); /* Q0 */
72 : }
73 1118 : if ( j != 0 )
74 : {
75 601 : temp = add( temp, 24 ); /* Q0 */
76 : }
77 : }
78 : }
79 : }
80 25481 : *pidx++ = temp; /* Q0 */
81 25481 : move16();
82 : }
83 :
84 934 : return;
85 : }
86 :
87 : /*--------------------------------------------------------------------------*/
88 : /* Function decode_huff_context */
89 : /* ~~~~~~~~~~~~~~~~~ */
90 : /* */
91 : /* Context based Huffman decoding for indices of quantized norms */
92 : /*--------------------------------------------------------------------------*/
93 : /* const Word16 *hufftab, (i) Huffman table */
94 : /* Word16 *rbits (i/o) the number of read bits */
95 : /*--------------------------------------------------------------------------*/
96 :
97 132408 : Word16 decode_huff_context_fx(
98 : Decoder_State *st_fx, /* i/o: decoder state structure */
99 : const Word16 *hufftab, /* Q0 */
100 : Word16 *rbits /* Q0 */
101 : )
102 : {
103 : Word16 tmp_l, tmp_h;
104 : Word32 hufftab_idx;
105 :
106 132408 : hufftab_idx = L_deposit_l( 0 );
107 406447 : WHILE( hufftab[hufftab_idx] > 0 )
108 : {
109 274039 : tmp_h = shr( hufftab[hufftab_idx], 4 ); /* Q0 */
110 274039 : tmp_l = sub( hufftab[hufftab_idx], shl( tmp_h, 4 ) ); /* Q0 */
111 274039 : *rbits = add( *rbits, tmp_l ); /* Q0 */
112 274039 : move16();
113 274039 : hufftab_idx = L_add( hufftab_idx, L_add( L_deposit_l( tmp_h ), get_next_indice_fx( st_fx, tmp_l ) ) ); /* Q0 */
114 : }
115 132408 : return negate( hufftab[hufftab_idx] );
116 : }
117 :
118 :
119 : /*--------------------------------------------------------------------------*/
120 : /* hdecnrm_context_fx() */
121 : /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
122 : /* */
123 : /* Huffman decoding for indices of quantized norms */
124 : /*--------------------------------------------------------------------------*/
125 : /* Word16 N (i) number of norms */
126 : /* Word16 *index (o) indices of quantized norms */
127 : /* Word16 *n_length (o) decoded stream length */
128 : /*--------------------------------------------------------------------------*/
129 :
130 4592 : void hdecnrm_context_fx(
131 : Decoder_State *st_fx, /* i/o: decoder state structure */
132 : const Word16 N, /* Q0 */
133 : Word16 *index, /* Q0 */
134 : Word16 *n_length /* Q0 */
135 : )
136 : {
137 : Word16 i, prevj, tmp;
138 :
139 4592 : prevj = add( index[0], OFFSET_NORM ); /* Q0 */
140 137000 : FOR( i = 1; i < N; i++ )
141 : {
142 132408 : IF( GT_16( prevj, HTH_NORM ) )
143 : {
144 : /* above */
145 27846 : tmp = decode_huff_context_fx( st_fx, hntable, n_length ); /* Q0 */
146 27846 : index[i] = sub( 31, tmp ); /* Q0 */
147 27846 : move16();
148 : }
149 : ELSE
150 : {
151 104562 : IF( LT_16( prevj, LTH_NORM ) )
152 : {
153 : /* less */
154 17027 : index[i] = decode_huff_context_fx( st_fx, hntable, n_length ); /* Q0 */
155 17027 : move16();
156 : }
157 : ELSE
158 : {
159 : /* equal */
160 87535 : index[i] = decode_huff_context_fx( st_fx, hetable, n_length ); /* Q0 */
161 87535 : move16();
162 : }
163 : }
164 132408 : prevj = index[i]; /* Q0 */
165 132408 : move16();
166 : }
167 4592 : return;
168 : }
169 :
170 2220 : void hdecnrm_resize_fx(
171 : Decoder_State *st_fx, /* i/o: decoder state structure */
172 : const Word16 N, /* (i) number of SFMs Q0*/
173 : Word16 *index /* (o) norm quantization index vector Q0*/
174 : )
175 : {
176 : Word16 i, j, k, m;
177 : Word16 temp;
178 : Word16 *pidx;
179 :
180 2220 : pidx = index; /* Q0 */
181 :
182 2220 : m = sub( N, 1 ); /* Q0 */
183 2220 : move16();
184 65909 : FOR( i = 0; i < m; i++ )
185 : {
186 63689 : j = 0;
187 63689 : move16();
188 63689 : k = 0;
189 63689 : move16();
190 :
191 141469 : FOR( j = 0; j < 11; j++ )
192 : {
193 141465 : IF( get_next_indice_1_fx( st_fx ) != 0 )
194 : {
195 77780 : k = add( k, 1 ); /* Q0 */
196 77780 : move16();
197 : }
198 : ELSE
199 : {
200 63685 : BREAK;
201 : }
202 : }
203 :
204 63689 : IF( EQ_16( k, 11 ) )
205 : {
206 4 : temp = 25; /* Q0 */
207 4 : move16();
208 : }
209 63685 : ELSE IF( EQ_16( k, 10 ) )
210 : {
211 13 : temp = 5; /* Q0 */
212 13 : move16();
213 : }
214 63672 : ELSE IF( EQ_16( k, 9 ) )
215 : {
216 17 : temp = 6; /* Q0 */
217 17 : move16();
218 : }
219 : ELSE{
220 63655 : IF( get_next_indice_1_fx( st_fx ) != 0 ){
221 31043 : temp = add( 16, k ); /* Q0 */
222 : }
223 : ELSE
224 : {
225 32612 : temp = sub( 15, k ); /* Q0 */
226 32612 : move16();
227 : }
228 : }
229 :
230 63689 : *pidx++ = temp; /* Q0 */
231 63689 : move16();
232 : }
233 :
234 2220 : return;
235 : }
236 :
237 : /*--------------------------------------------------------------------------
238 : * huff_dec()
239 : *
240 : * Huffman decoding
241 : *--------------------------------------------------------------------------*/
242 :
243 2284 : void huff_dec_fx(
244 : Decoder_State *st_fx, /* i/o: decoder state structure */
245 : const Word16 N, /* i : Number of codewords to decode Q0*/
246 : const Word16 buffer_len, /* i : Number of bits to read Q0*/
247 : const Word16 num_lengths, /* i : Number of different huffman codeword lengths Q0*/
248 : const Word16 *thres, /* i : Threshold of first codeword of each length Q0*/
249 : const Word16 *offset, /* i : Offset for first codeword Q0*/
250 : const Word16 *huff_tab, /* i : Huffman table order by codeword lengths Q0*/
251 : Word16 *index /* o : Decoded index Q0*/
252 : )
253 : {
254 : Word16 i, j, k;
255 : UWord16 val;
256 : Word16 last_bits;
257 :
258 2284 : last_bits = buffer_len; /* Q0 */
259 2284 : move16();
260 :
261 2284 : val = 0;
262 2284 : move16();
263 2284 : j = 0;
264 2284 : move16();
265 40600 : FOR( i = 0; i < N; i++ )
266 : {
267 38316 : last_bits = sub( buffer_len, j ); /* Q0 */
268 38316 : val = (UWord16) L_shl( val, last_bits ); /* Q0 */
269 38316 : val = (UWord16) L_and( val, sub( lshl( 1, buffer_len ), 1 ) ); /* Q0 */
270 38316 : val = (UWord16) L_or( val, get_next_indice_fx( st_fx, last_bits ) ); /* Q0 */
271 :
272 : /* Find codeword length */
273 38316 : j = sub( num_lengths, 1 ); /* Q0 */
274 84349 : WHILE( LT_16( val, thres[j] ) )
275 : {
276 46033 : j = sub( j, 1 ); /* Q0 */
277 : }
278 38316 : k = lshr( sub( val, thres[j] ), j ); /* Q0 */
279 38316 : *index++ = huff_tab[offset[j] + k]; /* Q0 */
280 38316 : move16();
281 : }
282 :
283 : /* Put back unused bits */
284 2284 : st_fx->next_bit_pos = sub( st_fx->next_bit_pos, j ); /* Q0 */
285 2284 : move16();
286 :
287 2284 : return;
288 : }
289 :
290 : /*--------------------------------------------------------------------------
291 : * hdecnrm_trans()
292 : *
293 : * Huffman decoding for indices of quantized norms
294 : *--------------------------------------------------------------------------*/
295 :
296 2 : void hdecnrm_tran_fx(
297 : Decoder_State *st_fx, /* i/o: decoder state structure */
298 : const Word16 N, /* i : number of norms Q0*/
299 : Word16 *index /* o : indices of quantized norms Q0*/
300 : )
301 : {
302 : Word16 i, j, k, n, m;
303 : Word16 temp;
304 : Word16 *pidx;
305 : Word16 l;
306 :
307 2 : pidx = index; /* Q0 */
308 :
309 2 : m = sub( N, 1 ); /* Q0 */
310 64 : FOR( i = 0; i < m; i++ )
311 : {
312 62 : j = 0;
313 62 : move16();
314 62 : k = 0;
315 62 : move16();
316 62 : if ( get_next_indice_1_fx( st_fx ) != 0 )
317 : {
318 30 : j = 1; /* Q0 */
319 30 : move16();
320 : }
321 :
322 62 : if ( get_next_indice_1_fx( st_fx ) != 0 )
323 : {
324 16 : k = 1; /* Q0 */
325 16 : move16();
326 : }
327 :
328 : /*n = k * 2 + j; */
329 62 : n = add( shl( k, 1 ), j ); /* Q0 */
330 : /*l = k * 4; */
331 62 : l = shl( k, 2 ); /* Q0 */
332 62 : test();
333 62 : test();
334 62 : test();
335 62 : test();
336 62 : test();
337 62 : IF( ( j == 0 && k == 0 ) || ( EQ_16( j, 1 ) && k == 0 ) || ( EQ_16( j, 1 ) && EQ_16( k, 1 ) ) )
338 : {
339 60 : temp = sub( add( 15, l ), n ); /* Q0 */
340 : }
341 : ELSE{
342 2 : IF( get_next_indice_1_fx( st_fx ) != 0 ){
343 0 : temp = sub( add( 15, n ), l ); /* Q0 */
344 : }
345 : ELSE
346 : {
347 2 : temp = sub( add( 15, l ), n ); /* Q0 */
348 2 : IF( get_next_indice_1_fx( st_fx ) != 0 )
349 : {
350 0 : FOR( k = 0; k < 3; )
351 : {
352 0 : IF( get_next_indice_1_fx( st_fx ) != 0 )
353 : {
354 0 : k++; /* Q0 */
355 : }
356 : ELSE
357 : {
358 0 : BREAK;
359 : }
360 : }
361 :
362 0 : test();
363 0 : IF( k == 0 || EQ_16( k, 3 ) )
364 : {
365 0 : temp = sub( temp, 5 );
366 0 : if ( EQ_16( k, 3 ) )
367 : {
368 0 : temp = sub( temp, 1 ); /* Q0 */
369 : }
370 : }
371 0 : ELSE IF( EQ_16( k, 1 ) )
372 : {
373 0 : temp = add( temp, 1 ); /* Q0 */
374 : }
375 : ELSE
376 : {
377 0 : temp = add( temp, 2 ); /* Q0 */
378 0 : IF( get_next_indice_1_fx( st_fx ) != 0 )
379 : {
380 0 : temp = add( temp, 1 );
381 0 : if ( get_next_indice_1_fx( st_fx ) != 0 )
382 : {
383 0 : temp = add( temp, 1 ); /* Q0 */
384 : }
385 : }
386 : }
387 : }
388 : }
389 : }
390 :
391 62 : *pidx++ = temp; /* Q0 */
392 62 : move16();
393 : }
394 :
395 2 : return;
396 : }
|
