Line data Source code
1 : /*====================================================================================
2 : EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
3 : ====================================================================================*/
4 : #include <stdint.h>
5 : #include <math.h>
6 : #include "options.h" /* Compilation switches */
7 : #include "cnst.h"
8 : #include <assert.h> /* Compilation switches */
9 : #include "prot_fx.h" /* Function prototypes */
10 : #include "prot_fx_enc.h" /* Function prototypes */
11 : #include "rom_com.h" /* Static table prototypes */
12 :
13 : /*-------------------------------------------------------------------*
14 : * Local prototypes
15 : *-------------------------------------------------------------------*/
16 : static void wrte_cv( BSTR_ENC_HANDLE hBstr, const Word16 nq, const Word16 i_ind, const Word16 kv_ind, UWord16 I, Word16 kv[], Word16 *bits );
17 : static void wrte_cv_ivas_fx( BSTR_ENC_HANDLE hBstr, const Word16 nq, const Word16 i_ind, const Word16 kv_ind, UWord16 I, Word16 kv[], Word16 *bits );
18 :
19 : /*-------------------------------------------------------------------*
20 : * Function AVQ_cod() *
21 : * *
22 : * Split algevraic vector quantizer (AVQ) base on RE8 latice *
23 : *-------------------------------------------------------------------*/
24 :
25 75610 : void AVQ_cod_fx( /* o: comfort noise gain factor */
26 : const Word16 xri[], /* i: vector to quantize Qx*/
27 : Word16 xriq[], /* o: quantized normalized vector (assuming the bit budget is enough) */
28 : const Word16 NB_BITS, /* i: number of allocated bits */
29 : const Word16 Nsv, /* i: number of subvectors (lg=Nsv*8) */
30 : const Word16 Q_in_ref /* i: Scaling input */
31 : )
32 : {
33 : Word16 i, l, iter, c[8];
34 : Word16 gain_inv, tmp, nbits, nbits_max, fac, offset;
35 : Word16 ebits[NSV_MAX], e_ebits, f_ebits, e_tmp, f_tmp, tmp16, l_8;
36 : Word32 Lener, Ltmp, Lgain, x1[8];
37 : Word16 tot_est_bits, Q_in;
38 : #ifdef BASOP_NOGLOB_DECLARE_LOCAL
39 75610 : Flag Overflow = 0;
40 : #endif
41 75610 : Q_in = sub( Q_in_ref, 1 );
42 75610 : move16();
43 :
44 : /* find energy of each subvector in log domain (scaled for bits estimation) */
45 : /* if the number of allocated bits is high, recompute the energy of sub vectors with a different scaling factor (applicable only in BASOP code) */
46 : DO
47 : {
48 75610 : Q_in = add( Q_in, 1 );
49 75610 : tot_est_bits = 0;
50 75610 : move16();
51 688745 : FOR( l = 0; l < Nsv; l++ )
52 : {
53 613135 : Lener = L_shl( 4, shl( Q_in, 1 ) ); /* to set ebits >= 0 */
54 5518215 : FOR( i = 0; i < 8; i++ )
55 : {
56 4905080 : Lener = L_mac_o( Lener, xri[l * 8 + i], xri[l * 8 + i], &Overflow );
57 : }
58 : /* estimated bit consumption when gain=1 */
59 : /* ebits[l] = 5.0 * FAC_LOG2 * (Word16)log10(ener * 0.5) */
60 613135 : e_ebits = norm_l( Lener );
61 613135 : f_ebits = Log2_norm_lc( L_shl( Lener, e_ebits ) );
62 613135 : e_ebits = sub( 30 - 2, e_ebits ); /* -2 = *0.25 */
63 613135 : e_ebits = sub( e_ebits, shl( Q_in, 1 ) );
64 :
65 613135 : Ltmp = L_deposit_h( e_ebits );
66 613135 : Ltmp = L_mac( Ltmp, f_ebits, 1 );
67 613135 : Ltmp = L_add( L_shl( Ltmp, 6 ), L_shl( Ltmp, 4 ) ); /* Mult by 5.0 and then by 16 (To go to Q4). Do it using Mult by 80 (which is 64+16) */
68 613135 : ebits[l] = round_fx( Ltmp ); /*Q4*/
69 613135 : move16();
70 613135 : tot_est_bits = add( tot_est_bits, shr( ebits[l], 4 ) ); // Q0
71 : }
72 75610 : test();
73 75610 : test();
74 : }
75 75610 : WHILE( ( LE_16( Q_in, Q_in_ref ) ) && LE_16( tot_est_bits, mult( 26214, NB_BITS ) ) && GT_16( tot_est_bits, 600 ) ); /* limited to 1 possible iteration */
76 :
77 : /*----------------------------------------------------------------*
78 : * subvector energy worst case:
79 : * - typically, it's a tone with maximum of amplitude (RMS=23170).
80 : * - fft length max = 1024 (N/2 is 512)
81 : * log10(energy) = log10(23710*23710*1024*(N/2)) = 14.45
82 : * ebits --> 5.0*FAC_LOG2*14.45 = 240 bits
83 : *----------------------------------------------------------------*/
84 :
85 : /* estimate gain according to number of bits allowed */
86 : /* start at the middle (offset range = 0 to 255.75) Q6 */
87 75610 : fac = 2048; // 128.0f in Q4
88 75610 : move16();
89 75610 : offset = 0;
90 75610 : move16();
91 :
92 75610 : Ltmp = L_mult( 31130 /*.95f in Q15*/, sub( NB_BITS, Nsv ) ); /* (1810 - 8 - 1152/8)*.95*/
93 75610 : nbits_max = round_fx( L_shl( Ltmp, 4 ) );
94 :
95 : /* tree search with 10 iterations : offset with step of 0.25 bits (0.3 dB) */
96 831710 : FOR( iter = 0; iter < 10; iter++ )
97 : {
98 756100 : offset = add( fac, offset );
99 : /* calculate the required number of bits */
100 756100 : nbits = 0;
101 756100 : move16();
102 6887450 : FOR( l = 0; l < Nsv; l++ )
103 : {
104 6131350 : tmp = sub( ebits[l], offset );
105 6131350 : tmp = s_max( tmp, 0 );
106 6131350 : nbits = add( tmp, nbits );
107 : }
108 : /* decrease gain when no overflow occurs */
109 756100 : if ( LE_16( nbits, nbits_max ) )
110 : {
111 430376 : offset = sub( offset, fac );
112 : }
113 756100 : fac = mult( fac, 16384 /*.5 in Q15*/ );
114 : }
115 :
116 75610 : Ltmp = L_shr( L_mult( offset, 13107 ), 6 ); /* offset((2^21)/160 */
117 :
118 : /* estimated gain (when offset=0, estimated gain=1) */
119 75610 : f_tmp = L_Extract_lc( Ltmp, &e_tmp );
120 75610 : tmp16 = extract_l( Pow2( 14, f_tmp ) );
121 75610 : Lgain = L_shl_sat( tmp16, e_tmp );
122 : /* gain_inv = 1.0f / gain */
123 75610 : e_tmp = norm_l( Lgain );
124 75610 : tmp16 = extract_h( L_shl( Lgain, e_tmp ) );
125 75610 : e_tmp = sub( 31 - 14, e_tmp );
126 75610 : gain_inv = div_s( 16384, tmp16 );
127 75610 : e_tmp = sub( 0, e_tmp );
128 75610 : e_tmp = sub( e_tmp, Q_in );
129 : /* quantize all subvector using estimated gain */
130 688745 : FOR( l = 0; l < Nsv; l++ )
131 : {
132 613135 : l_8 = shl( l, 3 );
133 5518215 : FOR( i = 0; i < 8; i++ )
134 : {
135 4905080 : x1[i] = L_shl( L_mult( xri[l_8 + i], gain_inv ), e_tmp ); // Q15
136 4905080 : move32();
137 : }
138 :
139 613135 : re8_PPV_fx( x1, c );
140 :
141 5518215 : FOR( i = 0; i < 8; i++ )
142 : {
143 4905080 : xriq[l_8 + i] = c[i]; // Q0
144 4905080 : move16();
145 : }
146 : }
147 :
148 : /* round_fx bit allocations and save */
149 688745 : FOR( i = 0; i < Nsv; i++ )
150 : {
151 613135 : xriq[( Nsv * 8 ) + i] = shl( ebits[i], 7 - 4 ); // Q0
152 613135 : move16();
153 : }
154 :
155 75610 : return;
156 : }
157 :
158 :
159 : /*-----------------------------------------------------------------*
160 : * AVQ_encmux()
161 : *
162 : * Encode subvectors and write indexes into the bitstream
163 : *-----------------------------------------------------------------*/
164 4840 : void AVQ_encmux_fx(
165 : BSTR_ENC_HANDLE hBstr, /* i/o: bitstream handle */
166 : const Word16 extl, /* i : extension layer */
167 : Word16 xriq[], /* i/o: rounded subvectors [0..8*Nsv-1] followed
168 : by rounded bit allocations [8*Nsv..8*Nsv+Nsv-1] */
169 : Word16 *nb_bits, /* i/o: number of allocated bits */
170 : const Word16 Nsv, /* i: number of subvectors */
171 : Word16 nq_out[], /* o : AVQ nq index */
172 : Word16 avq_bit_sFlag, /* i : flag for AVQ bit saving solution */
173 : Word16 trgtSvPos /* i : target SV for AVQ bit savings */
174 : )
175 : {
176 4840 : Word16 i, j = 0, bits, pos, pos_max, overflow, pos_tmp, bit_tmp;
177 : Word16 sort_idx[NSV_MAX], nq[NSV_MAX], kv[NSV_MAX * 8];
178 : Word16 *t;
179 : UWord16 I[NSV_MAX];
180 : Word16 nq_ind, i_ind, kv_ind;
181 : Word16 nq_est, unused_bits, unused_bits_idx;
182 : Word16 bitsMod, Nsvm1, Nsvm2;
183 : Word16 unusedbitsFlag;
184 : Word16 svOrder[NSV_MAX], k, nullVec, dummy_bits;
185 :
186 4840 : test();
187 4840 : IF( EQ_16( extl, SWB_BWE_HIGHRATE ) || EQ_16( extl, FB_BWE_HIGHRATE ) )
188 : {
189 1470 : nq_ind = IND_NQ2;
190 1470 : move16();
191 1470 : i_ind = IND_I2;
192 1470 : move16();
193 1470 : kv_ind = IND_KV2;
194 1470 : move16();
195 : }
196 : ELSE
197 : {
198 3370 : nq_ind = IND_NQ;
199 3370 : move16();
200 3370 : i_ind = IND_I;
201 3370 : move16();
202 3370 : kv_ind = IND_KV;
203 3370 : move16();
204 : }
205 :
206 169400 : FOR( i = 0; i < NSV_MAX; i++ )
207 : {
208 164560 : I[i] = (UWord16) -1;
209 164560 : move16();
210 : }
211 4840 : unusedbitsFlag = 0;
212 4840 : bitsMod = 0;
213 4840 : move16();
214 4840 : move16();
215 : /*-----------------------------------------------------------------
216 : * Encode subvectors and fix possible overflows in total bit budget,
217 : * i.e. find for each subvector a codebook index nq (nq=0,2,3,4,...,NSV_MAX),
218 : * a base codebook index (I), and a Voronoi index (kv)
219 : *-----------------------------------------------------------------*/
220 :
221 : /* sort subvectors by estimated bit allocations in decreasing order */
222 4840 : t = kv;
223 : /* reuse vector to save memory */
224 : /*ptr init*/
225 51815 : FOR( i = 0; i < Nsv; i++ )
226 : {
227 46975 : t[i] = xriq[8 * Nsv + i];
228 46975 : move16();
229 : }
230 :
231 51815 : FOR( i = 0; i < Nsv; i++ )
232 : {
233 46975 : bits = t[0];
234 46975 : move16();
235 46975 : pos = 0;
236 46975 : move16();
237 630853 : FOR( j = 1; j < Nsv; j++ )
238 : {
239 583878 : if ( GT_16( t[j], bits ) )
240 : {
241 82657 : pos = j;
242 82657 : move16();
243 : }
244 583878 : bits = s_max( t[j], bits );
245 : }
246 46975 : sort_idx[i] = pos;
247 46975 : move16();
248 46975 : t[pos] = -1;
249 46975 : move16();
250 : }
251 :
252 : /* compute multi-rate indices and avoid bit budget overflow */
253 4840 : pos_max = 0;
254 4840 : move16();
255 4840 : bits = 0;
256 4840 : move16();
257 51815 : FOR( i = 0; i < Nsv; i++ )
258 : {
259 : /* find vector to quantize (criteria: nb of estimated bits) */
260 46975 : pos = sort_idx[i];
261 46975 : move16();
262 :
263 : /* compute multi-rate index of rounded subvector (nq,I,kv[]) */
264 46975 : re8_cod_fx( &xriq[pos * 8], &nq[pos], &I[pos], &kv[8 * pos] );
265 :
266 46975 : IF( nq[pos] > 0 )
267 : {
268 42702 : j = pos_max;
269 42702 : move16();
270 42702 : j = s_max( pos, j );
271 :
272 : /* compute (number of bits -1) to describe Q #nq */
273 42702 : IF( GE_16( nq[pos], 2 ) )
274 : {
275 42702 : overflow = sub( i_mult2( nq[pos], 5 ), 1 );
276 : }
277 : ELSE
278 : {
279 0 : overflow = 0;
280 0 : move16();
281 : }
282 :
283 : /* check for overflow and compute number of bits-1 (n) */
284 42702 : IF( GT_16( add( bits, add( overflow, j ) ), *nb_bits ) )
285 : {
286 : /* if budget overflow */
287 1008 : pos_tmp = add( shl( pos, 3 ), 8 ); /*(pos*8)+8*/
288 9072 : FOR( j = pos * 8; j < pos_tmp; j++ )
289 : {
290 8064 : xriq[j] = 0;
291 8064 : move16();
292 : }
293 1008 : nq[pos] = 0;
294 1008 : move16(); /* force Q0 */
295 : }
296 : ELSE
297 : {
298 41694 : bits = add( bits, overflow );
299 41694 : pos_max = j;
300 41694 : move16(); /* update index of the last described subvector */
301 : }
302 : }
303 : }
304 4840 : nullVec = 0;
305 4840 : Nsvm1 = sub( Nsv, 1 );
306 4840 : Nsvm2 = sub( Nsvm1, 1 );
307 4840 : dummy_bits = 0;
308 4840 : svOrder[Nsvm1] = trgtSvPos;
309 4840 : svOrder[0] = 0;
310 4840 : svOrder[1] = 1;
311 4840 : i = 2;
312 4840 : j = i;
313 4840 : move16();
314 4840 : move16();
315 4840 : move16();
316 4840 : move16();
317 4840 : move16();
318 4840 : move16();
319 4840 : move16();
320 4840 : if ( EQ_16( avq_bit_sFlag, 2 ) )
321 : {
322 0 : j = add( i, 1 );
323 : }
324 37459 : WHILE( i < Nsvm1 )
325 : {
326 32619 : svOrder[i] = j;
327 32619 : move16();
328 32619 : i++; /*ptr*/
329 32619 : j = add( j, 1 );
330 : }
331 : /* write indexes to the bitstream */
332 : /* ============================== */
333 :
334 4840 : bits = *nb_bits;
335 4840 : move16();
336 4840 : overflow = 0;
337 4840 : move16();
338 51815 : FOR( i = 0; i < Nsv; i++ )
339 : {
340 46975 : k = svOrder[i];
341 46975 : move16();
342 46975 : test();
343 46975 : test();
344 46975 : test();
345 46975 : test();
346 46975 : test();
347 46975 : IF( EQ_16( avq_bit_sFlag, 2 ) && EQ_16( s_and( bits, 4 ), 4 ) && GT_16( bits, 8 ) && LT_16( bits, 30 ) && GE_16( k, trgtSvPos ) && LT_16( i, Nsvm1 ) )
348 : {
349 0 : ordr_esti( sub( Nsv, i ), &trgtSvPos, &svOrder[i], Nsv );
350 0 : k = svOrder[i];
351 0 : move16();
352 0 : avq_bit_sFlag = 1;
353 0 : move16();
354 : }
355 :
356 46975 : test();
357 46975 : IF( EQ_16( k, trgtSvPos ) && avq_bit_sFlag > 0 )
358 : {
359 0 : test();
360 0 : test();
361 0 : IF( EQ_16( sub( *nb_bits, bits ), 7 ) || LT_16( bits, BIT_SAVING_LOW_THR ) || GE_16( bits, BIT_SAVING_HIGH_THR ) )
362 : {
363 0 : avq_bit_sFlag = 0;
364 0 : move16();
365 : }
366 : ELSE
367 : {
368 : BREAK;
369 : }
370 : }
371 :
372 46975 : if ( EQ_16( sub( i_mult2( 5, nq[k] ), 1 ), bits ) ) /* check the overflow */
373 : {
374 182 : overflow = 1;
375 182 : move16();
376 : }
377 :
378 46975 : IF( GT_16( bits, 8 ) )
379 : {
380 : /* write the unary code for nq[i] */
381 46658 : j = sub( nq[k], 1 );
382 46658 : IF( nq[k] > 0 )
383 : {
384 : /* write the unary code */
385 41694 : FOR( ; j > 16; j -= 16 )
386 : {
387 0 : push_indice( hBstr, nq_ind, 65535, 16 );
388 0 : bits = sub( bits, 16 );
389 : }
390 :
391 41694 : IF( j > 0 )
392 : {
393 41694 : push_indice( hBstr, nq_ind, extract_l( L_sub( L_shl( 1L, j ), 1L ) ), j );
394 41694 : bits = sub( bits, j );
395 : }
396 : }
397 46658 : IF( !overflow )
398 : {
399 : /* write the stop bit */
400 46476 : push_indice( hBstr, nq_ind, 0, 1 );
401 46476 : bits = sub( bits, 1 );
402 : }
403 :
404 46658 : wrte_cv( hBstr, nq[k], i_ind, kv_ind, I[k], &kv[k * 8], &bits );
405 : }
406 : } /* for */
407 : /* Bit Saving Solution */
408 4840 : test();
409 4840 : IF( avq_bit_sFlag > 0 && GT_16( bits, 8 ) )
410 : {
411 : // PMT("code not validated yet")
412 0 : bitsMod = s_and( bits, 4 /*bits%5*/ );
413 0 : i = svOrder[Nsvm1];
414 0 : move16();
415 0 : IF( NE_16( i, Nsvm1 ) )
416 : {
417 0 : nullVec = 0;
418 0 : move16();
419 0 : FOR( j = i; j < Nsv - 1; j++ )
420 : {
421 0 : if ( nq[svOrder[j]] == 0 )
422 : {
423 0 : nullVec = add( nullVec, 1 );
424 : }
425 : }
426 : /*nq_est = bits / 5;*/
427 0 : nq_est = mult( bits, 6554 );
428 0 : assert( nq_est == bits / 5 );
429 :
430 0 : test();
431 0 : test();
432 0 : test();
433 0 : test();
434 0 : test();
435 0 : test();
436 0 : test();
437 0 : test();
438 0 : test();
439 0 : test();
440 0 : test();
441 0 : IF( ( bitsMod > 0 || ( EQ_16( nullVec, 4 ) && EQ_16( nq_est, 5 ) ) ) && NE_16( bitsMod, 4 ) && GE_16( add( bits, nullVec ), add( add( shl( nq_est, 2 ), nq_est ), 4 ) ) /*5 * nq_est + 4*/ && nq[svOrder[Nsvm2]] == 0 ) /* detect need for dummy bits */
442 : {
443 0 : dummy_bits = sub( 5, bitsMod );
444 0 : bits = add( bits, dummy_bits ); /* add dummy bits */
445 0 : bitsMod = 0;
446 0 : move16();
447 : }
448 0 : ELSE IF( nq_est > 4 && ( ( bitsMod == 0 && GT_16( nullVec, 3 ) && GT_16( nullVec, 6 ) ) || ( EQ_16( bitsMod, 4 ) && EQ_16( nullVec, 5 ) ) ) && nq[svOrder[Nsvm2]] == 0 ) /* wasted bits 4, 5 for nq 6,7..*/
449 : {
450 0 : overflow = 0;
451 0 : move16();
452 0 : if ( s_and( add( bitsMod, nullVec ), 4 ) != 0 )
453 : {
454 0 : overflow = 1;
455 0 : move16();
456 : }
457 0 : dummy_bits = add( nullVec, overflow );
458 0 : bits = add( bits, dummy_bits ); /* add dummy bits */
459 0 : bitsMod = 0;
460 0 : move16();
461 : }
462 : }
463 :
464 0 : overflow = 1;
465 0 : move16();
466 0 : IF( NE_16( bitsMod, 4 ) )
467 : {
468 0 : overflow = 0;
469 0 : move16();
470 0 : bits = sub( bits, bitsMod );
471 : }
472 0 : bits = add( bits, overflow ); /*add fake bit */
473 0 : unused_bits = sub( bits, add( shl( nq[i], 2 ), nq[i] ) );
474 0 : if ( nq[i] == 0 ) /*no bit savings*/
475 : {
476 0 : unused_bits = sub( unused_bits, 1 ); /*Stop Bit*/
477 : }
478 : /*unused_bits_idx = (int16_t)unused_bits / 5;*/
479 0 : unused_bits_idx = mult( unused_bits, 6554 );
480 0 : assert( unused_bits_idx == unused_bits / 5 );
481 0 : unusedbitsFlag = 0;
482 0 : move16();
483 0 : IF( dummy_bits == 0 )
484 : {
485 0 : test();
486 0 : test();
487 0 : IF( EQ_16( unused_bits_idx, 1 ) && GT_16( bits, BIT_SAVING_LOW_THR ) )
488 : {
489 0 : unused_bits_idx = 0;
490 0 : unusedbitsFlag = 1;
491 0 : move16();
492 0 : move16();
493 : }
494 0 : ELSE IF( unused_bits_idx == 0 && GT_16( bits, BIT_SAVING_LOW_THR ) )
495 : {
496 0 : unused_bits_idx = 1;
497 0 : unusedbitsFlag = -1;
498 0 : move16();
499 0 : move16();
500 : }
501 : }
502 :
503 0 : j = unused_bits_idx;
504 0 : move16();
505 : /*Encode Unused Bit Unary Codeword */
506 0 : IF( j > 0 )
507 : {
508 : /* write the unary code */
509 0 : push_indice( hBstr, nq_ind, sub( shl( 1, j ), 1 ), j );
510 : }
511 :
512 0 : IF( nq[i] != 0 )
513 : {
514 : /* write the stop bit */
515 0 : push_indice( hBstr, nq_ind, 0, 1 );
516 : }
517 :
518 : /*Compute AVQ code book number from unused Bits */
519 0 : bit_tmp = add( unusedbitsFlag, unused_bits_idx );
520 : /*nq_est = (int16_t)ceil(0.2f * (bits - 5 * (unusedbitsFlag + unused_bits_idx)));*/
521 0 : nq_est = mult( 6554, sub( bits, add( shl( bit_tmp, 2 ), bit_tmp ) ) );
522 0 : assert( (Word16) ceil( 0.2f * ( bits - 5 * ( unusedbitsFlag + unused_bits_idx ) ) ) == nq_est );
523 :
524 0 : if ( EQ_16( nq_est, 1 ) )
525 : {
526 0 : nq_est = 0;
527 0 : move16();
528 : }
529 0 : bits = sub( bits, overflow );
530 :
531 0 : bits = sub( bits, j );
532 :
533 0 : if ( nq_est != 0 )
534 : {
535 0 : bits = sub( bits, 1 );
536 : }
537 0 : nq[i] = nq_est;
538 0 : move16();
539 :
540 : /* write codebook indices (rank I and event. Voronoi index kv) */
541 0 : wrte_cv( hBstr, nq[i], i_ind, kv_ind, I[i], &kv[i * 8], &bits );
542 :
543 0 : bits = sub( bits, dummy_bits );
544 :
545 0 : if ( NE_16( bitsMod, 4 ) )
546 : {
547 0 : bits = add( bits, bitsMod );
548 : }
549 : }
550 4840 : *nb_bits = bits;
551 4840 : move16();
552 :
553 51815 : FOR( i = 0; i < Nsv; i++ )
554 : {
555 46975 : nq_out[i] = nq[i];
556 46975 : move16();
557 : }
558 :
559 4840 : return;
560 : }
561 :
562 70770 : void AVQ_encmux_ivas_fx(
563 : BSTR_ENC_HANDLE hBstr, /* i/o: bitstream handle */
564 : const Word16 extl, /* i : extension layer */
565 : Word16 xriq[], /* i/o: rounded subvectors [0..8*Nsv-1] followed
566 : by rounded bit allocations [8*Nsv..8*Nsv+Nsv-1] */
567 : Word16 *nb_bits, /* i/o: number of allocated bits */
568 : const Word16 Nsv, /* i: number of subvectors */
569 : Word16 nq_out[], /* o : AVQ nq index */
570 : Word16 avq_bit_sFlag, /* i : flag for AVQ bit saving solution */
571 : Word16 trgtSvPos /* i : target SV for AVQ bit savings */
572 : )
573 : {
574 70770 : Word16 i, j = 0, bits, pos, pos_max, overflow, pos_tmp, bit_tmp;
575 : Word16 sort_idx[NSV_MAX], nq[NSV_MAX], kv[NSV_MAX * 8];
576 : Word16 *t;
577 : UWord16 I[NSV_MAX];
578 : Word16 nq_ind, i_ind, kv_ind;
579 : Word16 nq_est, unused_bits, unused_bits_idx;
580 : Word16 bitsMod, Nsvm1, Nsvm2;
581 : Word16 unusedbitsFlag;
582 : Word16 svOrder[NSV_MAX], k, nullVec, dummy_bits;
583 : Word16 tmp;
584 :
585 70770 : test();
586 70770 : IF( EQ_16( extl, SWB_BWE_HIGHRATE ) || EQ_16( extl, FB_BWE_HIGHRATE ) )
587 : {
588 0 : nq_ind = IND_NQ2;
589 0 : move16();
590 0 : i_ind = IND_I2;
591 0 : move16();
592 0 : kv_ind = IND_KV2;
593 0 : move16();
594 : }
595 : ELSE
596 : {
597 70770 : nq_ind = IND_NQ;
598 70770 : move16();
599 70770 : i_ind = IND_I;
600 70770 : move16();
601 70770 : kv_ind = IND_KV;
602 70770 : move16();
603 : }
604 :
605 2476950 : FOR( i = 0; i < NSV_MAX; i++ )
606 : {
607 2406180 : I[i] = (UWord16) -1;
608 2406180 : move16();
609 : }
610 70770 : unusedbitsFlag = 0;
611 70770 : bitsMod = 0;
612 70770 : move16();
613 70770 : move16();
614 : /*-----------------------------------------------------------------
615 : * Encode subvectors and fix possible overflows in total bit budget,
616 : * i.e. find for each subvector a codebook index nq (nq=0,2,3,4,...,NSV_MAX),
617 : * a base codebook index (I), and a Voronoi index (kv)
618 : *-----------------------------------------------------------------*/
619 :
620 : /* sort subvectors by estimated bit allocations in decreasing order */
621 70770 : t = kv;
622 : /* reuse vector to save memory */
623 : /*ptr init*/
624 636930 : FOR( i = 0; i < Nsv; i++ )
625 : {
626 566160 : t[i] = xriq[8 * Nsv + i];
627 566160 : move16();
628 : }
629 :
630 636930 : FOR( i = 0; i < Nsv; i++ )
631 : {
632 566160 : bits = t[0];
633 566160 : move16();
634 566160 : pos = 0;
635 566160 : move16();
636 4529280 : FOR( j = 1; j < Nsv; j++ )
637 : {
638 3963120 : if ( GT_16( t[j], bits ) )
639 : {
640 819992 : pos = j;
641 819992 : move16();
642 : }
643 3963120 : bits = s_max( t[j], bits );
644 : }
645 566160 : sort_idx[i] = pos;
646 566160 : move16();
647 566160 : t[pos] = -1;
648 566160 : move16();
649 : }
650 :
651 : /* compute multi-rate indices and avoid bit budget overflow */
652 70770 : pos_max = 0;
653 70770 : move16();
654 70770 : bits = 0;
655 70770 : move16();
656 636930 : FOR( i = 0; i < Nsv; i++ )
657 : {
658 : /* find vector to quantize (criteria: nb of estimated bits) */
659 566160 : pos = sort_idx[i];
660 566160 : move16();
661 :
662 : /* compute multi-rate index of rounded subvector (nq,I,kv[]) */
663 566160 : re8_cod_fx( &xriq[pos * 8], &nq[pos], &I[pos], &kv[8 * pos] );
664 :
665 566160 : IF( nq[pos] > 0 )
666 : {
667 483089 : j = pos_max;
668 483089 : move16();
669 483089 : j = s_max( pos, j );
670 :
671 : /* compute (number of bits -1) to describe Q #nq */
672 483089 : IF( GE_16( nq[pos], 2 ) )
673 : {
674 483089 : overflow = sub( i_mult2( nq[pos], 5 ), 1 );
675 : }
676 : ELSE
677 : {
678 0 : overflow = 0;
679 0 : move16();
680 : }
681 :
682 : /* check for overflow and compute number of bits-1 (n) */
683 483089 : IF( GT_16( add( bits, add( overflow, j ) ), *nb_bits ) )
684 : {
685 : /* if budget overflow */
686 84333 : pos_tmp = add( shl( pos, 3 ), 8 ); /*(pos*8)+8*/
687 758997 : FOR( j = pos * 8; j < pos_tmp; j++ )
688 : {
689 674664 : xriq[j] = 0;
690 674664 : move16();
691 : }
692 84333 : nq[pos] = 0;
693 84333 : move16(); /* force Q0 */
694 : }
695 : ELSE
696 : {
697 398756 : bits = add( bits, overflow );
698 398756 : pos_max = j;
699 398756 : move16(); /* update index of the last described subvector */
700 : }
701 : }
702 : }
703 70770 : nullVec = 0;
704 70770 : Nsvm1 = sub( Nsv, 1 );
705 70770 : Nsvm2 = sub( Nsvm1, 1 );
706 70770 : dummy_bits = 0;
707 70770 : svOrder[Nsvm1] = trgtSvPos;
708 70770 : svOrder[0] = 0;
709 70770 : svOrder[1] = 1;
710 70770 : i = 2;
711 70770 : j = i;
712 70770 : move16();
713 70770 : move16();
714 70770 : move16();
715 70770 : move16();
716 70770 : move16();
717 70770 : move16();
718 70770 : move16();
719 70770 : if ( EQ_16( avq_bit_sFlag, 2 ) )
720 : {
721 20080 : j = add( i, 1 );
722 : }
723 424620 : WHILE( LT_16( i, Nsvm1 ) )
724 : {
725 353850 : svOrder[i] = j;
726 353850 : move16();
727 353850 : i++; /*ptr*/
728 353850 : j = add( j, 1 );
729 : }
730 : /* write indexes to the bitstream */
731 : /* ============================== */
732 :
733 70770 : bits = *nb_bits;
734 70770 : move16();
735 70770 : overflow = 0;
736 70770 : move16();
737 591877 : FOR( i = 0; i < Nsv; i++ )
738 : {
739 566160 : k = svOrder[i];
740 566160 : move16();
741 566160 : test();
742 566160 : test();
743 566160 : test();
744 566160 : test();
745 566160 : test();
746 566160 : tmp = bits;
747 566160 : move16();
748 5266256 : WHILE( GE_16( tmp, 5 ) )
749 : {
750 4700096 : tmp = sub( tmp, 5 );
751 : }
752 566160 : assert( tmp == bits % 5 );
753 566160 : IF( EQ_16( avq_bit_sFlag, 2 ) && EQ_16( tmp, 4 ) && GT_16( bits, 8 ) && LT_16( bits, 30 ) && GE_16( k, trgtSvPos ) && LT_16( i, Nsvm1 ) )
754 : {
755 2932 : ordr_esti( sub( Nsv, i ), &trgtSvPos, &svOrder[i], Nsv );
756 2932 : k = svOrder[i];
757 2932 : move16();
758 2932 : avq_bit_sFlag = 1;
759 2932 : move16();
760 : }
761 :
762 566160 : test();
763 566160 : IF( EQ_16( k, trgtSvPos ) && avq_bit_sFlag > 0 )
764 : {
765 70770 : test();
766 70770 : test();
767 70770 : IF( EQ_16( sub( *nb_bits, bits ), 7 ) || LT_16( bits, BIT_SAVING_LOW_THR ) || GE_16( bits, BIT_SAVING_HIGH_THR ) )
768 : {
769 25717 : avq_bit_sFlag = 0;
770 25717 : move16();
771 : }
772 : ELSE
773 : {
774 : BREAK;
775 : }
776 : }
777 :
778 521107 : if ( EQ_16( sub( i_mult2( 5, nq[k] ), 1 ), bits ) ) /* check the overflow */
779 : {
780 6431 : overflow = 1;
781 6431 : move16();
782 : }
783 :
784 521107 : IF( GT_16( bits, 8 ) )
785 : {
786 : /* write the unary code for nq[i] */
787 489748 : j = sub( nq[k], 1 );
788 489748 : IF( nq[k] > 0 )
789 : {
790 : /* write the unary code */
791 353951 : FOR( ; j > 16; j -= 16 )
792 : {
793 0 : push_indice( hBstr, nq_ind, 65535, 16 );
794 0 : bits = sub( bits, 16 );
795 : }
796 :
797 353951 : IF( j > 0 )
798 : {
799 353951 : push_indice( hBstr, nq_ind, extract_l( L_sub( L_shl( 1L, j ), 1L ) ), j );
800 353951 : bits = sub( bits, j );
801 : }
802 : }
803 489748 : IF( !overflow )
804 : {
805 : /* write the stop bit */
806 483317 : push_indice( hBstr, nq_ind, 0, 1 );
807 483317 : bits = sub( bits, 1 );
808 : }
809 :
810 489748 : wrte_cv_ivas_fx( hBstr, nq[k], i_ind, kv_ind, I[k], &kv[k * 8], &bits );
811 : }
812 : } /* for */
813 : /* Bit Saving Solution */
814 70770 : test();
815 70770 : IF( avq_bit_sFlag > 0 && GT_16( bits, 8 ) )
816 : {
817 : // PMT("code not validated yet")
818 : // bitsMod = bits%5;
819 45053 : bitsMod = bits;
820 45053 : move16();
821 179018 : WHILE( bitsMod >= 5 )
822 : {
823 133965 : bitsMod = sub( bitsMod, 5 );
824 : }
825 45053 : assert( bitsMod == bits % 5 );
826 45053 : i = svOrder[Nsvm1];
827 45053 : move16();
828 45053 : IF( NE_16( i, Nsvm1 ) )
829 : {
830 15645 : nullVec = 0;
831 15645 : move16();
832 93870 : FOR( j = i; j < Nsv - 1; j++ )
833 : {
834 78225 : IF( nq[svOrder[j]] == 0 )
835 : {
836 11009 : nullVec = add( nullVec, 1 );
837 : }
838 : }
839 : /*nq_est = bits / 5;*/
840 15645 : nq_est = mult( bits, 6554 /*1/5 in Q15*/ );
841 15645 : assert( nq_est == bits / 5 );
842 :
843 15645 : test();
844 15645 : test();
845 15645 : test();
846 15645 : test();
847 15645 : test();
848 15645 : test();
849 15645 : test();
850 15645 : test();
851 15645 : test();
852 15645 : test();
853 :
854 15645 : IF( ( bitsMod > 0 || ( EQ_16( nullVec, 4 ) && EQ_16( nq_est, 5 ) ) ) && NE_16( bitsMod, 4 ) && GE_16( add( bits, nullVec ), add( add( shl( nq_est, 2 ), nq_est ), 4 ) ) /*5 * nq_est + 4*/ && nq[svOrder[Nsvm2]] == 0 ) /* detect need for dummy bits */
855 : {
856 107 : dummy_bits = sub( 5, bitsMod );
857 107 : bits = add( bits, dummy_bits ); /* add dummy bits */
858 107 : bitsMod = 0;
859 107 : move16();
860 : }
861 15538 : ELSE IF( GT_16( nq_est, 4 ) && ( ( bitsMod == 0 && GT_16( nullVec, 3 ) && LT_16( nullVec, 6 ) ) || ( EQ_16( bitsMod, 4 ) && EQ_16( nullVec, 5 ) ) ) && nq[svOrder[Nsvm2]] == 0 ) /* wasted bits 4, 5 for nq 6,7..*/
862 : {
863 2 : overflow = 0;
864 2 : move16();
865 2 : tmp = add( bitsMod, nullVec );
866 4 : WHILE( tmp >= 5 )
867 : {
868 2 : tmp = sub( tmp, 5 );
869 : }
870 2 : assert( tmp == add( bitsMod, nullVec ) % 5 );
871 2 : if ( tmp != 0 )
872 : {
873 2 : overflow = 1;
874 2 : move16();
875 : }
876 2 : dummy_bits = add( nullVec, overflow );
877 2 : bits = add( bits, dummy_bits ); /* add dummy bits */
878 2 : bitsMod = 0;
879 2 : move16();
880 : }
881 : }
882 :
883 45053 : overflow = 1;
884 45053 : move16();
885 45053 : IF( NE_16( bitsMod, 4 ) )
886 : {
887 37826 : overflow = 0;
888 37826 : move16();
889 37826 : bits = sub( bits, bitsMod );
890 : }
891 45053 : bits = add( bits, overflow ); /*add fake bit */
892 45053 : unused_bits = sub( bits, add( shl( nq[i], 2 ), nq[i] ) );
893 45053 : IF( nq[i] == 0 ) /*no bit savings*/
894 : {
895 248 : unused_bits = sub( unused_bits, 1 ); /*Stop Bit*/
896 : }
897 : /*unused_bits_idx = (int16_t)unused_bits / 5;*/
898 45053 : IF( unused_bits >= 0 )
899 : {
900 45053 : unused_bits_idx = mult( unused_bits, 6554 /*1/5 in Q15*/ );
901 : }
902 : ELSE
903 : {
904 0 : unused_bits_idx = negate( mult( negate( unused_bits ), 6554 /*1/5 in Q15*/ ) );
905 : }
906 45053 : assert( unused_bits_idx == unused_bits / 5 );
907 45053 : unusedbitsFlag = 0;
908 45053 : move16();
909 45053 : IF( dummy_bits == 0 )
910 : {
911 44944 : test();
912 44944 : test();
913 44944 : IF( EQ_16( unused_bits_idx, 1 ) && GT_16( bits, BIT_SAVING_LOW_THR ) )
914 : {
915 20681 : unused_bits_idx = 0;
916 20681 : unusedbitsFlag = 1;
917 20681 : move16();
918 20681 : move16();
919 : }
920 24263 : ELSE IF( unused_bits_idx == 0 && GT_16( bits, BIT_SAVING_LOW_THR ) )
921 : {
922 8904 : unused_bits_idx = 1;
923 8904 : unusedbitsFlag = -1;
924 8904 : move16();
925 8904 : move16();
926 : }
927 : }
928 :
929 45053 : j = unused_bits_idx;
930 45053 : move16();
931 : /*Encode Unused Bit Unary Codeword */
932 45053 : IF( j > 0 )
933 : {
934 : /* write the unary code */
935 11210 : push_indice( hBstr, nq_ind, u_extract_l( L_sub( L_shl_sat( 1, j ), 1 ) ), j );
936 11210 : assert( abs( ( 1 << j ) - 1 ) <= 65536 );
937 : }
938 :
939 45053 : IF( nq[i] != 0 )
940 : {
941 : /* write the stop bit */
942 44805 : push_indice( hBstr, nq_ind, 0, 1 );
943 : }
944 :
945 : /*Compute AVQ code book number from unused Bits */
946 45053 : bit_tmp = add( unusedbitsFlag, unused_bits_idx );
947 : /*nq_est = (int16_t)ceil(0.2f * (bits - 5 * (unusedbitsFlag + unused_bits_idx)));*/
948 45053 : nq_est = mult( 6554 /*.2 in Q15*/, sub( bits, add( shl( bit_tmp, 2 ), bit_tmp ) ) );
949 45053 : assert( (Word16) ceil( 0.2f * ( bits - 5 * ( unusedbitsFlag + unused_bits_idx ) ) ) == nq_est );
950 :
951 45053 : if ( EQ_16( nq_est, 1 ) )
952 : {
953 248 : nq_est = 0;
954 248 : move16();
955 : }
956 45053 : bits = sub( bits, overflow );
957 :
958 45053 : bits = sub( bits, j );
959 :
960 45053 : IF( nq_est != 0 )
961 : {
962 44805 : bits = sub( bits, 1 );
963 : }
964 45053 : nq[i] = nq_est;
965 45053 : move16();
966 :
967 : /* write codebook indices (rank I and event. Voronoi index kv) */
968 45053 : wrte_cv_ivas_fx( hBstr, nq[i], i_ind, kv_ind, I[i], &kv[i * 8], &bits );
969 :
970 45053 : bits = sub( bits, dummy_bits );
971 :
972 45053 : IF( NE_16( bitsMod, 4 ) )
973 : {
974 37826 : bits = add( bits, bitsMod );
975 : }
976 : }
977 70770 : *nb_bits = bits;
978 70770 : move16();
979 :
980 636930 : FOR( i = 0; i < Nsv; i++ )
981 : {
982 566160 : nq_out[i] = nq[i];
983 566160 : move16();
984 : }
985 :
986 70770 : return;
987 : }
988 :
989 : /*-------------------------------------------------------------------*
990 : * Function AVQ_cod_lpc_fx() *
991 : * *
992 : * Split algebraic vector quantizer (AVQ) for LPC quantization *
993 : *-------------------------------------------------------------------*/
994 :
995 647100 : void AVQ_cod_lpc_fx(
996 : Word16 *nvec, /* input: vector to quantize (normalized) (5Q10)*/
997 : Word16 *nvecq, /* output: quantized vector (5Q10)*/
998 : Word16 *indx, /* output: index[] (4 bits per words) (15Q0)*/
999 : Word16 Nsv /* input: number of subvectors (lg=Nsv*8) */
1000 : )
1001 : {
1002 : Word16 ival, n, nq, nk, c[8], kv[8];
1003 : Word16 i, l, pos;
1004 : Word32 I;
1005 : Word32 x1[8];
1006 : UWord16 I16;
1007 :
1008 :
1009 : /* quantize all subvector using estimated gain */
1010 647100 : pos = Nsv;
1011 647100 : move16();
1012 1941300 : FOR( l = 0; l < Nsv; l++ )
1013 : {
1014 11647800 : FOR( i = 0; i < 8; i++ )
1015 : {
1016 10353600 : x1[i] = L_mult( nvec[l * 8 + i], 1 << 4 ); /* 5Q10 -> 16Q15*/
1017 10353600 : move32();
1018 : }
1019 1294200 : re8_PPV_fx( x1, c ); /*x1:8Q15, c:15Q0*/
1020 1294200 : re8_cod_fx( c, &nq, &I16, kv );
1021 1294200 : I = UL_deposit_l( I16 );
1022 :
1023 11647800 : FOR( i = 0; i < 8; i++ )
1024 : {
1025 10353600 : nvecq[l * 8 + i] = shl( c[i], 10 ); /*15Q0->5Q10*/
1026 10353600 : move16();
1027 : }
1028 :
1029 1294200 : indx[l] = nq; /* index[0..Nsv-1] = quantizer number (0,2,3,4...) */
1030 1294200 : move16();
1031 1294200 : nk = 0;
1032 1294200 : move16();
1033 1294200 : n = nq;
1034 1294200 : move16();
1035 :
1036 1294200 : IF( GT_16( nq, 4 ) )
1037 : {
1038 206943 : nk = shr( sub( nq, 3 ), 1 ); /*nk = (nq-3)>>1;*/
1039 206943 : n = sub( nq, shl( nk, 1 ) ); /*n = nq - nk*2; */
1040 : }
1041 :
1042 : /* write n groups of 4-bit for base codebook index (I) */
1043 4749363 : FOR( ; n > 0; n-- )
1044 : {
1045 3455163 : indx[pos++] = s_and( extract_l( I ), 0x000F );
1046 3455163 : move16();
1047 3455163 : I = L_shr( I, 4 );
1048 : }
1049 :
1050 : /* write n groups of 4-bit for Voronoi index (k[]) */
1051 1582537 : FOR( ; nk > 0; nk-- )
1052 : {
1053 288337 : ival = 0;
1054 288337 : move16();
1055 2595033 : FOR( i = 0; i < 8; i++ )
1056 : {
1057 2306696 : ival = shl( ival, 1 ); /*ival <<= 1;*/
1058 2306696 : ival = add( ival, s_and( kv[i], 0x0001 ) ); /*ival += (kv[i] & 0x01);*/
1059 2306696 : kv[i] = shr( kv[i], 1 ); /*kv[i] >>= 1;*/
1060 2306696 : move16();
1061 : }
1062 288337 : indx[pos++] = s_and( ival, 0x000F );
1063 288337 : move16();
1064 288337 : ival = shr( ival, 4 );
1065 288337 : indx[pos++] = s_and( ival, 0x000F );
1066 288337 : move16();
1067 : }
1068 : }
1069 :
1070 :
1071 647100 : return;
1072 : }
1073 : /*------------------------------------------------------------------ - *
1074 : * Function wrte_cv()
1075 : *
1076 : * write codebook indices(rank I and event.Voronoi index kv) *
1077 : *------------------------------------------------------------------ - */
1078 46658 : static void wrte_cv(
1079 : BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */
1080 : const Word16 nq, /* i : AVQ nq index */
1081 : const Word16 i_ind, /* i : Base Bitstream index */
1082 : const Word16 kv_ind, /* i : Vornoi Bitstream index */
1083 : UWord16 I, /* o : rank I code book index */
1084 : Word16 kv[], /* o : Vornoi index kv */
1085 : Word16 *nbits /* i/o: bits */
1086 : )
1087 : {
1088 : Word16 pos, j;
1089 : Word16 bits, nq4;
1090 :
1091 46658 : bits = *nbits;
1092 46658 : move16();
1093 :
1094 : /* write codebook indices (rank I and event. Voronoi index kv) */
1095 46658 : IF( nq == 0 ) /* Q0 */
1096 : {
1097 : /* nothing to write */
1098 : }
1099 41694 : ELSE IF( LT_16( nq, 5 ) ) /* Q2, Q3, Q4 */
1100 : {
1101 40740 : nq4 = shl( nq, 2 );
1102 40740 : push_indice( hBstr, i_ind, I, nq4 );
1103 40740 : bits = sub( bits, nq4 );
1104 : }
1105 954 : ELSE IF( EQ_16( s_and( nq, 1 ), 0 ) ) /* Q4 + Voronoi extensions r=1,2,3,... */
1106 : {
1107 230 : push_indice( hBstr, i_ind, I, 4 * 4 );
1108 230 : bits = sub( bits, 4 * 4 );
1109 : /*pos = (int16_t)(nq / 2 - 2);*/ /* Voronoi order determination */
1110 230 : pos = sub( shr( nq, 1 ), 2 );
1111 2070 : FOR( j = 0; j < 8; j++ )
1112 : {
1113 1840 : push_indice( hBstr, kv_ind, kv[j], pos );
1114 : }
1115 :
1116 230 : bits = sub( bits, shl( pos, 3 ) );
1117 : }
1118 : ELSE /* Q3 + Voronoi extensions r=1,2,3,... */
1119 : {
1120 724 : push_indice( hBstr, i_ind, I, 4 * 3 );
1121 724 : bits = sub( bits, 4 * 3 );
1122 :
1123 : /*pos = (int16_t)(nq / 2 - 1);*/ /* Voronoi order determination */
1124 724 : pos = sub( shr( nq, 1 ), 1 );
1125 6516 : FOR( j = 0; j < 8; j++ )
1126 : {
1127 5792 : push_indice( hBstr, kv_ind, kv[j], pos );
1128 : }
1129 :
1130 724 : bits = sub( bits, shl( pos, 3 ) );
1131 : }
1132 :
1133 46658 : *nbits = bits;
1134 46658 : move16();
1135 46658 : return;
1136 : }
1137 :
1138 534801 : static void wrte_cv_ivas_fx(
1139 : BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */
1140 : const Word16 nq, /* i : AVQ nq index */
1141 : const Word16 i_ind, /* i : Base Bitstream index */
1142 : const Word16 kv_ind, /* i : Vornoi Bitstream index */
1143 : UWord16 I, /* o : rank I code book index */
1144 : Word16 kv[], /* o : Vornoi index kv */
1145 : Word16 *nbits /* i/o: bits */
1146 : )
1147 : {
1148 : Word16 pos, j;
1149 : Word16 bits, nq4;
1150 :
1151 534801 : bits = *nbits;
1152 534801 : move16();
1153 :
1154 : /* write codebook indices (rank I and event. Voronoi index kv) */
1155 534801 : IF( nq == 0 ) /* Q0 */
1156 : {
1157 : /* nothing to write */
1158 : }
1159 398756 : ELSE IF( LT_16( nq, 5 ) ) /* Q2, Q3, Q4 */
1160 : {
1161 394336 : nq4 = shl( nq, 2 );
1162 394336 : push_indice( hBstr, i_ind, I, nq4 );
1163 394336 : bits = sub( bits, nq4 );
1164 : }
1165 4420 : ELSE IF( EQ_16( s_and( nq, 1 ), 0 ) ) /* Q4 + Voronoi extensions r=1,2,3,... */
1166 : {
1167 1821 : push_indice( hBstr, i_ind, I, 4 * 4 );
1168 1821 : bits = sub( bits, 4 * 4 );
1169 : /*pos = (int16_t)(nq / 2 - 2);*/ /* Voronoi order determination */
1170 1821 : pos = sub( shr( nq, 1 ), 2 );
1171 16389 : FOR( j = 0; j < 8; j++ )
1172 : {
1173 14568 : push_indice( hBstr, kv_ind, kv[j], pos );
1174 : }
1175 :
1176 1821 : bits = sub( bits, shl( pos, 3 ) );
1177 : }
1178 : ELSE /* Q3 + Voronoi extensions r=1,2,3,... */
1179 : {
1180 2599 : push_indice( hBstr, i_ind, I, 4 * 3 );
1181 2599 : bits = sub( bits, 4 * 3 );
1182 :
1183 : /*pos = (int16_t)(nq / 2 - 1);*/ /* Voronoi order determination */
1184 2599 : pos = sub( shr( nq, 1 ), 1 );
1185 23391 : FOR( j = 0; j < 8; j++ )
1186 : {
1187 20792 : push_indice( hBstr, kv_ind, kv[j], pos );
1188 : }
1189 :
1190 2599 : bits = sub( bits, shl( pos, 3 ) );
1191 : }
1192 :
1193 534801 : *nbits = bits;
1194 534801 : move16();
1195 534801 : return;
1196 : }
|
