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 927 : 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 927 : pidx = index; /* Q0 */
25 :
26 927 : m = sub( numNorms, 1 ); /* Q0 */
27 26184 : FOR( i = 0; i < m; i++ )
28 : {
29 25257 : j = (Word16) 0;
30 25257 : move16();
31 25257 : k = (Word16) 0;
32 25257 : move16();
33 :
34 25257 : if ( get_next_indice_1_fx( st_fx ) != 0 )
35 : {
36 12303 : j = (Word16) 1; /* Q0 */
37 12303 : move16();
38 : }
39 25257 : if ( get_next_indice_1_fx( st_fx ) != 0 )
40 : {
41 12765 : k = (Word16) 1; /* Q0 */
42 12765 : move16();
43 : }
44 25257 : n = add( shl( j, 1 ), k ); /* Q0 */
45 25257 : j = shl( j, 2 ); /* Q0 */
46 25257 : temp = sub( add( 16, n ), j ); /* Q0 */
47 25257 : IF( get_next_indice_1_fx( st_fx ) != 0 )
48 : {
49 14164 : temp = add( add( 12, n ), j ); /* Q0 */
50 14164 : IF( get_next_indice_1_fx( st_fx ) != 0 )
51 : {
52 6406 : j = (Word16) 0;
53 6406 : move16();
54 6406 : if ( get_next_indice_1_fx( st_fx ) != 0 )
55 : {
56 2816 : j = 1; /* Q0 */
57 2816 : move16();
58 : }
59 6406 : temp = add( 8, n ); /* Q0 */
60 6406 : if ( j != 0 )
61 : {
62 2816 : temp = add( temp, 12 ); /* Q0 */
63 : }
64 6406 : IF( get_next_indice_1_fx( st_fx ) != 0 )
65 : {
66 1113 : temp = n; /* Q0 */
67 1113 : move16();
68 :
69 1113 : if ( get_next_indice_1_fx( st_fx ) != 0 )
70 : {
71 485 : temp = add( 4, n ); /* Q0 */
72 : }
73 1113 : if ( j != 0 )
74 : {
75 599 : temp = add( temp, 24 ); /* Q0 */
76 : }
77 : }
78 : }
79 : }
80 25257 : *pidx++ = temp; /* Q0 */
81 25257 : move16();
82 : }
83 :
84 927 : 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 130180 : 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 130180 : hufftab_idx = L_deposit_l( 0 );
107 399210 : WHILE( hufftab[hufftab_idx] > 0 )
108 : {
109 269030 : tmp_h = shr( hufftab[hufftab_idx], 4 ); /* Q0 */
110 269030 : tmp_l = sub( hufftab[hufftab_idx], shl( tmp_h, 4 ) ); /* Q0 */
111 269030 : *rbits = add( *rbits, tmp_l ); /* Q0 */
112 269030 : move16();
113 269030 : hufftab_idx = L_add( hufftab_idx, L_add( L_deposit_l( tmp_h ), get_next_indice_fx( st_fx, tmp_l ) ) ); /* Q0 */
114 : }
115 130180 : 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 4515 : 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 4515 : prevj = add( index[0], OFFSET_NORM ); /* Q0 */
140 134695 : FOR( i = 1; i < N; i++ )
141 : {
142 130180 : IF( GT_16( prevj, HTH_NORM ) )
143 : {
144 : /* above */
145 27351 : tmp = decode_huff_context_fx( st_fx, hntable, n_length ); /* Q0 */
146 27351 : index[i] = sub( 31, tmp ); /* Q0 */
147 27351 : move16();
148 : }
149 : ELSE
150 : {
151 102829 : IF( LT_16( prevj, LTH_NORM ) )
152 : {
153 : /* less */
154 16647 : index[i] = decode_huff_context_fx( st_fx, hntable, n_length ); /* Q0 */
155 16647 : move16();
156 : }
157 : ELSE
158 : {
159 : /* equal */
160 86182 : index[i] = decode_huff_context_fx( st_fx, hetable, n_length ); /* Q0 */
161 86182 : move16();
162 : }
163 : }
164 130180 : prevj = index[i]; /* Q0 */
165 130180 : move16();
166 : }
167 4515 : return;
168 : }
169 :
170 2193 : 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 2193 : pidx = index; /* Q0 */
181 :
182 2193 : m = sub( N, 1 ); /* Q0 */
183 2193 : move16();
184 65105 : FOR( i = 0; i < m; i++ )
185 : {
186 62912 : j = 0;
187 62912 : move16();
188 62912 : k = 0;
189 62912 : move16();
190 :
191 139748 : FOR( j = 0; j < 11; j++ )
192 : {
193 139744 : IF( get_next_indice_1_fx( st_fx ) != 0 )
194 : {
195 76836 : k = add( k, 1 ); /* Q0 */
196 76836 : move16();
197 : }
198 : ELSE
199 : {
200 62908 : BREAK;
201 : }
202 : }
203 :
204 62912 : IF( EQ_16( k, 11 ) )
205 : {
206 4 : temp = 25; /* Q0 */
207 4 : move16();
208 : }
209 62908 : ELSE IF( EQ_16( k, 10 ) )
210 : {
211 13 : temp = 5; /* Q0 */
212 13 : move16();
213 : }
214 62895 : ELSE IF( EQ_16( k, 9 ) )
215 : {
216 17 : temp = 6; /* Q0 */
217 17 : move16();
218 : }
219 : ELSE{
220 62878 : IF( get_next_indice_1_fx( st_fx ) != 0 ){
221 30689 : temp = add( 16, k ); /* Q0 */
222 : }
223 : ELSE
224 : {
225 32189 : temp = sub( 15, k ); /* Q0 */
226 32189 : move16();
227 : }
228 : }
229 :
230 62912 : *pidx++ = temp; /* Q0 */
231 62912 : move16();
232 : }
233 :
234 2193 : return;
235 : }
236 :
237 : /*--------------------------------------------------------------------------
238 : * huff_dec()
239 : *
240 : * Huffman decoding
241 : *--------------------------------------------------------------------------*/
242 :
243 2281 : 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 2281 : last_bits = buffer_len; /* Q0 */
259 2281 : move16();
260 :
261 2281 : val = 0;
262 2281 : move16();
263 2281 : j = 0;
264 2281 : move16();
265 40554 : FOR( i = 0; i < N; i++ )
266 : {
267 38273 : last_bits = sub( buffer_len, j ); /* Q0 */
268 38273 : val = (UWord16) L_shl( val, last_bits ); /* Q0 */
269 38273 : val = (UWord16) L_and( val, sub( lshl( 1, buffer_len ), 1 ) ); /* Q0 */
270 38273 : val = (UWord16) L_or( val, get_next_indice_fx( st_fx, last_bits ) ); /* Q0 */
271 :
272 : /* Find codeword length */
273 38273 : j = sub( num_lengths, 1 ); /* Q0 */
274 84279 : WHILE( LT_16( val, thres[j] ) )
275 : {
276 46006 : j = sub( j, 1 ); /* Q0 */
277 : }
278 38273 : k = lshr( sub( val, thres[j] ), j ); /* Q0 */
279 38273 : *index++ = huff_tab[offset[j] + k]; /* Q0 */
280 38273 : move16();
281 : }
282 :
283 : /* Put back unused bits */
284 2281 : st_fx->next_bit_pos = sub( st_fx->next_bit_pos, j ); /* Q0 */
285 2281 : move16();
286 :
287 2281 : return;
288 : }
289 :
290 : /*--------------------------------------------------------------------------
291 : * hdecnrm_trans()
292 : *
293 : * Huffman decoding for indices of quantized norms
294 : *--------------------------------------------------------------------------*/
295 :
296 1 : 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 1 : pidx = index; /* Q0 */
308 :
309 1 : m = sub( N, 1 ); /* Q0 */
310 32 : FOR( i = 0; i < m; i++ )
311 : {
312 31 : j = 0;
313 31 : move16();
314 31 : k = 0;
315 31 : move16();
316 31 : if ( get_next_indice_1_fx( st_fx ) != 0 )
317 : {
318 16 : j = 1; /* Q0 */
319 16 : move16();
320 : }
321 :
322 31 : if ( get_next_indice_1_fx( st_fx ) != 0 )
323 : {
324 8 : k = 1; /* Q0 */
325 8 : move16();
326 : }
327 :
328 : /*n = k * 2 + j; */
329 31 : n = add( shl( k, 1 ), j ); /* Q0 */
330 : /*l = k * 4; */
331 31 : l = shl( k, 2 ); /* Q0 */
332 31 : test();
333 31 : test();
334 31 : test();
335 31 : test();
336 31 : test();
337 31 : IF( ( j == 0 && k == 0 ) || ( EQ_16( j, 1 ) && k == 0 ) || ( EQ_16( j, 1 ) && EQ_16( k, 1 ) ) )
338 : {
339 31 : temp = sub( add( 15, l ), n ); /* Q0 */
340 : }
341 : ELSE{
342 0 : IF( get_next_indice_1_fx( st_fx ) != 0 ){
343 0 : temp = sub( add( 15, n ), l ); /* Q0 */
344 : }
345 : ELSE
346 : {
347 0 : temp = sub( add( 15, l ), n ); /* Q0 */
348 0 : 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 31 : *pidx++ = temp; /* Q0 */
392 31 : move16();
393 : }
394 :
395 1 : return;
396 : }
|
