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