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 88706 : Word32 Mult_32_16( Word32 a, Word16 b )
62 : {
63 : Word32 result;
64 : UWord16 lo;
65 : /* use Mpy_32_16_ss(): */
66 88706 : Mpy_32_16_ss( a, b, &result, &lo );
67 :
68 88706 : return result;
69 : }
70 :
71 : /* 32x32 multiply: */
72 52163 : Word32 Mult_32_32( Word32 a, Word32 b )
73 : {
74 : Word32 result;
75 : UWord32 lo;
76 : /* use Mpy_32_32_ss(): */
77 52163 : Mpy_32_32_ss( a, b, &result, &lo );
78 :
79 52163 : return result;
80 : }
81 :
82 6471 : 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 973935 : for ( i = 0; i < N; i++ )
91 : {
92 967464 : y[i] = a;
93 : }
94 :
95 6471 : return;
96 : }
97 :
98 324 : 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 2712 : for ( i = 0; i < N; i++ )
106 : {
107 2388 : y[i] = a;
108 : }
109 :
110 324 : return;
111 : }
112 :
113 18693 : Word32 ar_div(
114 : Word32 num,
115 : Word32 denum )
116 : {
117 : Word16 exp1, exp2, exp, i;
118 : Word32 varout;
119 : Word32 sign;
120 :
121 18693 : sign = L_and( L_xor( num, denum ), 0x80000000 );
122 :
123 18693 : num = L_abs( num );
124 18693 : denum = L_abs( denum );
125 :
126 18693 : if ( L_sub( num, denum ) < 0 || denum == 0 )
127 : {
128 1041 : return 0;
129 : }
130 17652 : else if ( L_sub( num, denum ) == 0 )
131 : {
132 0 : return 1;
133 : }
134 : else
135 : {
136 17652 : exp1 = norm_l( num );
137 17652 : exp2 = norm_l( denum );
138 17652 : exp = sub( exp2, exp1 );
139 17652 : denum = L_shl( denum, exp );
140 17652 : exp = add( exp, 1 );
141 17652 : varout = 0;
142 376812 : for ( i = 0; i < exp; i++ )
143 : {
144 359160 : num = L_sub( num, denum );
145 359160 : varout = L_shl( varout, 1 );
146 359160 : if ( num >= 0 )
147 : {
148 172433 : num = L_shl( num, 1 );
149 172433 : varout = L_add( varout, 1 );
150 : }
151 : else
152 : {
153 186727 : num = L_add( num, denum );
154 186727 : num = L_shl( num, 1 );
155 : }
156 : }
157 : }
158 :
159 17652 : if ( sign != 0 )
160 : {
161 0 : varout = L_negate( varout );
162 : }
163 :
164 17652 : return varout;
165 : }
166 :
167 136 : 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 3248 : for ( pos = 0; pos < length; pos++ )
179 : {
180 3112 : I[pos] = pos;
181 : }
182 :
183 3248 : for ( pos = 0; pos < length; pos++ )
184 : {
185 3112 : srt[pos] = linear[pos];
186 : }
187 :
188 : /* now iterate */
189 3112 : for ( pos = 0; pos < ( length - 1 ); pos++ )
190 : {
191 37572 : for ( npos = ( pos + 1 ); npos < length; npos++ )
192 : {
193 34596 : if ( L_sub( srt[npos], srt[pos] ) < 0 )
194 : {
195 13080 : idxMem = I[pos];
196 13080 : I[pos] = I[npos];
197 13080 : I[npos] = idxMem;
198 :
199 13080 : valMem = srt[pos];
200 13080 : srt[pos] = srt[npos];
201 13080 : srt[npos] = valMem;
202 : }
203 : }
204 : }
205 :
206 136 : return;
207 : }
208 :
209 9269 : 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 9269 : Word16 exp = 0;
218 9269 : Word32 mantissa_fx = 0;
219 :
220 9269 : if ( m == 0 )
221 : {
222 140 : return 0;
223 : }
224 :
225 43034 : for ( i = 0; i < min( m, n ); i++ )
226 : {
227 33905 : 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 33905 : 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 33905 : integer_fx = extract_h( logCoeff_fx ); /*Q0 */
231 33905 : 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 33905 : temp_fx1 = extract_h( L_shl( frac_fx32, 4 ) );
241 33905 : temp_fx2 = extract_l( L_and( frac_fx32, 0xfff ) ); /*Q16 */
242 :
243 33905 : frac_fx32 = L_add( L_mult( temp_fx2, 22708 ), Mult_32_16( L_mult0( temp_fx2, temp_fx2 ), 7864 ) ); /*Q32 */
244 33905 : frac_fx32 = L_add( 0x40000000, L_shr( frac_fx32, 2 ) ); /*30 */
245 :
246 33905 : exp1 = norm_l( pow_getbitsfrompulses_fx[temp_fx1] );
247 33905 : exp2 = norm_l( frac_fx32 );
248 33905 : frac_fx32 = Mult_32_32( L_shl( pow_getbitsfrompulses_fx[temp_fx1], exp1 ), L_shl( frac_fx32, exp2 ) ); /*21 + exp1 + 30 + exp2 - 31 */
249 33905 : frac_fx32 = L_shr( frac_fx32, exp1 + exp2 ) + 1; /*20 */
250 :
251 33905 : if ( sub( exp, integer_fx ) < 0 )
252 : {
253 29813 : mantissa_fx = L_shr( mantissa_fx, sub( integer_fx, exp ) );
254 29813 : mantissa_fx = L_add( mantissa_fx, frac_fx32 );
255 :
256 29813 : exp = integer_fx;
257 : }
258 : else
259 : {
260 4092 : mantissa_fx = L_add( mantissa_fx, L_shr( frac_fx32, sub( exp, integer_fx ) ) );
261 : }
262 33905 : if ( L_sub( mantissa_fx, 0x200000 ) >= 0 )
263 : {
264 7092 : exp++;
265 :
266 7092 : mantissa_fx = L_shr( mantissa_fx, 1 );
267 : }
268 : }
269 :
270 9129 : mantissa_fx = L_shl( mantissa_fx, 2 ); /*22 */
271 9129 : temp_fx1 = extract_h( mantissa_fx );
272 9129 : temp32 = L_shl( L_sub( mantissa_fx, L_deposit_h( temp_fx1 ) ), 15 ); /*31 */
273 9129 : exp1 = sub( norm_l( temp32 ), 1 );
274 9129 : temp32 = ar_div( L_shl( temp32, exp1 ), temp_fx1 ); /*31 + exp1 */
275 9129 : temp32 = L_shr( temp32, exp1 + 1 ); /*30 */
276 :
277 9129 : frac_fx32 = L_sub( 0x40000000, L_shr( temp32, 1 ) ); /*30 */
278 9129 : frac_fx32 = Mult_32_32( frac_fx32, temp32 ); /*29 */
279 9129 : frac_fx32 = L_shr( frac_fx32, 13 ); /*16 */
280 9129 : exp1 = norm_l( temp_fx1 );
281 9129 : temp_fx1 = Log2_norm_lc( L_shl( temp_fx1, exp1 ) ); /*15 */
282 9129 : frac_fx32 = frac_fx32 + Mult_32_32( frac_fx32, 950680361 ); /* frac_fx32 *= 1/ln(2) */
283 9129 : return L_add( L_deposit_h( exp ), L_add( L_shl( temp_fx1, 1 ), frac_fx32 ) );
284 : }
285 :
286 1647 : 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 1647 : Word16 stpos = 0, pos, ovrflag, temppos, storepos;
302 :
303 1647 : fxone = 32768;
304 1647 : fxp1 = 512 * 32768;
305 1647 : temppos = 0;
306 1647 : storepos = 0;
307 1647 : ovrflag = 0;
308 :
309 1647 : set16_fx( mode_num_nz, 0, TCQ_MAX_BAND_SIZE );
310 1647 : set16_fx( prob, 0, TCQ_MAX_BAND_SIZE );
311 :
312 23703 : for ( i = 0; i < size; i++ )
313 : {
314 22056 : position[i] = 0;
315 : }
316 :
317 1647 : if ( L_sub( npulses, 1 ) > 0 )
318 : {
319 1008 : btcq_fx = GetBitsFromPulses_fx( npulses, size );
320 4212 : for ( i = 0; i < L_min( npulses, size ); i++ )
321 : {
322 : /*calculate the probability of #nz */
323 :
324 3204 : pnzp_fx = L_sub( L_deposit_h( add( i, 1 ) ), btcq_fx );
325 3204 : 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 3204 : pnzp_fx = L_add( pnzp_fx, 917498 ); /*16 */
327 3204 : if ( L_sub( pnzp_fx, 0 ) > 0 )
328 : {
329 3183 : integer = extract_h( pnzp_fx );
330 3183 : frac = extract_l( L_shr( L_sub( pnzp_fx, L_deposit_h( integer ) ), 1 ) ); /*15 */
331 3183 : prob[i] = extract_h( L_shl( Pow2( integer, frac ), 16 ) ); /*0 */
332 3183 : if ( prob[i] == 0 )
333 : {
334 0 : prob[i] = 1;
335 : }
336 : }
337 : else
338 : {
339 21 : prob[i] = 1;
340 : }
341 : }
342 :
343 1008 : ar_make_model( prob, mode_num_nz, min( npulses, size ) );
344 1008 : *nz = add( 1, (Word16) ar_decode( pardec, mode_num_nz ) ); /*get #nz */
345 1008 : nzp = *nz;
346 :
347 1008 : if ( nzp == 1 )
348 : {
349 : Word16 tmp;
350 123 : mode_num_nz[0] = MAX_AR_FREQ;
351 1230 : for ( i = 0; i < size; i++ )
352 : {
353 1107 : tmp = div_l( L_deposit_h( size - i - 1 ), size );
354 1107 : mode_num_nz[i + 1] = round_fx( L_shr( L_deposit_h( tmp ), 1 ) );
355 : }
356 :
357 123 : position[ar_decode( pardec, mode_num_nz )] = 1;
358 : }
359 : else
360 : {
361 : Word16 tmp;
362 885 : mode_num_nz[0] = MAX_AR_FREQ;
363 :
364 3186 : for ( ; nzp > 0; nzp-- )
365 : {
366 2301 : scp = fxp1;
367 2301 : temppos = 0;
368 2301 : storepos = 0;
369 :
370 20028 : for ( i = stpos; i < size; i++ )
371 : {
372 19143 : ovrflag = 0;
373 :
374 19143 : if ( nzp == ( size - i ) )
375 : {
376 2301 : cp = 0;
377 : }
378 : else
379 : {
380 16842 : tmp = div_l( L_deposit_h( nzp ), ( size - i ) );
381 16842 : cp = L_sub( fxone, tmp );
382 : }
383 19143 : scp = Mult_32_16( scp, extract_l( cp ) );
384 19143 : mode_num_nz[i + 1 - storepos - stpos] = round_fx( L_shl( scp, 6 ) );
385 :
386 19143 : 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 1416 : ovrflag = 1;
389 1416 : temppos = (Word16) ar_decode( pardec, mode_num_nz );
390 1416 : storepos += temppos;
391 1416 : scp = fxp1;
392 :
393 1416 : if ( temppos == i - stpos ) /* esc transmitted */
394 : {
395 0 : i--;
396 : }
397 : else
398 : {
399 1416 : break;
400 : }
401 : }
402 : }
403 2301 : if ( !ovrflag )
404 : {
405 885 : pos = (Word16) ar_decode( pardec, mode_num_nz ) + storepos;
406 : }
407 : else
408 : {
409 1416 : pos = storepos;
410 : }
411 :
412 2301 : position[stpos + pos] = 1;
413 2301 : stpos += pos + 1;
414 : }
415 : }
416 : }
417 639 : else if ( L_sub( npulses, 1 ) == 0 )
418 : {
419 : Word16 tmp;
420 555 : *nz = npulses;
421 555 : nzp = *nz;
422 555 : mode_num_nz[0] = MAX_AR_FREQ;
423 9474 : for ( i = 0; i < size; i++ )
424 : {
425 8919 : tmp = div_l( L_deposit_h( size - i - 1 ), size );
426 8919 : mode_num_nz[i + 1] = round_fx( L_shr( L_deposit_h( tmp ), 1 ) );
427 : }
428 :
429 555 : position[ar_decode( pardec, mode_num_nz )] = 1;
430 : }
431 : else
432 : {
433 84 : *nz = 0;
434 : }
435 :
436 1647 : return;
437 : }
438 :
439 :
440 1647 : 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 1647 : Word16 magns[TCQ_MAX_BAND_SIZE], magncout = 0;
450 :
451 1647 : Word16 storemagn, ovrflag, pos, tempmagn = 0, mmodel[MAX_PULSES + 2];
452 : Word32 cp, scp, fxone, fxp1;
453 :
454 1647 : fxone = 32768;
455 1647 : fxp1 = 512 * 32768;
456 1647 : ovrflag = 0;
457 :
458 :
459 1647 : set16_fx( magns, 1, TCQ_MAX_BAND_SIZE );
460 1647 : if ( sub( nzpos, npulses ) == 0 )
461 : {
462 19761 : for ( i = 0; i < size; i++ )
463 : {
464 18561 : out[i] = positions[i];
465 : }
466 1200 : return;
467 : }
468 447 : else if ( sub( nzpos, 1 ) == 0 )
469 : {
470 717 : for ( i = 0; i < size; i++ )
471 : {
472 717 : if ( positions[i] != 0 )
473 : {
474 123 : out[i] = npulses;
475 123 : return;
476 : }
477 : }
478 : }
479 :
480 324 : magnzp = sub( nzpos, 1 );
481 324 : magnp = sub( npulses, 1 );
482 :
483 324 : magncout = 0;
484 :
485 324 : set32_fx( out, 0, size );
486 324 : set16_fx( mmodel, 0, MAX_PULSES + 2 );
487 :
488 324 : mmodel[0] = MAX_AR_FREQ;
489 324 : magncout = 0;
490 1059 : for ( pos = 0; pos < size; pos++ )
491 : {
492 1059 : scp = fxp1;
493 1059 : if ( positions[pos] != 0 )
494 : {
495 594 : storemagn = 0;
496 :
497 2799 : for ( i = 0; i < magnp; i++ )
498 : {
499 2526 : ovrflag = 0;
500 :
501 2526 : if ( magnzp == ( magnp - i ) )
502 : {
503 594 : cp = 0;
504 : }
505 : else
506 : {
507 : Word16 tmp;
508 1932 : tmp = div_l( L_deposit_h( magnzp ), magnp - i );
509 1932 : cp = L_sub( fxone, tmp );
510 : }
511 :
512 2526 : if ( cp == fxone )
513 : {
514 0 : break;
515 : }
516 :
517 2526 : scp = Mult_32_16( scp, extract_l( cp ) );
518 2526 : mmodel[i + 1 - storemagn] = round_fx( L_shl( scp, 6 ) );
519 :
520 2526 : if ( ( mmodel[i + 1 - storemagn] == 0 && scp > 0 ) || mmodel[i - storemagn] == mmodel[i + 1 - storemagn] )
521 : {
522 321 : mmodel[i + 1 - storemagn] = 0;
523 : /* read data */
524 321 : tempmagn = (Word16) ar_decode( pardec, mmodel );
525 321 : storemagn += tempmagn;
526 :
527 321 : if ( tempmagn < i )
528 : {
529 : /* just magnitude */
530 321 : ovrflag = 1;
531 321 : break;
532 : }
533 : else
534 : {
535 : /* esc code */
536 0 : scp = fxp1;
537 0 : i--;
538 : }
539 : }
540 : }
541 :
542 594 : if ( ovrflag )
543 : {
544 321 : out[magncout] = storemagn + 1;
545 : }
546 : else
547 : {
548 273 : out[magncout] = ar_decode( pardec, mmodel ) + storemagn + 1;
549 : }
550 594 : magnp -= (Word16) out[magncout];
551 594 : magnzp--;
552 594 : magncout++;
553 :
554 594 : if ( magnzp == 0 ) /* last magnitude generation */
555 : {
556 504 : for ( pos = pos + 1; pos < size; pos++ )
557 : {
558 504 : if ( positions[pos] != 0 )
559 : {
560 273 : out[magncout] = magnp + 1;
561 273 : return;
562 : }
563 : else
564 : {
565 231 : out[magncout] = 0;
566 231 : magncout++;
567 : }
568 : }
569 : }
570 321 : else if ( magnzp == magnp ) /* rest magnitudes generation */
571 : {
572 270 : for ( pos = pos + 1; pos < size; pos++ )
573 : {
574 219 : out[magncout] = positions[pos];
575 219 : magncout++;
576 : }
577 51 : return;
578 : }
579 : }
580 : else
581 : {
582 465 : out[magncout] = 0;
583 465 : magncout++;
584 : }
585 : }
586 :
587 0 : return;
588 : }
589 :
590 0 : static Word16 quantize_fx(
591 : Word16 val,
592 : Word16 D )
593 : {
594 : Word16 qval4_fx;
595 : Word16 retval_fx;
596 :
597 0 : qval4_fx = shr( abs_s( add( val, 512 ) ), 12 );
598 0 : retval_fx = add( shl( qval4_fx, 2 ), DDP_fx[D] );
599 : /* 2nd zero check */
600 0 : if ( D == 0 )
601 : {
602 0 : if ( sub( abs_s( sub( shl( abs_s( retval_fx ), 10 ), abs_s( val ) ) ), abs_s( val ) ) > 0 )
603 : {
604 0 : retval_fx = 0;
605 : }
606 : }
607 :
608 0 : return retval_fx;
609 : }
610 :
611 0 : 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 0 : Word16 leftp = npulses; /*pulsesnum; */
627 0 : Word16 leftnz = nzpos; /*nzpos; */
628 0 : Word16 magn_mode[3] = { MAX_AR_FREQ, 0, 0 };
629 :
630 0 : bits_fx = 0;
631 0 : tcq_bits_fx = L_sub( table_logcum_fx[npulses], L_add( table_logcum_fx[nzpos], table_logcum_fx[npulses - ( nzpos - 1 )] ) );
632 :
633 0 : if ( sub( nzpos, npulses ) == 0 )
634 : {
635 0 : for ( i = 0; i < size; i++ )
636 : {
637 0 : out[i] = positions[i];
638 : }
639 :
640 0 : return;
641 : }
642 0 : else if ( sub( nzpos, 1 ) == 0 )
643 : {
644 0 : for ( i = 0; i < size; i++ )
645 : {
646 0 : if ( positions[i] != 0 )
647 : {
648 0 : out[i] = npulses;
649 0 : return;
650 : }
651 : }
652 : }
653 0 : st = 0;
654 0 : for ( i = 0; i < size && leftnz > 1; i++ )
655 : {
656 0 : out[i] = positions[i];
657 0 : if ( positions[i] != 0 )
658 : {
659 : /*generate the trellis path */
660 0 : symbol = 0;
661 0 : for ( j = 0; j < leftp; j++ )
662 : {
663 0 : num = sub( leftnz, 1 );
664 0 : denum = sub( leftp, add( j, 1 ) );
665 0 : if ( sub( num, denum ) >= 0 )
666 : {
667 0 : prob1_fx = MAX_16;
668 0 : prob0_fx = 0;
669 : }
670 : else
671 : {
672 0 : exp1 = sub( norm_s( num ), 1 );
673 0 : exp2 = norm_s( denum );
674 0 : prob1_fx = div_s( shl( num, exp1 ), shl( denum, exp2 ) ); /*15 + exp1 - exp2 */
675 0 : exp = 15 + exp1 - exp2;
676 0 : prob1_fx = shl( prob1_fx, sub( 15, exp ) );
677 0 : prob0_fx = sub( MAX_16, prob1_fx );
678 : }
679 0 : if ( L_sub( sub( leftp, j ), leftnz ) == 0 )
680 : {
681 0 : symbol = add( j, 1 );
682 0 : break;
683 : }
684 :
685 0 : quantum1_fx = quantize_fx( shl( add( j, 1 ), 10 ), ddec[st][0] );
686 0 : quantum2_fx = quantize_fx( shl( add( j, 1 ), 10 ), ddec[st][1] );
687 :
688 0 : if ( sub( quantum1_fx, add( j, 1 ) ) != 0 && sub( quantum2_fx, add( j, 1 ) ) != 0 )
689 : {
690 0 : prob0_fx = MAX_16;
691 0 : move16();
692 0 : prob1_fx = 0;
693 0 : move16();
694 : }
695 0 : if ( sub( prob0_fx, MAX_16 ) == 0 || sub( prob1_fx, MAX_16 ) == 0 )
696 : {
697 0 : symbol = add( j, 1 );
698 0 : continue;
699 : }
700 :
701 : /*magn_mode[1] = (int16_t)(prob1 * MAX_AR_FREQ); */
702 0 : magn_mode[1] = mult( prob1_fx, MAX_AR_FREQ );
703 :
704 0 : if ( ar_decode( pardec, magn_mode ) )
705 : {
706 0 : exp1 = norm_s( prob1_fx );
707 0 : tmp32 = L_deposit_h( shl( prob1_fx, exp1 ) ); /*exp1 + 15 + 16 */
708 0 : tmp16 = Log2_norm_lc( tmp32 ); /*15 */
709 0 : bits_fx = L_sub( bits_fx, L_sub( tmp16, L_shl( add( exp1, 1 ), 15 ) ) ); /*15 */
710 :
711 0 : symbol = add( j, 1 );
712 0 : break;
713 : }
714 : else
715 : {
716 0 : exp1 = norm_s( prob0_fx );
717 0 : tmp32 = L_deposit_h( shl( prob0_fx, exp1 ) ); /*exp1 + 15 + 16 */
718 0 : tmp16 = Log2_norm_lc( tmp32 ); /*15 */
719 0 : bits_fx = L_sub( bits_fx, L_sub( tmp16, L_shl( add( exp1, 1 ), 15 ) ) ); /*15 */
720 : }
721 : }
722 0 : out[i] = symbol;
723 : /*leftp -= symbol; */
724 0 : leftp = sub( leftp, symbol );
725 0 : leftnz--;
726 : }
727 :
728 0 : quantum1_fx = quantize_fx( (Word16) out[i], ddec[st][0] );
729 0 : quantum2_fx = quantize_fx( (Word16) out[i], ddec[st][1] );
730 :
731 : /*generate the next state */
732 0 : if ( sub( quantum1_fx, (Word16) out[i] ) == 0 )
733 : {
734 0 : st = nextstate[st][0];
735 : }
736 : else
737 : {
738 0 : st = nextstate[st][1];
739 : }
740 : }
741 :
742 : /*generate the magnitudes */
743 0 : for ( ; i < size; i++ )
744 : {
745 0 : out[i] = 0;
746 0 : if ( positions[i] != 0 )
747 : {
748 0 : out[i] = add( sub( leftp, leftnz ), 1 );
749 : }
750 : }
751 :
752 0 : if ( sub( nzpos, npulses ) != 0 && sub( nzpos, 1 ) > 0 )
753 : {
754 : /*update the surplus */
755 0 : *surplus_fx = L_add( *surplus_fx, L_sub( tcq_bits_fx, L_shl( bits_fx, 1 ) ) );
756 : }
757 :
758 0 : return;
759 : }
760 :
761 2196 : Word16 GetScale_fx(
762 : Word16 blen,
763 : Word32 bits_fx /*Q16*/,
764 : Word32 *surplus_fx /*Q16*/
765 : )
766 : {
767 2196 : Word16 pulses = MAX_PULSES, p_est, exp, exp1, exp2, magicnum, tmp;
768 2196 : Word32 t, a, b, ab, estbits_fx = 0;
769 :
770 2196 : magicnum = 24773; /*Q17: 0.188992013101951f; */
771 :
772 2196 : t = L_shr( L_mult( magicnum, blen ), 2 );
773 2196 : exp = norm_l( t );
774 2196 : a = L_shl( 14 - exp, 15 ) + Log2_norm_lc( L_shl( t, exp ) );
775 :
776 2196 : exp1 = sub( norm_l( bits_fx ), 1 );
777 2196 : exp2 = norm_s( blen - 1 );
778 :
779 2196 : tmp = div_l( L_shl( bits_fx, exp1 ), shl( blen - 1, exp2 ) );
780 2196 : b = L_shr( L_deposit_l( tmp ), exp1 - exp2 );
781 :
782 2196 : ab = L_add( a, b );
783 :
784 2196 : p_est = extract_h( L_shl( Pow2( extract_l( L_shr( ab, 15 ) ), ab & 0x7FFF ), 16 ) ); /* enable saturation of pow2 result */
785 :
786 2196 : pulses = min( p_est, MAX_PULSES );
787 :
788 7712 : for ( ; pulses >= 0; pulses-- )
789 : {
790 7712 : estbits_fx = GetBitsFromPulses_fx( pulses, blen );
791 7712 : if ( L_sub( bits_fx, estbits_fx ) >= 0 )
792 : {
793 2196 : break;
794 : }
795 : }
796 :
797 2196 : if ( surplus_fx != NULL )
798 : {
799 2196 : *surplus_fx = L_add( *surplus_fx, L_sub( bits_fx, estbits_fx ) );
800 : }
801 :
802 2196 : return pulses;
803 : }
804 :
805 :
806 1647 : void decode_signs_fx(
807 : ARCODEC *pardec,
808 : Word16 size,
809 : Word32 *out )
810 : {
811 : Word16 i;
812 :
813 23703 : for ( i = 0; i < size; i++ )
814 : {
815 22056 : if ( out[i] != 0 )
816 : {
817 2979 : out[i] = ( ar_decode( pardec, uniform_model ) > 0 ) ? out[i] : -out[i];
818 : }
819 : }
820 :
821 1647 : return;
822 : }
823 :
824 549 : 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 549 : Word16 nz = 0, pulses = 0;
832 : Word16 prob[TCQ_MAX_BAND_SIZE];
833 : Word16 model_num_nz[TCQ_MAX_BAND_SIZE];
834 549 : float *cur_quants = quants;
835 : Word16 integer, frac;
836 549 : Word32 /*est_bits_frame_fx, */ btcq_fx = 0, bits_fx = 0, pnzp_fx;
837 : Word32 cp, scp, fxone, fxp1;
838 : Word16 pos;
839 :
840 549 : fxone = 32768;
841 549 : fxp1 = 512 * 32768;
842 :
843 549 : set16_fx( prob, 0, TCQ_MAX_BAND_SIZE );
844 549 : set16_fx( model_num_nz, 0, TCQ_MAX_BAND_SIZE );
845 :
846 7901 : for ( i = 0; i < size; i++ )
847 : {
848 7352 : pulses = add( pulses, abs_s( (int16_t) cur_quants[i] ) );
849 7352 : if ( cur_quants[i] != 0 )
850 : {
851 993 : nz++;
852 : }
853 : }
854 :
855 549 : btcq_fx = GetBitsFromPulses_fx( pulses, size );
856 : /* Estimate TCQ bits */
857 549 : bits_fx = L_sub( table_logcum_fx[size + 1], L_add( table_logcum_fx[nz + 1], table_logcum_fx[size - nz + 1] ) );
858 549 : 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 549 : 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 549 : bits_fx = L_sub( bits_fx, nz );
862 549 : *est_bits_frame_fx = L_add( *est_bits_frame_fx, bits_fx );
863 :
864 : /*caculate the #nz probability */
865 1802 : for ( i = 0; i < min( pulses, size ); i++ )
866 : {
867 1253 : pnzp_fx = L_sub( L_deposit_h( add( i, 1 ) ), btcq_fx );
868 :
869 1253 : 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 1253 : pnzp_fx = L_add( pnzp_fx, 917498 ); /*16 */
872 1253 : if ( L_sub( pnzp_fx, 0 ) > 0 )
873 : {
874 1246 : integer = extract_h( pnzp_fx );
875 1246 : frac = extract_l( L_shr( L_sub( pnzp_fx, L_deposit_h( integer ) ), 1 ) ); /*15 */
876 1246 : prob[i] = extract_h( L_shl( Pow2( integer, frac ), 16 ) ); /*0 */
877 :
878 : /*zero probability will incur problems in ar_make_model() */
879 1246 : if ( prob[i] == 0 )
880 : {
881 0 : prob[i] = 1;
882 : }
883 : }
884 : else
885 : {
886 7 : prob[i] = 1;
887 : }
888 : }
889 :
890 549 : ar_make_model( prob, model_num_nz, min( pulses, size ) );
891 :
892 549 : if ( sub( nz, 1 ) > 0 )
893 : {
894 295 : ar_encode( parenc, model_num_nz, nz - 1 ); /*encode #nz */
895 :
896 295 : scp = fxp1;
897 295 : pos = 0;
898 2869 : for ( i = 0; i < size && nz > 0; i++ )
899 : {
900 2574 : if ( nz == ( size - i ) )
901 : {
902 169 : cp = 0;
903 : }
904 : else
905 : {
906 : Word16 tmp;
907 2405 : tmp = div_l( L_deposit_h( nz ), ( size - i ) );
908 2405 : cp = L_sub( fxone, tmp );
909 : }
910 2574 : scp = Mult_32_16( scp, extract_l( cp ) );
911 2574 : model_num_nz[pos + 1] = round_fx( L_shl( scp, 6 ) );
912 :
913 2574 : 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 2574 : if ( cur_quants[i] != 0 )
924 : {
925 767 : ar_encode( parenc, model_num_nz, pos );
926 767 : pos = 0;
927 767 : scp = fxp1;
928 767 : nz--;
929 : }
930 : else
931 : {
932 1807 : pos++;
933 : }
934 : }
935 : }
936 254 : else if ( sub( nz, 1 ) == 0 )
937 : {
938 226 : if ( sub( pulses, 1 ) > 0 )
939 : {
940 : /*temp -= log2_f((float)(model_num_nz[nz-1] - model_num_nz[nz]) / MAX_AR_FREQ); */
941 41 : ar_encode( parenc, model_num_nz, 0 ); /*encode #nz */
942 : }
943 :
944 226 : pos = 0;
945 3568 : for ( i = 0; i < size; i++ )
946 : {
947 : Word16 tmp;
948 3342 : tmp = div_l( L_deposit_h( size - i - 1 ), size );
949 3342 : model_num_nz[i + 1] = round_fx( L_shr( L_deposit_h( tmp ), 1 ) );
950 :
951 3342 : if ( cur_quants[i] != 0 )
952 : {
953 226 : pos = i;
954 : }
955 : }
956 226 : ar_encode( parenc, model_num_nz, pos ); /* encode pos */
957 : }
958 549 : return bits_fx;
959 : }
960 :
961 :
962 0 : 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 0 : Word16 magn_mode[3] = { MAX_AR_FREQ, 0, 0 };
978 :
979 0 : Word16 leftp = npulses; /*pulsesnum; */
980 0 : Word16 leftnz = nzpos; /*nzpos; */
981 :
982 0 : bits_fx = 0;
983 :
984 0 : tcq_bits_fx = L_sub( table_logcum_fx[npulses], L_add( table_logcum_fx[nzpos], table_logcum_fx[npulses - ( nzpos - 1 )] ) );
985 :
986 0 : *est_frame_bits_fx = L_add( *est_frame_bits_fx, tcq_bits_fx );
987 :
988 0 : if ( sub( nzpos, npulses ) == 0 || sub( nzpos, 1 ) == 0 )
989 : {
990 0 : return bits_fx;
991 : }
992 :
993 0 : st = 0;
994 0 : for ( i = 0; i < size && leftnz > 1; i++ )
995 : {
996 0 : st = savedstates[i];
997 0 : if ( magn_fx[i] != 0 )
998 : {
999 0 : for ( j = 0; j < leftp; j++ )
1000 : {
1001 : /*calculate the two path probs point to next two states */
1002 0 : num = sub( leftnz, 1 );
1003 0 : denum = sub( leftp, add( j, 0x1 ) );
1004 0 : if ( sub( num, denum ) >= 0 )
1005 : {
1006 0 : prob1_fx = MAX_16;
1007 0 : prob0_fx = 0;
1008 : }
1009 : else
1010 : {
1011 0 : exp1 = sub( norm_s( num ), 1 );
1012 0 : exp2 = norm_s( denum );
1013 0 : prob1_fx = div_s( shl( num, exp1 ), shl( denum, exp2 ) ); /*15 + exp1 - exp2 */
1014 0 : exp = 15 + exp1 - exp2;
1015 0 : prob1_fx = shl( prob1_fx, sub( 15, exp ) );
1016 0 : prob0_fx = sub( MAX_16, prob1_fx );
1017 : }
1018 :
1019 0 : quantum1_fx = quantize_fx( shl( add( j, 1 ), 10 ), ddec[st][0] );
1020 0 : quantum2_fx = quantize_fx( shl( add( j, 1 ), 10 ), ddec[st][1] );
1021 :
1022 0 : if ( sub( quantum1_fx, add( j, 1 ) ) != 0 && sub( quantum2_fx, add( j, 1 ) ) != 0 )
1023 : {
1024 0 : prob0_fx = MAX_16;
1025 0 : prob1_fx = 0;
1026 : }
1027 0 : if ( sub( prob0_fx, MAX_16 ) == 0 || sub( prob1_fx, MAX_16 ) == 0 )
1028 : {
1029 0 : continue;
1030 : }
1031 :
1032 0 : magn_mode[1] = mult( prob1_fx, MAX_AR_FREQ );
1033 0 : if ( sub( j, sub( abs_s( (int16_t) magn_fx[i] ), 1 ) ) < 0 )
1034 : {
1035 0 : ar_encode( parenc, magn_mode, 0 );
1036 : }
1037 : else
1038 : {
1039 0 : if ( sub( leftp, j ) > leftnz )
1040 : {
1041 0 : ar_encode( parenc, magn_mode, 1 );
1042 : }
1043 0 : break;
1044 : }
1045 : }
1046 :
1047 0 : leftnz--;
1048 0 : leftp = sub( leftp, abs_s( (int16_t) magn_fx[i] ) );
1049 : }
1050 : }
1051 :
1052 0 : return bits_fx;
1053 : }
1054 :
1055 :
1056 549 : 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 549 : *est_frame_bits_fx = L_add( *est_frame_bits_fx, L_deposit_h( npos ) );
1066 7901 : for ( i = 0; i < size; i++ )
1067 : {
1068 7352 : if ( magn[i] != 0 )
1069 : {
1070 993 : sign = ( magn[i] > 0 ) ? 1 : 0;
1071 993 : ar_encode_uniform( parenc, (uint16_t) sign, 1 );
1072 : }
1073 : }
1074 :
1075 549 : return L_deposit_h( npos );
1076 : }
1077 :
1078 :
1079 549 : 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 549 : fxone = 32768;
1095 549 : fxp1 = 512 * 32768;
1096 :
1097 : /*estimate fac bits */
1098 549 : bits_fx = L_sub( table_logcum_fx[npulses], L_add( table_logcum_fx[nzpos], table_logcum_fx[npulses - nzpos + 1] ) );
1099 :
1100 549 : *est_frame_bits_fx = L_add( *est_frame_bits_fx, bits_fx );
1101 :
1102 549 : if ( sub( npulses, nzpos ) == 0 || sub( nzpos, 1 ) == 0 )
1103 : {
1104 441 : return bits_fx;
1105 : }
1106 108 : magnp = sub( npulses, 1 );
1107 108 : magnzp = sub( nzpos, 1 );
1108 :
1109 : /*generate the binary sequences of magnitudes */
1110 108 : k = 0;
1111 904 : for ( i = 0; i < size; i++ )
1112 : {
1113 796 : if ( magn_fx[i] != 0 )
1114 : {
1115 611 : for ( j = 0; j < abs_s( (int16_t) magn_fx[i] ) - 1; j++ )
1116 : {
1117 284 : magn_position[k++] = 0;
1118 : }
1119 327 : magn_position[k++] = 1;
1120 : }
1121 : }
1122 :
1123 108 : set16_fx( model_m, 0, MAX_PULSES + 2 );
1124 108 : scp = fxp1;
1125 108 : model_m[0] = MAX_AR_FREQ;
1126 108 : pos = 0;
1127 510 : for ( i = 0; i < npulses - 1 && magnzp > 0; i++ )
1128 : {
1129 402 : if ( magnzp == magnp )
1130 : {
1131 76 : cp = 0;
1132 : }
1133 : else
1134 : {
1135 : Word16 tmp;
1136 326 : tmp = div_l( L_deposit_h( magnzp ), magnp );
1137 326 : cp = L_sub( fxone, tmp );
1138 : }
1139 402 : scp = Mult_32_16( scp, extract_l( cp ) );
1140 402 : model_m[pos + 1] = round_fx( L_shl( scp, 6 ) );
1141 :
1142 402 : 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 402 : if ( magn_position[i] != 0 )
1154 : {
1155 219 : ar_encode( parenc, model_m, pos );
1156 219 : pos = 0;
1157 219 : magnzp--;
1158 219 : scp = fxp1;
1159 : }
1160 : else
1161 : {
1162 183 : pos++;
1163 : }
1164 :
1165 402 : magnp--;
1166 : }
1167 108 : return bits_fx;
1168 : }
1169 :
1170 :
1171 2920 : static void transmission_bits(
1172 : PARCODEC arInst,
1173 : int16_t bit )
1174 : {
1175 2920 : bitstream_save_bit( arInst->bsInst, bit );
1176 2920 : arInst->num_bits++;
1177 2920 : bit = !bit;
1178 :
1179 4635 : for ( ; arInst->bits_to_follow > 0 && arInst->num_bits < arInst->max_bits; arInst->bits_to_follow-- )
1180 : {
1181 1715 : bitstream_save_bit( arInst->bsInst, bit );
1182 1715 : arInst->num_bits++;
1183 : }
1184 :
1185 2920 : return;
1186 : }
1187 :
1188 34 : void ar_encoder_start(
1189 : PARCODEC arInst,
1190 : TCQ_PBITSTREAM bsInst,
1191 : int16_t max_bits )
1192 : {
1193 34 : arInst->bsInst = bsInst;
1194 :
1195 34 : arInst->low = 0;
1196 34 : arInst->high = AR_TOP;
1197 34 : arInst->bits_to_follow = 0;
1198 :
1199 34 : arInst->num_bits = 0;
1200 34 : arInst->max_bits = max_bits;
1201 :
1202 34 : return;
1203 : }
1204 :
1205 :
1206 2881 : 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 2881 : high = arInst->high;
1214 2881 : low = arInst->low;
1215 :
1216 2881 : symbol++;
1217 2881 : range = high - low + 1;
1218 :
1219 2881 : high = low + ( range * model[symbol - 1] ) / model[0] - 1;
1220 2881 : low = low + ( range * model[symbol] ) / model[0];
1221 :
1222 : for ( ;; )
1223 : {
1224 7448 : if ( high < AR_HALF )
1225 : {
1226 1373 : transmission_bits( arInst, 0 );
1227 : }
1228 : else
1229 : {
1230 6075 : if ( low >= AR_HALF )
1231 : {
1232 1513 : transmission_bits( arInst, 1 );
1233 :
1234 1513 : low -= AR_HALF;
1235 1513 : high -= AR_HALF;
1236 : }
1237 : else
1238 : {
1239 4562 : if ( low >= AR_FIRST && high < AR_THIRD )
1240 : {
1241 1681 : arInst->bits_to_follow++;
1242 :
1243 1681 : low -= AR_FIRST;
1244 1681 : high -= AR_FIRST;
1245 : }
1246 : else
1247 : {
1248 : break;
1249 : }
1250 : }
1251 : }
1252 :
1253 4567 : low = low << 1;
1254 4567 : high = ( high << 1 ) + 1;
1255 : }
1256 :
1257 2881 : arInst->high = high;
1258 2881 : arInst->low = low;
1259 :
1260 2881 : return;
1261 : }
1262 :
1263 :
1264 1333 : static void ar_encode_uniform(
1265 : PARCODEC arInst,
1266 : uint16_t data,
1267 : const int16_t bits )
1268 : {
1269 : int16_t i;
1270 :
1271 2666 : for ( i = 0; i < bits; i++ )
1272 : {
1273 1333 : ar_encode( arInst, uniform_model, data & 0x1 );
1274 1333 : data >>= 1;
1275 : }
1276 :
1277 1333 : return;
1278 : }
1279 :
1280 :
1281 34 : void ar_encoder_done(
1282 : PARCODEC arInst )
1283 : {
1284 34 : arInst->bits_to_follow++;
1285 34 : transmission_bits( arInst, arInst->low >= AR_FIRST );
1286 :
1287 34 : return;
1288 : }
1289 :
1290 :
1291 102 : void ar_decoder_start(
1292 : PARCODEC arInst,
1293 : TCQ_PBITSTREAM bsInst )
1294 : {
1295 : int16_t i;
1296 :
1297 102 : arInst->bsInst = bsInst;
1298 :
1299 102 : arInst->low = 0;
1300 102 : arInst->high = AR_TOP;
1301 102 : arInst->value = 0;
1302 :
1303 1734 : for ( i = 0; i < AR_BITS; i++ )
1304 : {
1305 1632 : arInst->value = ( arInst->value << 1 ) + bitstream_load_bit( arInst->bsInst );
1306 : }
1307 :
1308 102 : return;
1309 : }
1310 :
1311 :
1312 8580 : 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 8580 : range = (uint32_t) ( arInst->high - arInst->low ) + 1;
1321 8580 : cum = (int16_t) ( ( ( (uint32_t) ( arInst->value - arInst->low ) + 1 ) * model[0] - 1 ) / range );
1322 :
1323 22848 : for ( symbol = 1; model[symbol] > cum; symbol++ )
1324 : {
1325 : ;
1326 : }
1327 :
1328 8580 : arInst->high = arInst->low + ( range * model[symbol - 1] ) / model[0] - 1;
1329 8580 : arInst->low = arInst->low + ( range * model[symbol] ) / model[0];
1330 :
1331 : for ( ;; )
1332 : {
1333 22281 : if ( arInst->high >= AR_HALF )
1334 : {
1335 18162 : if ( arInst->low >= AR_HALF )
1336 : {
1337 4539 : arInst->value -= AR_HALF;
1338 4539 : arInst->low -= AR_HALF;
1339 4539 : arInst->high -= AR_HALF;
1340 : }
1341 : else
1342 : {
1343 13623 : if ( arInst->low >= AR_FIRST && arInst->high < AR_THIRD )
1344 : {
1345 5043 : arInst->value -= AR_FIRST;
1346 5043 : arInst->low -= AR_FIRST;
1347 5043 : arInst->high -= AR_FIRST;
1348 : }
1349 : else
1350 : {
1351 : break;
1352 : }
1353 : }
1354 : }
1355 13701 : arInst->low <<= 1;
1356 13701 : arInst->high = ( arInst->high << 1 ) + 1;
1357 13701 : arInst->value = ( arInst->value << 1 ) + bitstream_load_bit( arInst->bsInst );
1358 : }
1359 :
1360 8580 : return ( symbol - 1 );
1361 : }
1362 :
1363 102 : void ar_decoder_done(
1364 : PARCODEC arInst )
1365 : {
1366 102 : bitstream_rollback( arInst->bsInst, AR_BITS - 2 );
1367 :
1368 102 : return;
1369 : }
1370 :
1371 :
1372 1557 : 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 1557 : uint32_t sum = 0;
1379 1557 : uint32_t cum = 0;
1380 : int16_t i;
1381 :
1382 6014 : for ( i = 0; i < len; i++ )
1383 : {
1384 4457 : sum += freq[i];
1385 : }
1386 :
1387 1557 : if ( sum == 0 )
1388 : {
1389 28 : return 0;
1390 : }
1391 :
1392 1529 : for ( i = len;; i-- )
1393 : {
1394 5986 : model[i] = (int16_t) ( ( cum * MAX_AR_FREQ ) / sum );
1395 :
1396 5986 : if ( !i )
1397 : {
1398 1529 : break;
1399 : }
1400 :
1401 4457 : cum += freq[i - 1];
1402 : }
1403 :
1404 :
1405 4457 : for ( i = 0; i < len - 1; i++ )
1406 : {
1407 2928 : dist = model[i] - model[i + 1];
1408 :
1409 2928 : if ( dist <= 0 )
1410 : {
1411 0 : model[i + 1] += dist - 1;
1412 : }
1413 : }
1414 :
1415 5986 : for ( i = len; i; i-- )
1416 : {
1417 4457 : dist = model[i - 1] - model[i];
1418 :
1419 4457 : if ( dist <= 0 )
1420 : {
1421 0 : model[i - 1] -= dist - 1;
1422 : }
1423 : }
1424 :
1425 1529 : return ( model[0] > model[1] );
1426 : }
1427 :
1428 4635 : static void bitstream_save_bit(
1429 : TCQ_PBITSTREAM pBS,
1430 : const int16_t bit )
1431 : {
1432 : uint8_t cur;
1433 :
1434 4635 : cur = pBS->buf[pBS->numByte];
1435 :
1436 4635 : cur = (uint8_t) ( cur | ( bit << pBS->curPos-- ) );
1437 4635 : pBS->buf[pBS->numByte] = cur;
1438 4635 : pBS->numbits++;
1439 :
1440 4635 : if ( pBS->curPos < 0 )
1441 : {
1442 565 : pBS->curPos = 7;
1443 565 : pBS->numByte++;
1444 : }
1445 :
1446 4635 : return;
1447 : }
1448 :
1449 :
1450 15333 : 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 15333 : if ( pBS->numByte >= pBS->maxBytes )
1458 : {
1459 0 : return 0;
1460 : }
1461 :
1462 15333 : curPos = &pBS->curPos;
1463 15333 : bit = ( ( pBS->buf[pBS->numByte] >> ( *curPos )-- ) & 0x00000001 );
1464 :
1465 15333 : if ( *curPos < 0 )
1466 : {
1467 1875 : pBS->numByte++;
1468 1875 : *curPos = 7;
1469 : }
1470 :
1471 15333 : return bit;
1472 : }
1473 :
1474 :
1475 102 : static void bitstream_rollback(
1476 : TCQ_PBITSTREAM pBS,
1477 : int16_t numBits )
1478 : {
1479 1530 : while ( numBits > 0 )
1480 : {
1481 1428 : pBS->curPos++;
1482 1428 : pBS->numbits--;
1483 1428 : if ( pBS->curPos == 8 )
1484 : {
1485 180 : pBS->curPos = 0;
1486 180 : pBS->numByte--;
1487 : }
1488 1428 : numBits--;
1489 : }
1490 :
1491 102 : return;
1492 : }
1493 :
1494 :
1495 0 : 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 0 : qval4 = (int32_t) fabs( ( val + 0.5 ) / 4.0 );
1503 0 : retval = qval4 * 4.0f + DDP[D];
1504 :
1505 : /* 2nd zero check */
1506 0 : if ( D == 0 )
1507 : {
1508 0 : if ( fabs( fabs( retval ) - fabs( val ) ) > fabs( val ) )
1509 : {
1510 0 : retval = 0;
1511 : }
1512 : }
1513 :
1514 0 : return retval;
1515 : }
1516 :
1517 :
1518 0 : 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 0 : 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 0 : set_f( *metric, 0.0f, STATES * TCQ_MAX_BAND_SIZE );
1539 0 : set_s( *path, 0, STATES * TCQ_MAX_BAND_SIZE );
1540 0 : set_s( *quant, 0, STATES * TCQ_MAX_BAND_SIZE );
1541 0 : set_s( *pused, 0, STATES * TCQ_MAX_BAND_SIZE );
1542 :
1543 : /* Initialize metric */
1544 0 : for ( st = 1; st < STATES; st++ )
1545 : {
1546 0 : metric[st][0] = 1000;
1547 : }
1548 0 : for ( st = 2; st < STATES; st++ )
1549 : {
1550 0 : metric[st][1] = 1000;
1551 : }
1552 0 : for ( st = 4; st < STATES; st++ )
1553 : {
1554 0 : metric[st][2] = 1000;
1555 : }
1556 :
1557 : /* Viterbi for input sequence */
1558 0 : for ( i = 0; i < length; i++ ) /* cycle over symbols */
1559 : {
1560 0 : for ( st = 0; st < STATES; st++ ) /* cycle over conditions */
1561 : {
1562 0 : curdist1 = metric[step_tcq[st][0]][i];
1563 0 : curdist2 = metric[step_tcq[st][1]][i];
1564 :
1565 : /* step 1 */
1566 0 : quantum1 = quantize( v[i] * scale, denc[st][0] );
1567 0 : newdist1 = (float) ( quantum1 - fabs( v[i] ) * scale );
1568 0 : newdist1 *= newdist1;
1569 :
1570 0 : if ( quantum1 + pused[step_tcq[st][0]][i] > pulses && terminate )
1571 : {
1572 0 : newdist1 = 10000.0f; /* pulses check */
1573 : }
1574 :
1575 : /* step 2 */
1576 0 : quantum2 = quantize( v[i] * scale, denc[st][1] );
1577 0 : newdist2 = (float) ( quantum2 - fabs( v[i] ) * scale );
1578 0 : newdist2 *= newdist2;
1579 :
1580 0 : if ( quantum2 + pused[step_tcq[st][1]][i] > pulses && terminate )
1581 : {
1582 0 : newdist2 = 10000.0f; /* pulses check */
1583 : }
1584 :
1585 : /* decision */
1586 0 : if ( curdist1 + newdist1 < curdist2 + newdist2 )
1587 : {
1588 0 : path[st][i + 1] = step_tcq[st][0];
1589 0 : metric[st][i + 1] = curdist1 + newdist1;
1590 0 : quant[st][i + 1] = (int16_t) quantize( v[i] * scale, denc[st][0] );
1591 0 : pused[st][i + 1] = (int16_t) ( pused[step_tcq[st][0]][i] + abs( quant[st][i + 1] ) );
1592 : }
1593 : else
1594 : {
1595 0 : path[st][i + 1] = step_tcq[st][1];
1596 0 : metric[st][i + 1] = curdist2 + newdist2;
1597 0 : quant[st][i + 1] = (int16_t) quantize( v[i] * scale, denc[st][1] );
1598 0 : 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 0 : dminpos = 0;
1605 0 : dmin = metric[dminpos][length];
1606 0 : for ( i = 1; i < STATES; i++ )
1607 : {
1608 0 : if ( ( dmin > metric[i][length] && pused[i][length] == pulses ) ||
1609 0 : ( pused[dminpos][length] != pulses && pused[i][length] == pulses ) )
1610 : {
1611 0 : dmin = metric[i][length];
1612 0 : dminpos = i;
1613 : }
1614 : }
1615 :
1616 : /* Trace back to get output */
1617 0 : pulsesnum = 0;
1618 0 : position = dminpos;
1619 :
1620 0 : for ( i = length; i > 0; i-- )
1621 : {
1622 0 : signq = ( v[i - 1] > 0.0f ) ? ( 1.0f ) : ( -1.0f );
1623 0 : vout[i - 1] = signq * quant[position][i];
1624 :
1625 0 : position = path[position][i];
1626 0 : savedstates[i - 1] = position;
1627 :
1628 : /* calculate output pulses number & nz */
1629 0 : pulsesnum += (int16_t) fabs( vout[i - 1] ); /*quant[position][i]; */
1630 0 : if ( fabs( vout[i - 1] ) > 0.0f )
1631 : {
1632 0 : if ( nzpos == 0 )
1633 : {
1634 0 : *lasttrellislevel = i;
1635 : }
1636 :
1637 0 : nzpos++;
1638 : }
1639 : }
1640 :
1641 0 : if ( pulsesout != NULL )
1642 : {
1643 0 : *pulsesout = pulsesnum;
1644 : }
1645 0 : if ( nzposout != NULL )
1646 : {
1647 0 : *nzposout = nzpos;
1648 : }
1649 :
1650 0 : return;
1651 : }
1652 :
1653 :
1654 549 : 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 549 : 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 549 : float sx2 = 0, sy2 = 0, sxy = 0, g;
1677 549 : int32_t pn = 0;
1678 549 : float pt = 0.f;
1679 : int32_t diff;
1680 : int16_t sign;
1681 : int32_t m_int;
1682 : int8_t flag_g1;
1683 :
1684 549 : set_f( dist, 0.0f, TCQ_MAX_BAND_SIZE );
1685 549 : set_f( aquants, 0.0f, TCQ_MAX_BAND_SIZE );
1686 :
1687 549 : 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 549 : pulsesnum = GetScale_fx( size, bits_fx, surplus_fx );
1699 : }
1700 549 : *nzpout = 0;
1701 :
1702 549 : if ( pulses != NULL )
1703 : {
1704 549 : *pulses = (float) pulsesnum;
1705 : }
1706 :
1707 549 : if ( pulsesnum > 0 )
1708 : {
1709 : /* Initial quantization */
1710 7511 : for ( i = 0, m = 0; i < size; i++ )
1711 : {
1712 6990 : aquants[i] = (float) fabs( quants[i] );
1713 6990 : m += aquants[i];
1714 : }
1715 :
1716 521 : scale = ( pulsesnum + EPSILON ) / ( m + EPSILON );
1717 :
1718 7511 : for ( i = 0, t = 0.0f; i < size; i++ )
1719 : {
1720 6990 : magn[i] = (float) ( (int16_t) ( 0.5f + aquants[i] * scale ) );
1721 :
1722 6990 : t += magn[i];
1723 : }
1724 :
1725 : /* Pulses redistribution */
1726 1050 : while ( t != pulsesnum )
1727 : {
1728 529 : pn = 0;
1729 529 : pt = 0.f;
1730 :
1731 :
1732 9583 : for ( i = 0, nzpos = 0; i < size; i++ )
1733 : {
1734 9054 : if ( magn[i] > 0.0f )
1735 : {
1736 443 : pn += (int32_t) magn[i];
1737 443 : pt += aquants[i];
1738 : }
1739 : }
1740 :
1741 529 : direction = ( pulsesnum - t > 0 ) ? ( 1 ) : ( -1 );
1742 :
1743 : /* new alg */
1744 : {
1745 9583 : for ( i = 0; i < size; i++ )
1746 : {
1747 9054 : sxy += aquants[i] * magn[i];
1748 9054 : sx2 += aquants[i] * aquants[i];
1749 9054 : sy2 += magn[i] * magn[i];
1750 : }
1751 9583 : for ( i = 0; i < size; i++ )
1752 : {
1753 9054 : if ( magn[i] > 0.0f )
1754 : {
1755 443 : g = ( pt ) / ( pn + direction + EPSILON );
1756 : }
1757 : else
1758 : {
1759 8611 : g = ( pt + aquants[i] ) / ( pn + direction + EPSILON );
1760 : }
1761 :
1762 9054 : 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 529 : pos = 0;
1768 529 : dmin = dist[0];
1769 :
1770 : /* find min */
1771 9054 : for ( i = 1; i < size; i++ )
1772 : {
1773 8525 : if ( dmin > dist[i] )
1774 : {
1775 1327 : pos = i;
1776 1327 : dmin = dist[i];
1777 : }
1778 : }
1779 :
1780 529 : magn[pos] += direction;
1781 529 : t += direction;
1782 : }
1783 : }
1784 :
1785 : /* calculate actual nz positions */
1786 521 : actualt = 0.0f;
1787 7511 : for ( i = 0, nzpos = 0; i < size; i++ )
1788 : {
1789 6990 : if ( magn[i] > 0.0f )
1790 : {
1791 993 : if ( quants[i] < 0 )
1792 : {
1793 478 : magn[i] *= -1;
1794 : }
1795 :
1796 993 : actualt += aquants[i];
1797 993 : nzpos++;
1798 : }
1799 : }
1800 :
1801 : /* calculate scale */
1802 521 : if ( actualt > 0 )
1803 : {
1804 521 : scale = pulsesnum / actualt;
1805 : }
1806 : else
1807 : {
1808 0 : scale = FLT_MAX;
1809 : }
1810 521 : *qscale = scale;
1811 521 : *nzpout = nzpos;
1812 :
1813 521 : if ( ( nzpos != pulsesnum && nzpos > 1 ) && noTCQ == 0 )
1814 : {
1815 0 : terminate = 1;
1816 0 : TCQnew( quants, scale, size, magn, pulsesnum, &pulsescurr, &nzposcurr, savedstates, &lasttrellislevel, terminate );
1817 :
1818 0 : if ( pulsesnum > pulsescurr )
1819 : {
1820 0 : scale *= 1.1f;
1821 : }
1822 :
1823 0 : if ( pulsesnum < pulsescurr )
1824 : {
1825 0 : scale *= 0.9f;
1826 : }
1827 0 : if ( pulsesnum > pulsescurr )
1828 : {
1829 0 : diff = pulsesnum - pulsescurr;
1830 :
1831 0 : for ( i = size - 1; i >= 0; i-- )
1832 : {
1833 0 : if ( fabs( magn[i] ) > 0 )
1834 : {
1835 0 : sign = ( magn[i] > 0 ) ? ( 1 ) : ( -1 );
1836 0 : magn[i] = (float) ( sign * ( fabs( magn[i] ) + diff ) );
1837 :
1838 0 : break;
1839 : }
1840 : }
1841 : }
1842 0 : 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 0 : pulsescurr = pulsesnum;
1869 :
1870 : /* Magnitudes coding */
1871 : {
1872 0 : leftp = pulsescurr; /*pulsesnum; */
1873 0 : leftnz = nzposcurr; /*nzpos; */
1874 0 : trellislevel = 0;
1875 :
1876 0 : for ( i = 0; i < size && leftnz > 1; i++ )
1877 : {
1878 0 : if ( magn[i] != 0.0f )
1879 : {
1880 0 : for ( j = 0; j < leftp; j++ )
1881 : {
1882 0 : prob1 = ( leftnz - 1.0f ) / ( leftp - j - 1.0f );
1883 0 : prob0 = 1.0f - prob1;
1884 :
1885 0 : st = savedstates[trellislevel];
1886 0 : quantum1 = (float) quantize( (float) ( j + 1 ), ddec[st][0] );
1887 0 : quantum2 = (float) quantize( (float) ( j + 1 ), ddec[st][1] );
1888 :
1889 0 : if ( quantum1 != ( j + 1 ) && quantum2 != ( j + 1 ) )
1890 : {
1891 : /* this magnitude is not possible so set probabilities */
1892 0 : prob0 = 1.0f;
1893 0 : prob1 = 0.0f;
1894 : }
1895 :
1896 0 : if ( j < fabs( magn[i] ) - 1 )
1897 : {
1898 0 : magnbits -= log2_f( prob0 );
1899 : }
1900 : else
1901 : {
1902 0 : magnbits -= log2_f( prob1 );
1903 0 : break;
1904 : }
1905 : }
1906 :
1907 0 : leftnz--;
1908 0 : leftp -= (int32_t) fabs( magn[i] );
1909 : }
1910 :
1911 0 : trellislevel++;
1912 : }
1913 :
1914 : /* Update actual occured surplus */
1915 0 : *nzpout = nzposcurr;
1916 : }
1917 : }
1918 :
1919 521 : if ( *nzpout > 1 && bcount != NULL )
1920 : {
1921 295 : flag_g1 = 0;
1922 :
1923 3943 : for ( i = 0; i < size; i++ )
1924 : {
1925 3648 : if ( fabs( magn[i] ) > 1.0f )
1926 : {
1927 162 : flag_g1 = 1;
1928 : }
1929 : }
1930 : /* prepare vector for TCQ */
1931 1077 : for ( i = 0; i < size && flag_g1 && *bcount < 2 * TCQ_AMP; i++ )
1932 : {
1933 782 : if ( fabs( magn[i] ) > 0.0f )
1934 : {
1935 322 : abuffer[*bcount] = quants[i];
1936 322 : mbuffer[*bcount] = magn[i];
1937 322 : sbuffer[*bcount] = scale;
1938 :
1939 322 : ( *bcount )++;
1940 : }
1941 : }
1942 : }
1943 :
1944 521 : if ( actualt > 0 )
1945 : {
1946 521 : *qscale = pulsesnum / actualt;
1947 : }
1948 : else
1949 : {
1950 0 : *qscale = FLT_MAX;
1951 : }
1952 : }
1953 :
1954 549 : return magnbits;
1955 : }
1956 :
1957 :
1958 68 : void InitLSBTCQ(
1959 : int16_t *bcount )
1960 : {
1961 68 : *bcount = 0;
1962 :
1963 68 : return;
1964 : }
1965 :
1966 :
1967 34 : 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 34 : 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 34 : set_f( *metric, 0.0f, STATES_LSB * TCQ_LSB_SIZE );
1986 34 : set_s( *path, 0, STATES_LSB * TCQ_LSB_SIZE );
1987 34 : set_s( *quant, 0, STATES_LSB * TCQ_LSB_SIZE );
1988 34 : set_s( *dquant, 0, STATES_LSB * TCQ_LSB_SIZE );
1989 34 : set_s( qout, 0, TCQ_LSB_SIZE );
1990 34 : set_f( dbuffer, 0.0f, MAX_PULSES );
1991 :
1992 34 : metric[1][0] = 16777216.0f;
1993 34 : metric[2][0] = 16777216.0f;
1994 34 : metric[3][0] = 16777216.0f;
1995 :
1996 374 : for ( i = 0; i < 2 * TCQ_AMP; i += 2 )
1997 : {
1998 340 : q1 = mbuffer[i];
1999 340 : q2 = mbuffer[i + 1];
2000 :
2001 340 : s1 = sbuffer[i];
2002 340 : s2 = sbuffer[i + 1];
2003 :
2004 340 : a1 = abuffer[i];
2005 340 : a2 = abuffer[i + 1];
2006 :
2007 : /* cycle over conditions */
2008 1700 : for ( st = 0; st < 4; st++ )
2009 : {
2010 1360 : curdist1 = metric[step_LSB[st][0]][i / 2];
2011 1360 : curdist2 = metric[step_LSB[st][1]][i / 2];
2012 :
2013 : /* step 1 */
2014 1360 : sign1 = ( denc_LSB[st][0] & 0x1 ) ? ( q ) : ( -q );
2015 1360 : sign2 = ( denc_LSB[st][0] & 0x2 ) ? ( q ) : ( -q );
2016 1360 : newdist1 = ( a1 - ( q1 + sign1 ) / s1 ) * ( a1 - ( q1 + sign1 ) / s1 ) + ( a2 - ( q2 + sign2 ) / s2 ) * ( a2 - ( q2 + sign2 ) / s2 );
2017 :
2018 : /* step 2 */
2019 1360 : sign1 = ( denc_LSB[st][1] & 0x1 ) ? ( q ) : ( -q );
2020 1360 : sign2 = ( denc_LSB[st][1] & 0x2 ) ? ( q ) : ( -q );
2021 1360 : newdist2 = ( a1 - ( q1 + sign1 ) / s1 ) * ( a1 - ( q1 + sign1 ) / s1 ) + ( a2 - ( q2 + sign2 ) / s2 ) * ( a2 - ( q2 + sign2 ) / s2 );
2022 :
2023 : /* decision */
2024 1360 : if ( curdist1 + newdist1 < curdist2 + newdist2 )
2025 : {
2026 553 : path[st][i / 2 + 1] = step_LSB[st][0];
2027 553 : metric[st][i / 2 + 1] = curdist1 + newdist1;
2028 553 : quant[st][i / 2 + 1] = 0;
2029 553 : dquant[st][i / 2 + 1] = dqnt_LSB[step_LSB[st][0]][st];
2030 : }
2031 : else
2032 : {
2033 807 : path[st][i / 2 + 1] = step_LSB[st][1];
2034 807 : metric[st][i / 2 + 1] = curdist2 + newdist2;
2035 807 : quant[st][i / 2 + 1] = 1;
2036 807 : dquant[st][i / 2 + 1] = dqnt_LSB[step_LSB[st][0]][st];
2037 : }
2038 : }
2039 : }
2040 :
2041 : /* Find path with minimal metric */
2042 34 : dminpos = 0;
2043 34 : dmin = metric[dminpos][i / 2];
2044 136 : for ( st = 1; st < 4; st++ )
2045 : {
2046 102 : if ( dmin > metric[st][i / 2] )
2047 : {
2048 3 : dmin = metric[st][i / 2];
2049 3 : dminpos = st;
2050 : }
2051 : }
2052 :
2053 : /* Trace back to get output */
2054 34 : position = dminpos;
2055 :
2056 408 : for ( ; i >= 0; i -= 2 )
2057 : {
2058 374 : qout[i / 2] = quant[position][i / 2 + 1];
2059 374 : dpath[i / 2] = dquant[position][i / 2 + 1];
2060 :
2061 374 : dbuffer[i] = ( denc_LSB[position][qout[i / 2]] & 0x1 ) ? ( q ) : ( -q );
2062 374 : dbuffer[i + 1] = ( denc_LSB[position][qout[i / 2]] & 0x2 ) ? ( q ) : ( -q );
2063 :
2064 374 : position = path[position][i / 2 + 1];
2065 : }
2066 :
2067 : /* add decoded sequence to quanta */
2068 356 : for ( i = 0; i < bcount; i++ )
2069 : {
2070 322 : mbuffer[i] += dbuffer[i];
2071 : }
2072 :
2073 34 : return;
2074 : }
2075 :
2076 102 : void TCQLSBdec(
2077 : int16_t *dpath,
2078 : float *mbuffer,
2079 : int16_t bcount )
2080 : {
2081 102 : float q = QTCQ;
2082 102 : int16_t i, state = 0;
2083 :
2084 1122 : for ( i = 0; i < bcount / 2; i++ )
2085 : {
2086 1020 : mbuffer[2 * i] = ( ddec_LSB[state][dpath[i]] & 0x1 ) ? ( q ) : ( -q );
2087 1020 : mbuffer[2 * i + 1] = ( ddec_LSB[state][dpath[i]] & 0x2 ) ? ( q ) : ( -q );
2088 :
2089 1020 : state = dstep_LSB[state][dpath[i]];
2090 : }
2091 :
2092 102 : return;
2093 : }
2094 :
2095 34 : void SaveTCQdata(
2096 : PARCODEC arInst,
2097 : int16_t *dpath,
2098 : int16_t bcount )
2099 : {
2100 : int16_t i;
2101 :
2102 374 : for ( i = 0; i < bcount; i++ )
2103 : {
2104 340 : ar_encode_uniform( arInst, dpath[i], 1 );
2105 : }
2106 :
2107 34 : return;
2108 : }
2109 :
2110 102 : void LoadTCQdata(
2111 : PARCODEC arInst,
2112 : int16_t *dpath,
2113 : int16_t bcount )
2114 : {
2115 : int16_t i;
2116 :
2117 1122 : for ( i = 0; i < bcount; i++ )
2118 : {
2119 1020 : dpath[i] = (int16_t) ar_decode( arInst, uniform_model );
2120 : }
2121 :
2122 102 : return;
2123 : }
2124 :
2125 1647 : void RestoreTCQdec(
2126 : int32_t *magn,
2127 : int16_t size,
2128 : int16_t *bcount,
2129 : float *mbuffer )
2130 : {
2131 1647 : int16_t i, nzpos = 0, flag_g1 = 0;
2132 :
2133 : /* calculate actual nz positions */
2134 23703 : for ( i = 0, nzpos = 0; i < size; i++ )
2135 : {
2136 22056 : if ( magn[i] != 0 )
2137 : {
2138 2979 : nzpos++;
2139 2979 : if ( abs( magn[i] ) > 1 )
2140 : {
2141 609 : flag_g1 = 1;
2142 : }
2143 2979 : magn[i] *= (int32_t) ( 1.0f / QTCQ );
2144 : }
2145 : }
2146 :
2147 1647 : if ( nzpos > 1 )
2148 : {
2149 3231 : for ( i = 0; i < size && flag_g1 && *bcount < 2 * TCQ_AMP; i++ )
2150 : {
2151 2346 : if ( magn[i] != 0 )
2152 : {
2153 966 : mbuffer[*bcount] = magn[i] + ( 1.0f / QTCQ ) * mbuffer[*bcount];
2154 966 : magn[i] = round_f( mbuffer[*bcount] );
2155 966 : ( *bcount )++;
2156 : }
2157 : }
2158 : }
2159 :
2160 1647 : return;
2161 : }
2162 :
2163 :
2164 549 : void RestoreTCQ(
2165 : float *magn,
2166 : int16_t size,
2167 : int16_t *bcount,
2168 : float *mbuffer )
2169 : {
2170 549 : int16_t i, nzpos = 0, flag_g1 = 0;
2171 :
2172 : /* calculate actual nz positions */
2173 7901 : for ( i = 0, nzpos = 0; i < size; i++ )
2174 : {
2175 7352 : if ( magn[i] != 0.0f )
2176 : {
2177 993 : nzpos++;
2178 993 : if ( fabs( magn[i] ) > 1.0f )
2179 : {
2180 203 : flag_g1 = 1;
2181 : }
2182 : }
2183 : }
2184 :
2185 549 : if ( nzpos > 1 )
2186 : {
2187 1077 : for ( i = 0; i < size && flag_g1 && *bcount < 2 * TCQ_AMP; i++ )
2188 : {
2189 782 : if ( fabs( magn[i] ) > 0.0f )
2190 : {
2191 322 : magn[i] = mbuffer[*bcount];
2192 322 : ( *bcount )++;
2193 : }
2194 : }
2195 : }
2196 :
2197 549 : return;
2198 : }
|
