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 392447 : 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 392447 : mask = ( ( 1 << N ) - 1 );
70 :
71 392447 : index = ( pos & mask );
72 :
73 392447 : if ( ( pos & nb_pos ) != 0 )
74 : {
75 196827 : index += 1 << N;
76 : }
77 :
78 392447 : return index;
79 : }
80 :
81 : /*-------------------------------------------------------------------*
82 : * Function find_best_pulse()
83 : *
84 : * Find best pulse
85 : *-------------------------------------------------------------------*/
86 :
87 866412 : 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 866412 : max_val = FLT_MIN;
99 866412 : m = track;
100 19052684 : for ( i = track; i < L_subfr; i += nb_tracks )
101 : {
102 18186272 : temp = dn[i] * sign[i];
103 :
104 18186272 : if ( temp >= max_val )
105 : {
106 2704680 : max_val = temp;
107 2704680 : m = i;
108 : }
109 : }
110 :
111 866412 : *s = (int16_t) sign[m];
112 :
113 866412 : 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 200218 : 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 200218 : nb_iter = NB_TRACK_FCB_4T;
155 200218 : nb_tracks = NB_TRACK_FCB_4T;
156 200218 : nb_pulse = 0; /* to avoid compilation warnings */
157 :
158 200218 : if ( L_subfr == L_SUBFR )
159 : {
160 167918 : config = PulseConfTable[cdk_index];
161 167918 : bits = config.bits;
162 167918 : nb_pulse = config.nb_pulse;
163 167918 : codetrackpos = config.codetrackpos;
164 :
165 167918 : if ( cdk_index == 2 )
166 : {
167 : /* 12 bits, 2 pulses, 2 tracks: 11 (used all tracks) */
168 38284 : nb_tracks = NB_TRACK_FCB_2T;
169 38284 : nb_iter = NB_TRACK_FCB_2T;
170 : }
171 129634 : else if ( nb_pulse == 2 )
172 : {
173 : /* 10 bits, 2 pulses, 4 tracks: 1010 (used only even tracks) */
174 3911 : nb_iter = NB_TRACK_FCB_4T - 2;
175 : }
176 125723 : else if ( nb_pulse == 3 )
177 : {
178 107794 : if ( codetrackpos == TRACKPOS_FIXED_FIRST )
179 : {
180 : /* 15 bits, 3 pulses, 4 tracks: 1110 (fixed track to first) */
181 103391 : nb_iter = NB_TRACK_FCB_4T - 1;
182 : }
183 4403 : else if ( codetrackpos == TRACKPOS_FREE_THREE )
184 : {
185 : /* 17 bits, 3 pulses, 4 tracks (used all tracks): 1110, 1101, 1011, 0111 */
186 4403 : nb_iter = NB_TRACK_FCB_4T;
187 : }
188 : }
189 : }
190 : else /* L_subfr == 2*L_SUBFFR */
191 : {
192 32300 : bits = cdk_index;
193 32300 : codetrackpos = -1; /* to avoid compilation warnings */
194 :
195 32300 : if ( cdk_index == 14 )
196 : {
197 : /* 14 bits, 2 pulses, 2 tracks: 11 (used all tracks) */
198 32232 : nb_pulse = 2;
199 32232 : nb_iter = NB_TRACK_FCB_2T;
200 32232 : codetrackpos = TRACKPOS_FIXED_TWO;
201 32232 : nb_tracks = NB_TRACK_FCB_2T;
202 : }
203 68 : 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 68 : else if ( cdk_index == 18 )
211 : {
212 : /* 18 bits, 3 pulses, 4 tracks: 1110 (used first three tracks) */
213 2 : nb_pulse = 3;
214 2 : nb_iter = NB_TRACK_FCB_4T - 1;
215 2 : codetrackpos = TRACKPOS_FIXED_FIRST;
216 : }
217 66 : else if ( cdk_index == 20 )
218 : {
219 : /* 20 bits, 3 pulses, 4 tracks (used all tracks): 1110, 1101, 1011, 0111 */
220 66 : nb_pulse = 3;
221 66 : nb_iter = NB_TRACK_FCB_4T;
222 66 : 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 200218 : beta1 = BETA_BN1;
234 200218 : beta2 = BETA_BN2;
235 :
236 200218 : if ( cdk_index <= 2 )
237 : {
238 42195 : beta1 = BETA_BN1 * 2;
239 42195 : beta2 = BETA_BN2 * 2;
240 : }
241 :
242 : /*-----------------------------------------------------------------*
243 : * Find signal bn[] and sign pre-selection vector sign[].
244 : *-----------------------------------------------------------------*/
245 :
246 200218 : dndn = sum2_f( dn_orig, L_subfr ) + 0.01f;
247 :
248 200218 : cncn = 0.1f;
249 860058 : for ( q = 0; q < nb_tracks; q++ )
250 : {
251 659840 : cncn_track[q] = 0.1f;
252 :
253 15540992 : for ( i = 0; i < L_subfr; i += nb_tracks )
254 : {
255 14881152 : cncn_track[q] += ( cn[i + q] * cn[i + q] );
256 : }
257 659840 : cncn += cncn_track[q];
258 : }
259 :
260 200218 : s_coef = sqrtf( dndn / cncn );
261 :
262 15081370 : for ( i = 0; i < L_subfr; i++ )
263 : {
264 14881152 : temp = ( s_coef * cn[i] ) + ( beta1 * dn_orig[i] );
265 14881152 : bn_orig[i] = temp;
266 :
267 14881152 : if ( temp >= 0 )
268 : {
269 7408694 : sign[i] = 1.0f;
270 : }
271 : else
272 : {
273 7472458 : sign[i] = -1.0f;
274 : }
275 : }
276 :
277 : /*-----------------------------------------------------------------*
278 : * Compute buffer h_buf[].
279 : *-----------------------------------------------------------------*/
280 :
281 200218 : h = h_buf;
282 200218 : h_inv = h_buf + ( 2 * L_subfr );
283 :
284 15081370 : for ( i = 0; i < L_subfr; i++ )
285 : {
286 14881152 : *h++ = 0.0f;
287 14881152 : *h_inv++ = 0.0f;
288 : }
289 :
290 15081370 : for ( i = 0; i < L_subfr; i++ )
291 : {
292 14881152 : h[i] = H[i];
293 14881152 : 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 200218 : alp = alp_buf + L_subfr;
301 :
302 15081370 : for ( i = 0; i < L_subfr; i++ )
303 : {
304 14881152 : *alp = 0.0f;
305 :
306 630819392 : for ( j = i; j < L_subfr; j++ )
307 : {
308 615938240 : *alp += H[j] * H[j - i];
309 : }
310 14881152 : alp_buf[L_subfr - i] = *alp++;
311 : }
312 :
313 200218 : alp = alp_buf + L_subfr;
314 :
315 860058 : for ( q = 0; q < nb_tracks; q++ )
316 : {
317 659840 : max_track[q] = 0.0f;
318 :
319 15540992 : for ( i = q; i < L_subfr; i += nb_tracks )
320 : {
321 14881152 : temp = bn_orig[i] * sign[i];
322 :
323 14881152 : if ( temp >= max_track[q] )
324 : {
325 2230004 : max_track[q] = temp;
326 2230004 : m0_track[q] = i;
327 : }
328 : }
329 : }
330 :
331 : /*-----------------------------------------------------------------*
332 : * Track re-order
333 : *-----------------------------------------------------------------*/
334 :
335 200218 : if ( nb_tracks == NB_TRACK_FCB_2T )
336 : {
337 70516 : track_order[0] = 0;
338 70516 : track_order[1] = 1;
339 70516 : track_order[2] = 1;
340 70516 : track_order[3] = 0;
341 : }
342 : else
343 : {
344 : /* skip certain tracks if number of pulses is lower than number of tracks */
345 129702 : if ( nb_pulse == 2 && nb_tracks == NB_TRACK_FCB_4T )
346 : {
347 3911 : max_track[NB_TRACK_FCB_4T - 3] = -1;
348 3911 : max_track[NB_TRACK_FCB_4T - 1] = -1;
349 : }
350 125791 : else if ( nb_pulse == 3 && codetrackpos == TRACKPOS_FIXED_FIRST )
351 : {
352 103393 : max_track[NB_TRACK_FCB_4T - 1] = -1;
353 : }
354 :
355 648510 : for ( q = 0; q < nb_tracks; q++ )
356 : {
357 518808 : i = maximum( max_track, nb_tracks, &tmpF );
358 518808 : track_order[q] = i;
359 518808 : max_track[i] = -1.0f;
360 : }
361 :
362 129702 : track_order[4] = track_order[1];
363 129702 : track_order[5] = track_order[0];
364 129702 : track_order[6] = track_order[2];
365 129702 : track_order[7] = track_order[3];
366 :
367 129702 : track_order[8] = track_order[2];
368 129702 : track_order[9] = track_order[0];
369 129702 : track_order[10] = track_order[1];
370 129702 : track_order[11] = track_order[3];
371 :
372 129702 : track_order[12] = track_order[3];
373 129702 : track_order[13] = track_order[0];
374 129702 : track_order[14] = track_order[1];
375 129702 : track_order[15] = track_order[2];
376 :
377 129702 : if ( cdk_index == 3 )
378 : {
379 103391 : track_order[12] = track_order[2];
380 103391 : track_order[13] = track_order[1];
381 103391 : track_order[14] = track_order[0];
382 :
383 103391 : track_order[16] = track_order[1];
384 103391 : track_order[17] = track_order[2];
385 103391 : track_order[18] = track_order[0];
386 103391 : nb_iter = 5;
387 : }
388 26311 : else if ( cdk_index == 4 )
389 : {
390 4403 : track_order[16] = track_order[2];
391 4403 : track_order[17] = track_order[3];
392 4403 : track_order[18] = track_order[1];
393 4403 : track_order[19] = track_order[0];
394 4403 : nb_iter = 5;
395 : }
396 : }
397 :
398 : /*-----------------------------------------------------------------*
399 : * Main searching loop
400 : *-----------------------------------------------------------------*/
401 :
402 200218 : crit_num_max = -1.0f;
403 200218 : crit_den_max = 1.0f;
404 200218 : skip_track_max = -1;
405 :
406 960028 : for ( q = 0; q < nb_iter; q++ )
407 : {
408 : /*-----------------------------------------------------------------*
409 : * First pulse search
410 : *-----------------------------------------------------------------*/
411 :
412 759810 : track = track_order[q * nb_tracks];
413 759810 : m[0] = m0_track[track];
414 759810 : s[0] = (int16_t) sign[m[0]];
415 :
416 : /*-----------------------------------------------------------------*
417 : * Second pulse search
418 : *-----------------------------------------------------------------*/
419 :
420 759810 : if ( nb_tracks == NB_TRACK_FCB_2T )
421 : {
422 141032 : Gn = s[0] * dn_orig[m[0]];
423 141032 : Gd = alp[0];
424 141032 : G = Gn / Gd;
425 141032 : G *= s[0];
426 :
427 141032 : track = track_order[q * nb_tracks + 1];
428 141032 : alp_pos0 = alp - m[0] + track;
429 :
430 6716904 : for ( i = track; i < L_subfr; i += NB_TRACK_FCB_2T )
431 : {
432 6575872 : dn[i] = dn_orig[i] - G * ( *alp_pos0 );
433 6575872 : alp_pos0 += NB_TRACK_FCB_2T;
434 : }
435 :
436 141032 : m[1] = find_best_pulse( L_subfr, NB_TRACK_FCB_2T, track, dn, sign, &s[1] );
437 : }
438 : else
439 : {
440 618778 : Gn = s[0] * dn_orig[m[0]];
441 618778 : Gd = alp[0];
442 618778 : G = Gn;
443 618778 : G *= s[0];
444 :
445 618778 : track = track_order[q * nb_tracks + 1];
446 618778 : alp_pos0 = alp - m[0] + track;
447 :
448 618778 : dndn = 0.1f;
449 10523546 : for ( i = track; i < L_subfr; i += nb_tracks )
450 : {
451 9904768 : dn[i] = Gd * dn_orig[i] - G * ( *alp_pos0 );
452 9904768 : alp_pos0 += nb_tracks;
453 9904768 : dndn += ( dn[i] * dn[i] );
454 : }
455 :
456 618778 : s_coef = sqrtf( dndn / cncn_track[track] );
457 :
458 618778 : max_val = FLT_MIN;
459 618778 : m[1] = track;
460 10523546 : for ( i = track; i < L_subfr; i += nb_tracks )
461 : {
462 9904768 : dn[i] = ( s_coef * cn[i] ) + ( beta2 * dn[i] );
463 9904768 : temp = dn[i] * sign[i];
464 :
465 9904768 : if ( temp >= max_val )
466 : {
467 1818358 : max_val = temp;
468 1818358 : m[1] = i;
469 : }
470 : }
471 :
472 618778 : s[1] = (int16_t) sign[m[1]];
473 : }
474 :
475 : /*-----------------------------------------------------------------*
476 : * Third pulse search
477 : *-----------------------------------------------------------------*/
478 :
479 759810 : if ( nb_pulse >= 3 )
480 : {
481 610956 : Gn += s[1] * dn_orig[m[1]];
482 610956 : Gd += alp[0] + 2 * s[0] * s[1] * alp[m[0] - m[1]];
483 610956 : G = Gn;
484 610956 : G1 = G * s[1];
485 610956 : G *= s[0];
486 :
487 610956 : track = track_order[q * nb_tracks + 2];
488 610956 : alp_pos0 = alp - m[0] + track;
489 610956 : alp_pos1 = alp - m[1] + track;
490 :
491 10390572 : for ( i = track; i < L_subfr; i += nb_tracks )
492 : {
493 9779616 : dn[i] = Gd * dn_orig[i] - G * ( *alp_pos0 ) - G1 * ( *alp_pos1 );
494 9779616 : alp_pos0 += nb_tracks;
495 9779616 : alp_pos1 += nb_tracks;
496 : }
497 :
498 610956 : m[2] = find_best_pulse( L_subfr, nb_tracks, track, dn, sign, &s[2] );
499 : }
500 :
501 : /*-----------------------------------------------------------------*
502 : * Fourth pulse search
503 : *-----------------------------------------------------------------*/
504 :
505 759810 : if ( nb_pulse >= 4 )
506 : {
507 71716 : Gn += s[2] * dn_orig[m[2]];
508 71716 : Gd += alp[0] + 2 * s[0] * s[2] * alp[m[0] - m[2]] + 2 * s[1] * s[2] * alp[m[1] - m[2]];
509 71716 : G = Gn;
510 71716 : G1 = G * s[1];
511 71716 : G2 = G * s[2];
512 71716 : G *= s[0];
513 :
514 71716 : track = track_order[q * nb_tracks + 3];
515 71716 : alp_pos0 = alp - m[0] + track;
516 71716 : alp_pos1 = alp - m[1] + track;
517 71716 : alp_pos2 = alp - m[2] + track;
518 :
519 1219172 : for ( i = track; i < L_subfr; i += nb_tracks )
520 : {
521 1147456 : dn[i] = Gd * dn_orig[i] - G * ( *alp_pos0 ) - G1 * ( *alp_pos1 ) - G2 * ( *alp_pos2 );
522 1147456 : alp_pos0 += nb_tracks;
523 1147456 : alp_pos1 += nb_tracks;
524 1147456 : alp_pos2 += nb_tracks;
525 : }
526 :
527 71716 : m[3] = find_best_pulse( L_subfr, nb_tracks, track, dn, sign, &s[3] );
528 : }
529 : else
530 : {
531 688094 : skip_track[q] = track_order[q * nb_tracks + 3];
532 : }
533 :
534 : /*-----------------------------------------------------------------*
535 : * Fifth pulse search
536 : *-----------------------------------------------------------------*/
537 :
538 759810 : if ( nb_pulse >= 5 )
539 : {
540 42708 : Gn += s[3] * dn_orig[m[3]];
541 42708 : 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 42708 : G = Gn;
543 42708 : G1 = G * s[1];
544 42708 : G2 = G * s[2];
545 42708 : G3 = G * s[3];
546 42708 : G *= s[0];
547 :
548 42708 : if ( cdk_index == 6 )
549 : {
550 21940 : track = 0; /* always track 0 */
551 :
552 21940 : alp_pos0 = alp - m[0];
553 21940 : alp_pos1 = alp - m[1];
554 21940 : alp_pos2 = alp - m[2];
555 21940 : alp_pos3 = alp - m[3];
556 :
557 372980 : for ( i = track; i < L_subfr; i += nb_tracks )
558 : {
559 351040 : dn[i] = Gd * dn_orig[i] - G * ( *alp_pos0 ) - G1 * ( *alp_pos1 ) - G2 * ( *alp_pos2 ) - G3 * ( *alp_pos3 );
560 351040 : alp_pos0 += nb_tracks;
561 351040 : alp_pos1 += nb_tracks;
562 351040 : alp_pos2 += nb_tracks;
563 351040 : alp_pos3 += nb_tracks;
564 : }
565 :
566 21940 : 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 20768 : alp_pos0 = alp - m[0];
571 20768 : alp_pos1 = alp - m[1];
572 20768 : alp_pos2 = alp - m[2];
573 20768 : alp_pos3 = alp - m[3];
574 :
575 1349920 : for ( i = 0; i < L_subfr; i++ )
576 : {
577 1329152 : dn[i] = Gd * dn_orig[i] - G * ( *alp_pos0 ) - G1 * ( *alp_pos1 ) - G2 * ( *alp_pos2 ) - G3 * ( *alp_pos3 );
578 1329152 : alp_pos0++;
579 1329152 : alp_pos1++;
580 1329152 : alp_pos2++;
581 1329152 : alp_pos3++;
582 : }
583 :
584 20768 : i = emaximum( dn, L_subfr, &temp );
585 20768 : track = i % nb_tracks;
586 :
587 20768 : m[4] = find_best_pulse( L_subfr, nb_tracks, track, dn, sign, &s[4] );
588 : }
589 42708 : 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 759810 : crit_num = 0.0f;
598 759810 : set_zero( y_tmp, L_subfr );
599 :
600 3004810 : for ( j = 0; j < nb_pulse; j++ )
601 : {
602 2245000 : p_hn = ( ( s[j] > 0 ) ? h - m[j] : h_inv - m[j] );
603 :
604 154228232 : for ( i = 0; i < L_subfr; i++ )
605 : {
606 151983232 : y_tmp[i] += *p_hn++;
607 : }
608 :
609 2245000 : crit_num += s[j] * dn_orig[m[j]];
610 : }
611 :
612 759810 : crit_num = crit_num * crit_num;
613 759810 : crit_den = sum2_f( y_tmp, L_subfr );
614 :
615 759810 : if ( crit_num * crit_den_max >= crit_den * crit_num_max )
616 : {
617 432557 : crit_num_max = crit_num;
618 432557 : crit_den_max = crit_den;
619 :
620 1682759 : for ( j = 0; j < nb_pulse; j++ )
621 : {
622 1250202 : m_max[j] = m[j];
623 1250202 : s_max[j] = s[j];
624 : }
625 :
626 432557 : mvr2r( y_tmp, y, L_subfr );
627 432557 : 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 200218 : set_zero( code, L_subfr );
637 755051 : for ( q = 0; q < nb_pulse; q++ )
638 : {
639 554833 : code[m_max[q]] += s_max[q];
640 : }
641 :
642 200218 : if ( bits == 12 || bits == 14 )
643 : {
644 : /* 12 bits, 2 pulses, 2 tracks 11 used all tracks */
645 70516 : i = 6;
646 70516 : j = 0x800;
647 70516 : q = 0x20;
648 :
649 70516 : if ( L_subfr == 2 * L_SUBFR )
650 : {
651 : /* 14 bits, 2 pulses, 2 tracks: 11 (used all tracks) */
652 32232 : i = 7;
653 32232 : j = 0x2000;
654 32232 : q = 0x40;
655 : }
656 :
657 70516 : if ( m_max[0] % NB_TRACK_FCB_2T == 1 )
658 : {
659 40183 : idx = ( ( m_max[1] / NB_TRACK_FCB_2T ) << i ) + ( m_max[0] / NB_TRACK_FCB_2T );
660 :
661 40183 : if ( s_max[1] < 0.0f )
662 : {
663 19964 : idx += j;
664 : }
665 :
666 40183 : if ( s_max[0] < 0.0f )
667 : {
668 19804 : idx += q;
669 : }
670 : }
671 : else
672 : {
673 30333 : idx = ( ( m_max[0] / NB_TRACK_FCB_2T ) << i ) + ( m_max[1] / NB_TRACK_FCB_2T );
674 :
675 30333 : if ( s_max[0] < 0.0f )
676 : {
677 15004 : idx += j;
678 : }
679 :
680 30333 : if ( s_max[1] < 0.0f )
681 : {
682 15101 : idx += q;
683 : }
684 : }
685 :
686 70516 : push_indice( hBstr, IND_ALG_CDBK_2T32, idx, bits );
687 : }
688 : else
689 : {
690 : /* compute index of codevector */
691 129702 : set_s( ind_stream, -1, NPMAXPT * nb_tracks );
692 :
693 129702 : bits_track = 4;
694 129702 : nb_pos = NB_POS_FCB_4T;
695 :
696 129702 : if ( L_subfr == 2 * L_SUBFR )
697 : {
698 68 : bits_track = 5;
699 68 : nb_pos = NB_POS_FCB_4T_128;
700 : }
701 :
702 543503 : for ( q = 0; q < nb_pulse; q++ )
703 : {
704 413801 : i = ( m_max[q] % NB_TRACK_FCB_4T ) * NPMAXPT; /* track number */
705 413801 : if ( ind_stream[i] >= 0 )
706 : {
707 10677 : i++;
708 : }
709 413801 : ind_stream[i] = m_max[q] / NB_TRACK_FCB_4T; /* pos of pulse */
710 :
711 413801 : if ( s_max[q] < 0 )
712 : {
713 207760 : ind_stream[i] += nb_pos;
714 : }
715 : }
716 :
717 129702 : if ( codetrackpos == TRACKPOS_FREE_THREE || codetrackpos == TRACKPOS_FREE_ONE )
718 : {
719 9661 : push_indice( hBstr, IND_ALG_CDBK_4T64, skip_track_max, 2 );
720 : }
721 :
722 129702 : if ( nb_pulse < 5 )
723 : {
724 595125 : for ( q = 0; q < NB_TRACK_FCB_4T; q++ )
725 : {
726 476100 : j = q * NPMAXPT;
727 476100 : if ( ind_stream[j] != -1 )
728 : {
729 360416 : idx = quant_1p_N1_L_subfr( nb_pos, ind_stream[j], bits_track );
730 360416 : push_indice( hBstr, IND_ALG_CDBK_4T64, idx, bits_track + 1 );
731 : }
732 : }
733 : }
734 : else
735 : {
736 53385 : for ( q = 0; q < NB_TRACK_FCB_4T; q++ )
737 : {
738 42708 : j = q * NPMAXPT;
739 42708 : if ( q == skip_track_max )
740 : {
741 10677 : idx = quant_2p_2N1( ind_stream[j], ind_stream[j + 1], bits_track );
742 10677 : push_indice( hBstr, IND_ALG_CDBK_4T64, idx, ( 2 * bits_track ) + 1 );
743 : }
744 : else
745 : {
746 32031 : idx = quant_1p_N1_L_subfr( nb_pos, ind_stream[j], bits_track );
747 32031 : push_indice( hBstr, IND_ALG_CDBK_4T64, idx, bits_track + 1 );
748 : }
749 : }
750 : }
751 : }
752 :
753 200218 : return;
754 : }
|
