Line data Source code
1 : /******************************************************************************************************
2 :
3 : (C) 2022-2025 IVAS codec Public Collaboration with portions copyright Dolby International AB, Ericsson AB,
4 : Fraunhofer-Gesellschaft zur Foerderung der angewandten Forschung e.V., Huawei Technologies Co. LTD.,
5 : Koninklijke Philips N.V., Nippon Telegraph and Telephone Corporation, Nokia Technologies Oy, Orange,
6 : Panasonic Holdings Corporation, Qualcomm Technologies, Inc., VoiceAge Corporation, and other
7 : contributors to this repository. All Rights Reserved.
8 :
9 : This software is protected by copyright law and by international treaties.
10 : The IVAS codec Public Collaboration consisting of Dolby International AB, Ericsson AB,
11 : Fraunhofer-Gesellschaft zur Foerderung der angewandten Forschung e.V., Huawei Technologies Co. LTD.,
12 : Koninklijke Philips N.V., Nippon Telegraph and Telephone Corporation, Nokia Technologies Oy, Orange,
13 : Panasonic Holdings Corporation, Qualcomm Technologies, Inc., VoiceAge Corporation, and other
14 : contributors to this repository retain full ownership rights in their respective contributions in
15 : the software. This notice grants no license of any kind, including but not limited to patent
16 : license, nor is any license granted by implication, estoppel or otherwise.
17 :
18 : Contributors are required to enter into the IVAS codec Public Collaboration agreement before making
19 : contributions.
20 :
21 : This software is provided "AS IS", without any express or implied warranties. The software is in the
22 : development stage. It is intended exclusively for experts who have experience with such software and
23 : solely for the purpose of inspection. All implied warranties of non-infringement, merchantability
24 : and fitness for a particular purpose are hereby disclaimed and excluded.
25 :
26 : Any dispute, controversy or claim arising under or in relation to providing this software shall be
27 : submitted to and settled by the final, binding jurisdiction of the courts of Munich, Germany in
28 : accordance with the laws of the Federal Republic of Germany excluding its conflict of law rules and
29 : the United Nations Convention on Contracts on the International Sales of Goods.
30 :
31 : *******************************************************************************************************/
32 :
33 : /*====================================================================================
34 : EVS Codec 3GPP TS26.443 Nov 04, 2021. Version 12.14.0 / 13.10.0 / 14.6.0 / 15.4.0 / 16.3.0
35 : ====================================================================================*/
36 :
37 : #include <stdint.h>
38 : #include "options.h"
39 : #ifdef DEBUGGING
40 : #include "debug.h"
41 : #endif
42 : #include <math.h>
43 : #include "prot.h"
44 : #include "rom_com.h"
45 : #include "basop_util.h"
46 : #include "basop_proto_func.h"
47 : #include "wmc_auto.h"
48 :
49 :
50 : static void bitstream_save_bit( TCQ_PBITSTREAM pBS, const int16_t bit );
51 : static uint32_t bitstream_load_bit( TCQ_PBITSTREAM pBS );
52 : static void bitstream_rollback( TCQ_PBITSTREAM pBS, int16_t numBits );
53 :
54 : static int32_t ar_make_model( const int16_t *freq, int16_t *model, const int16_t len );
55 : static int32_t ar_decode( PARCODEC arInst, const int16_t *model );
56 : static void ar_encode( PARCODEC arInst, const int16_t *model, int32_t symbol );
57 : static void ar_encode_uniform( PARCODEC arInst, uint16_t data, const int16_t bits );
58 :
59 :
60 : /* 32x16 multiply: */
61 1749233 : Word32 Mult_32_16( Word32 a, Word16 b )
62 : {
63 : Word32 result;
64 : UWord16 lo;
65 : /* use Mpy_32_16_ss(): */
66 1749233 : Mpy_32_16_ss( a, b, &result, &lo );
67 :
68 1749233 : return result;
69 : }
70 :
71 : /* 32x32 multiply: */
72 1448151 : Word32 Mult_32_32( Word32 a, Word32 b )
73 : {
74 : Word32 result;
75 : UWord32 lo;
76 : /* use Mpy_32_32_ss(): */
77 1448151 : Mpy_32_32_ss( a, b, &result, &lo );
78 :
79 1448151 : return result;
80 : }
81 :
82 177380 : static void set16_fx(
83 : Word16 y[], /* i/o: Vector to set */
84 : const Word16 a, /* i : Value to set the vector to */
85 : const Word16 N /* i : Lenght of the vector */
86 : )
87 : {
88 : Word16 i;
89 :
90 29772580 : for ( i = 0; i < N; i++ )
91 : {
92 29595200 : y[i] = a;
93 : }
94 :
95 177380 : return;
96 : }
97 :
98 9503 : static void set32_fx(
99 : Word32 y[], /* i/o: Vector to set */
100 : const Word32 a, /* i : Value to set the vector to */
101 : const Word16 N /* i : Lenght of the vector */
102 : )
103 : {
104 : Word16 i;
105 71292 : for ( i = 0; i < N; i++ )
106 : {
107 61789 : y[i] = a;
108 : }
109 :
110 9503 : return;
111 : }
112 :
113 519853 : Word32 ar_div(
114 : Word32 num,
115 : Word32 denum )
116 : {
117 : Word16 exp1, exp2, exp, i;
118 : Word32 varout;
119 : Word32 sign;
120 :
121 519853 : sign = L_and( L_xor( num, denum ), 0x80000000 );
122 :
123 519853 : num = L_abs( num );
124 519853 : denum = L_abs( denum );
125 :
126 519853 : if ( L_sub( num, denum ) < 0 || denum == 0 )
127 : {
128 37790 : return 0;
129 : }
130 482063 : else if ( L_sub( num, denum ) == 0 )
131 : {
132 0 : return 1;
133 : }
134 : else
135 : {
136 482063 : exp1 = norm_l( num );
137 482063 : exp2 = norm_l( denum );
138 482063 : exp = sub( exp2, exp1 );
139 482063 : denum = L_shl( denum, exp );
140 482063 : exp = add( exp, 1 );
141 482063 : varout = 0;
142 10340595 : for ( i = 0; i < exp; i++ )
143 : {
144 9858532 : num = L_sub( num, denum );
145 9858532 : varout = L_shl( varout, 1 );
146 9858532 : if ( num >= 0 )
147 : {
148 4816557 : num = L_shl( num, 1 );
149 4816557 : varout = L_add( varout, 1 );
150 : }
151 : else
152 : {
153 5041975 : num = L_add( num, denum );
154 5041975 : num = L_shl( num, 1 );
155 : }
156 : }
157 : }
158 :
159 482063 : if ( sign != 0 )
160 : {
161 0 : varout = L_negate( varout );
162 : }
163 :
164 482063 : return varout;
165 : }
166 :
167 4020 : void srt_vec_ind_fx(
168 : const Word32 *linear, /* linear input */
169 : Word32 *srt, /* sorted output*/
170 : Word16 *I, /* index for sorted output */
171 : Word16 length )
172 : {
173 : Word16 pos, npos;
174 : Word16 idxMem;
175 : Word32 valMem;
176 :
177 : /*initialize */
178 87882 : for ( pos = 0; pos < length; pos++ )
179 : {
180 83862 : I[pos] = pos;
181 : }
182 :
183 87882 : for ( pos = 0; pos < length; pos++ )
184 : {
185 83862 : srt[pos] = linear[pos];
186 : }
187 :
188 : /* now iterate */
189 83862 : for ( pos = 0; pos < ( length - 1 ); pos++ )
190 : {
191 940953 : for ( npos = ( pos + 1 ); npos < length; npos++ )
192 : {
193 861111 : if ( L_sub( srt[npos], srt[pos] ) < 0 )
194 : {
195 418922 : idxMem = I[pos];
196 418922 : I[pos] = I[npos];
197 418922 : I[npos] = idxMem;
198 :
199 418922 : valMem = srt[pos];
200 418922 : srt[pos] = srt[npos];
201 418922 : srt[npos] = valMem;
202 : }
203 : }
204 : }
205 :
206 4020 : return;
207 : }
208 :
209 259087 : static Word32 GetBitsFromPulses_fx(
210 : Word16 m,
211 : Word16 n )
212 : {
213 : Word16 i, integer_fx, temp_fx1, temp_fx2, exp1, exp2;
214 : Word32 temp32;
215 : Word32 frac_fx32;
216 : Word32 logCoeff_fx;
217 259087 : Word16 exp = 0;
218 259087 : Word32 mantissa_fx = 0;
219 :
220 259087 : if ( m == 0 )
221 : {
222 4810 : return 0;
223 : }
224 :
225 1193874 : for ( i = 0; i < min( m, n ); i++ )
226 : {
227 939597 : logCoeff_fx = L_add( L_shl( i + 1, 16 ), L_sub( table_logcum_fx[n + 1], L_add( table_logcum_fx[i + 2], table_logcum_fx[n - i] ) ) );
228 939597 : logCoeff_fx = L_add( logCoeff_fx, L_sub( table_logcum_fx[m], L_add( table_logcum_fx[i + 1], table_logcum_fx[m - i] ) ) ); /*Q16 */
229 :
230 939597 : integer_fx = extract_h( logCoeff_fx ); /*Q0 */
231 939597 : frac_fx32 = L_sub( logCoeff_fx, L_shl( integer_fx, 16 ) ); /*Q16 */
232 :
233 : /*ln2, 0.987, ln2 * ln2, 0.977 */
234 : /*temp1 = (long) (frac / 0.0625); */
235 : /*temp2 = frac - (float)temp1 * 0.0625f; */
236 :
237 : /* frac = pow(2.0, temp1 * 0.0625) * (1 + 0.693 * temp2 + 0.480 * temp2 * temp2 * 0.5);*/
238 : /*frac = pow_getbitsfrompulses[temp1] * (1 + 0.693f * temp2 + 0.480f * temp2 * temp2 * 0.5f); */
239 :
240 939597 : temp_fx1 = extract_h( L_shl( frac_fx32, 4 ) );
241 939597 : temp_fx2 = extract_l( L_and( frac_fx32, 0xfff ) ); /*Q16 */
242 :
243 939597 : frac_fx32 = L_add( L_mult( temp_fx2, 22708 ), Mult_32_16( L_mult0( temp_fx2, temp_fx2 ), 7864 ) ); /*Q32 */
244 939597 : frac_fx32 = L_add( 0x40000000, L_shr( frac_fx32, 2 ) ); /*30 */
245 :
246 939597 : exp1 = norm_l( pow_getbitsfrompulses_fx[temp_fx1] );
247 939597 : exp2 = norm_l( frac_fx32 );
248 939597 : frac_fx32 = Mult_32_32( L_shl( pow_getbitsfrompulses_fx[temp_fx1], exp1 ), L_shl( frac_fx32, exp2 ) ); /*21 + exp1 + 30 + exp2 - 31 */
249 939597 : frac_fx32 = L_shr( frac_fx32, exp1 + exp2 ) + 1; /*20 */
250 :
251 939597 : if ( sub( exp, integer_fx ) < 0 )
252 : {
253 801273 : mantissa_fx = L_shr( mantissa_fx, sub( integer_fx, exp ) );
254 801273 : mantissa_fx = L_add( mantissa_fx, frac_fx32 );
255 :
256 801273 : exp = integer_fx;
257 : }
258 : else
259 : {
260 138324 : mantissa_fx = L_add( mantissa_fx, L_shr( frac_fx32, sub( exp, integer_fx ) ) );
261 : }
262 939597 : if ( L_sub( mantissa_fx, 0x200000 ) >= 0 )
263 : {
264 197563 : exp++;
265 :
266 197563 : mantissa_fx = L_shr( mantissa_fx, 1 );
267 : }
268 : }
269 :
270 254277 : mantissa_fx = L_shl( mantissa_fx, 2 ); /*22 */
271 254277 : temp_fx1 = extract_h( mantissa_fx );
272 254277 : temp32 = L_shl( L_sub( mantissa_fx, L_deposit_h( temp_fx1 ) ), 15 ); /*31 */
273 254277 : exp1 = sub( norm_l( temp32 ), 1 );
274 254277 : temp32 = ar_div( L_shl( temp32, exp1 ), temp_fx1 ); /*31 + exp1 */
275 254277 : temp32 = L_shr( temp32, exp1 + 1 ); /*30 */
276 :
277 254277 : frac_fx32 = L_sub( 0x40000000, L_shr( temp32, 1 ) ); /*30 */
278 254277 : frac_fx32 = Mult_32_32( frac_fx32, temp32 ); /*29 */
279 254277 : frac_fx32 = L_shr( frac_fx32, 13 ); /*16 */
280 254277 : exp1 = norm_l( temp_fx1 );
281 254277 : temp_fx1 = Log2_norm_lc( L_shl( temp_fx1, exp1 ) ); /*15 */
282 254277 : frac_fx32 = frac_fx32 + Mult_32_32( frac_fx32, 950680361 ); /* frac_fx32 *= 1/ln(2) */
283 254277 : return L_add( L_deposit_h( exp ), L_add( L_shl( temp_fx1, 1 ), frac_fx32 ) );
284 : }
285 :
286 32403 : void decode_position_ari_fx(
287 : PARCODEC pardec,
288 : Word16 size,
289 : Word16 npulses,
290 : Word16 *nz,
291 : Word32 *position )
292 : {
293 : Word16 i, nzp;
294 : Word16 mode_num_nz[TCQ_MAX_BAND_SIZE];
295 : Word16 prob[TCQ_MAX_BAND_SIZE];
296 :
297 : Word32 btcq_fx, pnzp_fx;
298 : Word16 integer, frac;
299 :
300 : Word32 cp, scp, fxone, fxp1;
301 32403 : Word16 stpos = 0, pos, ovrflag, temppos, storepos;
302 :
303 32403 : fxone = 32768;
304 32403 : fxp1 = 512 * 32768;
305 32403 : temppos = 0;
306 32403 : storepos = 0;
307 32403 : ovrflag = 0;
308 :
309 32403 : set16_fx( mode_num_nz, 0, TCQ_MAX_BAND_SIZE );
310 32403 : set16_fx( prob, 0, TCQ_MAX_BAND_SIZE );
311 :
312 432593 : for ( i = 0; i < size; i++ )
313 : {
314 400190 : position[i] = 0;
315 : }
316 :
317 32403 : if ( L_sub( npulses, 1 ) > 0 )
318 : {
319 21526 : btcq_fx = GetBitsFromPulses_fx( npulses, size );
320 101935 : for ( i = 0; i < L_min( npulses, size ); i++ )
321 : {
322 : /*calculate the probability of #nz */
323 :
324 80409 : pnzp_fx = L_sub( L_deposit_h( add( i, 1 ) ), btcq_fx );
325 80409 : pnzp_fx = L_add( pnzp_fx, L_add( L_sub( table_logcum_fx[size + 1], L_add( table_logcum_fx[i + 2], table_logcum_fx[size - i] ) ), L_sub( table_logcum_fx[npulses], L_add( table_logcum_fx[i + 1], table_logcum_fx[npulses - i] ) ) ) );
326 80409 : pnzp_fx = L_add( pnzp_fx, 917498 ); /*16 */
327 80409 : if ( L_sub( pnzp_fx, 0 ) > 0 )
328 : {
329 79547 : integer = extract_h( pnzp_fx );
330 79547 : frac = extract_l( L_shr( L_sub( pnzp_fx, L_deposit_h( integer ) ), 1 ) ); /*15 */
331 79547 : prob[i] = extract_h( L_shl( Pow2( integer, frac ), 16 ) ); /*0 */
332 79547 : if ( prob[i] == 0 )
333 : {
334 0 : prob[i] = 1;
335 : }
336 : }
337 : else
338 : {
339 862 : prob[i] = 1;
340 : }
341 : }
342 :
343 21526 : ar_make_model( prob, mode_num_nz, min( npulses, size ) );
344 21526 : *nz = add( 1, (Word16) ar_decode( pardec, mode_num_nz ) ); /*get #nz */
345 21526 : nzp = *nz;
346 :
347 21526 : if ( nzp == 1 )
348 : {
349 : Word16 tmp;
350 966 : mode_num_nz[0] = MAX_AR_FREQ;
351 10416 : for ( i = 0; i < size; i++ )
352 : {
353 9450 : tmp = div_l( L_deposit_h( size - i - 1 ), size );
354 9450 : mode_num_nz[i + 1] = round_fx( L_shr( L_deposit_h( tmp ), 1 ) );
355 : }
356 :
357 966 : position[ar_decode( pardec, mode_num_nz )] = 1;
358 : }
359 : else
360 : {
361 : Word16 tmp;
362 20560 : mode_num_nz[0] = MAX_AR_FREQ;
363 :
364 84270 : for ( ; nzp > 0; nzp-- )
365 : {
366 63710 : scp = fxp1;
367 63710 : temppos = 0;
368 63710 : storepos = 0;
369 :
370 372512 : for ( i = stpos; i < size; i++ )
371 : {
372 351952 : ovrflag = 0;
373 :
374 351952 : if ( nzp == ( size - i ) )
375 : {
376 63656 : cp = 0;
377 : }
378 : else
379 : {
380 288296 : tmp = div_l( L_deposit_h( nzp ), ( size - i ) );
381 288296 : cp = L_sub( fxone, tmp );
382 : }
383 351952 : scp = Mult_32_16( scp, extract_l( cp ) );
384 351952 : mode_num_nz[i + 1 - storepos - stpos] = round_fx( L_shl( scp, 6 ) );
385 :
386 351952 : if ( ( mode_num_nz[i + 1 - storepos - stpos] == 0 && scp > 0 ) || mode_num_nz[i - storepos - stpos] == mode_num_nz[i + 1 - storepos - stpos] )
387 : {
388 43150 : ovrflag = 1;
389 43150 : temppos = (Word16) ar_decode( pardec, mode_num_nz );
390 43150 : storepos += temppos;
391 43150 : scp = fxp1;
392 :
393 43150 : if ( temppos == i - stpos ) /* esc transmitted */
394 : {
395 0 : i--;
396 : }
397 : else
398 : {
399 43150 : break;
400 : }
401 : }
402 : }
403 63710 : if ( !ovrflag )
404 : {
405 20560 : pos = (Word16) ar_decode( pardec, mode_num_nz ) + storepos;
406 : }
407 : else
408 : {
409 43150 : pos = storepos;
410 : }
411 :
412 63710 : position[stpos + pos] = 1;
413 63710 : stpos += pos + 1;
414 : }
415 : }
416 : }
417 10877 : else if ( L_sub( npulses, 1 ) == 0 )
418 : {
419 : Word16 tmp;
420 9227 : *nz = npulses;
421 9227 : nzp = *nz;
422 9227 : mode_num_nz[0] = MAX_AR_FREQ;
423 179457 : for ( i = 0; i < size; i++ )
424 : {
425 170230 : tmp = div_l( L_deposit_h( size - i - 1 ), size );
426 170230 : mode_num_nz[i + 1] = round_fx( L_shr( L_deposit_h( tmp ), 1 ) );
427 : }
428 :
429 9227 : position[ar_decode( pardec, mode_num_nz )] = 1;
430 : }
431 : else
432 : {
433 1650 : *nz = 0;
434 : }
435 :
436 32403 : return;
437 : }
438 :
439 :
440 31104 : void decode_magnitude_usq_fx(
441 : ARCODEC *pardec,
442 : Word16 size,
443 : Word16 npulses,
444 : Word16 nzpos,
445 : Word32 *positions,
446 : Word32 *out )
447 : {
448 : Word16 i, magnp, magnzp;
449 31104 : Word16 magns[TCQ_MAX_BAND_SIZE], magncout = 0;
450 :
451 31104 : Word16 storemagn, ovrflag, pos, tempmagn = 0, mmodel[MAX_PULSES + 2];
452 : Word32 cp, scp, fxone, fxp1;
453 :
454 31104 : fxone = 32768;
455 31104 : fxp1 = 512 * 32768;
456 31104 : ovrflag = 0;
457 :
458 :
459 31104 : set16_fx( magns, 1, TCQ_MAX_BAND_SIZE );
460 31104 : if ( sub( nzpos, npulses ) == 0 )
461 : {
462 330423 : for ( i = 0; i < size; i++ )
463 : {
464 309752 : out[i] = positions[i];
465 : }
466 20671 : return;
467 : }
468 10433 : else if ( sub( nzpos, 1 ) == 0 )
469 : {
470 4428 : for ( i = 0; i < size; i++ )
471 : {
472 4428 : if ( positions[i] != 0 )
473 : {
474 930 : out[i] = npulses;
475 930 : return;
476 : }
477 : }
478 : }
479 :
480 9503 : magnzp = sub( nzpos, 1 );
481 9503 : magnp = sub( npulses, 1 );
482 :
483 9503 : magncout = 0;
484 :
485 9503 : set32_fx( out, 0, size );
486 9503 : set16_fx( mmodel, 0, MAX_PULSES + 2 );
487 :
488 9503 : mmodel[0] = MAX_AR_FREQ;
489 9503 : magncout = 0;
490 32528 : for ( pos = 0; pos < size; pos++ )
491 : {
492 32528 : scp = fxp1;
493 32528 : if ( positions[pos] != 0 )
494 : {
495 22081 : storemagn = 0;
496 :
497 114676 : for ( i = 0; i < magnp; i++ )
498 : {
499 107591 : ovrflag = 0;
500 :
501 107591 : if ( magnzp == ( magnp - i ) )
502 : {
503 22003 : cp = 0;
504 : }
505 : else
506 : {
507 : Word16 tmp;
508 85588 : tmp = div_l( L_deposit_h( magnzp ), magnp - i );
509 85588 : cp = L_sub( fxone, tmp );
510 : }
511 :
512 107591 : if ( cp == fxone )
513 : {
514 0 : break;
515 : }
516 :
517 107591 : scp = Mult_32_16( scp, extract_l( cp ) );
518 107591 : mmodel[i + 1 - storemagn] = round_fx( L_shl( scp, 6 ) );
519 :
520 107591 : if ( ( mmodel[i + 1 - storemagn] == 0 && scp > 0 ) || mmodel[i - storemagn] == mmodel[i + 1 - storemagn] )
521 : {
522 14996 : mmodel[i + 1 - storemagn] = 0;
523 : /* read data */
524 14996 : tempmagn = (Word16) ar_decode( pardec, mmodel );
525 14996 : storemagn += tempmagn;
526 :
527 14996 : if ( tempmagn < i )
528 : {
529 : /* just magnitude */
530 14996 : ovrflag = 1;
531 14996 : break;
532 : }
533 : else
534 : {
535 : /* esc code */
536 0 : scp = fxp1;
537 0 : i--;
538 : }
539 : }
540 : }
541 :
542 22081 : if ( ovrflag )
543 : {
544 14996 : out[magncout] = storemagn + 1;
545 : }
546 : else
547 : {
548 7085 : out[magncout] = ar_decode( pardec, mmodel ) + storemagn + 1;
549 : }
550 22081 : magnp -= (Word16) out[magncout];
551 22081 : magnzp--;
552 22081 : magncout++;
553 :
554 22081 : if ( magnzp == 0 ) /* last magnitude generation */
555 : {
556 11719 : for ( pos = pos + 1; pos < size; pos++ )
557 : {
558 11719 : if ( positions[pos] != 0 )
559 : {
560 7085 : out[magncout] = magnp + 1;
561 7085 : return;
562 : }
563 : else
564 : {
565 4634 : out[magncout] = 0;
566 4634 : magncout++;
567 : }
568 : }
569 : }
570 14996 : else if ( magnzp == magnp ) /* rest magnitudes generation */
571 : {
572 12021 : for ( pos = pos + 1; pos < size; pos++ )
573 : {
574 9603 : out[magncout] = positions[pos];
575 9603 : magncout++;
576 : }
577 2418 : return;
578 : }
579 : }
580 : else
581 : {
582 10447 : out[magncout] = 0;
583 10447 : magncout++;
584 : }
585 : }
586 :
587 0 : return;
588 : }
589 :
590 1044 : static Word16 quantize_fx(
591 : Word16 val,
592 : Word16 D )
593 : {
594 : Word16 qval4_fx;
595 : Word16 retval_fx;
596 :
597 1044 : qval4_fx = shr( abs_s( add( val, 512 ) ), 12 );
598 1044 : retval_fx = add( shl( qval4_fx, 2 ), DDP_fx[D] );
599 : /* 2nd zero check */
600 1044 : if ( D == 0 )
601 : {
602 335 : if ( sub( abs_s( sub( shl( abs_s( retval_fx ), 10 ), abs_s( val ) ) ), abs_s( val ) ) > 0 )
603 : {
604 276 : retval_fx = 0;
605 : }
606 : }
607 :
608 1044 : return retval_fx;
609 : }
610 :
611 1299 : void decode_mangitude_tcq_fx(
612 : ARCODEC *pardec,
613 : Word16 size,
614 : Word16 npulses,
615 : Word16 nzpos,
616 : Word32 *positions,
617 : Word32 *out,
618 : Word32 *surplus_fx )
619 : {
620 : Word32 tcq_bits_fx, bits_fx /*, surplus_fx*/;
621 : Word16 prob0_fx, prob1_fx, num, denum, quantum1_fx, quantum2_fx;
622 : Word16 exp, exp1, exp2, tmp16;
623 : Word32 tmp32;
624 :
625 : Word16 i, j, symbol, st;
626 1299 : Word16 leftp = npulses; /*pulsesnum; */
627 1299 : Word16 leftnz = nzpos; /*nzpos; */
628 1299 : Word16 magn_mode[3] = { MAX_AR_FREQ, 0, 0 };
629 :
630 1299 : bits_fx = 0;
631 1299 : tcq_bits_fx = L_sub( table_logcum_fx[npulses], L_add( table_logcum_fx[nzpos], table_logcum_fx[npulses - ( nzpos - 1 )] ) );
632 :
633 1299 : if ( sub( nzpos, npulses ) == 0 )
634 : {
635 20018 : for ( i = 0; i < size; i++ )
636 : {
637 18791 : out[i] = positions[i];
638 : }
639 :
640 1227 : return;
641 : }
642 72 : else if ( sub( nzpos, 1 ) == 0 )
643 : {
644 191 : for ( i = 0; i < size; i++ )
645 : {
646 191 : if ( positions[i] != 0 )
647 : {
648 36 : out[i] = npulses;
649 36 : return;
650 : }
651 : }
652 : }
653 36 : st = 0;
654 285 : for ( i = 0; i < size && leftnz > 1; i++ )
655 : {
656 249 : out[i] = positions[i];
657 249 : if ( positions[i] != 0 )
658 : {
659 : /*generate the trellis path */
660 83 : symbol = 0;
661 126 : for ( j = 0; j < leftp; j++ )
662 : {
663 126 : num = sub( leftnz, 1 );
664 126 : denum = sub( leftp, add( j, 1 ) );
665 126 : if ( sub( num, denum ) >= 0 )
666 : {
667 31 : prob1_fx = MAX_16;
668 31 : prob0_fx = 0;
669 : }
670 : else
671 : {
672 95 : exp1 = sub( norm_s( num ), 1 );
673 95 : exp2 = norm_s( denum );
674 95 : prob1_fx = div_s( shl( num, exp1 ), shl( denum, exp2 ) ); /*15 + exp1 - exp2 */
675 95 : exp = 15 + exp1 - exp2;
676 95 : prob1_fx = shl( prob1_fx, sub( 15, exp ) );
677 95 : prob0_fx = sub( MAX_16, prob1_fx );
678 : }
679 126 : if ( L_sub( sub( leftp, j ), leftnz ) == 0 )
680 : {
681 31 : symbol = add( j, 1 );
682 31 : break;
683 : }
684 :
685 95 : quantum1_fx = quantize_fx( shl( add( j, 1 ), 10 ), ddec[st][0] );
686 95 : quantum2_fx = quantize_fx( shl( add( j, 1 ), 10 ), ddec[st][1] );
687 :
688 95 : if ( sub( quantum1_fx, add( j, 1 ) ) != 0 && sub( quantum2_fx, add( j, 1 ) ) != 0 )
689 : {
690 33 : prob0_fx = MAX_16;
691 33 : move16();
692 33 : prob1_fx = 0;
693 33 : move16();
694 : }
695 95 : if ( sub( prob0_fx, MAX_16 ) == 0 || sub( prob1_fx, MAX_16 ) == 0 )
696 : {
697 33 : symbol = add( j, 1 );
698 33 : continue;
699 : }
700 :
701 : /*magn_mode[1] = (int16_t)(prob1 * MAX_AR_FREQ); */
702 62 : magn_mode[1] = mult( prob1_fx, MAX_AR_FREQ );
703 :
704 62 : if ( ar_decode( pardec, magn_mode ) )
705 : {
706 52 : exp1 = norm_s( prob1_fx );
707 52 : tmp32 = L_deposit_h( shl( prob1_fx, exp1 ) ); /*exp1 + 15 + 16 */
708 52 : tmp16 = Log2_norm_lc( tmp32 ); /*15 */
709 52 : bits_fx = L_sub( bits_fx, L_sub( tmp16, L_shl( add( exp1, 1 ), 15 ) ) ); /*15 */
710 :
711 52 : symbol = add( j, 1 );
712 52 : break;
713 : }
714 : else
715 : {
716 10 : exp1 = norm_s( prob0_fx );
717 10 : tmp32 = L_deposit_h( shl( prob0_fx, exp1 ) ); /*exp1 + 15 + 16 */
718 10 : tmp16 = Log2_norm_lc( tmp32 ); /*15 */
719 10 : bits_fx = L_sub( bits_fx, L_sub( tmp16, L_shl( add( exp1, 1 ), 15 ) ) ); /*15 */
720 : }
721 : }
722 83 : out[i] = symbol;
723 : /*leftp -= symbol; */
724 83 : leftp = sub( leftp, symbol );
725 83 : leftnz--;
726 : }
727 :
728 249 : quantum1_fx = quantize_fx( (Word16) out[i], ddec[st][0] );
729 249 : quantum2_fx = quantize_fx( (Word16) out[i], ddec[st][1] );
730 :
731 : /*generate the next state */
732 249 : if ( sub( quantum1_fx, (Word16) out[i] ) == 0 )
733 : {
734 148 : st = nextstate[st][0];
735 : }
736 : else
737 : {
738 101 : st = nextstate[st][1];
739 : }
740 : }
741 :
742 : /*generate the magnitudes */
743 195 : for ( ; i < size; i++ )
744 : {
745 159 : out[i] = 0;
746 159 : if ( positions[i] != 0 )
747 : {
748 36 : out[i] = add( sub( leftp, leftnz ), 1 );
749 : }
750 : }
751 :
752 36 : if ( sub( nzpos, npulses ) != 0 && sub( nzpos, 1 ) > 0 )
753 : {
754 : /*update the surplus */
755 36 : *surplus_fx = L_add( *surplus_fx, L_sub( tcq_bits_fx, L_shl( bits_fx, 1 ) ) );
756 : }
757 :
758 36 : return;
759 : }
760 :
761 63738 : Word16 GetScale_fx(
762 : Word16 blen,
763 : Word32 bits_fx /*Q16*/,
764 : Word32 *surplus_fx /*Q16*/
765 : )
766 : {
767 63738 : Word16 pulses = MAX_PULSES, p_est, exp, exp1, exp2, magicnum, tmp;
768 63738 : Word32 t, a, b, ab, estbits_fx = 0;
769 :
770 63738 : magicnum = 24773; /*Q17: 0.188992013101951f; */
771 :
772 63738 : t = L_shr( L_mult( magicnum, blen ), 2 );
773 63738 : exp = norm_l( t );
774 63738 : a = L_shl( 14 - exp, 15 ) + Log2_norm_lc( L_shl( t, exp ) );
775 :
776 63738 : exp1 = sub( norm_l( bits_fx ), 1 );
777 63738 : exp2 = norm_s( blen - 1 );
778 :
779 63738 : tmp = div_l( L_shl( bits_fx, exp1 ), shl( blen - 1, exp2 ) );
780 63738 : b = L_shr( L_deposit_l( tmp ), exp1 - exp2 );
781 :
782 63738 : ab = L_add( a, b );
783 :
784 63738 : p_est = extract_h( L_shl( Pow2( extract_l( L_shr( ab, 15 ) ), ab & 0x7FFF ), 16 ) ); /* enable saturation of pow2 result */
785 :
786 63738 : pulses = min( p_est, MAX_PULSES );
787 :
788 206226 : for ( ; pulses >= 0; pulses-- )
789 : {
790 206226 : estbits_fx = GetBitsFromPulses_fx( pulses, blen );
791 206226 : if ( L_sub( bits_fx, estbits_fx ) >= 0 )
792 : {
793 63738 : break;
794 : }
795 : }
796 :
797 63738 : if ( surplus_fx != NULL )
798 : {
799 63738 : *surplus_fx = L_add( *surplus_fx, L_sub( bits_fx, estbits_fx ) );
800 : }
801 :
802 63738 : return pulses;
803 : }
804 :
805 :
806 32403 : void decode_signs_fx(
807 : ARCODEC *pardec,
808 : Word16 size,
809 : Word32 *out )
810 : {
811 : Word16 i;
812 :
813 432593 : for ( i = 0; i < size; i++ )
814 : {
815 400190 : if ( out[i] != 0 )
816 : {
817 73903 : out[i] = ( ar_decode( pardec, uniform_model ) > 0 ) ? out[i] : -out[i];
818 : }
819 : }
820 :
821 32403 : return;
822 : }
823 :
824 31335 : Word32 encode_position_ari_fx(
825 : PARCODEC parenc,
826 : float *quants,
827 : Word16 size,
828 : Word32 *est_bits_frame_fx )
829 : {
830 : Word16 i;
831 31335 : Word16 nz = 0, pulses = 0;
832 : Word16 prob[TCQ_MAX_BAND_SIZE];
833 : Word16 model_num_nz[TCQ_MAX_BAND_SIZE];
834 31335 : float *cur_quants = quants;
835 : Word16 integer, frac;
836 31335 : Word32 /*est_bits_frame_fx, */ btcq_fx = 0, bits_fx = 0, pnzp_fx;
837 : Word32 cp, scp, fxone, fxp1;
838 : Word16 pos;
839 :
840 31335 : fxone = 32768;
841 31335 : fxp1 = 512 * 32768;
842 :
843 31335 : set16_fx( prob, 0, TCQ_MAX_BAND_SIZE );
844 31335 : set16_fx( model_num_nz, 0, TCQ_MAX_BAND_SIZE );
845 :
846 417600 : for ( i = 0; i < size; i++ )
847 : {
848 386265 : pulses = add( pulses, abs_s( (int16_t) cur_quants[i] ) );
849 386265 : if ( cur_quants[i] != 0 )
850 : {
851 72026 : nz++;
852 : }
853 : }
854 :
855 31335 : btcq_fx = GetBitsFromPulses_fx( pulses, size );
856 : /* Estimate TCQ bits */
857 31335 : bits_fx = L_sub( table_logcum_fx[size + 1], L_add( table_logcum_fx[nz + 1], table_logcum_fx[size - nz + 1] ) );
858 31335 : bits_fx = L_add( bits_fx, L_sub( btcq_fx, L_sub( table_logcum_fx[size + 1], L_add( table_logcum_fx[nz + 1], table_logcum_fx[size - nz + 1] ) ) ) );
859 31335 : bits_fx = L_sub( bits_fx, L_sub( table_logcum_fx[pulses], L_add( table_logcum_fx[nz], table_logcum_fx[pulses - ( nz - 1 )] ) ) );
860 :
861 31335 : bits_fx = L_sub( bits_fx, nz );
862 31335 : *est_bits_frame_fx = L_add( *est_bits_frame_fx, bits_fx );
863 :
864 : /*caculate the #nz probability */
865 118561 : for ( i = 0; i < min( pulses, size ); i++ )
866 : {
867 87226 : pnzp_fx = L_sub( L_deposit_h( add( i, 1 ) ), btcq_fx );
868 :
869 87226 : pnzp_fx = L_add( pnzp_fx, L_add( L_sub( table_logcum_fx[size + 1], L_add( table_logcum_fx[i + 2], table_logcum_fx[size - i] ) ), L_sub( table_logcum_fx[pulses], L_add( table_logcum_fx[i + 1], table_logcum_fx[pulses - i] ) ) ) );
870 :
871 87226 : pnzp_fx = L_add( pnzp_fx, 917498 ); /*16 */
872 87226 : if ( L_sub( pnzp_fx, 0 ) > 0 )
873 : {
874 86376 : integer = extract_h( pnzp_fx );
875 86376 : frac = extract_l( L_shr( L_sub( pnzp_fx, L_deposit_h( integer ) ), 1 ) ); /*15 */
876 86376 : prob[i] = extract_h( L_shl( Pow2( integer, frac ), 16 ) ); /*0 */
877 :
878 : /*zero probability will incur problems in ar_make_model() */
879 86376 : if ( prob[i] == 0 )
880 : {
881 0 : prob[i] = 1;
882 : }
883 : }
884 : else
885 : {
886 850 : prob[i] = 1;
887 : }
888 : }
889 :
890 31335 : ar_make_model( prob, model_num_nz, min( pulses, size ) );
891 :
892 31335 : if ( sub( nz, 1 ) > 0 )
893 : {
894 20015 : ar_encode( parenc, model_num_nz, nz - 1 ); /*encode #nz */
895 :
896 20015 : scp = fxp1;
897 20015 : pos = 0;
898 158163 : for ( i = 0; i < size && nz > 0; i++ )
899 : {
900 138148 : if ( nz == ( size - i ) )
901 : {
902 17801 : cp = 0;
903 : }
904 : else
905 : {
906 : Word16 tmp;
907 120347 : tmp = div_l( L_deposit_h( nz ), ( size - i ) );
908 120347 : cp = L_sub( fxone, tmp );
909 : }
910 138148 : scp = Mult_32_16( scp, extract_l( cp ) );
911 138148 : model_num_nz[pos + 1] = round_fx( L_shl( scp, 6 ) );
912 :
913 138148 : if ( ( model_num_nz[pos + 1] == 0 && scp > 0 ) || model_num_nz[pos] == model_num_nz[pos + 1] )
914 : {
915 0 : model_num_nz[pos + 1] = 0;
916 0 : ar_encode( parenc, model_num_nz, pos );
917 0 : i--;
918 0 : scp = fxp1;
919 0 : pos = 0;
920 0 : continue;
921 : }
922 :
923 138148 : if ( cur_quants[i] != 0 )
924 : {
925 62286 : ar_encode( parenc, model_num_nz, pos );
926 62286 : pos = 0;
927 62286 : scp = fxp1;
928 62286 : nz--;
929 : }
930 : else
931 : {
932 75862 : pos++;
933 : }
934 : }
935 : }
936 11320 : else if ( sub( nz, 1 ) == 0 )
937 : {
938 9740 : if ( sub( pulses, 1 ) > 0 )
939 : {
940 : /*temp -= log2_f((float)(model_num_nz[nz-1] - model_num_nz[nz]) / MAX_AR_FREQ); */
941 878 : ar_encode( parenc, model_num_nz, 0 ); /*encode #nz */
942 : }
943 :
944 9740 : pos = 0;
945 183086 : for ( i = 0; i < size; i++ )
946 : {
947 : Word16 tmp;
948 173346 : tmp = div_l( L_deposit_h( size - i - 1 ), size );
949 173346 : model_num_nz[i + 1] = round_fx( L_shr( L_deposit_h( tmp ), 1 ) );
950 :
951 173346 : if ( cur_quants[i] != 0 )
952 : {
953 9740 : pos = i;
954 : }
955 : }
956 9740 : ar_encode( parenc, model_num_nz, pos ); /* encode pos */
957 : }
958 31335 : return bits_fx;
959 : }
960 :
961 :
962 1307 : Word32 encode_magnitude_tcq_fx(
963 : ARCODEC *parenc,
964 : float *magn_fx,
965 : Word16 size,
966 : Word16 npulses,
967 : Word16 nzpos,
968 : Word32 *savedstates,
969 : Word32 *est_frame_bits_fx )
970 : {
971 : Word32 tcq_bits_fx, bits_fx /*, est_frame_bits_fx*/;
972 : Word16 prob0_fx, prob1_fx, num, denum, quantum1_fx, quantum2_fx;
973 : Word16 exp, exp1, exp2;
974 :
975 : Word16 i, j;
976 : Word32 st;
977 1307 : Word16 magn_mode[3] = { MAX_AR_FREQ, 0, 0 };
978 :
979 1307 : Word16 leftp = npulses; /*pulsesnum; */
980 1307 : Word16 leftnz = nzpos; /*nzpos; */
981 :
982 1307 : bits_fx = 0;
983 :
984 1307 : tcq_bits_fx = L_sub( table_logcum_fx[npulses], L_add( table_logcum_fx[nzpos], table_logcum_fx[npulses - ( nzpos - 1 )] ) );
985 :
986 1307 : *est_frame_bits_fx = L_add( *est_frame_bits_fx, tcq_bits_fx );
987 :
988 1307 : if ( sub( nzpos, npulses ) == 0 || sub( nzpos, 1 ) == 0 )
989 : {
990 1271 : return bits_fx;
991 : }
992 :
993 36 : st = 0;
994 285 : for ( i = 0; i < size && leftnz > 1; i++ )
995 : {
996 249 : st = savedstates[i];
997 249 : if ( magn_fx[i] != 0 )
998 : {
999 209 : for ( j = 0; j < leftp; j++ )
1000 : {
1001 : /*calculate the two path probs point to next two states */
1002 178 : num = sub( leftnz, 1 );
1003 178 : denum = sub( leftp, add( j, 0x1 ) );
1004 178 : if ( sub( num, denum ) >= 0 )
1005 : {
1006 83 : prob1_fx = MAX_16;
1007 83 : prob0_fx = 0;
1008 : }
1009 : else
1010 : {
1011 95 : exp1 = sub( norm_s( num ), 1 );
1012 95 : exp2 = norm_s( denum );
1013 95 : prob1_fx = div_s( shl( num, exp1 ), shl( denum, exp2 ) ); /*15 + exp1 - exp2 */
1014 95 : exp = 15 + exp1 - exp2;
1015 95 : prob1_fx = shl( prob1_fx, sub( 15, exp ) );
1016 95 : prob0_fx = sub( MAX_16, prob1_fx );
1017 : }
1018 :
1019 178 : quantum1_fx = quantize_fx( shl( add( j, 1 ), 10 ), ddec[st][0] );
1020 178 : quantum2_fx = quantize_fx( shl( add( j, 1 ), 10 ), ddec[st][1] );
1021 :
1022 178 : if ( sub( quantum1_fx, add( j, 1 ) ) != 0 && sub( quantum2_fx, add( j, 1 ) ) != 0 )
1023 : {
1024 70 : prob0_fx = MAX_16;
1025 70 : prob1_fx = 0;
1026 : }
1027 178 : if ( sub( prob0_fx, MAX_16 ) == 0 || sub( prob1_fx, MAX_16 ) == 0 )
1028 : {
1029 116 : continue;
1030 : }
1031 :
1032 62 : magn_mode[1] = mult( prob1_fx, MAX_AR_FREQ );
1033 62 : if ( sub( j, sub( abs_s( (int16_t) magn_fx[i] ), 1 ) ) < 0 )
1034 : {
1035 10 : ar_encode( parenc, magn_mode, 0 );
1036 : }
1037 : else
1038 : {
1039 52 : if ( sub( leftp, j ) > leftnz )
1040 : {
1041 52 : ar_encode( parenc, magn_mode, 1 );
1042 : }
1043 52 : break;
1044 : }
1045 : }
1046 :
1047 83 : leftnz--;
1048 83 : leftp = sub( leftp, abs_s( (int16_t) magn_fx[i] ) );
1049 : }
1050 : }
1051 :
1052 36 : return bits_fx;
1053 : }
1054 :
1055 :
1056 31335 : Word32 encode_signs_fx(
1057 : ARCODEC *parenc,
1058 : float *magn,
1059 : Word16 size,
1060 : Word16 npos,
1061 : Word32 *est_frame_bits_fx )
1062 : {
1063 : Word32 i, sign;
1064 :
1065 31335 : *est_frame_bits_fx = L_add( *est_frame_bits_fx, L_deposit_h( npos ) );
1066 417600 : for ( i = 0; i < size; i++ )
1067 : {
1068 386265 : if ( magn[i] != 0 )
1069 : {
1070 72026 : sign = ( magn[i] > 0 ) ? 1 : 0;
1071 72026 : ar_encode_uniform( parenc, (uint16_t) sign, 1 );
1072 : }
1073 : }
1074 :
1075 31335 : return L_deposit_h( npos );
1076 : }
1077 :
1078 :
1079 30028 : Word32 encode_magnitude_usq_fx(
1080 : ARCODEC *parenc,
1081 : float *magn_fx,
1082 : Word16 size,
1083 : Word16 npulses,
1084 : Word16 nzpos,
1085 : Word32 *est_frame_bits_fx )
1086 : {
1087 : Word16 i, j, k, magnp, magnzp;
1088 : Word16 magn_position[MAX_PULSES];
1089 : Word32 /*est_frame_bits_fx, */ bits_fx;
1090 :
1091 : Word16 pos, model_m[MAX_PULSES + 2];
1092 : Word32 fxone, fxp1, cp, scp;
1093 :
1094 30028 : fxone = 32768;
1095 30028 : fxp1 = 512 * 32768;
1096 :
1097 : /*estimate fac bits */
1098 30028 : bits_fx = L_sub( table_logcum_fx[npulses], L_add( table_logcum_fx[nzpos], table_logcum_fx[npulses - nzpos + 1] ) );
1099 :
1100 30028 : *est_frame_bits_fx = L_add( *est_frame_bits_fx, bits_fx );
1101 :
1102 30028 : if ( sub( npulses, nzpos ) == 0 || sub( nzpos, 1 ) == 0 )
1103 : {
1104 20731 : return bits_fx;
1105 : }
1106 9297 : magnp = sub( npulses, 1 );
1107 9297 : magnzp = sub( nzpos, 1 );
1108 :
1109 : /*generate the binary sequences of magnitudes */
1110 9297 : k = 0;
1111 69601 : for ( i = 0; i < size; i++ )
1112 : {
1113 60304 : if ( magn_fx[i] != 0 )
1114 : {
1115 65661 : for ( j = 0; j < abs_s( (int16_t) magn_fx[i] ) - 1; j++ )
1116 : {
1117 31262 : magn_position[k++] = 0;
1118 : }
1119 34399 : magn_position[k++] = 1;
1120 : }
1121 : }
1122 :
1123 9297 : set16_fx( model_m, 0, MAX_PULSES + 2 );
1124 9297 : scp = fxp1;
1125 9297 : model_m[0] = MAX_AR_FREQ;
1126 9297 : pos = 0;
1127 58741 : for ( i = 0; i < npulses - 1 && magnzp > 0; i++ )
1128 : {
1129 49444 : if ( magnzp == magnp )
1130 : {
1131 8748 : cp = 0;
1132 : }
1133 : else
1134 : {
1135 : Word16 tmp;
1136 40696 : tmp = div_l( L_deposit_h( magnzp ), magnp );
1137 40696 : cp = L_sub( fxone, tmp );
1138 : }
1139 49444 : scp = Mult_32_16( scp, extract_l( cp ) );
1140 49444 : model_m[pos + 1] = round_fx( L_shl( scp, 6 ) );
1141 :
1142 49444 : if ( ( model_m[pos + 1] == 0 && scp > 0 ) || model_m[pos] == model_m[pos + 1] )
1143 : {
1144 0 : model_m[pos + 1] = 0;
1145 :
1146 0 : ar_encode( parenc, model_m, pos );
1147 0 : pos = 0;
1148 0 : i--;
1149 0 : scp = fxp1;
1150 0 : continue;
1151 : }
1152 :
1153 49444 : if ( magn_position[i] != 0 )
1154 : {
1155 25102 : ar_encode( parenc, model_m, pos );
1156 25102 : pos = 0;
1157 25102 : magnzp--;
1158 25102 : scp = fxp1;
1159 : }
1160 : else
1161 : {
1162 24342 : pos++;
1163 : }
1164 :
1165 49444 : magnp--;
1166 : }
1167 9297 : return bits_fx;
1168 : }
1169 :
1170 :
1171 177680 : static void transmission_bits(
1172 : PARCODEC arInst,
1173 : int16_t bit )
1174 : {
1175 177680 : bitstream_save_bit( arInst->bsInst, bit );
1176 177680 : arInst->num_bits++;
1177 177680 : bit = !bit;
1178 :
1179 288248 : for ( ; arInst->bits_to_follow > 0 && arInst->num_bits < arInst->max_bits; arInst->bits_to_follow-- )
1180 : {
1181 110568 : bitstream_save_bit( arInst->bsInst, bit );
1182 110568 : arInst->num_bits++;
1183 : }
1184 :
1185 177680 : return;
1186 : }
1187 :
1188 1976 : void ar_encoder_start(
1189 : PARCODEC arInst,
1190 : TCQ_PBITSTREAM bsInst,
1191 : int16_t max_bits )
1192 : {
1193 1976 : arInst->bsInst = bsInst;
1194 :
1195 1976 : arInst->low = 0;
1196 1976 : arInst->high = AR_TOP;
1197 1976 : arInst->bits_to_follow = 0;
1198 :
1199 1976 : arInst->num_bits = 0;
1200 1976 : arInst->max_bits = max_bits;
1201 :
1202 1976 : return;
1203 : }
1204 :
1205 :
1206 206959 : static void ar_encode(
1207 : PARCODEC arInst,
1208 : const int16_t *model,
1209 : int32_t symbol )
1210 : {
1211 : uint32_t range, high, low;
1212 :
1213 206959 : high = arInst->high;
1214 206959 : low = arInst->low;
1215 :
1216 206959 : symbol++;
1217 206959 : range = high - low + 1;
1218 :
1219 206959 : high = low + ( range * model[symbol - 1] ) / model[0] - 1;
1220 206959 : low = low + ( range * model[symbol] ) / model[0];
1221 :
1222 : for ( ;; )
1223 : {
1224 491255 : if ( high < AR_HALF )
1225 : {
1226 86751 : transmission_bits( arInst, 0 );
1227 : }
1228 : else
1229 : {
1230 404504 : if ( low >= AR_HALF )
1231 : {
1232 88953 : transmission_bits( arInst, 1 );
1233 :
1234 88953 : low -= AR_HALF;
1235 88953 : high -= AR_HALF;
1236 : }
1237 : else
1238 : {
1239 315551 : if ( low >= AR_FIRST && high < AR_THIRD )
1240 : {
1241 108592 : arInst->bits_to_follow++;
1242 :
1243 108592 : low -= AR_FIRST;
1244 108592 : high -= AR_FIRST;
1245 : }
1246 : else
1247 : {
1248 : break;
1249 : }
1250 : }
1251 : }
1252 :
1253 284296 : low = low << 1;
1254 284296 : high = ( high << 1 ) + 1;
1255 : }
1256 :
1257 206959 : arInst->high = high;
1258 206959 : arInst->low = low;
1259 :
1260 206959 : return;
1261 : }
1262 :
1263 :
1264 88876 : static void ar_encode_uniform(
1265 : PARCODEC arInst,
1266 : uint16_t data,
1267 : const int16_t bits )
1268 : {
1269 : int16_t i;
1270 :
1271 177752 : for ( i = 0; i < bits; i++ )
1272 : {
1273 88876 : ar_encode( arInst, uniform_model, data & 0x1 );
1274 88876 : data >>= 1;
1275 : }
1276 :
1277 88876 : return;
1278 : }
1279 :
1280 :
1281 1976 : void ar_encoder_done(
1282 : PARCODEC arInst )
1283 : {
1284 1976 : arInst->bits_to_follow++;
1285 1976 : transmission_bits( arInst, arInst->low >= AR_FIRST );
1286 :
1287 1976 : return;
1288 : }
1289 :
1290 :
1291 2044 : void ar_decoder_start(
1292 : PARCODEC arInst,
1293 : TCQ_PBITSTREAM bsInst )
1294 : {
1295 : int16_t i;
1296 :
1297 2044 : arInst->bsInst = bsInst;
1298 :
1299 2044 : arInst->low = 0;
1300 2044 : arInst->high = AR_TOP;
1301 2044 : arInst->value = 0;
1302 :
1303 34748 : for ( i = 0; i < AR_BITS; i++ )
1304 : {
1305 32704 : arInst->value = ( arInst->value << 1 ) + bitstream_load_bit( arInst->bsInst );
1306 : }
1307 :
1308 2044 : return;
1309 : }
1310 :
1311 :
1312 209025 : static int32_t ar_decode(
1313 : PARCODEC arInst,
1314 : const int16_t *model )
1315 : {
1316 : uint32_t range;
1317 : int16_t cum;
1318 : int16_t symbol;
1319 :
1320 209025 : range = (uint32_t) ( arInst->high - arInst->low ) + 1;
1321 209025 : cum = (int16_t) ( ( ( (uint32_t) ( arInst->value - arInst->low ) + 1 ) * model[0] - 1 ) / range );
1322 :
1323 474338 : for ( symbol = 1; model[symbol] > cum; symbol++ )
1324 : {
1325 : ;
1326 : }
1327 :
1328 209025 : arInst->high = arInst->low + ( range * model[symbol - 1] ) / model[0] - 1;
1329 209025 : arInst->low = arInst->low + ( range * model[symbol] ) / model[0];
1330 :
1331 : for ( ;; )
1332 : {
1333 502045 : if ( arInst->high >= AR_HALF )
1334 : {
1335 412697 : if ( arInst->low >= AR_HALF )
1336 : {
1337 91876 : arInst->value -= AR_HALF;
1338 91876 : arInst->low -= AR_HALF;
1339 91876 : arInst->high -= AR_HALF;
1340 : }
1341 : else
1342 : {
1343 320821 : if ( arInst->low >= AR_FIRST && arInst->high < AR_THIRD )
1344 : {
1345 111796 : arInst->value -= AR_FIRST;
1346 111796 : arInst->low -= AR_FIRST;
1347 111796 : arInst->high -= AR_FIRST;
1348 : }
1349 : else
1350 : {
1351 : break;
1352 : }
1353 : }
1354 : }
1355 293020 : arInst->low <<= 1;
1356 293020 : arInst->high = ( arInst->high << 1 ) + 1;
1357 293020 : arInst->value = ( arInst->value << 1 ) + bitstream_load_bit( arInst->bsInst );
1358 : }
1359 :
1360 209025 : return ( symbol - 1 );
1361 : }
1362 :
1363 2044 : void ar_decoder_done(
1364 : PARCODEC arInst )
1365 : {
1366 2044 : bitstream_rollback( arInst->bsInst, AR_BITS - 2 );
1367 :
1368 2044 : return;
1369 : }
1370 :
1371 :
1372 52861 : static int32_t ar_make_model(
1373 : const int16_t *freq,
1374 : int16_t *model,
1375 : const int16_t len )
1376 : {
1377 : int16_t dist;
1378 52861 : uint32_t sum = 0;
1379 52861 : uint32_t cum = 0;
1380 : int16_t i;
1381 :
1382 220496 : for ( i = 0; i < len; i++ )
1383 : {
1384 167635 : sum += freq[i];
1385 : }
1386 :
1387 52861 : if ( sum == 0 )
1388 : {
1389 1580 : return 0;
1390 : }
1391 :
1392 51281 : for ( i = len;; i-- )
1393 : {
1394 218916 : model[i] = (int16_t) ( ( cum * MAX_AR_FREQ ) / sum );
1395 :
1396 218916 : if ( !i )
1397 : {
1398 51281 : break;
1399 : }
1400 :
1401 167635 : cum += freq[i - 1];
1402 : }
1403 :
1404 :
1405 167635 : for ( i = 0; i < len - 1; i++ )
1406 : {
1407 116354 : dist = model[i] - model[i + 1];
1408 :
1409 116354 : if ( dist <= 0 )
1410 : {
1411 0 : model[i + 1] += dist - 1;
1412 : }
1413 : }
1414 :
1415 218916 : for ( i = len; i; i-- )
1416 : {
1417 167635 : dist = model[i - 1] - model[i];
1418 :
1419 167635 : if ( dist <= 0 )
1420 : {
1421 0 : model[i - 1] -= dist - 1;
1422 : }
1423 : }
1424 :
1425 51281 : return ( model[0] > model[1] );
1426 : }
1427 :
1428 288248 : static void bitstream_save_bit(
1429 : TCQ_PBITSTREAM pBS,
1430 : const int16_t bit )
1431 : {
1432 : uint8_t cur;
1433 :
1434 288248 : cur = pBS->buf[pBS->numByte];
1435 :
1436 288248 : cur = (uint8_t) ( cur | ( bit << pBS->curPos-- ) );
1437 288248 : pBS->buf[pBS->numByte] = cur;
1438 288248 : pBS->numbits++;
1439 :
1440 288248 : if ( pBS->curPos < 0 )
1441 : {
1442 35179 : pBS->curPos = 7;
1443 35179 : pBS->numByte++;
1444 : }
1445 :
1446 288248 : return;
1447 : }
1448 :
1449 :
1450 325724 : static uint32_t bitstream_load_bit(
1451 : TCQ_PBITSTREAM pBS )
1452 : {
1453 : uint32_t bit;
1454 : signed char *curPos;
1455 :
1456 : /* safety check in case of bit errors */
1457 325724 : if ( pBS->numByte >= pBS->maxBytes )
1458 : {
1459 0 : return 0;
1460 : }
1461 :
1462 325724 : curPos = &pBS->curPos;
1463 325724 : bit = ( ( pBS->buf[pBS->numByte] >> ( *curPos )-- ) & 0x00000001 );
1464 :
1465 325724 : if ( *curPos < 0 )
1466 : {
1467 39840 : pBS->numByte++;
1468 39840 : *curPos = 7;
1469 : }
1470 :
1471 325724 : return bit;
1472 : }
1473 :
1474 :
1475 2044 : static void bitstream_rollback(
1476 : TCQ_PBITSTREAM pBS,
1477 : int16_t numBits )
1478 : {
1479 30660 : while ( numBits > 0 )
1480 : {
1481 28616 : pBS->curPos++;
1482 28616 : pBS->numbits--;
1483 28616 : if ( pBS->curPos == 8 )
1484 : {
1485 3582 : pBS->curPos = 0;
1486 3582 : pBS->numByte--;
1487 : }
1488 28616 : numBits--;
1489 : }
1490 :
1491 2044 : return;
1492 : }
1493 :
1494 :
1495 10884 : static float quantize(
1496 : float val,
1497 : const int16_t D )
1498 : {
1499 : int32_t qval4;
1500 : float retval; /* = qval4*4.0f + DD[D]; */
1501 :
1502 10884 : qval4 = (int32_t) fabs( ( val + 0.5 ) / 4.0 );
1503 10884 : retval = qval4 * 4.0f + DDP[D];
1504 :
1505 : /* 2nd zero check */
1506 10884 : if ( D == 0 )
1507 : {
1508 2939 : if ( fabs( fabs( retval ) - fabs( val ) ) > fabs( val ) )
1509 : {
1510 2639 : retval = 0;
1511 : }
1512 : }
1513 :
1514 10884 : return retval;
1515 : }
1516 :
1517 :
1518 40 : static void TCQnew(
1519 : float *v,
1520 : float scale,
1521 : int16_t length,
1522 : float *vout,
1523 : int32_t pulses,
1524 : int32_t *pulsesout,
1525 : int32_t *nzposout,
1526 : int32_t *savedstates,
1527 : int32_t *lasttrellislevel,
1528 : int32_t terminate )
1529 : {
1530 40 : int16_t i, st, dminpos, position, pulsesnum, nzpos = 0;
1531 : float dmin, quantum1, quantum2, curdist1, curdist2, newdist1, newdist2, signq;
1532 :
1533 : float metric[STATES][TCQ_MAX_BAND_SIZE];
1534 : int16_t path[STATES][TCQ_MAX_BAND_SIZE];
1535 : int16_t quant[STATES][TCQ_MAX_BAND_SIZE];
1536 : int16_t pused[STATES][TCQ_MAX_BAND_SIZE];
1537 :
1538 40 : set_f( *metric, 0.0f, STATES * TCQ_MAX_BAND_SIZE );
1539 40 : set_s( *path, 0, STATES * TCQ_MAX_BAND_SIZE );
1540 40 : set_s( *quant, 0, STATES * TCQ_MAX_BAND_SIZE );
1541 40 : set_s( *pused, 0, STATES * TCQ_MAX_BAND_SIZE );
1542 :
1543 : /* Initialize metric */
1544 320 : for ( st = 1; st < STATES; st++ )
1545 : {
1546 280 : metric[st][0] = 1000;
1547 : }
1548 280 : for ( st = 2; st < STATES; st++ )
1549 : {
1550 240 : metric[st][1] = 1000;
1551 : }
1552 200 : for ( st = 4; st < STATES; st++ )
1553 : {
1554 160 : metric[st][2] = 1000;
1555 : }
1556 :
1557 : /* Viterbi for input sequence */
1558 482 : for ( i = 0; i < length; i++ ) /* cycle over symbols */
1559 : {
1560 3978 : for ( st = 0; st < STATES; st++ ) /* cycle over conditions */
1561 : {
1562 3536 : curdist1 = metric[step_tcq[st][0]][i];
1563 3536 : curdist2 = metric[step_tcq[st][1]][i];
1564 :
1565 : /* step 1 */
1566 3536 : quantum1 = quantize( v[i] * scale, denc[st][0] );
1567 3536 : newdist1 = (float) ( quantum1 - fabs( v[i] ) * scale );
1568 3536 : newdist1 *= newdist1;
1569 :
1570 3536 : if ( quantum1 + pused[step_tcq[st][0]][i] > pulses && terminate )
1571 : {
1572 459 : newdist1 = 10000.0f; /* pulses check */
1573 : }
1574 :
1575 : /* step 2 */
1576 3536 : quantum2 = quantize( v[i] * scale, denc[st][1] );
1577 3536 : newdist2 = (float) ( quantum2 - fabs( v[i] ) * scale );
1578 3536 : newdist2 *= newdist2;
1579 :
1580 3536 : if ( quantum2 + pused[step_tcq[st][1]][i] > pulses && terminate )
1581 : {
1582 494 : newdist2 = 10000.0f; /* pulses check */
1583 : }
1584 :
1585 : /* decision */
1586 3536 : if ( curdist1 + newdist1 < curdist2 + newdist2 )
1587 : {
1588 2261 : path[st][i + 1] = step_tcq[st][0];
1589 2261 : metric[st][i + 1] = curdist1 + newdist1;
1590 2261 : quant[st][i + 1] = (int16_t) quantize( v[i] * scale, denc[st][0] );
1591 2261 : pused[st][i + 1] = (int16_t) ( pused[step_tcq[st][0]][i] + abs( quant[st][i + 1] ) );
1592 : }
1593 : else
1594 : {
1595 1275 : path[st][i + 1] = step_tcq[st][1];
1596 1275 : metric[st][i + 1] = curdist2 + newdist2;
1597 1275 : quant[st][i + 1] = (int16_t) quantize( v[i] * scale, denc[st][1] );
1598 1275 : pused[st][i + 1] = (int16_t) ( pused[step_tcq[st][1]][i] + abs( quant[st][i + 1] ) );
1599 : }
1600 : }
1601 : }
1602 :
1603 : /* Find path with minimal metric */
1604 40 : dminpos = 0;
1605 40 : dmin = metric[dminpos][length];
1606 320 : for ( i = 1; i < STATES; i++ )
1607 : {
1608 280 : if ( ( dmin > metric[i][length] && pused[i][length] == pulses ) ||
1609 245 : ( pused[dminpos][length] != pulses && pused[i][length] == pulses ) )
1610 : {
1611 44 : dmin = metric[i][length];
1612 44 : dminpos = i;
1613 : }
1614 : }
1615 :
1616 : /* Trace back to get output */
1617 40 : pulsesnum = 0;
1618 40 : position = dminpos;
1619 :
1620 482 : for ( i = length; i > 0; i-- )
1621 : {
1622 442 : signq = ( v[i - 1] > 0.0f ) ? ( 1.0f ) : ( -1.0f );
1623 442 : vout[i - 1] = signq * quant[position][i];
1624 :
1625 442 : position = path[position][i];
1626 442 : savedstates[i - 1] = position;
1627 :
1628 : /* calculate output pulses number & nz */
1629 442 : pulsesnum += (int16_t) fabs( vout[i - 1] ); /*quant[position][i]; */
1630 442 : if ( fabs( vout[i - 1] ) > 0.0f )
1631 : {
1632 135 : if ( nzpos == 0 )
1633 : {
1634 40 : *lasttrellislevel = i;
1635 : }
1636 :
1637 135 : nzpos++;
1638 : }
1639 : }
1640 :
1641 40 : if ( pulsesout != NULL )
1642 : {
1643 40 : *pulsesout = pulsesnum;
1644 : }
1645 40 : if ( nzposout != NULL )
1646 : {
1647 40 : *nzposout = nzpos;
1648 : }
1649 :
1650 40 : return;
1651 : }
1652 :
1653 :
1654 31335 : float GetISCScale(
1655 : float *quants,
1656 : int16_t size,
1657 : Word32 bits_fx,
1658 : float *magn,
1659 : float *qscale,
1660 : Word32 *surplus_fx,
1661 : float *pulses,
1662 : int32_t *savedstates,
1663 : int16_t noTCQ,
1664 : int32_t *nzpout,
1665 : int16_t *bcount,
1666 : float *abuffer,
1667 : float *mbuffer,
1668 : float *sbuffer )
1669 : {
1670 31335 : float scale, m, t, actualt, magnbits = 0.0f;
1671 : int32_t pulsesnum, pos, terminate, leftp, leftnz, trellislevel, st;
1672 : int32_t i, j, nzpos, direction, pulsescurr, nzposcurr, lasttrellislevel;
1673 : float dist[TCQ_MAX_BAND_SIZE];
1674 : float aquants[TCQ_MAX_BAND_SIZE];
1675 : float dmin, prob0, prob1, quantum1, quantum2;
1676 31335 : float sx2 = 0, sy2 = 0, sxy = 0, g;
1677 31335 : int32_t pn = 0;
1678 31335 : float pt = 0.f;
1679 : int32_t diff;
1680 : int16_t sign;
1681 : int32_t m_int;
1682 : int8_t flag_g1;
1683 :
1684 31335 : set_f( dist, 0.0f, TCQ_MAX_BAND_SIZE );
1685 31335 : set_f( aquants, 0.0f, TCQ_MAX_BAND_SIZE );
1686 :
1687 31335 : if ( bits_fx < 0 )
1688 : {
1689 0 : pulsesnum = 0;
1690 :
1691 0 : if ( surplus_fx != NULL )
1692 : {
1693 0 : *surplus_fx = L_add( *surplus_fx, bits_fx );
1694 : }
1695 : }
1696 : else
1697 : {
1698 31335 : pulsesnum = GetScale_fx( size, bits_fx, surplus_fx );
1699 : }
1700 31335 : *nzpout = 0;
1701 :
1702 31335 : if ( pulses != NULL )
1703 : {
1704 31335 : *pulses = (float) pulsesnum;
1705 : }
1706 :
1707 31335 : if ( pulsesnum > 0 )
1708 : {
1709 : /* Initial quantization */
1710 385303 : for ( i = 0, m = 0; i < size; i++ )
1711 : {
1712 355548 : aquants[i] = (float) fabs( quants[i] );
1713 355548 : m += aquants[i];
1714 : }
1715 :
1716 29755 : scale = ( pulsesnum + EPSILON ) / ( m + EPSILON );
1717 :
1718 385303 : for ( i = 0, t = 0.0f; i < size; i++ )
1719 : {
1720 355548 : magn[i] = (float) ( (int16_t) ( 0.5f + aquants[i] * scale ) );
1721 :
1722 355548 : t += magn[i];
1723 : }
1724 :
1725 : /* Pulses redistribution */
1726 57223 : while ( t != pulsesnum )
1727 : {
1728 27468 : pn = 0;
1729 27468 : pt = 0.f;
1730 :
1731 :
1732 418449 : for ( i = 0, nzpos = 0; i < size; i++ )
1733 : {
1734 390981 : if ( magn[i] > 0.0f )
1735 : {
1736 32161 : pn += (int32_t) magn[i];
1737 32161 : pt += aquants[i];
1738 : }
1739 : }
1740 :
1741 27468 : direction = ( pulsesnum - t > 0 ) ? ( 1 ) : ( -1 );
1742 :
1743 : /* new alg */
1744 : {
1745 418449 : for ( i = 0; i < size; i++ )
1746 : {
1747 390981 : sxy += aquants[i] * magn[i];
1748 390981 : sx2 += aquants[i] * aquants[i];
1749 390981 : sy2 += magn[i] * magn[i];
1750 : }
1751 418449 : for ( i = 0; i < size; i++ )
1752 : {
1753 390981 : if ( magn[i] > 0.0f )
1754 : {
1755 32161 : g = ( pt ) / ( pn + direction + EPSILON );
1756 : }
1757 : else
1758 : {
1759 358820 : g = ( pt + aquants[i] ) / ( pn + direction + EPSILON );
1760 : }
1761 :
1762 390981 : dist[i] = sx2 - 2.0f * ( sxy + direction * aquants[i] ) * g + g * g * ( sy2 + 2.0f * magn[i] * direction + 1.0f );
1763 : }
1764 : }
1765 :
1766 : {
1767 27468 : pos = 0;
1768 27468 : dmin = dist[0];
1769 :
1770 : /* find min */
1771 390981 : for ( i = 1; i < size; i++ )
1772 : {
1773 363513 : if ( dmin > dist[i] )
1774 : {
1775 57027 : pos = i;
1776 57027 : dmin = dist[i];
1777 : }
1778 : }
1779 :
1780 27468 : magn[pos] += direction;
1781 27468 : t += direction;
1782 : }
1783 : }
1784 :
1785 : /* calculate actual nz positions */
1786 29755 : actualt = 0.0f;
1787 385303 : for ( i = 0, nzpos = 0; i < size; i++ )
1788 : {
1789 355548 : if ( magn[i] > 0.0f )
1790 : {
1791 72028 : if ( quants[i] < 0 )
1792 : {
1793 36267 : magn[i] *= -1;
1794 : }
1795 :
1796 72028 : actualt += aquants[i];
1797 72028 : nzpos++;
1798 : }
1799 : }
1800 :
1801 : /* calculate scale */
1802 29755 : if ( actualt > 0 )
1803 : {
1804 29755 : scale = pulsesnum / actualt;
1805 : }
1806 : else
1807 : {
1808 0 : scale = FLT_MAX;
1809 : }
1810 29755 : *qscale = scale;
1811 29755 : *nzpout = nzpos;
1812 :
1813 29755 : if ( ( nzpos != pulsesnum && nzpos > 1 ) && noTCQ == 0 )
1814 : {
1815 40 : terminate = 1;
1816 40 : TCQnew( quants, scale, size, magn, pulsesnum, &pulsescurr, &nzposcurr, savedstates, &lasttrellislevel, terminate );
1817 :
1818 40 : if ( pulsesnum > pulsescurr )
1819 : {
1820 2 : scale *= 1.1f;
1821 : }
1822 :
1823 40 : if ( pulsesnum < pulsescurr )
1824 : {
1825 0 : scale *= 0.9f;
1826 : }
1827 40 : if ( pulsesnum > pulsescurr )
1828 : {
1829 2 : diff = pulsesnum - pulsescurr;
1830 :
1831 3 : for ( i = size - 1; i >= 0; i-- )
1832 : {
1833 3 : if ( fabs( magn[i] ) > 0 )
1834 : {
1835 2 : sign = ( magn[i] > 0 ) ? ( 1 ) : ( -1 );
1836 2 : magn[i] = (float) ( sign * ( fabs( magn[i] ) + diff ) );
1837 :
1838 2 : break;
1839 : }
1840 : }
1841 : }
1842 38 : else if ( pulsesnum < pulsescurr )
1843 : {
1844 0 : diff = pulsescurr - pulsesnum;
1845 :
1846 0 : for ( i = size - 1; i >= 0 && diff > 0; i-- )
1847 : {
1848 0 : if ( fabs( magn[i] ) > 0 )
1849 : {
1850 0 : sign = ( magn[i] > 0 ) ? ( 1 ) : ( -1 );
1851 0 : m_int = (int32_t) fabs( magn[i] );
1852 :
1853 0 : if ( diff < m_int )
1854 : {
1855 0 : magn[i] = (float) ( sign * ( fabs( magn[i] ) - diff ) );
1856 0 : break;
1857 : }
1858 : else
1859 : {
1860 0 : diff = diff - m_int;
1861 0 : magn[i] = 0;
1862 0 : nzposcurr--;
1863 : }
1864 : }
1865 : }
1866 : }
1867 :
1868 40 : pulsescurr = pulsesnum;
1869 :
1870 : /* Magnitudes coding */
1871 : {
1872 40 : leftp = pulsescurr; /*pulsesnum; */
1873 40 : leftnz = nzposcurr; /*nzpos; */
1874 40 : trellislevel = 0;
1875 :
1876 310 : for ( i = 0; i < size && leftnz > 1; i++ )
1877 : {
1878 270 : if ( magn[i] != 0.0f )
1879 : {
1880 138 : for ( j = 0; j < leftp; j++ )
1881 : {
1882 138 : prob1 = ( leftnz - 1.0f ) / ( leftp - j - 1.0f );
1883 138 : prob0 = 1.0f - prob1;
1884 :
1885 138 : st = savedstates[trellislevel];
1886 138 : quantum1 = (float) quantize( (float) ( j + 1 ), ddec[st][0] );
1887 138 : quantum2 = (float) quantize( (float) ( j + 1 ), ddec[st][1] );
1888 :
1889 138 : if ( quantum1 != ( j + 1 ) && quantum2 != ( j + 1 ) )
1890 : {
1891 : /* this magnitude is not possible so set probabilities */
1892 33 : prob0 = 1.0f;
1893 33 : prob1 = 0.0f;
1894 : }
1895 :
1896 138 : if ( j < fabs( magn[i] ) - 1 )
1897 : {
1898 43 : magnbits -= log2_f( prob0 );
1899 : }
1900 : else
1901 : {
1902 95 : magnbits -= log2_f( prob1 );
1903 95 : break;
1904 : }
1905 : }
1906 :
1907 95 : leftnz--;
1908 95 : leftp -= (int32_t) fabs( magn[i] );
1909 : }
1910 :
1911 270 : trellislevel++;
1912 : }
1913 :
1914 : /* Update actual occured surplus */
1915 40 : *nzpout = nzposcurr;
1916 : }
1917 : }
1918 :
1919 29755 : if ( *nzpout > 1 && bcount != NULL )
1920 : {
1921 17908 : flag_g1 = 0;
1922 :
1923 181260 : for ( i = 0; i < size; i++ )
1924 : {
1925 163352 : if ( fabs( magn[i] ) > 1.0f )
1926 : {
1927 13738 : flag_g1 = 1;
1928 : }
1929 : }
1930 : /* prepare vector for TCQ */
1931 66575 : for ( i = 0; i < size && flag_g1 && *bcount < 2 * TCQ_AMP; i++ )
1932 : {
1933 48667 : if ( fabs( magn[i] ) > 0.0f )
1934 : {
1935 26852 : abuffer[*bcount] = quants[i];
1936 26852 : mbuffer[*bcount] = magn[i];
1937 26852 : sbuffer[*bcount] = scale;
1938 :
1939 26852 : ( *bcount )++;
1940 : }
1941 : }
1942 : }
1943 :
1944 29755 : if ( actualt > 0 )
1945 : {
1946 29755 : *qscale = pulsesnum / actualt;
1947 : }
1948 : else
1949 : {
1950 0 : *qscale = FLT_MAX;
1951 : }
1952 : }
1953 :
1954 31335 : return magnbits;
1955 : }
1956 :
1957 :
1958 3952 : void InitLSBTCQ(
1959 : int16_t *bcount )
1960 : {
1961 3952 : *bcount = 0;
1962 :
1963 3952 : return;
1964 : }
1965 :
1966 :
1967 1976 : void TCQLSB(
1968 : int16_t bcount,
1969 : float *abuffer,
1970 : float *mbuffer,
1971 : float *sbuffer,
1972 : int16_t *dpath )
1973 : {
1974 : int16_t i, st, dminpos, position;
1975 1976 : float q = QTCQ;
1976 : float dmin, curdist1, curdist2, newdist1, newdist2;
1977 : float metric[STATES_LSB][TCQ_LSB_SIZE];
1978 : int16_t path[STATES_LSB][TCQ_LSB_SIZE];
1979 : int16_t quant[STATES_LSB][TCQ_LSB_SIZE];
1980 : int16_t dquant[STATES_LSB][TCQ_LSB_SIZE];
1981 : int16_t qout[TCQ_LSB_SIZE];
1982 : float q1, q2, s1, s2, a1, a2, sign1, sign2;
1983 : float dbuffer[MAX_PULSES];
1984 :
1985 1976 : set_f( *metric, 0.0f, STATES_LSB * TCQ_LSB_SIZE );
1986 1976 : set_s( *path, 0, STATES_LSB * TCQ_LSB_SIZE );
1987 1976 : set_s( *quant, 0, STATES_LSB * TCQ_LSB_SIZE );
1988 1976 : set_s( *dquant, 0, STATES_LSB * TCQ_LSB_SIZE );
1989 1976 : set_s( qout, 0, TCQ_LSB_SIZE );
1990 1976 : set_f( dbuffer, 0.0f, MAX_PULSES );
1991 :
1992 1976 : metric[1][0] = 16777216.0f;
1993 1976 : metric[2][0] = 16777216.0f;
1994 1976 : metric[3][0] = 16777216.0f;
1995 :
1996 21736 : for ( i = 0; i < 2 * TCQ_AMP; i += 2 )
1997 : {
1998 19760 : q1 = mbuffer[i];
1999 19760 : q2 = mbuffer[i + 1];
2000 :
2001 19760 : s1 = sbuffer[i];
2002 19760 : s2 = sbuffer[i + 1];
2003 :
2004 19760 : a1 = abuffer[i];
2005 19760 : a2 = abuffer[i + 1];
2006 :
2007 : /* cycle over conditions */
2008 98800 : for ( st = 0; st < 4; st++ )
2009 : {
2010 79040 : curdist1 = metric[step_LSB[st][0]][i / 2];
2011 79040 : curdist2 = metric[step_LSB[st][1]][i / 2];
2012 :
2013 : /* step 1 */
2014 79040 : sign1 = ( denc_LSB[st][0] & 0x1 ) ? ( q ) : ( -q );
2015 79040 : sign2 = ( denc_LSB[st][0] & 0x2 ) ? ( q ) : ( -q );
2016 79040 : newdist1 = ( a1 - ( q1 + sign1 ) / s1 ) * ( a1 - ( q1 + sign1 ) / s1 ) + ( a2 - ( q2 + sign2 ) / s2 ) * ( a2 - ( q2 + sign2 ) / s2 );
2017 :
2018 : /* step 2 */
2019 79040 : sign1 = ( denc_LSB[st][1] & 0x1 ) ? ( q ) : ( -q );
2020 79040 : sign2 = ( denc_LSB[st][1] & 0x2 ) ? ( q ) : ( -q );
2021 79040 : newdist2 = ( a1 - ( q1 + sign1 ) / s1 ) * ( a1 - ( q1 + sign1 ) / s1 ) + ( a2 - ( q2 + sign2 ) / s2 ) * ( a2 - ( q2 + sign2 ) / s2 );
2022 :
2023 : /* decision */
2024 79040 : if ( curdist1 + newdist1 < curdist2 + newdist2 )
2025 : {
2026 36707 : path[st][i / 2 + 1] = step_LSB[st][0];
2027 36707 : metric[st][i / 2 + 1] = curdist1 + newdist1;
2028 36707 : quant[st][i / 2 + 1] = 0;
2029 36707 : dquant[st][i / 2 + 1] = dqnt_LSB[step_LSB[st][0]][st];
2030 : }
2031 : else
2032 : {
2033 42333 : path[st][i / 2 + 1] = step_LSB[st][1];
2034 42333 : metric[st][i / 2 + 1] = curdist2 + newdist2;
2035 42333 : quant[st][i / 2 + 1] = 1;
2036 42333 : dquant[st][i / 2 + 1] = dqnt_LSB[step_LSB[st][0]][st];
2037 : }
2038 : }
2039 : }
2040 :
2041 : /* Find path with minimal metric */
2042 1976 : dminpos = 0;
2043 1976 : dmin = metric[dminpos][i / 2];
2044 7904 : for ( st = 1; st < 4; st++ )
2045 : {
2046 5928 : if ( dmin > metric[st][i / 2] )
2047 : {
2048 938 : dmin = metric[st][i / 2];
2049 938 : dminpos = st;
2050 : }
2051 : }
2052 :
2053 : /* Trace back to get output */
2054 1976 : position = dminpos;
2055 :
2056 23712 : for ( ; i >= 0; i -= 2 )
2057 : {
2058 21736 : qout[i / 2] = quant[position][i / 2 + 1];
2059 21736 : dpath[i / 2] = dquant[position][i / 2 + 1];
2060 :
2061 21736 : dbuffer[i] = ( denc_LSB[position][qout[i / 2]] & 0x1 ) ? ( q ) : ( -q );
2062 21736 : dbuffer[i + 1] = ( denc_LSB[position][qout[i / 2]] & 0x2 ) ? ( q ) : ( -q );
2063 :
2064 21736 : position = path[position][i / 2 + 1];
2065 : }
2066 :
2067 : /* add decoded sequence to quanta */
2068 28828 : for ( i = 0; i < bcount; i++ )
2069 : {
2070 26852 : mbuffer[i] += dbuffer[i];
2071 : }
2072 :
2073 1976 : return;
2074 : }
2075 :
2076 2044 : void TCQLSBdec(
2077 : int16_t *dpath,
2078 : float *mbuffer,
2079 : int16_t bcount )
2080 : {
2081 2044 : float q = QTCQ;
2082 2044 : int16_t i, state = 0;
2083 :
2084 19594 : for ( i = 0; i < bcount / 2; i++ )
2085 : {
2086 17550 : mbuffer[2 * i] = ( ddec_LSB[state][dpath[i]] & 0x1 ) ? ( q ) : ( -q );
2087 17550 : mbuffer[2 * i + 1] = ( ddec_LSB[state][dpath[i]] & 0x2 ) ? ( q ) : ( -q );
2088 :
2089 17550 : state = dstep_LSB[state][dpath[i]];
2090 : }
2091 :
2092 2044 : return;
2093 : }
2094 :
2095 1976 : void SaveTCQdata(
2096 : PARCODEC arInst,
2097 : int16_t *dpath,
2098 : int16_t bcount )
2099 : {
2100 : int16_t i;
2101 :
2102 18826 : for ( i = 0; i < bcount; i++ )
2103 : {
2104 16850 : ar_encode_uniform( arInst, dpath[i], 1 );
2105 : }
2106 :
2107 1976 : return;
2108 : }
2109 :
2110 2044 : void LoadTCQdata(
2111 : PARCODEC arInst,
2112 : int16_t *dpath,
2113 : int16_t bcount )
2114 : {
2115 : int16_t i;
2116 :
2117 19594 : for ( i = 0; i < bcount; i++ )
2118 : {
2119 17550 : dpath[i] = (int16_t) ar_decode( arInst, uniform_model );
2120 : }
2121 :
2122 2044 : return;
2123 : }
2124 :
2125 32403 : void RestoreTCQdec(
2126 : int32_t *magn,
2127 : int16_t size,
2128 : int16_t *bcount,
2129 : float *mbuffer )
2130 : {
2131 32403 : int16_t i, nzpos = 0, flag_g1 = 0;
2132 :
2133 : /* calculate actual nz positions */
2134 432593 : for ( i = 0, nzpos = 0; i < size; i++ )
2135 : {
2136 400190 : if ( magn[i] != 0 )
2137 : {
2138 73903 : nzpos++;
2139 73903 : if ( abs( magn[i] ) > 1 )
2140 : {
2141 17359 : flag_g1 = 1;
2142 : }
2143 73903 : magn[i] *= (int32_t) ( 1.0f / QTCQ );
2144 : }
2145 : }
2146 :
2147 32403 : if ( nzpos > 1 )
2148 : {
2149 77210 : for ( i = 0; i < size && flag_g1 && *bcount < 2 * TCQ_AMP; i++ )
2150 : {
2151 56650 : if ( magn[i] != 0 )
2152 : {
2153 31055 : mbuffer[*bcount] = magn[i] + ( 1.0f / QTCQ ) * mbuffer[*bcount];
2154 31055 : magn[i] = round_f( mbuffer[*bcount] );
2155 31055 : ( *bcount )++;
2156 : }
2157 : }
2158 : }
2159 :
2160 32403 : return;
2161 : }
2162 :
2163 :
2164 27934 : void RestoreTCQ(
2165 : float *magn,
2166 : int16_t size,
2167 : int16_t *bcount,
2168 : float *mbuffer )
2169 : {
2170 27934 : int16_t i, nzpos = 0, flag_g1 = 0;
2171 :
2172 : /* calculate actual nz positions */
2173 379289 : for ( i = 0, nzpos = 0; i < size; i++ )
2174 : {
2175 351355 : if ( magn[i] != 0.0f )
2176 : {
2177 64302 : nzpos++;
2178 64302 : if ( fabs( magn[i] ) > 1.0f )
2179 : {
2180 14414 : flag_g1 = 1;
2181 : }
2182 : }
2183 : }
2184 :
2185 27934 : if ( nzpos > 1 )
2186 : {
2187 66575 : for ( i = 0; i < size && flag_g1 && *bcount < 2 * TCQ_AMP; i++ )
2188 : {
2189 48667 : if ( fabs( magn[i] ) > 0.0f )
2190 : {
2191 26852 : magn[i] = mbuffer[*bcount];
2192 26852 : ( *bcount )++;
2193 : }
2194 : }
2195 : }
2196 :
2197 27934 : return;
2198 : }
|
