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 : #include <stdint.h>
34 : #include "options.h"
35 : #ifdef DEBUGGING
36 : #include "debug.h"
37 : #endif
38 : #include <math.h>
39 : #include "cnst.h"
40 : #include "prot.h"
41 : #include "ivas_prot.h"
42 : #include "rom_com.h"
43 : #include "wmc_auto.h"
44 :
45 : /*-------------------------------------------------------------------*
46 : * Local constants
47 : *-------------------------------------------------------------------*/
48 :
49 : #define BETA_BN1 2.0f
50 : #define BETA_BN2 2.25f
51 :
52 : #define L_SUBFR_MAX 2 * L_SUBFR
53 : #define MAX_NUM_INTER 5
54 : #define MAX_PULSES_STEREO 5
55 :
56 : /*---------------------------------------------------------------------*
57 : * Quantization of 1 pulse with N+1 bits: *
58 : *---------------------------------------------------------------------*/
59 :
60 : /*! r: return index (N+1 bits) */
61 24337 : static int16_t quant_1p_N1_L_subfr(
62 : const int16_t nb_pos, /* i : number of positions */
63 : const int16_t pos, /* i : position of the pulse */
64 : const int16_t N /* i : number of bits for position */
65 : )
66 : {
67 : int16_t mask, index;
68 :
69 24337 : mask = ( ( 1 << N ) - 1 );
70 :
71 24337 : index = ( pos & mask );
72 :
73 24337 : if ( ( pos & nb_pos ) != 0 )
74 : {
75 11996 : index += 1 << N;
76 : }
77 :
78 24337 : return index;
79 : }
80 :
81 : /*-------------------------------------------------------------------*
82 : * Function find_best_pulse()
83 : *
84 : * Find best pulse
85 : *-------------------------------------------------------------------*/
86 :
87 58897 : static int16_t find_best_pulse(
88 : const int16_t L_subfr,
89 : const int16_t nb_tracks,
90 : const int16_t track,
91 : const float dn[],
92 : const float sign[],
93 : int16_t *s )
94 : {
95 : int16_t m, i;
96 : float temp, max_val;
97 :
98 58897 : max_val = FLT_MIN;
99 58897 : m = track;
100 1510497 : for ( i = track; i < L_subfr; i += nb_tracks )
101 : {
102 1451600 : temp = dn[i] * sign[i];
103 :
104 1451600 : if ( temp >= max_val )
105 : {
106 196847 : max_val = temp;
107 196847 : m = i;
108 : }
109 : }
110 :
111 58897 : *s = (int16_t) sign[m];
112 :
113 58897 : return m;
114 : }
115 :
116 :
117 : /*-------------------------------------------------------------------*
118 : * Function acelp_fast()
119 : *
120 : * Fast algebraic codebook search.
121 : * Supports 10, 15, 17, 20, 24, and 26 bits codebooks.
122 : *-------------------------------------------------------------------*/
123 :
124 16490 : void acelp_fast(
125 : BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */
126 : const int16_t cdk_index, /* i : codebook index */
127 : const float dn_orig[L_SUBFR], /* i : corr. between target and h[]. */
128 : const float cn[L_SUBFR], /* i : residual after long term prediction */
129 : const float H[L_SUBFR], /* i : impulse response of weighted synthesis filter */
130 : float code[L_SUBFR], /* o : algebraic (fixed) codebook excitation */
131 : float y[], /* o : filtered fixed codebook excitation */
132 : const int16_t L_subfr /* i : subframe length */
133 : )
134 : {
135 : int16_t i, j, q, bits, bits_track, nb_pos, nb_pulse, track, nb_iter, nb_tracks;
136 : int16_t skip_track[MAX_NUM_INTER], skip_track_max;
137 : PulseConfig config;
138 : enum TRACKPOS codetrackpos;
139 : int16_t m[MAX_PULSES_STEREO], s[MAX_PULSES_STEREO], m_max[MAX_PULSES_STEREO], s_max[MAX_PULSES_STEREO];
140 : int16_t track_order[NB_TRACK_FCB_4T * MAX_NUM_INTER], m0_track[NB_TRACK_FCB_4T];
141 : int16_t ind_stream[NPMAXPT * NB_TRACK_FCB_4T], idx;
142 : float G, G1, G2, G3, Gn, Gd, dn[L_SUBFR_MAX];
143 : float tmpF, y_tmp[L_SUBFR_MAX];
144 : float crit_num, crit_den, crit_num_max, crit_den_max;
145 : float h_buf[4 * L_SUBFR_MAX], *h, *h_inv, *p_hn, alp_buf[2 * L_SUBFR_MAX], *alp, *alp_pos0, *alp_pos1, *alp_pos2, *alp_pos3;
146 : float dndn, cncn, s_coef, bn_orig[L_SUBFR_MAX], cncn_track[NB_TRACK_FCB_4T];
147 : float max_val, temp, sign[L_SUBFR_MAX], max_track[MAX_NUM_INTER];
148 : float beta1, beta2;
149 :
150 : /*-----------------------------------------------------------------*
151 : * Initialization
152 : *-----------------------------------------------------------------*/
153 :
154 16490 : nb_iter = NB_TRACK_FCB_4T;
155 16490 : nb_tracks = NB_TRACK_FCB_4T;
156 16490 : nb_pulse = 0; /* to avoid compilation warnings */
157 :
158 16490 : if ( L_subfr == L_SUBFR )
159 : {
160 12666 : config = PulseConfTable[cdk_index];
161 12666 : bits = config.bits;
162 12666 : nb_pulse = config.nb_pulse;
163 12666 : codetrackpos = config.codetrackpos;
164 :
165 12666 : if ( cdk_index == 2 )
166 : {
167 : /* 12 bits, 2 pulses, 2 tracks: 11 (used all tracks) */
168 4442 : nb_tracks = NB_TRACK_FCB_2T;
169 4442 : nb_iter = NB_TRACK_FCB_2T;
170 : }
171 8224 : else if ( nb_pulse == 2 )
172 : {
173 : /* 10 bits, 2 pulses, 4 tracks: 1010 (used only even tracks) */
174 660 : nb_iter = NB_TRACK_FCB_4T - 2;
175 : }
176 7564 : else if ( nb_pulse == 3 )
177 : {
178 6729 : if ( codetrackpos == TRACKPOS_FIXED_FIRST )
179 : {
180 : /* 15 bits, 3 pulses, 4 tracks: 1110 (fixed track to first) */
181 6288 : nb_iter = NB_TRACK_FCB_4T - 1;
182 : }
183 441 : else if ( codetrackpos == TRACKPOS_FREE_THREE )
184 : {
185 : /* 17 bits, 3 pulses, 4 tracks (used all tracks): 1110, 1101, 1011, 0111 */
186 441 : nb_iter = NB_TRACK_FCB_4T;
187 : }
188 : }
189 : }
190 : else /* L_subfr == 2*L_SUBFFR */
191 : {
192 3824 : bits = cdk_index;
193 3824 : codetrackpos = -1; /* to avoid compilation warnings */
194 :
195 3824 : if ( cdk_index == 14 )
196 : {
197 : /* 14 bits, 2 pulses, 2 tracks: 11 (used all tracks) */
198 3824 : nb_pulse = 2;
199 3824 : nb_iter = NB_TRACK_FCB_2T;
200 3824 : codetrackpos = TRACKPOS_FIXED_TWO;
201 3824 : nb_tracks = NB_TRACK_FCB_2T;
202 : }
203 0 : else if ( cdk_index == 12 )
204 : {
205 : /* 12 bits, 2 pulses, 4 tracks: 1010 (used only even tracks) */
206 0 : nb_pulse = 2;
207 0 : nb_iter = NB_TRACK_FCB_4T - 2;
208 0 : codetrackpos = TRACKPOS_FIXED_EVEN;
209 : }
210 0 : else if ( cdk_index == 18 )
211 : {
212 : /* 18 bits, 3 pulses, 4 tracks: 1110 (used first three tracks) */
213 0 : nb_pulse = 3;
214 0 : nb_iter = NB_TRACK_FCB_4T - 1;
215 0 : codetrackpos = TRACKPOS_FIXED_FIRST;
216 : }
217 0 : else if ( cdk_index == 20 )
218 : {
219 : /* 20 bits, 3 pulses, 4 tracks (used all tracks): 1110, 1101, 1011, 0111 */
220 0 : nb_pulse = 3;
221 0 : nb_iter = NB_TRACK_FCB_4T;
222 0 : codetrackpos = TRACKPOS_FREE_THREE;
223 : }
224 0 : else if ( cdk_index == 24 )
225 : {
226 : /* 24 bits, 4 pulses, 4 tracks: 1111 */
227 0 : nb_pulse = 4;
228 0 : nb_iter = NB_TRACK_FCB_4T;
229 0 : codetrackpos = TRACKPOS_FIXED_FIRST;
230 : }
231 : }
232 :
233 16490 : beta1 = BETA_BN1;
234 16490 : beta2 = BETA_BN2;
235 :
236 16490 : if ( cdk_index <= 2 )
237 : {
238 5102 : beta1 = BETA_BN1 * 2;
239 5102 : beta2 = BETA_BN2 * 2;
240 : }
241 :
242 : /*-----------------------------------------------------------------*
243 : * Find signal bn[] and sign pre-selection vector sign[].
244 : *-----------------------------------------------------------------*/
245 :
246 16490 : dndn = sum2_f( dn_orig, L_subfr ) + 0.01f;
247 :
248 16490 : cncn = 0.1f;
249 65918 : for ( q = 0; q < nb_tracks; q++ )
250 : {
251 49428 : cncn_track[q] = 0.1f;
252 :
253 1349524 : for ( i = 0; i < L_subfr; i += nb_tracks )
254 : {
255 1300096 : cncn_track[q] += ( cn[i + q] * cn[i + q] );
256 : }
257 49428 : cncn += cncn_track[q];
258 : }
259 :
260 16490 : s_coef = sqrtf( dndn / cncn );
261 :
262 1316586 : for ( i = 0; i < L_subfr; i++ )
263 : {
264 1300096 : temp = ( s_coef * cn[i] ) + ( beta1 * dn_orig[i] );
265 1300096 : bn_orig[i] = temp;
266 :
267 1300096 : if ( temp >= 0 )
268 : {
269 650638 : sign[i] = 1.0f;
270 : }
271 : else
272 : {
273 649458 : sign[i] = -1.0f;
274 : }
275 : }
276 :
277 : /*-----------------------------------------------------------------*
278 : * Compute buffer h_buf[].
279 : *-----------------------------------------------------------------*/
280 :
281 16490 : h = h_buf;
282 16490 : h_inv = h_buf + ( 2 * L_subfr );
283 :
284 1316586 : for ( i = 0; i < L_subfr; i++ )
285 : {
286 1300096 : *h++ = 0.0f;
287 1300096 : *h_inv++ = 0.0f;
288 : }
289 :
290 1316586 : for ( i = 0; i < L_subfr; i++ )
291 : {
292 1300096 : h[i] = H[i];
293 1300096 : h_inv[i] = -H[i];
294 : }
295 :
296 : /*-----------------------------------------------------------------*
297 : * Approximate FI[i][j] by alp[abs(i-j)] and compute buffer alp_buf[].
298 : *-----------------------------------------------------------------*/
299 :
300 16490 : alp = alp_buf + L_subfr;
301 :
302 1316586 : for ( i = 0; i < L_subfr; i++ )
303 : {
304 1300096 : *alp = 0.0f;
305 :
306 59216320 : for ( j = i; j < L_subfr; j++ )
307 : {
308 57916224 : *alp += H[j] * H[j - i];
309 : }
310 1300096 : alp_buf[L_subfr - i] = *alp++;
311 : }
312 :
313 16490 : alp = alp_buf + L_subfr;
314 :
315 65918 : for ( q = 0; q < nb_tracks; q++ )
316 : {
317 49428 : max_track[q] = 0.0f;
318 :
319 1349524 : for ( i = q; i < L_subfr; i += nb_tracks )
320 : {
321 1300096 : temp = bn_orig[i] * sign[i];
322 :
323 1300096 : if ( temp >= max_track[q] )
324 : {
325 175860 : max_track[q] = temp;
326 175860 : m0_track[q] = i;
327 : }
328 : }
329 : }
330 :
331 : /*-----------------------------------------------------------------*
332 : * Track re-order
333 : *-----------------------------------------------------------------*/
334 :
335 16490 : if ( nb_tracks == NB_TRACK_FCB_2T )
336 : {
337 8266 : track_order[0] = 0;
338 8266 : track_order[1] = 1;
339 8266 : track_order[2] = 1;
340 8266 : track_order[3] = 0;
341 : }
342 : else
343 : {
344 : /* skip certain tracks if number of pulses is lower than number of tracks */
345 8224 : if ( nb_pulse == 2 && nb_tracks == NB_TRACK_FCB_4T )
346 : {
347 660 : max_track[NB_TRACK_FCB_4T - 3] = -1;
348 660 : max_track[NB_TRACK_FCB_4T - 1] = -1;
349 : }
350 7564 : else if ( nb_pulse == 3 && codetrackpos == TRACKPOS_FIXED_FIRST )
351 : {
352 6288 : max_track[NB_TRACK_FCB_4T - 1] = -1;
353 : }
354 :
355 41120 : for ( q = 0; q < nb_tracks; q++ )
356 : {
357 32896 : i = maximum( max_track, nb_tracks, &tmpF );
358 32896 : track_order[q] = i;
359 32896 : max_track[i] = -1.0f;
360 : }
361 :
362 8224 : track_order[4] = track_order[1];
363 8224 : track_order[5] = track_order[0];
364 8224 : track_order[6] = track_order[2];
365 8224 : track_order[7] = track_order[3];
366 :
367 8224 : track_order[8] = track_order[2];
368 8224 : track_order[9] = track_order[0];
369 8224 : track_order[10] = track_order[1];
370 8224 : track_order[11] = track_order[3];
371 :
372 8224 : track_order[12] = track_order[3];
373 8224 : track_order[13] = track_order[0];
374 8224 : track_order[14] = track_order[1];
375 8224 : track_order[15] = track_order[2];
376 :
377 8224 : if ( cdk_index == 3 )
378 : {
379 6288 : track_order[12] = track_order[2];
380 6288 : track_order[13] = track_order[1];
381 6288 : track_order[14] = track_order[0];
382 :
383 6288 : track_order[16] = track_order[1];
384 6288 : track_order[17] = track_order[2];
385 6288 : track_order[18] = track_order[0];
386 6288 : nb_iter = 5;
387 : }
388 1936 : else if ( cdk_index == 4 )
389 : {
390 441 : track_order[16] = track_order[2];
391 441 : track_order[17] = track_order[3];
392 441 : track_order[18] = track_order[1];
393 441 : track_order[19] = track_order[0];
394 441 : nb_iter = 5;
395 : }
396 : }
397 :
398 : /*-----------------------------------------------------------------*
399 : * Main searching loop
400 : *-----------------------------------------------------------------*/
401 :
402 16490 : crit_num_max = -1.0f;
403 16490 : crit_den_max = 1.0f;
404 16490 : skip_track_max = -1;
405 :
406 71327 : for ( q = 0; q < nb_iter; q++ )
407 : {
408 : /*-----------------------------------------------------------------*
409 : * First pulse search
410 : *-----------------------------------------------------------------*/
411 :
412 54837 : track = track_order[q * nb_tracks];
413 54837 : m[0] = m0_track[track];
414 54837 : s[0] = (int16_t) sign[m[0]];
415 :
416 : /*-----------------------------------------------------------------*
417 : * Second pulse search
418 : *-----------------------------------------------------------------*/
419 :
420 54837 : if ( nb_tracks == NB_TRACK_FCB_2T )
421 : {
422 16532 : Gn = s[0] * dn_orig[m[0]];
423 16532 : Gd = alp[0];
424 16532 : G = Gn / Gd;
425 16532 : G *= s[0];
426 :
427 16532 : track = track_order[q * nb_tracks + 1];
428 16532 : alp_pos0 = alp - m[0] + track;
429 :
430 790292 : for ( i = track; i < L_subfr; i += NB_TRACK_FCB_2T )
431 : {
432 773760 : dn[i] = dn_orig[i] - G * ( *alp_pos0 );
433 773760 : alp_pos0 += NB_TRACK_FCB_2T;
434 : }
435 :
436 16532 : m[1] = find_best_pulse( L_subfr, NB_TRACK_FCB_2T, track, dn, sign, &s[1] );
437 : }
438 : else
439 : {
440 38305 : Gn = s[0] * dn_orig[m[0]];
441 38305 : Gd = alp[0];
442 38305 : G = Gn;
443 38305 : G *= s[0];
444 :
445 38305 : track = track_order[q * nb_tracks + 1];
446 38305 : alp_pos0 = alp - m[0] + track;
447 :
448 38305 : dndn = 0.1f;
449 651185 : for ( i = track; i < L_subfr; i += nb_tracks )
450 : {
451 612880 : dn[i] = Gd * dn_orig[i] - G * ( *alp_pos0 );
452 612880 : alp_pos0 += nb_tracks;
453 612880 : dndn += ( dn[i] * dn[i] );
454 : }
455 :
456 38305 : s_coef = sqrtf( dndn / cncn_track[track] );
457 :
458 38305 : max_val = FLT_MIN;
459 38305 : m[1] = track;
460 651185 : for ( i = track; i < L_subfr; i += nb_tracks )
461 : {
462 612880 : dn[i] = ( s_coef * cn[i] ) + ( beta2 * dn[i] );
463 612880 : temp = dn[i] * sign[i];
464 :
465 612880 : if ( temp >= max_val )
466 : {
467 114329 : max_val = temp;
468 114329 : m[1] = i;
469 : }
470 : }
471 :
472 38305 : s[1] = (int16_t) sign[m[1]];
473 : }
474 :
475 : /*-----------------------------------------------------------------*
476 : * Third pulse search
477 : *-----------------------------------------------------------------*/
478 :
479 54837 : if ( nb_pulse >= 3 )
480 : {
481 36985 : Gn += s[1] * dn_orig[m[1]];
482 36985 : Gd += alp[0] + 2 * s[0] * s[1] * alp[m[0] - m[1]];
483 36985 : G = Gn;
484 36985 : G1 = G * s[1];
485 36985 : G *= s[0];
486 :
487 36985 : track = track_order[q * nb_tracks + 2];
488 36985 : alp_pos0 = alp - m[0] + track;
489 36985 : alp_pos1 = alp - m[1] + track;
490 :
491 628745 : for ( i = track; i < L_subfr; i += nb_tracks )
492 : {
493 591760 : dn[i] = Gd * dn_orig[i] - G * ( *alp_pos0 ) - G1 * ( *alp_pos1 );
494 591760 : alp_pos0 += nb_tracks;
495 591760 : alp_pos1 += nb_tracks;
496 : }
497 :
498 36985 : m[2] = find_best_pulse( L_subfr, nb_tracks, track, dn, sign, &s[2] );
499 : }
500 :
501 : /*-----------------------------------------------------------------*
502 : * Fourth pulse search
503 : *-----------------------------------------------------------------*/
504 :
505 54837 : if ( nb_pulse >= 4 )
506 : {
507 3340 : Gn += s[2] * dn_orig[m[2]];
508 3340 : Gd += alp[0] + 2 * s[0] * s[2] * alp[m[0] - m[2]] + 2 * s[1] * s[2] * alp[m[1] - m[2]];
509 3340 : G = Gn;
510 3340 : G1 = G * s[1];
511 3340 : G2 = G * s[2];
512 3340 : G *= s[0];
513 :
514 3340 : track = track_order[q * nb_tracks + 3];
515 3340 : alp_pos0 = alp - m[0] + track;
516 3340 : alp_pos1 = alp - m[1] + track;
517 3340 : alp_pos2 = alp - m[2] + track;
518 :
519 56780 : for ( i = track; i < L_subfr; i += nb_tracks )
520 : {
521 53440 : dn[i] = Gd * dn_orig[i] - G * ( *alp_pos0 ) - G1 * ( *alp_pos1 ) - G2 * ( *alp_pos2 );
522 53440 : alp_pos0 += nb_tracks;
523 53440 : alp_pos1 += nb_tracks;
524 53440 : alp_pos2 += nb_tracks;
525 : }
526 :
527 3340 : m[3] = find_best_pulse( L_subfr, nb_tracks, track, dn, sign, &s[3] );
528 : }
529 : else
530 : {
531 51497 : skip_track[q] = track_order[q * nb_tracks + 3];
532 : }
533 :
534 : /*-----------------------------------------------------------------*
535 : * Fifth pulse search
536 : *-----------------------------------------------------------------*/
537 :
538 54837 : if ( nb_pulse >= 5 )
539 : {
540 2040 : Gn += s[3] * dn_orig[m[3]];
541 2040 : Gd += alp[0] + 2 * s[0] * s[3] * alp[m[0] - m[3]] + 2 * s[1] * s[3] * alp[m[1] - m[3]] + 2 * s[2] * s[3] * alp[m[2] - m[3]];
542 2040 : G = Gn;
543 2040 : G1 = G * s[1];
544 2040 : G2 = G * s[2];
545 2040 : G3 = G * s[3];
546 2040 : G *= s[0];
547 :
548 2040 : if ( cdk_index == 6 )
549 : {
550 1248 : track = 0; /* always track 0 */
551 :
552 1248 : alp_pos0 = alp - m[0];
553 1248 : alp_pos1 = alp - m[1];
554 1248 : alp_pos2 = alp - m[2];
555 1248 : alp_pos3 = alp - m[3];
556 :
557 21216 : for ( i = track; i < L_subfr; i += nb_tracks )
558 : {
559 19968 : dn[i] = Gd * dn_orig[i] - G * ( *alp_pos0 ) - G1 * ( *alp_pos1 ) - G2 * ( *alp_pos2 ) - G3 * ( *alp_pos3 );
560 19968 : alp_pos0 += nb_tracks;
561 19968 : alp_pos1 += nb_tracks;
562 19968 : alp_pos2 += nb_tracks;
563 19968 : alp_pos3 += nb_tracks;
564 : }
565 :
566 1248 : m[4] = find_best_pulse( L_subfr, nb_tracks, track, dn, sign, &s[4] );
567 : }
568 : else /* cdk_index == 7 (26 bits codebook) */
569 : {
570 792 : alp_pos0 = alp - m[0];
571 792 : alp_pos1 = alp - m[1];
572 792 : alp_pos2 = alp - m[2];
573 792 : alp_pos3 = alp - m[3];
574 :
575 51480 : for ( i = 0; i < L_subfr; i++ )
576 : {
577 50688 : dn[i] = Gd * dn_orig[i] - G * ( *alp_pos0 ) - G1 * ( *alp_pos1 ) - G2 * ( *alp_pos2 ) - G3 * ( *alp_pos3 );
578 50688 : alp_pos0++;
579 50688 : alp_pos1++;
580 50688 : alp_pos2++;
581 50688 : alp_pos3++;
582 : }
583 :
584 792 : i = emaximum( dn, L_subfr, &temp );
585 792 : track = i % nb_tracks;
586 :
587 792 : m[4] = find_best_pulse( L_subfr, nb_tracks, track, dn, sign, &s[4] );
588 : }
589 2040 : skip_track[q] = track;
590 : }
591 :
592 : /*-----------------------------------------------------------------*
593 : * - Build the filtered codeword and criterion computing.
594 : * - Memorize the best code positions & signs, and the best filtered codevector.
595 : *-----------------------------------------------------------------*/
596 :
597 54837 : crit_num = 0.0f;
598 54837 : set_zero( y_tmp, L_subfr );
599 :
600 206876 : for ( j = 0; j < nb_pulse; j++ )
601 : {
602 152039 : p_hn = ( ( s[j] > 0 ) ? h - m[j] : h_inv - m[j] );
603 :
604 10861479 : for ( i = 0; i < L_subfr; i++ )
605 : {
606 10709440 : y_tmp[i] += *p_hn++;
607 : }
608 :
609 152039 : crit_num += s[j] * dn_orig[m[j]];
610 : }
611 :
612 54837 : crit_num = crit_num * crit_num;
613 54837 : crit_den = sum2_f( y_tmp, L_subfr );
614 :
615 54837 : if ( crit_num * crit_den_max >= crit_den * crit_num_max )
616 : {
617 32851 : crit_num_max = crit_num;
618 32851 : crit_den_max = crit_den;
619 :
620 120553 : for ( j = 0; j < nb_pulse; j++ )
621 : {
622 87702 : m_max[j] = m[j];
623 87702 : s_max[j] = s[j];
624 : }
625 :
626 32851 : mvr2r( y_tmp, y, L_subfr );
627 32851 : skip_track_max = skip_track[q];
628 : }
629 : }
630 :
631 : /*-----------------------------------------------------------------*
632 : * Reconstruct the best codevector,
633 : * compute index of codevector and write it into the bitstream.
634 : *-----------------------------------------------------------------*/
635 :
636 16490 : set_zero( code, L_subfr );
637 58379 : for ( q = 0; q < nb_pulse; q++ )
638 : {
639 41889 : code[m_max[q]] += s_max[q];
640 : }
641 :
642 16490 : if ( bits == 12 || bits == 14 )
643 : {
644 : /* 12 bits, 2 pulses, 2 tracks 11 used all tracks */
645 8266 : i = 6;
646 8266 : j = 0x800;
647 8266 : q = 0x20;
648 :
649 8266 : if ( L_subfr == 2 * L_SUBFR )
650 : {
651 : /* 14 bits, 2 pulses, 2 tracks: 11 (used all tracks) */
652 3824 : i = 7;
653 3824 : j = 0x2000;
654 3824 : q = 0x40;
655 : }
656 :
657 8266 : if ( m_max[0] % NB_TRACK_FCB_2T == 1 )
658 : {
659 4652 : idx = ( ( m_max[1] / NB_TRACK_FCB_2T ) << i ) + ( m_max[0] / NB_TRACK_FCB_2T );
660 :
661 4652 : if ( s_max[1] < 0.0f )
662 : {
663 2318 : idx += j;
664 : }
665 :
666 4652 : if ( s_max[0] < 0.0f )
667 : {
668 2254 : idx += q;
669 : }
670 : }
671 : else
672 : {
673 3614 : idx = ( ( m_max[0] / NB_TRACK_FCB_2T ) << i ) + ( m_max[1] / NB_TRACK_FCB_2T );
674 :
675 3614 : if ( s_max[0] < 0.0f )
676 : {
677 1768 : idx += j;
678 : }
679 :
680 3614 : if ( s_max[1] < 0.0f )
681 : {
682 1863 : idx += q;
683 : }
684 : }
685 :
686 8266 : push_indice( hBstr, IND_ALG_CDBK_2T32, idx, bits );
687 : }
688 : else
689 : {
690 : /* compute index of codevector */
691 8224 : set_s( ind_stream, -1, NPMAXPT * nb_tracks );
692 :
693 8224 : bits_track = 4;
694 8224 : nb_pos = NB_POS_FCB_4T;
695 :
696 8224 : if ( L_subfr == 2 * L_SUBFR )
697 : {
698 0 : bits_track = 5;
699 0 : nb_pos = NB_POS_FCB_4T_128;
700 : }
701 :
702 33581 : for ( q = 0; q < nb_pulse; q++ )
703 : {
704 25357 : i = ( m_max[q] % NB_TRACK_FCB_4T ) * NPMAXPT; /* track number */
705 25357 : if ( ind_stream[i] >= 0 )
706 : {
707 510 : i++;
708 : }
709 25357 : ind_stream[i] = m_max[q] / NB_TRACK_FCB_4T; /* pos of pulse */
710 :
711 25357 : if ( s_max[q] < 0 )
712 : {
713 12531 : ind_stream[i] += nb_pos;
714 : }
715 : }
716 :
717 8224 : if ( codetrackpos == TRACKPOS_FREE_THREE || codetrackpos == TRACKPOS_FREE_ONE )
718 : {
719 639 : push_indice( hBstr, IND_ALG_CDBK_4T64, skip_track_max, 2 );
720 : }
721 :
722 8224 : if ( nb_pulse < 5 )
723 : {
724 38570 : for ( q = 0; q < NB_TRACK_FCB_4T; q++ )
725 : {
726 30856 : j = q * NPMAXPT;
727 30856 : if ( ind_stream[j] != -1 )
728 : {
729 22807 : idx = quant_1p_N1_L_subfr( nb_pos, ind_stream[j], bits_track );
730 22807 : push_indice( hBstr, IND_ALG_CDBK_4T64, idx, bits_track + 1 );
731 : }
732 : }
733 : }
734 : else
735 : {
736 2550 : for ( q = 0; q < NB_TRACK_FCB_4T; q++ )
737 : {
738 2040 : j = q * NPMAXPT;
739 2040 : if ( q == skip_track_max )
740 : {
741 510 : idx = quant_2p_2N1( ind_stream[j], ind_stream[j + 1], bits_track );
742 510 : push_indice( hBstr, IND_ALG_CDBK_4T64, idx, ( 2 * bits_track ) + 1 );
743 : }
744 : else
745 : {
746 1530 : idx = quant_1p_N1_L_subfr( nb_pos, ind_stream[j], bits_track );
747 1530 : push_indice( hBstr, IND_ALG_CDBK_4T64, idx, bits_track + 1 );
748 : }
749 : }
750 : }
751 : }
752 :
753 16490 : return;
754 : }
|
