Line data Source code
1 : /*====================================================================================
2 : EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
3 : ====================================================================================*/
4 :
5 : #include <stdint.h>
6 : #include <math.h>
7 : #include "options.h" /* Compilation switches */
8 : #include "cnst.h"
9 : #include <assert.h> /* Compilation switches */
10 : #include "prot_fx.h" /* Function prototypes */
11 : #include "prot_fx_enc.h" /* Function prototypes */
12 : #include "rom_com.h" /* Static table prototypes */
13 :
14 : /*-------------------------------------------------------------------*
15 : * Local prototypes
16 : *-------------------------------------------------------------------*/
17 :
18 : 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 );
19 :
20 : /*-------------------------------------------------------------------*
21 : * Function AVQ_cod() *
22 : * *
23 : * Split algevraic vector quantizer (AVQ) base on RE8 latice *
24 : *-------------------------------------------------------------------*/
25 :
26 : /* o: comfort noise gain factor */
27 75480 : void AVQ_cod_fx(
28 : const Word16 xri[], /* i : vector to quantize Qx*/
29 : Word16 xriq[], /* o : quantized normalized vector (assuming the bit budget is enough) */
30 : const Word16 NB_BITS, /* i : number of allocated bits */
31 : const Word16 Nsv, /* i : number of subvectors (lg=Nsv*8) */
32 : const Word16 Q_in_ref /* i : Scaling input */
33 : )
34 : {
35 : Word16 i, l, iter, c[8];
36 : Word16 gain_inv, tmp, nbits, nbits_max, fac, offset;
37 : Word16 ebits[NSV_MAX], e_ebits, f_ebits, e_tmp, f_tmp, tmp16, l_8;
38 : Word32 Lener, Ltmp, Lgain, x1[8];
39 : Word16 tot_est_bits, Q_in;
40 :
41 75480 : Q_in = sub( Q_in_ref, 1 );
42 75480 : 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 75480 : Q_in = add( Q_in, 1 );
49 75480 : tot_est_bits = 0;
50 75480 : move16();
51 687575 : FOR( l = 0; l < Nsv; l++ )
52 : {
53 612095 : Lener = L_shl( 4, shl( Q_in, 1 ) ); /* to set ebits >= 0 */
54 5508855 : FOR( i = 0; i < 8; i++ )
55 : {
56 4896760 : Lener = L_mac_sat( Lener, xri[l * 8 + i], xri[l * 8 + i] );
57 : }
58 : /* estimated bit consumption when gain=1 */
59 : /* ebits[l] = 5.0 * FAC_LOG2 * (Word16)log10(ener * 0.5) */
60 612095 : e_ebits = norm_l( Lener );
61 612095 : f_ebits = Log2_norm_lc( L_shl( Lener, e_ebits ) );
62 612095 : e_ebits = sub( 30 - 2, e_ebits ); /* -2 = *0.25 */
63 612095 : e_ebits = sub( e_ebits, shl( Q_in, 1 ) );
64 :
65 612095 : Ltmp = L_deposit_h( e_ebits );
66 612095 : Ltmp = L_mac( Ltmp, f_ebits, 1 );
67 612095 : 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 612095 : ebits[l] = round_fx( Ltmp ); /*Q4*/
69 612095 : move16();
70 612095 : tot_est_bits = add( tot_est_bits, shr( ebits[l], 4 ) ); // Q0
71 : }
72 75480 : test();
73 75480 : test();
74 : }
75 75480 : 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 75480 : fac = 2048; // 128.0f in Q4
88 75480 : move16();
89 75480 : offset = 0;
90 75480 : move16();
91 :
92 75480 : Ltmp = L_mult( 31130 /*.95f in Q15*/, sub( NB_BITS, Nsv ) ); /* (1810 - 8 - 1152/8)*.95*/
93 75480 : 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 830280 : FOR( iter = 0; iter < 10; iter++ )
97 : {
98 754800 : offset = add( fac, offset );
99 : /* calculate the required number of bits */
100 754800 : nbits = 0;
101 754800 : move16();
102 6875750 : FOR( l = 0; l < Nsv; l++ )
103 : {
104 6120950 : tmp = sub( ebits[l], offset );
105 6120950 : tmp = s_max( tmp, 0 );
106 6120950 : nbits = add( tmp, nbits );
107 : }
108 : /* decrease gain when no overflow occurs */
109 754800 : if ( LE_16( nbits, nbits_max ) )
110 : {
111 429335 : offset = sub( offset, fac );
112 : }
113 754800 : fac = mult( fac, 16384 /*.5 in Q15*/ );
114 : }
115 :
116 75480 : Ltmp = L_shr( L_mult( offset, 13107 ), 6 ); /* offset((2^21)/160 */
117 :
118 : /* estimated gain (when offset=0, estimated gain=1) */
119 75480 : f_tmp = L_Extract_lc( Ltmp, &e_tmp );
120 75480 : tmp16 = extract_l( Pow2( 14, f_tmp ) );
121 75480 : Lgain = L_shl_sat( tmp16, e_tmp );
122 : /* gain_inv = 1.0f / gain */
123 75480 : e_tmp = norm_l( Lgain );
124 75480 : tmp16 = extract_h( L_shl( Lgain, e_tmp ) );
125 75480 : e_tmp = sub( 31 - 14, e_tmp );
126 75480 : gain_inv = div_s( 16384, tmp16 );
127 75480 : e_tmp = sub( 0, e_tmp );
128 75480 : e_tmp = sub( e_tmp, Q_in );
129 : /* quantize all subvector using estimated gain */
130 687575 : FOR( l = 0; l < Nsv; l++ )
131 : {
132 612095 : l_8 = shl( l, 3 );
133 5508855 : FOR( i = 0; i < 8; i++ )
134 : {
135 4896760 : x1[i] = L_shl( L_mult( xri[l_8 + i], gain_inv ), e_tmp ); // Q15
136 4896760 : move32();
137 : }
138 :
139 612095 : re8_PPV_fx( x1, c );
140 :
141 5508855 : FOR( i = 0; i < 8; i++ )
142 : {
143 4896760 : xriq[l_8 + i] = c[i]; // Q0
144 4896760 : move16();
145 : }
146 : }
147 :
148 : /* round_fx bit allocations and save */
149 687575 : FOR( i = 0; i < Nsv; i++ )
150 : {
151 612095 : xriq[( Nsv * 8 ) + i] = shl( ebits[i], 7 - 4 ); // Q0
152 612095 : move16();
153 : }
154 :
155 75480 : return;
156 : }
157 :
158 :
159 : /*-----------------------------------------------------------------*
160 : * AVQ_encmux()
161 : *
162 : * Encode subvectors and write indexes into the bitstream
163 : *-----------------------------------------------------------------*/
164 :
165 75480 : void AVQ_encmux_fx(
166 : BSTR_ENC_HANDLE hBstr, /* i/o: bitstream handle */
167 : const Word16 extl, /* i : extension layer */
168 : Word16 xriq[], /* i/o: rounded subvectors [0..8*Nsv-1] followed 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 75480 : 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 : Word16 tmp;
186 :
187 75480 : test();
188 75480 : IF( EQ_16( extl, SWB_BWE_HIGHRATE ) || EQ_16( extl, FB_BWE_HIGHRATE ) )
189 : {
190 1470 : nq_ind = IND_NQ2;
191 1470 : move16();
192 1470 : i_ind = IND_I2;
193 1470 : move16();
194 1470 : kv_ind = IND_KV2;
195 1470 : move16();
196 : }
197 : ELSE
198 : {
199 74010 : nq_ind = IND_NQ;
200 74010 : move16();
201 74010 : i_ind = IND_I;
202 74010 : move16();
203 74010 : kv_ind = IND_KV;
204 74010 : move16();
205 : }
206 :
207 2641800 : FOR( i = 0; i < NSV_MAX; i++ )
208 : {
209 2566320 : I[i] = (UWord16) -1;
210 2566320 : move16();
211 : }
212 75480 : unusedbitsFlag = 0;
213 75480 : bitsMod = 0;
214 75480 : move16();
215 75480 : move16();
216 : /*-----------------------------------------------------------------
217 : * Encode subvectors and fix possible overflows in total bit budget,
218 : * i.e. find for each subvector a codebook index nq (nq=0,2,3,4,...,NSV_MAX),
219 : * a base codebook index (I), and a Voronoi index (kv)
220 : *-----------------------------------------------------------------*/
221 :
222 : /* sort subvectors by estimated bit allocations in decreasing order */
223 75480 : t = kv;
224 : /* reuse vector to save memory */
225 : /*ptr init*/
226 687575 : FOR( i = 0; i < Nsv; i++ )
227 : {
228 612095 : t[i] = xriq[8 * Nsv + i];
229 612095 : move16();
230 : }
231 :
232 687575 : FOR( i = 0; i < Nsv; i++ )
233 : {
234 612095 : bits = t[0];
235 612095 : move16();
236 612095 : pos = 0;
237 612095 : move16();
238 5151813 : FOR( j = 1; j < Nsv; j++ )
239 : {
240 4539718 : if ( GT_16( t[j], bits ) )
241 : {
242 901611 : pos = j;
243 901611 : move16();
244 : }
245 4539718 : bits = s_max( t[j], bits );
246 : }
247 612095 : sort_idx[i] = pos;
248 612095 : move16();
249 612095 : t[pos] = -1;
250 612095 : move16();
251 : }
252 :
253 : /* compute multi-rate indices and avoid bit budget overflow */
254 75480 : pos_max = 0;
255 75480 : move16();
256 75480 : bits = 0;
257 75480 : move16();
258 687575 : FOR( i = 0; i < Nsv; i++ )
259 : {
260 : /* find vector to quantize (criteria: nb of estimated bits) */
261 612095 : pos = sort_idx[i];
262 612095 : move16();
263 :
264 : /* compute multi-rate index of rounded subvector (nq,I,kv[]) */
265 612095 : re8_cod_fx( &xriq[pos * 8], &nq[pos], &I[pos], &kv[8 * pos] );
266 :
267 612095 : IF( nq[pos] > 0 )
268 : {
269 524992 : j = pos_max;
270 524992 : move16();
271 524992 : j = s_max( pos, j );
272 :
273 : /* compute (number of bits -1) to describe Q #nq */
274 524992 : IF( GE_16( nq[pos], 2 ) )
275 : {
276 524992 : overflow = sub( i_mult2( nq[pos], 5 ), 1 );
277 : }
278 : ELSE
279 : {
280 0 : overflow = 0;
281 0 : move16();
282 : }
283 :
284 : /* check for overflow and compute number of bits-1 (n) */
285 524992 : IF( GT_16( add( bits, add( overflow, j ) ), *nb_bits ) )
286 : {
287 : /* if budget overflow */
288 85076 : pos_tmp = add( shl( pos, 3 ), 8 ); /*(pos*8)+8*/
289 765684 : FOR( j = pos * 8; j < pos_tmp; j++ )
290 : {
291 680608 : xriq[j] = 0;
292 680608 : move16();
293 : }
294 85076 : nq[pos] = 0;
295 85076 : move16(); /* force Q0 */
296 : }
297 : ELSE
298 : {
299 439916 : bits = add( bits, overflow );
300 439916 : pos_max = j;
301 439916 : move16(); /* update index of the last described subvector */
302 : }
303 : }
304 : }
305 75480 : nullVec = 0;
306 75480 : Nsvm1 = sub( Nsv, 1 );
307 75480 : Nsvm2 = sub( Nsvm1, 1 );
308 75480 : dummy_bits = 0;
309 75480 : svOrder[Nsvm1] = trgtSvPos;
310 75480 : svOrder[0] = 0;
311 75480 : svOrder[1] = 1;
312 75480 : i = 2;
313 75480 : j = i;
314 75480 : move16();
315 75480 : move16();
316 75480 : move16();
317 75480 : move16();
318 75480 : move16();
319 75480 : move16();
320 75480 : move16();
321 75480 : if ( EQ_16( avq_bit_sFlag, 2 ) )
322 : {
323 19950 : j = add( i, 1 );
324 : }
325 461299 : WHILE( i < Nsvm1 )
326 : {
327 385819 : svOrder[i] = j;
328 385819 : move16();
329 385819 : i++; /*ptr*/
330 385819 : j = add( j, 1 );
331 : }
332 : /* write indexes to the bitstream */
333 : /* ============================== */
334 :
335 75480 : bits = *nb_bits;
336 75480 : move16();
337 75480 : overflow = 0;
338 75480 : move16();
339 642741 : FOR( i = 0; i < Nsv; i++ )
340 : {
341 612095 : k = svOrder[i];
342 612095 : move16();
343 612095 : test();
344 612095 : test();
345 612095 : test();
346 612095 : test();
347 612095 : test();
348 612095 : tmp = bits;
349 612095 : move16();
350 6254984 : WHILE( GE_16( tmp, 5 ) )
351 : {
352 5642889 : tmp = sub( tmp, 5 );
353 : }
354 612095 : assert( tmp == bits % 5 );
355 612095 : 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 ) )
356 :
357 : {
358 2925 : ordr_esti( sub( Nsv, i ), &trgtSvPos, &svOrder[i], Nsv );
359 2925 : k = svOrder[i];
360 2925 : move16();
361 2925 : avq_bit_sFlag = 1;
362 2925 : move16();
363 : }
364 :
365 612095 : test();
366 612095 : IF( EQ_16( k, trgtSvPos ) && avq_bit_sFlag > 0 )
367 : {
368 70640 : test();
369 70640 : test();
370 70640 : IF( EQ_16( sub( *nb_bits, bits ), 7 ) || LT_16( bits, BIT_SAVING_LOW_THR ) || GE_16( bits, BIT_SAVING_HIGH_THR ) )
371 : {
372 25806 : avq_bit_sFlag = 0;
373 25806 : move16();
374 : }
375 : ELSE
376 : {
377 : BREAK;
378 : }
379 : }
380 :
381 567261 : if ( EQ_16( sub( i_mult2( 5, nq[k] ), 1 ), bits ) ) /* check the overflow */
382 : {
383 6670 : overflow = 1;
384 6670 : move16();
385 : }
386 :
387 567261 : IF( GT_16( bits, 8 ) )
388 : {
389 : /* write the unary code for nq[i] */
390 535551 : j = sub( nq[k], 1 );
391 535551 : IF( nq[k] > 0 )
392 : {
393 : /* write the unary code */
394 395344 : FOR( ; j > 16; j -= 16 )
395 : {
396 0 : push_indice( hBstr, nq_ind, 65535, 16 );
397 0 : bits = sub( bits, 16 );
398 : }
399 :
400 395344 : IF( j > 0 )
401 : {
402 395344 : push_indice( hBstr, nq_ind, extract_l( L_sub( L_shl( 1L, j ), 1L ) ), j );
403 395344 : bits = sub( bits, j );
404 : }
405 : }
406 535551 : IF( !overflow )
407 : {
408 : /* write the stop bit */
409 528881 : push_indice( hBstr, nq_ind, 0, 1 );
410 528881 : bits = sub( bits, 1 );
411 : }
412 :
413 535551 : wrte_cv( hBstr, nq[k], i_ind, kv_ind, I[k], &kv[k * 8], &bits );
414 : }
415 : } /* for */
416 : /* Bit Saving Solution */
417 75480 : test();
418 75480 : IF( avq_bit_sFlag > 0 && GT_16( bits, 8 ) )
419 : {
420 : /* bitsMod = bits % 5;*/
421 44834 : bitsMod = bits;
422 44834 : move16();
423 177445 : WHILE( bitsMod >= 5 )
424 : {
425 132611 : bitsMod = sub( bitsMod, 5 );
426 : }
427 44834 : assert( bitsMod == bits % 5 );
428 44834 : i = svOrder[Nsvm1];
429 44834 : move16();
430 44834 : IF( NE_16( i, Nsvm1 ) )
431 : {
432 15541 : nullVec = 0;
433 15541 : move16();
434 93246 : FOR( j = i; j < Nsv - 1; j++ )
435 : {
436 77705 : if ( nq[svOrder[j]] == 0 )
437 : {
438 11006 : nullVec = add( nullVec, 1 );
439 : }
440 : }
441 : /*nq_est = bits / 5;*/
442 15541 : nq_est = mult( bits, 6554 );
443 15541 : assert( nq_est == bits / 5 );
444 :
445 15541 : test();
446 15541 : test();
447 15541 : test();
448 15541 : test();
449 15541 : test();
450 15541 : test();
451 15541 : test();
452 15541 : test();
453 15541 : test();
454 15541 : test();
455 15541 : test();
456 15541 : 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 */
457 : {
458 116 : dummy_bits = sub( 5, bitsMod );
459 116 : bits = add( bits, dummy_bits ); /* add dummy bits */
460 116 : bitsMod = 0;
461 116 : move16();
462 : }
463 15425 : 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..*/
464 : {
465 3 : overflow = 0;
466 3 : move16();
467 3 : tmp = add( bitsMod, nullVec );
468 4 : WHILE( tmp >= 5 )
469 : {
470 1 : tmp = sub( tmp, 5 );
471 : }
472 3 : assert( tmp == add( bitsMod, nullVec ) % 5 );
473 3 : if ( tmp != 0 )
474 : {
475 3 : overflow = 1;
476 3 : move16();
477 : }
478 3 : dummy_bits = add( nullVec, overflow );
479 3 : bits = add( bits, dummy_bits ); /* add dummy bits */
480 3 : bitsMod = 0;
481 3 : move16();
482 : }
483 : }
484 :
485 44834 : overflow = 1;
486 44834 : move16();
487 44834 : IF( NE_16( bitsMod, 4 ) )
488 : {
489 37584 : overflow = 0;
490 37584 : move16();
491 37584 : bits = sub( bits, bitsMod );
492 : }
493 44834 : bits = add( bits, overflow ); /*add fake bit */
494 44834 : unused_bits = sub( bits, add( shl( nq[i], 2 ), nq[i] ) );
495 44834 : if ( nq[i] == 0 ) /*no bit savings*/
496 : {
497 262 : unused_bits = sub( unused_bits, 1 ); /*Stop Bit*/
498 : }
499 : /*unused_bits_idx = (int16_t)unused_bits / 5;*/
500 44834 : IF( unused_bits >= 0 )
501 : {
502 44834 : unused_bits_idx = mult( unused_bits, 6554 /*1/5 in Q15*/ );
503 : }
504 : ELSE
505 : {
506 0 : unused_bits_idx = negate( mult( negate( unused_bits ), 6554 /*1/5 in Q15*/ ) );
507 : }
508 44834 : assert( unused_bits_idx == unused_bits / 5 );
509 44834 : unusedbitsFlag = 0;
510 44834 : move16();
511 44834 : IF( dummy_bits == 0 )
512 : {
513 44715 : test();
514 44715 : test();
515 44715 : IF( EQ_16( unused_bits_idx, 1 ) && GT_16( bits, BIT_SAVING_LOW_THR ) )
516 : {
517 20373 : unused_bits_idx = 0;
518 20373 : unusedbitsFlag = 1;
519 20373 : move16();
520 20373 : move16();
521 : }
522 24342 : ELSE IF( unused_bits_idx == 0 && GT_16( bits, BIT_SAVING_LOW_THR ) )
523 : {
524 8647 : unused_bits_idx = 1;
525 8647 : unusedbitsFlag = -1;
526 8647 : move16();
527 8647 : move16();
528 : }
529 : }
530 :
531 44834 : j = unused_bits_idx;
532 44834 : move16();
533 : /*Encode Unused Bit Unary Codeword */
534 44834 : IF( j > 0 )
535 : {
536 : /* write the unary code */
537 11004 : push_indice( hBstr, nq_ind, u_extract_l( L_sub( L_shl_sat( 1, j ), 1 ) ), j );
538 : }
539 :
540 44834 : IF( nq[i] != 0 )
541 : {
542 : /* write the stop bit */
543 44572 : push_indice( hBstr, nq_ind, 0, 1 );
544 : }
545 :
546 : /*Compute AVQ code book number from unused Bits */
547 44834 : bit_tmp = add( unusedbitsFlag, unused_bits_idx );
548 : /*nq_est = (int16_t)ceil(0.2f * (bits - 5 * (unusedbitsFlag + unused_bits_idx)));*/
549 44834 : nq_est = mult( 6554, sub( bits, add( shl( bit_tmp, 2 ), bit_tmp ) ) );
550 44834 : assert( (Word16) ceil( 0.2f * ( bits - 5 * ( unusedbitsFlag + unused_bits_idx ) ) ) == nq_est );
551 :
552 44834 : if ( EQ_16( nq_est, 1 ) )
553 : {
554 262 : nq_est = 0;
555 262 : move16();
556 : }
557 44834 : bits = sub( bits, overflow );
558 :
559 44834 : bits = sub( bits, j );
560 :
561 44834 : if ( nq_est != 0 )
562 : {
563 44572 : bits = sub( bits, 1 );
564 : }
565 44834 : nq[i] = nq_est;
566 44834 : move16();
567 :
568 : /* write codebook indices (rank I and event. Voronoi index kv) */
569 44834 : wrte_cv( hBstr, nq[i], i_ind, kv_ind, I[i], &kv[i * 8], &bits );
570 :
571 44834 : bits = sub( bits, dummy_bits );
572 :
573 44834 : if ( NE_16( bitsMod, 4 ) )
574 : {
575 37584 : bits = add( bits, bitsMod );
576 : }
577 : }
578 75480 : *nb_bits = bits;
579 75480 : move16();
580 :
581 687575 : FOR( i = 0; i < Nsv; i++ )
582 : {
583 612095 : nq_out[i] = nq[i];
584 612095 : move16();
585 : }
586 :
587 75480 : return;
588 : }
589 :
590 :
591 : /*-------------------------------------------------------------------*
592 : * Function AVQ_cod_lpc_fx() *
593 : * *
594 : * Split algebraic vector quantizer (AVQ) for LPC quantization *
595 : *-------------------------------------------------------------------*/
596 :
597 680832 : void AVQ_cod_lpc_fx(
598 : Word16 *nvec, /* input: vector to quantize (normalized) (5Q10)*/
599 : Word16 *nvecq, /* output: quantized vector (5Q10)*/
600 : Word16 *indx, /* output: index[] (4 bits per words) (15Q0)*/
601 : Word16 Nsv /* input: number of subvectors (lg=Nsv*8) */
602 : )
603 : {
604 : Word16 ival, n, nq, nk, c[8], kv[8];
605 : Word16 i, l, pos;
606 : Word32 I;
607 : Word32 x1[8];
608 : UWord16 I16;
609 :
610 :
611 : /* quantize all subvector using estimated gain */
612 680832 : pos = Nsv;
613 680832 : move16();
614 2042496 : FOR( l = 0; l < Nsv; l++ )
615 : {
616 12254976 : FOR( i = 0; i < 8; i++ )
617 : {
618 10893312 : x1[i] = L_mult( nvec[l * 8 + i], 1 << 4 ); /* 5Q10 -> 16Q15*/
619 10893312 : move32();
620 : }
621 1361664 : re8_PPV_fx( x1, c ); /*x1:8Q15, c:15Q0*/
622 1361664 : re8_cod_fx( c, &nq, &I16, kv );
623 1361664 : I = UL_deposit_l( I16 );
624 :
625 12254976 : FOR( i = 0; i < 8; i++ )
626 : {
627 10893312 : nvecq[l * 8 + i] = shl( c[i], 10 ); /*15Q0->5Q10*/
628 10893312 : move16();
629 : }
630 :
631 1361664 : indx[l] = nq; /* index[0..Nsv-1] = quantizer number (0,2,3,4...) */
632 1361664 : move16();
633 1361664 : nk = 0;
634 1361664 : move16();
635 1361664 : n = nq;
636 1361664 : move16();
637 :
638 1361664 : IF( GT_16( nq, 4 ) )
639 : {
640 210961 : nk = shr( sub( nq, 3 ), 1 ); /*nk = (nq-3)>>1;*/
641 210961 : n = sub( nq, shl( nk, 1 ) ); /*n = nq - nk*2; */
642 : }
643 :
644 : /* write n groups of 4-bit for base codebook index (I) */
645 4990925 : FOR( ; n > 0; n-- )
646 : {
647 3629261 : indx[pos++] = s_and( extract_l( I ), 0x000F );
648 3629261 : move16();
649 3629261 : I = L_shr( I, 4 );
650 : }
651 :
652 : /* write n groups of 4-bit for Voronoi index (k[]) */
653 1654081 : FOR( ; nk > 0; nk-- )
654 : {
655 292417 : ival = 0;
656 292417 : move16();
657 2631753 : FOR( i = 0; i < 8; i++ )
658 : {
659 2339336 : ival = shl( ival, 1 ); /*ival <<= 1;*/
660 2339336 : ival = add( ival, s_and( kv[i], 0x0001 ) ); /*ival += (kv[i] & 0x01);*/
661 2339336 : kv[i] = shr( kv[i], 1 ); /*kv[i] >>= 1;*/
662 2339336 : move16();
663 : }
664 292417 : indx[pos++] = s_and( ival, 0x000F );
665 292417 : move16();
666 292417 : ival = shr( ival, 4 );
667 292417 : indx[pos++] = s_and( ival, 0x000F );
668 292417 : move16();
669 : }
670 : }
671 :
672 :
673 680832 : return;
674 : }
675 : /*------------------------------------------------------------------ - *
676 : * Function wrte_cv()
677 : *
678 : * write codebook indices(rank I and event.Voronoi index kv) *
679 : *------------------------------------------------------------------ - */
680 580385 : static void wrte_cv(
681 : BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */
682 : const Word16 nq, /* i : AVQ nq index */
683 : const Word16 i_ind, /* i : Base Bitstream index */
684 : const Word16 kv_ind, /* i : Vornoi Bitstream index */
685 : UWord16 I, /* o : rank I code book index */
686 : Word16 kv[], /* o : Vornoi index kv */
687 : Word16 *nbits /* i/o: bits */
688 : )
689 : {
690 : Word16 pos, j;
691 : Word16 bits, nq4;
692 :
693 580385 : bits = *nbits;
694 580385 : move16();
695 :
696 : /* write codebook indices (rank I and event. Voronoi index kv) */
697 580385 : IF( nq == 0 ) /* Q0 */
698 : {
699 : /* nothing to write */
700 : }
701 439916 : ELSE IF( LT_16( nq, 5 ) ) /* Q2, Q3, Q4 */
702 : {
703 434519 : nq4 = shl( nq, 2 );
704 434519 : push_indice( hBstr, i_ind, I, nq4 );
705 434519 : bits = sub( bits, nq4 );
706 : }
707 5397 : ELSE IF( EQ_16( s_and( nq, 1 ), 0 ) ) /* Q4 + Voronoi extensions r=1,2,3,... */
708 : {
709 2059 : push_indice( hBstr, i_ind, I, 4 * 4 );
710 2059 : bits = sub( bits, 4 * 4 );
711 : /*pos = (int16_t)(nq / 2 - 2);*/ /* Voronoi order determination */
712 2059 : pos = sub( shr( nq, 1 ), 2 );
713 18531 : FOR( j = 0; j < 8; j++ )
714 : {
715 16472 : push_indice( hBstr, kv_ind, kv[j], pos );
716 : }
717 :
718 2059 : bits = sub( bits, shl( pos, 3 ) );
719 : }
720 : ELSE /* Q3 + Voronoi extensions r=1,2,3,... */
721 : {
722 3338 : push_indice( hBstr, i_ind, I, 4 * 3 );
723 3338 : bits = sub( bits, 4 * 3 );
724 :
725 : /*pos = (int16_t)(nq / 2 - 1);*/ /* Voronoi order determination */
726 3338 : pos = sub( shr( nq, 1 ), 1 );
727 30042 : FOR( j = 0; j < 8; j++ )
728 : {
729 26704 : push_indice( hBstr, kv_ind, kv[j], pos );
730 : }
731 :
732 3338 : bits = sub( bits, shl( pos, 3 ) );
733 : }
734 :
735 580385 : *nbits = bits;
736 580385 : move16();
737 580385 : return;
738 : }
|
