FreeCalypso > hg > gsm-codec-lib

comparison libgsmefr/cod_12k2.c @ 58:d285877fc4cc

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
libgsmefr: cod_12k2.c compiles
author Mychaela Falconia <falcon@freecalypso.org>
date Fri, 25 Nov 2022 18:50:50 +0000
parents 49dd1ac8e75b
children d9ad0f5121e8
comparison
equal deleted inserted replaced
57:e005e7b91f3c 58:d285877fc4cc
13 * Speech encoder routine operating on a frame basis. 13 * Speech encoder routine operating on a frame basis.
14 * 14 *
15 15
16 ***************************************************************************/ 16 ***************************************************************************/
17 17
18 #include "gsm_efr.h"
18 #include "typedef.h" 19 #include "typedef.h"
20 #include "namespace.h"
19 #include "basic_op.h" 21 #include "basic_op.h"
20 #include "sig_proc.h" 22 #include "sig_proc.h"
21 #include "count.h" 23 #include "memops.h"
24 #include "no_count.h"
22 #include "codec.h" 25 #include "codec.h"
23 #include "cnst.h" 26 #include "cnst.h"
27 #include "enc_state.h"
24 28
25 #include "window2.tab" 29 #include "window2.tab"
26 30
27 #include "vad.h" 31 #include "vad.h"
28 #include "dtx.h" 32 #include "dtx.h"
40 * PIT_MIN : Minimum pitch lag * 44 * PIT_MIN : Minimum pitch lag *
41 * PIT_MAX : Maximum pitch lag * 45 * PIT_MAX : Maximum pitch lag *
42 * L_INTERPOL : Length of filter for interpolation * 46 * L_INTERPOL : Length of filter for interpolation *
43 *-----------------------------------------------------------*/ 47 *-----------------------------------------------------------*/
44 48
45 /*--------------------------------------------------------*
46 * Static memory allocation. *
47 *--------------------------------------------------------*/
48
49 /* Speech vector */
50
51 static Word16 old_speech[L_TOTAL];
52 static Word16 *speech, *p_window, *p_window_mid;
53 Word16 *new_speech; /* Global variable */
54
55 /* Weight speech vector */
56
57 static Word16 old_wsp[L_FRAME + PIT_MAX];
58 static Word16 *wsp;
59
60 /* Excitation vector */
61
62 static Word16 old_exc[L_FRAME + PIT_MAX + L_INTERPOL];
63 static Word16 *exc;
64
65 /* Zero vector */
66
67 static Word16 ai_zero[L_SUBFR + MP1];
68 static Word16 *zero;
69
70 /* Impulse response vector */
71
72 static Word16 *h1;
73 static Word16 hvec[L_SUBFR * 2];
74
75 /* Spectral expansion factors */ 49 /* Spectral expansion factors */
76 50
77 static const Word16 F_gamma1[M] = 51 static const Word16 F_gamma1[M] =
78 { 52 {
79 29491, 26542, 23888, 21499, 19349, 53 29491, 26542, 23888, 21499, 19349,
83 { 57 {
84 19661, 11797, 7078, 4247, 2548, 58 19661, 11797, 7078, 4247, 2548,
85 1529, 917, 550, 330, 198 59 1529, 917, 550, 330, 198
86 }; 60 };
87 61
88 /* Lsp (Line spectral pairs) */
89
90 static Word16 lsp_old[M];
91 static Word16 lsp_old_q[M];
92
93 /* Filter's memory */
94
95 static Word16 mem_syn[M], mem_w0[M], mem_w[M];
96 static Word16 mem_err[M + L_SUBFR], *error;
97
98 /*************************************************************************** 62 /***************************************************************************
99 * FUNCTION: Init_Coder_12k2 63 * FUNCTION: Init_Coder_12k2
100 * 64 *
101 * PURPOSE: Initialization of variables for the coder section. 65 * PURPOSE: Initialization of variables for the coder section.
102 * 66 *
105 * - initialize static pointers 69 * - initialize static pointers
106 * - set static vectors to zero 70 * - set static vectors to zero
107 * 71 *
108 ***************************************************************************/ 72 ***************************************************************************/
109 73
110 void Init_Coder_12k2 (void) 74 void Init_Coder_12k2 (struct EFR_encoder_state *st)
111 { 75 {
112
113 /*--------------------------------------------------------------------------*
114 * Initialize pointers to speech vector. *
115 *--------------------------------------------------------------------------*/
116
117 new_speech = old_speech + L_TOTAL - L_FRAME;/* New speech */
118 speech = new_speech; /* Present frame */
119 p_window = old_speech + L_TOTAL - L_WINDOW; /* For LPC window */
120 p_window_mid = p_window; /* For LPC window */
121
122 /* Initialize static pointers */
123
124 wsp = old_wsp + PIT_MAX;
125 exc = old_exc + PIT_MAX + L_INTERPOL;
126 zero = ai_zero + MP1;
127 error = mem_err + M;
128 h1 = &hvec[L_SUBFR];
129
130 /* Static vectors to zero */ 76 /* Static vectors to zero */
131 77
132 Set_zero (old_speech, L_TOTAL); 78 Set_zero (st->old_speech, L_TOTAL);
133 Set_zero (old_exc, PIT_MAX + L_INTERPOL); 79 Set_zero (st->old_exc, PIT_MAX + L_INTERPOL);
134 Set_zero (old_wsp, PIT_MAX); 80 Set_zero (st->old_wsp, PIT_MAX);
135 Set_zero (mem_syn, M); 81 Set_zero (st->mem_syn, M);
136 Set_zero (mem_w, M); 82 Set_zero (st->mem_w, M);
137 Set_zero (mem_w0, M); 83 Set_zero (st->mem_w0, M);
138 Set_zero (mem_err, M); 84 Set_zero (st->mem_err, M);
139 Set_zero (zero, L_SUBFR); 85 Set_zero (st->ai_zero + MP1, L_SUBFR);
140 Set_zero (hvec, L_SUBFR); /* set to zero "h1[-L_SUBFR..-1]" */ 86 Set_zero (st->hvec, L_SUBFR); /* set to zero "h1[-L_SUBFR..-1]" */
141 87
142 /* Initialize lsp_old [] */ 88 /* Initialize lsp_old [] */
143 89
144 lsp_old[0] = 30000; 90 st->lsp_old[0] = 30000;
145 lsp_old[1] = 26000; 91 st->lsp_old[1] = 26000;
146 lsp_old[2] = 21000; 92 st->lsp_old[2] = 21000;
147 lsp_old[3] = 15000; 93 st->lsp_old[3] = 15000;
148 lsp_old[4] = 8000; 94 st->lsp_old[4] = 8000;
149 lsp_old[5] = 0; 95 st->lsp_old[5] = 0;
150 lsp_old[6] = -8000; 96 st->lsp_old[6] = -8000;
151 lsp_old[7] = -15000; 97 st->lsp_old[7] = -15000;
152 lsp_old[8] = -21000; 98 st->lsp_old[8] = -21000;
153 lsp_old[9] = -26000; 99 st->lsp_old[9] = -26000;
154 100
155 /* Initialize lsp_old_q[] */ 101 /* Initialize lsp_old_q[] */
156 102
157 Copy (lsp_old, lsp_old_q, M); 103 Copy (st->lsp_old, st->lsp_old_q, M);
158 104
159 return; 105 return;
160 } 106 }
161 107
162 /*************************************************************************** 108 /***************************************************************************
182 * synth[]: Local synthesis speech (for debugging purposes) 128 * synth[]: Local synthesis speech (for debugging purposes)
183 * 129 *
184 ***************************************************************************/ 130 ***************************************************************************/
185 131
186 void Coder_12k2 ( 132 void Coder_12k2 (
133 struct EFR_encoder_state *st,
187 Word16 ana[], /* output : Analysis parameters */ 134 Word16 ana[], /* output : Analysis parameters */
188 Word16 synth[] /* output : Local synthesis */ 135 Word16 synth[] /* output : Local synthesis */
189 ) 136 )
190 { 137 {
138 /* handy pointers that were static vars in the original code */
139 Word16 *speech = st->old_speech + L_TOTAL - L_FRAME;
140 Word16 *p_window = st->old_speech + L_TOTAL - L_WINDOW;
141 Word16 *wsp = st->old_wsp + PIT_MAX;
142 Word16 *exc = st->old_exc + PIT_MAX + L_INTERPOL;
143 Word16 *zero = st->ai_zero + MP1;
144 Word16 *h1 = st->hvec + L_SUBFR;
145 Word16 *error = st->mem_err + M;
146
191 /* LPC coefficients */ 147 /* LPC coefficients */
192 148
193 Word16 r_l[MP1], r_h[MP1]; /* Autocorrelations lo and hi */ 149 Word16 r_l[MP1], r_h[MP1]; /* Autocorrelations lo and hi */
194 Word16 A_t[(MP1) * 4]; /* A(z) unquantized for the 4 subframes */ 150 Word16 A_t[(MP1) * 4]; /* A(z) unquantized for the 4 subframes */
195 Word16 Aq_t[(MP1) * 4]; /* A(z) quantized for the 4 subframes */ 151 Word16 Aq_t[(MP1) * 4]; /* A(z) quantized for the 4 subframes */
215 Word16 gain_pit, gain_code, pit_flag, pit_sharp; 171 Word16 gain_pit, gain_code, pit_flag, pit_sharp;
216 Word16 temp; 172 Word16 temp;
217 Word32 L_temp; 173 Word32 L_temp;
218 174
219 Word16 scal_acf, VAD_flag, lags[2], rc[4]; 175 Word16 scal_acf, VAD_flag, lags[2], rc[4];
220
221 extern Word16 ptch;
222 extern Word16 txdtx_ctrl, CN_excitation_gain;
223 extern Word32 L_pn_seed_tx;
224 extern Word16 dtx_mode;
225 176
226 /*----------------------------------------------------------------------* 177 /*----------------------------------------------------------------------*
227 * - Perform LPC analysis: (twice per frame) * 178 * - Perform LPC analysis: (twice per frame) *
228 * * autocorrelation + lag windowing * 179 * * autocorrelation + lag windowing *
229 * * Levinson-Durbin algorithm to find a[] * 180 * * Levinson-Durbin algorithm to find a[] *
233 * subframes (both quantized and unquantized) * 184 * subframes (both quantized and unquantized) *
234 *----------------------------------------------------------------------*/ 185 *----------------------------------------------------------------------*/
235 186
236 /* LP analysis centered at 2nd subframe */ 187 /* LP analysis centered at 2nd subframe */
237 188
238 189 scal_acf = Autocorr (p_window, M, r_h, r_l, window_160_80);
239 scal_acf = Autocorr (p_window_mid, M, r_h, r_l, window_160_80);
240 /* Autocorrelations */ 190 /* Autocorrelations */
241 191
242 #if (WMOPS)
243 fwc (); /* function worst case */
244 #endif
245
246 Lag_window (M, r_h, r_l); /* Lag windowing */ 192 Lag_window (M, r_h, r_l); /* Lag windowing */
247 193
248 #if (WMOPS) 194 Levinson (st, r_h, r_l, &A_t[MP1], rc); /* Levinson-Durbin */
249 fwc (); /* function worst case */ 195
250 #endif 196 Az_lsp (&A_t[MP1], lsp_mid, st->lsp_old); /* From A(z) to lsp */
251
252 Levinson (r_h, r_l, &A_t[MP1], rc); /* Levinson-Durbin */
253
254 #if (WMOPS)
255 fwc (); /* function worst case */
256 #endif
257
258 Az_lsp (&A_t[MP1], lsp_mid, lsp_old); /* From A(z) to lsp */
259
260 #if (WMOPS)
261 fwc (); /* function worst case */
262 #endif
263 197
264 /* LP analysis centered at 4th subframe */ 198 /* LP analysis centered at 4th subframe */
265 199
266 /* Autocorrelations */ 200 /* Autocorrelations */
267 scal_acf = Autocorr (p_window, M, r_h, r_l, window_232_8); 201 scal_acf = Autocorr (p_window, M, r_h, r_l, window_232_8);
268 202
269 #if (WMOPS)
270 fwc (); /* function worst case */
271 #endif
272
273 Lag_window (M, r_h, r_l); /* Lag windowing */ 203 Lag_window (M, r_h, r_l); /* Lag windowing */
274 204
275 #if (WMOPS) 205 Levinson (st, r_h, r_l, &A_t[MP1 * 3], rc); /* Levinson-Durbin */
276 fwc (); /* function worst case */
277 #endif
278
279 Levinson (r_h, r_l, &A_t[MP1 * 3], rc); /* Levinson-Durbin */
280
281 #if (WMOPS)
282 fwc (); /* function worst case */
283 #endif
284 206
285 Az_lsp (&A_t[MP1 * 3], lsp_new, lsp_mid); /* From A(z) to lsp */ 207 Az_lsp (&A_t[MP1 * 3], lsp_new, lsp_mid); /* From A(z) to lsp */
286 208
287 #if (WMOPS) 209 if (st->dtx_mode)
288 fwc (); /* function worst case */
289 #endif
290
291 if (dtx_mode == 1)
292 { 210 {
293 /* DTX enabled, make voice activity decision */ 211 /* DTX enabled, make voice activity decision */
294 VAD_flag = vad_computation (r_h, r_l, scal_acf, rc, ptch); 212 VAD_flag = vad_computation (st, r_h, r_l, scal_acf, rc, st->ptch);
295 move16 (); 213 tx_dtx (st, VAD_flag); /* TX DTX handler */
296
297 tx_dtx (VAD_flag, &txdtx_ctrl); /* TX DTX handler */
298 } 214 }
299 else 215 else
300 { 216 {
301 /* DTX disabled, active speech in every frame */ 217 /* DTX disabled, active speech in every frame */
302 VAD_flag = 1; 218 VAD_flag = 1;
303 txdtx_ctrl = TX_VAD_FLAG | TX_SP_FLAG; 219 st->txdtx_ctrl = TX_VAD_FLAG | TX_SP_FLAG;
304 } 220 }
305 221
306 /* LSP quantization (lsp_mid[] and lsp_new[] jointly quantized) */ 222 /* LSP quantization (lsp_mid[] and lsp_new[] jointly quantized) */
307 223
308 Q_plsf_5 (lsp_mid, lsp_new, lsp_mid_q, lsp_new_q, ana, txdtx_ctrl); 224 Q_plsf_5 (st, lsp_mid, lsp_new, lsp_mid_q, lsp_new_q, ana, st->txdtx_ctrl);
309 225
310 #if (WMOPS) 226 ana += 5;
311 fwc (); /* function worst case */
312 #endif
313 ana += 5; move16 ();
314 227
315 /*--------------------------------------------------------------------* 228 /*--------------------------------------------------------------------*
316 * Find interpolated LPC parameters in all subframes (both quantized * 229 * Find interpolated LPC parameters in all subframes (both quantized *
317 * and unquantized). * 230 * and unquantized). *
318 * The interpolated parameters are in array A_t[] of size (M+1)*4 * 231 * The interpolated parameters are in array A_t[] of size (M+1)*4 *
319 * and the quantized interpolated parameters are in array Aq_t[] * 232 * and the quantized interpolated parameters are in array Aq_t[] *
320 *--------------------------------------------------------------------*/ 233 *--------------------------------------------------------------------*/
321 234
322 Int_lpc2 (lsp_old, lsp_mid, lsp_new, A_t); 235 Int_lpc2 (st->lsp_old, lsp_mid, lsp_new, A_t);
323 236
324 #if (WMOPS) 237 if ((st->txdtx_ctrl & TX_SP_FLAG) != 0)
325 fwc (); /* function worst case */ 238 {
326 #endif 239 Int_lpc (st->lsp_old_q, lsp_mid_q, lsp_new_q, Aq_t);
327
328 test (); logic16 ();
329 if ((txdtx_ctrl & TX_SP_FLAG) != 0)
330 {
331 Int_lpc (lsp_old_q, lsp_mid_q, lsp_new_q, Aq_t);
332 240
333 /* update the LSPs for the next frame */ 241 /* update the LSPs for the next frame */
334 for (i = 0; i < M; i++) 242 Copy (lsp_new, st->lsp_old, M);
335 { 243 Copy (lsp_new_q, st->lsp_old_q, M);
336 lsp_old[i] = lsp_new[i]; move16 ();
337 lsp_old_q[i] = lsp_new_q[i]; move16 ();
338 }
339 } 244 }
340 else 245 else
341 { 246 {
342 /* Use unquantized LPC parameters in case of no speech activity */ 247 /* Use unquantized LPC parameters in case of no speech activity */
343 for (i = 0; i < MP1; i++) 248 for (i = 0; i < MP1; i++)
347 Aq_t[i + MP1 * 2] = A_t[i + MP1 * 2]; move16 (); 252 Aq_t[i + MP1 * 2] = A_t[i + MP1 * 2]; move16 ();
348 Aq_t[i + MP1 * 3] = A_t[i + MP1 * 3]; move16 (); 253 Aq_t[i + MP1 * 3] = A_t[i + MP1 * 3]; move16 ();
349 } 254 }
350 255
351 /* update the LSPs for the next frame */ 256 /* update the LSPs for the next frame */
352 for (i = 0; i < M; i++) 257 Copy (lsp_new, st->lsp_old, M);
353 { 258 Copy (lsp_new_q, st->lsp_old_q, M);
354 lsp_old[i] = lsp_new[i]; move16 (); 259 }
355 lsp_old_q[i] = lsp_new[i]; move16 ();
356 }
357 }
358
359 #if (WMOPS)
360 fwc (); /* function worst case */
361 #endif
362 260
363 /*----------------------------------------------------------------------* 261 /*----------------------------------------------------------------------*
364 * - Find the weighted input speech wsp[] for the whole speech frame * 262 * - Find the weighted input speech wsp[] for the whole speech frame *
365 * - Find the open-loop pitch delay for first 2 subframes * 263 * - Find the open-loop pitch delay for first 2 subframes *
366 * - Set the range for searching closed-loop pitch in 1st subframe * 264 * - Set the range for searching closed-loop pitch in 1st subframe *
370 A = A_t; move16 (); 268 A = A_t; move16 ();
371 for (i = 0; i < L_FRAME; i += L_SUBFR) 269 for (i = 0; i < L_FRAME; i += L_SUBFR)
372 { 270 {
373 Weight_Ai (A, F_gamma1, Ap1); 271 Weight_Ai (A, F_gamma1, Ap1);
374 272
375 #if (WMOPS)
376 fwc (); /* function worst case */
377 #endif
378
379 Weight_Ai (A, F_gamma2, Ap2); 273 Weight_Ai (A, F_gamma2, Ap2);
380 274
381 #if (WMOPS)
382 fwc (); /* function worst case */
383 #endif
384
385 Residu (Ap1, &speech[i], &wsp[i], L_SUBFR); 275 Residu (Ap1, &speech[i], &wsp[i], L_SUBFR);
386 276
387 #if (WMOPS) 277 Syn_filt (Ap2, &wsp[i], &wsp[i], L_SUBFR, st->mem_w, 1);
388 fwc (); /* function worst case */
389 #endif
390
391 Syn_filt (Ap2, &wsp[i], &wsp[i], L_SUBFR, mem_w, 1);
392
393 #if (WMOPS)
394 fwc (); /* function worst case */
395 #endif
396 278
397 A += MP1; move16 (); 279 A += MP1; move16 ();
398 } 280 }
399 281
400 /* Find open loop pitch lag for first two subframes */ 282 /* Find open loop pitch lag for first two subframes */
401 283
402 T_op = Pitch_ol (wsp, PIT_MIN, PIT_MAX, L_FRAME_BY2); move16 (); 284 T_op = Pitch_ol (wsp, PIT_MIN, PIT_MAX, L_FRAME_BY2); move16 ();
403 285
404 #if (WMOPS)
405 fwc (); /* function worst case */
406 #endif
407
408 lags[0] = T_op; move16 (); 286 lags[0] = T_op; move16 ();
409 287
410 test (); logic16 (); 288 if ((st->txdtx_ctrl & TX_SP_FLAG) != 0)
411 if ((txdtx_ctrl & TX_SP_FLAG) != 0)
412 { 289 {
413 /* Range for closed loop pitch search in 1st subframe */ 290 /* Range for closed loop pitch search in 1st subframe */
414 291
415 T0_min = sub (T_op, 3); 292 T0_min = sub (T_op, 3);
416 test (); 293 if (T0_min < PIT_MIN)
417 if (sub (T0_min, PIT_MIN) < 0)
418 { 294 {
419 T0_min = PIT_MIN; move16 (); 295 T0_min = PIT_MIN; move16 ();
420 } 296 }
421 T0_max = add (T0_min, 6); 297 T0_max = add (T0_min, 6);
422 test (); 298 if (T0_max > PIT_MAX)
423 if (sub (T0_max, PIT_MAX) > 0)
424 { 299 {
425 T0_max = PIT_MAX; move16 (); 300 T0_max = PIT_MAX; move16 ();
426 T0_min = sub (T0_max, 6); 301 T0_min = sub (T0_max, 6);
427 } 302 }
428 #if (WMOPS)
429 fwc (); /* function worst case */
430 #endif
431 } 303 }
432 /* Find open loop pitch lag for last two subframes */ 304 /* Find open loop pitch lag for last two subframes */
433 305
434 T_op = Pitch_ol (&wsp[L_FRAME_BY2], PIT_MIN, PIT_MAX, L_FRAME_BY2); 306 T_op = Pitch_ol (&wsp[L_FRAME_BY2], PIT_MIN, PIT_MAX, L_FRAME_BY2);
435 move16 (); 307
436 308 if (st->dtx_mode)
437 #if (WMOPS)
438 fwc (); /* function worst case */
439 #endif
440
441 if (dtx_mode == 1)
442 { 309 {
443 lags[1] = T_op; move16 (); 310 lags[1] = T_op; move16 ();
444 periodicity_update (lags, &ptch); 311 periodicity_update (st, lags);
445 } 312 }
446 /*----------------------------------------------------------------------* 313 /*----------------------------------------------------------------------*
447 * Loop for every subframe in the analysis frame * 314 * Loop for every subframe in the analysis frame *
448 *----------------------------------------------------------------------* 315 *----------------------------------------------------------------------*
449 * To find the pitch and innovation parameters. The subframe size is * 316 * To find the pitch and innovation parameters. The subframe size is *
468 /* pointer to interpolated quantized LPC parameters */ 335 /* pointer to interpolated quantized LPC parameters */
469 Aq = Aq_t; move16 (); 336 Aq = Aq_t; move16 ();
470 337
471 for (i_subfr = 0; i_subfr < L_FRAME; i_subfr += L_SUBFR) 338 for (i_subfr = 0; i_subfr < L_FRAME; i_subfr += L_SUBFR)
472 { 339 {
473 340 if ((st->txdtx_ctrl & TX_SP_FLAG) != 0)
474 test (); logic16 ();
475 if ((txdtx_ctrl & TX_SP_FLAG) != 0)
476 { 341 {
477 342
478 /*---------------------------------------------------------------* 343 /*---------------------------------------------------------------*
479 * Find the weighted LPC coefficients for the weighting filter. * 344 * Find the weighted LPC coefficients for the weighting filter. *
480 *---------------------------------------------------------------*/ 345 *---------------------------------------------------------------*/
481 346
482 Weight_Ai (A, F_gamma1, Ap1); 347 Weight_Ai (A, F_gamma1, Ap1);
483 348
484 #if (WMOPS)
485 fwc (); /* function worst case */
486 #endif
487
488 Weight_Ai (A, F_gamma2, Ap2); 349 Weight_Ai (A, F_gamma2, Ap2);
489
490 #if (WMOPS)
491 fwc (); /* function worst case */
492 #endif
493 350
494 /*---------------------------------------------------------------* 351 /*---------------------------------------------------------------*
495 * Compute impulse response, h1[], of weighted synthesis filter * 352 * Compute impulse response, h1[], of weighted synthesis filter *
496 *---------------------------------------------------------------*/ 353 *---------------------------------------------------------------*/
497 354
498 for (i = 0; i <= M; i++) 355 Copy (Ap1, st->ai_zero, M+1);
499 { 356
500 ai_zero[i] = Ap1[i]; move16 (); 357 Syn_filt (Aq, st->ai_zero, h1, L_SUBFR, zero, 0);
501 }
502
503 Syn_filt (Aq, ai_zero, h1, L_SUBFR, zero, 0);
504
505 #if (WMOPS)
506 fwc (); /* function worst case */
507 #endif
508 358
509 Syn_filt (Ap2, h1, h1, L_SUBFR, zero, 0); 359 Syn_filt (Ap2, h1, h1, L_SUBFR, zero, 0);
510
511 #if (WMOPS)
512 fwc (); /* function worst case */
513 #endif
514 360
515 } 361 }
516 /*---------------------------------------------------------------* 362 /*---------------------------------------------------------------*
517 * Find the target vector for pitch search: * 363 * Find the target vector for pitch search: *
518 *---------------------------------------------------------------*/ 364 *---------------------------------------------------------------*/
519 365
520 Residu (Aq, &speech[i_subfr], res2, L_SUBFR); /* LPC residual */ 366 Residu (Aq, &speech[i_subfr], res2, L_SUBFR); /* LPC residual */
521 367
522 #if (WMOPS) 368 if ((st->txdtx_ctrl & TX_SP_FLAG) == 0)
523 fwc (); /* function worst case */
524 #endif
525
526 test (); logic16 ();
527 if ((txdtx_ctrl & TX_SP_FLAG) == 0)
528 { 369 {
529 /* Compute comfort noise excitation gain based on 370 /* Compute comfort noise excitation gain based on
530 LP residual energy */ 371 LP residual energy */
531 372
532 CN_excitation_gain = compute_CN_excitation_gain (res2); 373 st->CN_excitation_gain = compute_CN_excitation_gain (res2);
533 move16 ();
534 } 374 }
535 else 375 else
536 { 376 {
537 Copy (res2, &exc[i_subfr], L_SUBFR); 377 Copy (res2, &exc[i_subfr], L_SUBFR);
538 378
539 #if (WMOPS) 379 Syn_filt (Aq, &exc[i_subfr], error, L_SUBFR, st->mem_err, 0);
540 fwc (); /* function worst case */
541 #endif
542
543 Syn_filt (Aq, &exc[i_subfr], error, L_SUBFR, mem_err, 0);
544
545 #if (WMOPS)
546 fwc (); /* function worst case */
547 #endif
548 380
549 Residu (Ap1, error, xn, L_SUBFR); 381 Residu (Ap1, error, xn, L_SUBFR);
550 382
551 #if (WMOPS) 383 /* target signal xn[] */
552 fwc (); /* function worst case */ 384 Syn_filt (Ap2, xn, xn, L_SUBFR, st->mem_w0, 0);
553 #endif
554
555 Syn_filt (Ap2, xn, xn, L_SUBFR, mem_w0, 0); /* target signal xn[]*/
556
557 #if (WMOPS)
558 fwc (); /* function worst case */
559 #endif
560 385
561 /*--------------------------------------------------------------* 386 /*--------------------------------------------------------------*
562 * Closed-loop fractional pitch search * 387 * Closed-loop fractional pitch search *
563 *--------------------------------------------------------------*/ 388 *--------------------------------------------------------------*/
564 389
565 /* flag for first and 3th subframe */ 390 /* flag for first and 3th subframe */
566 pit_flag = i_subfr; move16 (); 391 pit_flag = i_subfr; move16 ();
567 test ();
568 /* set t0_min and t0_max for 3th subf.*/ 392 /* set t0_min and t0_max for 3th subf.*/
569 if (sub (i_subfr, L_FRAME_BY2) == 0) 393 if (i_subfr == L_FRAME_BY2)
570 { 394 {
571 T0_min = sub (T_op, 3); 395 T0_min = sub (T_op, 3);
572 396
573 test (); 397 if (T0_min < PIT_MIN)
574 if (sub (T0_min, PIT_MIN) < 0)
575 { 398 {
576 T0_min = PIT_MIN; move16 (); 399 T0_min = PIT_MIN; move16 ();
577 } 400 }
578 T0_max = add (T0_min, 6); 401 T0_max = add (T0_min, 6);
579 test (); 402 if (T0_max > PIT_MAX)
580 if (sub (T0_max, PIT_MAX) > 0)
581 { 403 {
582 T0_max = PIT_MAX; move16 (); 404 T0_max = PIT_MAX; move16 ();
583 T0_min = sub (T0_max, 6); 405 T0_min = sub (T0_max, 6);
584 } 406 }
585 pit_flag = 0; move16 (); 407 pit_flag = 0; move16 ();
586 } 408 }
587 #if (WMOPS)
588 fwc (); /* function worst case */
589 #endif
590 409
591 T0 = Pitch_fr6 (&exc[i_subfr], xn, h1, L_SUBFR, T0_min, T0_max, 410 T0 = Pitch_fr6 (&exc[i_subfr], xn, h1, L_SUBFR, T0_min, T0_max,
592 pit_flag, &T0_frac); move16 (); 411 pit_flag, &T0_frac); move16 ();
593 412
594 #if (WMOPS)
595 fwc (); /* function worst case */
596 #endif
597
598 *ana = Enc_lag6 (T0, &T0_frac, &T0_min, &T0_max, PIT_MIN, 413 *ana = Enc_lag6 (T0, &T0_frac, &T0_min, &T0_max, PIT_MIN,
599 PIT_MAX, pit_flag); 414 PIT_MAX, pit_flag);
600 move16 ();
601
602 #if (WMOPS)
603 fwc (); /* function worst case */
604 #endif
605 } 415 }
606 ana++; 416 ana++;
607 /* Incrementation of ana is done here to work also 417 /* Incrementation of ana is done here to work also
608 when no speech activity is present */ 418 when no speech activity is present */
609 419
610 test (); logic16 (); 420 if ((st->txdtx_ctrl & TX_SP_FLAG) != 0)
611
612 if ((txdtx_ctrl & TX_SP_FLAG) != 0)
613 { 421 {
614 422
615 /*---------------------------------------------------------------* 423 /*---------------------------------------------------------------*
616 * - find unity gain pitch excitation (adaptive codebook entry) * 424 * - find unity gain pitch excitation (adaptive codebook entry) *
617 * with fractional interpolation. * 425 * with fractional interpolation. *
621 * - find LTP residual. * 429 * - find LTP residual. *
622 *---------------------------------------------------------------*/ 430 *---------------------------------------------------------------*/
623 431
624 Pred_lt_6 (&exc[i_subfr], T0, T0_frac, L_SUBFR); 432 Pred_lt_6 (&exc[i_subfr], T0, T0_frac, L_SUBFR);
625 433
626 #if (WMOPS)
627 fwc (); /* function worst case */
628 #endif
629
630 Convolve (&exc[i_subfr], h1, y1, L_SUBFR); 434 Convolve (&exc[i_subfr], h1, y1, L_SUBFR);
631 435
632 #if (WMOPS)
633 fwc (); /* function worst case */
634 #endif
635
636 gain_pit = G_pitch (xn, y1, L_SUBFR); move16 (); 436 gain_pit = G_pitch (xn, y1, L_SUBFR); move16 ();
637 437
638 #if (WMOPS)
639 fwc (); /* function worst case */
640 #endif
641
642 *ana = q_gain_pitch (&gain_pit); move16 (); 438 *ana = q_gain_pitch (&gain_pit); move16 ();
643
644 #if (WMOPS)
645 fwc (); /* function worst case */
646 #endif
647 439
648 } 440 }
649 else 441 else
650 { 442 {
651 gain_pit = 0; move16 (); 443 gain_pit = 0; move16 ();
652 } 444 }
653 445
654 ana++; /* Incrementation of ana is done here to work 446 ana++; /* Incrementation of ana is done here to work
655 also when no speech activity is present */ 447 also when no speech activity is present */
656 448
657 test (); logic16 (); 449 if ((st->txdtx_ctrl & TX_SP_FLAG) != 0)
658
659 if ((txdtx_ctrl & TX_SP_FLAG) != 0)
660 { 450 {
661 /* xn2[i] = xn[i] - y1[i] * gain_pit */ 451 /* xn2[i] = xn[i] - y1[i] * gain_pit */
662 /* res2[i] -= exc[i+i_subfr] * gain_pit */ 452 /* res2[i] -= exc[i+i_subfr] * gain_pit */
663 453
664 for (i = 0; i < L_SUBFR; i++) 454 for (i = 0; i < L_SUBFR; i++)
670 L_temp = L_mult (exc[i + i_subfr], gain_pit); 460 L_temp = L_mult (exc[i + i_subfr], gain_pit);
671 L_temp = L_shl (L_temp, 3); 461 L_temp = L_shl (L_temp, 3);
672 res2[i] = sub (res2[i], extract_h (L_temp)); move16 (); 462 res2[i] = sub (res2[i], extract_h (L_temp)); move16 ();
673 } 463 }
674 464
675 #if (WMOPS)
676 fwc (); /* function worst case */
677 #endif
678
679 /*-------------------------------------------------------------* 465 /*-------------------------------------------------------------*
680 * - include pitch contribution into impulse resp. h1[] * 466 * - include pitch contribution into impulse resp. h1[] *
681 *-------------------------------------------------------------*/ 467 *-------------------------------------------------------------*/
682 468
683 /* pit_sharp = gain_pit; */ 469 /* pit_sharp = gain_pit; */
689 { 475 {
690 temp = mult (h1[i - T0], pit_sharp); 476 temp = mult (h1[i - T0], pit_sharp);
691 h1[i] = add (h1[i], temp); move16 (); 477 h1[i] = add (h1[i], temp); move16 ();
692 } 478 }
693 479
694 #if (WMOPS)
695 fwc (); /* function worst case */
696 #endif
697
698 /*--------------------------------------------------------------* 480 /*--------------------------------------------------------------*
699 * - Innovative codebook search (find index and gain) * 481 * - Innovative codebook search (find index and gain) *
700 *--------------------------------------------------------------*/ 482 *--------------------------------------------------------------*/
701 483
702 code_10i40_35bits (xn2, res2, h1, code, y2, ana); 484 code_10i40_35bits (xn2, res2, h1, code, y2, ana);
703
704 #if (WMOPS)
705 fwc (); /* function worst case */
706 #endif
707
708 } 485 }
709 else 486 else
710 { 487 {
711 build_CN_code (code, &L_pn_seed_tx); 488 build_CN_code (code, &st->L_pn_seed_tx);
712 } 489 }
713 ana += 10; move16 (); 490 ana += 10; move16 ();
714 491
715 test (); logic16 (); 492 if ((st->txdtx_ctrl & TX_SP_FLAG) != 0)
716 if ((txdtx_ctrl & TX_SP_FLAG) != 0)
717 { 493 {
718 494
719 /*-------------------------------------------------------* 495 /*-------------------------------------------------------*
720 * - Add the pitch contribution to code[]. * 496 * - Add the pitch contribution to code[]. *
721 *-------------------------------------------------------*/ 497 *-------------------------------------------------------*/
724 { 500 {
725 temp = mult (code[i - T0], pit_sharp); 501 temp = mult (code[i - T0], pit_sharp);
726 code[i] = add (code[i], temp); move16 (); 502 code[i] = add (code[i], temp); move16 ();
727 } 503 }
728 504
729 #if (WMOPS)
730 fwc (); /* function worst case */
731 #endif
732
733 /*------------------------------------------------------* 505 /*------------------------------------------------------*
734 * - Quantization of fixed codebook gain. * 506 * - Quantization of fixed codebook gain. *
735 *------------------------------------------------------*/ 507 *------------------------------------------------------*/
736 508
737 gain_code = G_code (xn2, y2); move16 (); 509 gain_code = G_code (xn2, y2); move16 ();
738 510 }
739 #if (WMOPS) 511 *ana++ = q_gain_code (st, code, L_SUBFR, &gain_code, st->txdtx_ctrl,
740 fwc (); /* function worst case */ 512 i_subfr);
741 #endif
742
743 }
744 *ana++ = q_gain_code (code, L_SUBFR, &gain_code, txdtx_ctrl, i_subfr);
745 move16 ();
746
747 #if (WMOPS)
748 fwc (); /* function worst case */
749 #endif
750 513
751 /*------------------------------------------------------* 514 /*------------------------------------------------------*
752 * - Find the total excitation * 515 * - Find the total excitation *
753 * - find synthesis speech corresponding to exc[] * 516 * - find synthesis speech corresponding to exc[] *
754 * - update filter memories for finding the target * 517 * - update filter memories for finding the target *
764 L_temp = L_mac (L_temp, code[i], gain_code); 527 L_temp = L_mac (L_temp, code[i], gain_code);
765 L_temp = L_shl (L_temp, 3); 528 L_temp = L_shl (L_temp, 3);
766 exc[i + i_subfr] = round (L_temp); move16 (); 529 exc[i + i_subfr] = round (L_temp); move16 ();
767 } 530 }
768 531
769 #if (WMOPS) 532 Syn_filt (Aq, &exc[i_subfr], &synth[i_subfr], L_SUBFR, st->mem_syn, 1);
770 fwc (); /* function worst case */ 533
771 #endif 534 if ((st->txdtx_ctrl & TX_SP_FLAG) != 0)
772
773 Syn_filt (Aq, &exc[i_subfr], &synth[i_subfr], L_SUBFR, mem_syn, 1);
774
775 #if (WMOPS)
776 fwc (); /* function worst case */
777 #endif
778
779 test (); logic16 ();
780 if ((txdtx_ctrl & TX_SP_FLAG) != 0)
781 { 535 {
782 536
783 for (i = L_SUBFR - M, j = 0; i < L_SUBFR; i++, j++) 537 for (i = L_SUBFR - M, j = 0; i < L_SUBFR; i++, j++)
784 { 538 {
785 mem_err[j] = sub (speech[i_subfr + i], synth[i_subfr + i]); 539 st->mem_err[j] = sub (speech[i_subfr + i], synth[i_subfr + i]);
786 move16 ();
787 temp = extract_h (L_shl (L_mult (y1[i], gain_pit), 3)); 540 temp = extract_h (L_shl (L_mult (y1[i], gain_pit), 3));
788 k = extract_h (L_shl (L_mult (y2[i], gain_code), 5)); 541 k = extract_h (L_shl (L_mult (y2[i], gain_code), 5));
789 mem_w0[j] = sub (xn[i], add (temp, k)); move16 (); 542 st->mem_w0[j] = sub (xn[i], add (temp, k));
790 } 543 }
791 } 544 }
792 else 545 else
793 { 546 {
794 for (j = 0; j < M; j++) 547 Set_zero (st->mem_err, M);
795 { 548 Set_zero (st->mem_w0, M);
796 mem_err[j] = 0; move16 (); 549 }
797 mem_w0[j] = 0; move16 (); 550
798 }
799 }
800
801 #if (WMOPS)
802 fwc (); /* function worst case */
803 #endif
804 /* interpolated LPC parameters for next subframe */ 551 /* interpolated LPC parameters for next subframe */
805 A += MP1; move16 (); 552 A += MP1; move16 ();
806 Aq += MP1; move16 (); 553 Aq += MP1; move16 ();
807 } 554 }
808 555
810 * Update signal for next frame. * 557 * Update signal for next frame. *
811 * -> shift to the left by L_FRAME: * 558 * -> shift to the left by L_FRAME: *
812 * speech[], wsp[] and exc[] * 559 * speech[], wsp[] and exc[] *
813 *--------------------------------------------------*/ 560 *--------------------------------------------------*/
814 561
815 Copy (&old_speech[L_FRAME], &old_speech[0], L_TOTAL - L_FRAME); 562 Copy (&st->old_speech[L_FRAME], &st->old_speech[0], L_TOTAL - L_FRAME);
816 563
817 #if (WMOPS) 564 Copy (&st->old_wsp[L_FRAME], &st->old_wsp[0], PIT_MAX);
818 fwc (); /* function worst case */ 565
819 #endif 566 Copy (&st->old_exc[L_FRAME], &st->old_exc[0], PIT_MAX + L_INTERPOL);
820
821 Copy (&old_wsp[L_FRAME], &old_wsp[0], PIT_MAX);
822
823 #if (WMOPS)
824 fwc (); /* function worst case */
825 #endif
826
827 Copy (&old_exc[L_FRAME], &old_exc[0], PIT_MAX + L_INTERPOL);
828
829 #if (WMOPS)
830 fwc (); /* function worst case */
831 #endif
832 567
833 return; 568 return;
834 } 569 }