1 /* ------------------------------------------------------------------
2 * Copyright (C) 1998-2009 PacketVideo
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
13 * express or implied.
14 * See the License for the specific language governing permissions
15 * and limitations under the License.
16 * -------------------------------------------------------------------
17 */
18 /****************************************************************************************
19 Portions of this file are derived from the following 3GPP standard:
20
21 3GPP TS 26.073
22 ANSI-C code for the Adaptive Multi-Rate (AMR) speech codec
23 Available from http://www.3gpp.org
24
25 (C) 2004, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TTA, TTC)
26 Permission to distribute, modify and use this file under the standard license
27 terms listed above has been obtained from the copyright holder.
28 ****************************************************************************************/
29 /*
30 ------------------------------------------------------------------------------
31
32
33
34 Pathname: ./audio/gsm-amr/c/src/pitch_ol.c
35 Funtions: Pitch_ol
36 Lag_max
37
38 ------------------------------------------------------------------------------
39 MODULE DESCRIPTION
40
41 The modules in this file compute the open loop pitch lag.
42 ------------------------------------------------------------------------------
43 */
44
45
46 /*----------------------------------------------------------------------------
47 ; INCLUDES
48 ----------------------------------------------------------------------------*/
49 #include <string.h>
50
51 #include "pitch_ol.h"
52 #include "typedef.h"
53 #include "basicop_malloc.h"
54 #include "cnst.h"
55 #include "inv_sqrt.h"
56 #include "vad.h"
57 #include "calc_cor.h"
58 #include "hp_max.h"
59 #include "basic_op.h"
60
61 /*----------------------------------------------------------------------------
62 ; MACROS
63 ; Define module specific macros here
64 ----------------------------------------------------------------------------*/
65
66
67 /*----------------------------------------------------------------------------
68 ; DEFINES
69 ; Include all pre-processor statements here. Include conditional
70 ; compile variables also.
71 ----------------------------------------------------------------------------*/
72 #define THRESHOLD 27853
73
74 /*----------------------------------------------------------------------------
75 ; LOCAL FUNCTION DEFINITIONS
76 ; Function Prototype declaration
77 ----------------------------------------------------------------------------*/
78
79 /*----------------------------------------------------------------------------
80 ; LOCAL VARIABLE DEFINITIONS
81 ; Variable declaration - defined here and used outside this module
82 ----------------------------------------------------------------------------*/
83
84
85 /*
86 ------------------------------------------------------------------------------
87 FUNCTION NAME: Lag_max
88 ------------------------------------------------------------------------------
89 INPUT AND OUTPUT DEFINITIONS (If VAD2 is defined)
90
91 Inputs
92 corr = pointer to buffer of correlation values (Word32)
93 scal_sig = pointer to buffer of scaled signal values (Word16)
94 scal_fac = scaled signal factor (Word16)
95 scal_flag = EFR compatible scaling flag (Word16)
96 L_frame = length of frame to compute pitch (Word16)
97 lag_max = maximum lag (Word16)
98 lag_min = minimum lag (Word16)
99 cor_max = pointer to the normalized correlation of selected lag (Word16)
100 rmax = pointer to max(<s[i]*s[j]>), (Word32)
101 r0 = pointer to the residual energy (Word32)
102 dtx = dtx flag; equal to 1, if dtx is enabled, 0, otherwise (Flag)
103
104 Outputs:
105 cor_max contains the newly calculated normalized correlation of the
106 selected lag
107 rmax contains the newly calculated max(<s[i]*s[j]>)
108 r0 contains the newly calculated residual energy
109
110 Returns:
111 p_max = lag of the max correlation found (Word16)
112
113 Global Variables Used:
114 None.
115
116 Local Variables Needed:
117 None.
118
119 ------------------------------------------------------------------------------
120 INPUT AND OUTPUT DEFINITIONS (If VAD2 is not defined)
121
122 Inputs
123 vadSt = pointer to a vadState structure
124 corr = pointer to buffer of correlation values (Word32)
125 scal_sig = pointer to buffer of scaled signal values (Word16)
126 scal_fac = scaled signal factor (Word16)
127 scal_flag = EFR compatible scaling flag (Word16)
128 L_frame = length of frame to compute pitch (Word16)
129 lag_max = maximum lag (Word16)
130 lag_min = minimum lag (Word16)
131 cor_max = pointer to the normalized correlation of selected lag (Word16)
132 dtx = dtx flag; equal to 1, if dtx is enabled, 0, otherwise (Flag)
133 pOverflow = pointer to overflow indicator (Flag)
134
135 Outputs:
136 cor_max contains the newly calculated normalized correlation of the
137 selected lag
138 vadSt contains the updated VAD state parameters
139 pOverflow -> 1 if the math operations called by this routine saturate
140
141 Returns:
142 p_max = lag of the max correlation found (Word16)
143
144 Global Variables Used:
145 None.
146
147 Local Variables Needed:
148 None.
149
150 ------------------------------------------------------------------------------
151 FUNCTION DESCRIPTION
152
153 Find the lag that has maximum correlation of scal_sig in a given delay range.
154 The correlation is given by:
155
156 cor[t] = <scal_sig[n],scal_sig[n-t]>, t=lag_min,...,lag_max
157
158 The function returns the maximum correlation after normalization and the
159 corresponding lag.
160
161 ------------------------------------------------------------------------------
162 REQUIREMENTS
163
164 None.
165
166 ------------------------------------------------------------------------------
167 REFERENCES
168
169 pitch_ol.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001
170
171 ------------------------------------------------------------------------------
172 PSEUDO-CODE
173
174 #ifdef VAD2
175 static Word16 Lag_max ( // o : lag found
176 Word32 corr[], // i : correlation vector.
177 Word16 scal_sig[], // i : scaled signal.
178 Word16 scal_fac, // i : scaled signal factor.
179 Word16 scal_flag, // i : if 1 use EFR compatible scaling
180 Word16 L_frame, // i : length of frame to compute pitch
181 Word16 lag_max, // i : maximum lag
182 Word16 lag_min, // i : minimum lag
183 Word16 *cor_max, // o : normalized correlation of selected lag
184 Word32 *rmax, // o : max(<s[i]*s[j]>)
185 Word32 *r0, // o : residual energy
186 Flag dtx // i : dtx flag; use dtx=1, do not use dtx=0
187 )
188 #else
189 static Word16 Lag_max ( // o : lag found
190 vadState *vadSt, // i/o : VAD state struct
191 Word32 corr[], // i : correlation vector.
192 Word16 scal_sig[], // i : scaled signal.
193 Word16 scal_fac, // i : scaled signal factor.
194 Word16 scal_flag, // i : if 1 use EFR compatible scaling
195 Word16 L_frame, // i : length of frame to compute pitch
196 Word16 lag_max, // i : maximum lag
197 Word16 lag_min, // i : minimum lag
198 Word16 *cor_max, // o : normalized correlation of selected lag
199 Flag dtx // i : dtx flag; use dtx=1, do not use dtx=0
200 )
201 #endif
202 {
203 Word16 i, j;
204 Word16 *p;
205 Word32 max, t0;
206 Word16 max_h, max_l, ener_h, ener_l;
207 Word16 p_max = 0; // initialization only needed to keep gcc silent
208
209 max = MIN_32;
210 p_max = lag_max;
211
212 for (i = lag_max, j = (PIT_MAX-lag_max-1); i >= lag_min; i--, j--)
213 {
214 if (L_sub (corr[-i], max) >= 0)
215 {
216 max = corr[-i];
217 p_max = i;
218 }
219 }
220
221 // compute energy
222
223 t0 = 0;
224 p = &scal_sig[-p_max];
225 for (i = 0; i < L_frame; i++, p++)
226 {
227 t0 = L_mac (t0, *p, *p);
228 }
229 // 1/sqrt(energy)
230
231 if (dtx)
232 { // no test() call since this if is only in simulation env
233 #ifdef VAD2
234 *rmax = max;
235 *r0 = t0;
236 #else
237 // check tone
238 vad_tone_detection (vadSt, max, t0);
239 #endif
240 }
241
242 t0 = Inv_sqrt (t0);
243
244 if (scal_flag)
245 {
246 t0 = L_shl (t0, 1);
247 }
248
249 // max = max/sqrt(energy)
250
251 L_Extract (max, &max_h, &max_l);
252 L_Extract (t0, &ener_h, &ener_l);
253
254 t0 = Mpy_32 (max_h, max_l, ener_h, ener_l);
255
256 if (scal_flag)
257 {
258 t0 = L_shr (t0, scal_fac);
259 *cor_max = extract_h (L_shl (t0, 15)); // divide by 2
260 }
261 else
262 {
263 *cor_max = extract_l(t0);
264 }
265
266 return (p_max);
267 }
268
269 ------------------------------------------------------------------------------
270 RESOURCES USED [optional]
271
272 When the code is written for a specific target processor the
273 the resources used should be documented below.
274
275 HEAP MEMORY USED: x bytes
276
277 STACK MEMORY USED: x bytes
278
279 CLOCK CYCLES: (cycle count equation for this function) + (variable
280 used to represent cycle count for each subroutine
281 called)
282 where: (cycle count variable) = cycle count for [subroutine
283 name]
284
285 ------------------------------------------------------------------------------
286 CAUTION [optional]
287 [State any special notes, constraints or cautions for users of this function]
288
289 ------------------------------------------------------------------------------
290 */
291
292 #ifdef VAD2
Lag_max(Word32 corr[],Word16 scal_sig[],Word16 scal_fac,Word16 scal_flag,Word16 L_frame,Word16 lag_max,Word16 lag_min,Word16 * cor_max,Word32 * rmax,Word32 * r0,Flag dtx,Flag * pOverflow)293 static Word16 Lag_max( /* o : lag found */
294 Word32 corr[], /* i : correlation vector. */
295 Word16 scal_sig[], /* i : scaled signal. */
296 Word16 scal_fac, /* i : scaled signal factor. */
297 Word16 scal_flag, /* i : if 1 use EFR compatible scaling */
298 Word16 L_frame, /* i : length of frame to compute pitch */
299 Word16 lag_max, /* i : maximum lag */
300 Word16 lag_min, /* i : minimum lag */
301 Word16 *cor_max, /* o : normalized correlation of selected lag */
302 Word32 *rmax, /* o : max(<s[i]*s[j]>) */
303 Word32 *r0, /* o : residual energy */
304 Flag dtx, /* i : dtx flag; use dtx=1, do not use dtx=0 */
305 Flag *pOverflow /* i/o : overflow Flag */
306 )
307 #else
308 static Word16 Lag_max( /* o : lag found */
309 vadState *vadSt, /* i/o : VAD state struct */
310 Word32 corr[], /* i : correlation vector. */
311 Word16 scal_sig[], /* i : scaled signal. */
312 Word16 scal_fac, /* i : scaled signal factor. */
313 Word16 scal_flag, /* i : if 1 use EFR compatible scaling */
314 Word16 L_frame, /* i : length of frame to compute pitch */
315 Word16 lag_max, /* i : maximum lag */
316 Word16 lag_min, /* i : minimum lag */
317 Word16 *cor_max, /* o : normalized correlation of selected lag */
318 Flag dtx, /* i : dtx flag; use dtx=1, do not use dtx=0 */
319 Flag *pOverflow /* i/o : overflow Flag */
320 )
321 #endif
322 {
323 Word16 i;
324 Word16 *p;
325 Word32 max;
326 Word32 t0;
327 Word16 max_h;
328 Word16 max_l;
329 Word16 ener_h;
330 Word16 ener_l;
331 Word16 p_max = 0; /* initialization only needed to keep gcc silent */
332 Word32 L_temp;
333 Word32 L_temp_2;
334 Word32 L_temp_3;
335 Word32 *p_corr = &corr[-lag_max];
336
337 max = MIN_32;
338 p_max = lag_max;
339
340 for (i = lag_max; i >= lag_min; i--)
341 {
342 /* The negative array index is equivalent to a negative */
343 /* address offset, i.e., corr[-i] == *(corr - i) */
344 if (*(p_corr++) >= max)
345 {
346 p_corr--;
347 max = *(p_corr++);
348 p_max = i;
349 }
350 }
351
352 /* compute energy */
353
354 t0 = 0;
355
356 /* The negative array index is equivalent to a negative */
357 /* address offset, i.e., scal_sig[-p_max] == *(scal_sig - p_max) */
358 p = &scal_sig[-p_max];
359 for (i = (L_frame >> 2); i != 0; i--)
360 {
361 t0 = amrnb_fxp_mac_16_by_16bb((Word32) * (p), (Word32) * (p), t0);
362 p++;
363 t0 = amrnb_fxp_mac_16_by_16bb((Word32) * (p), (Word32) * (p), t0);
364 p++;
365 t0 = amrnb_fxp_mac_16_by_16bb((Word32) * (p), (Word32) * (p), t0);
366 p++;
367 t0 = amrnb_fxp_mac_16_by_16bb((Word32) * (p), (Word32) * (p), t0);
368 p++;
369 }
370
371 t0 <<= 1;
372 /* 1/sqrt(energy) */
373
374 if (dtx)
375 { /* no test() call since this if is only in simulation env */
376 /* check tone */
377 #ifdef VAD2
378 *rmax = max;
379 *r0 = t0;
380 #else
381 /* check tone */
382 vad_tone_detection(vadSt, max, t0, pOverflow);
383 #endif
384 }
385
386 t0 = Inv_sqrt(t0, pOverflow);
387
388 if (scal_flag)
389 {
390 if (t0 > (Word32) 0x3fffffffL)
391 {
392 t0 = MAX_32;
393 }
394 else
395 {
396 t0 = t0 << 1;
397 }
398 }
399
400 /* max = max/sqrt(energy) */
401 /* The following code is an inlined version of */
402 /* L_Extract (max, &max_h, &max_l), i.e. */
403 /* */
404 /* *max_h = extract_h (max); */
405 max_h = (Word16)(max >> 16);
406
407 /* L_temp_2 = L_shr(max,1), which is used in */
408 /* the calculation of *max_l (see next operation) */
409 L_temp_2 = max >> 1;
410
411 /* *max_l = extract_l (L_msu (L_shr (max, 1), *max_h, 16384)); */
412 L_temp_3 = (Word32)(max_h << 15);
413
414 L_temp = L_temp_2 - L_temp_3;
415
416 max_l = (Word16)L_temp;
417
418 /* The following code is an inlined version of */
419 /* L_Extract (t0, &ener_h, &ener_l), i.e. */
420 /* */
421 /* *ener_h = extract_h (t0); */
422 ener_h = (Word16)(t0 >> 16);
423
424 /* L_temp_2 = L_shr(t0,1), which is used in */
425 /* the calculation of *ener_l (see next operation) */
426
427 L_temp_2 = t0 >> 1;
428
429 L_temp_3 = (Word32)(ener_h << 15);
430
431 L_temp = L_temp_2 - L_temp_3;
432
433 ener_l = (Word16)L_temp;
434
435 t0 = Mpy_32(max_h, max_l, ener_h, ener_l, pOverflow);
436
437 if (scal_flag)
438 {
439 t0 = L_shr(t0, scal_fac, pOverflow);
440
441 if (t0 > (Word32) 0X0000FFFFL)
442 {
443 *cor_max = MAX_16;
444 }
445 else if (t0 < (Word32) 0xFFFF0000L)
446 {
447 *cor_max = MIN_16;
448 }
449 else
450 {
451 *cor_max = (Word16)(t0 >> 1);
452 }
453 }
454 else
455 {
456 *cor_max = (Word16)t0;
457 }
458
459 return (p_max);
460 }
461
462 /*----------------------------------------------------------------------------
463 ; End Function: Lag_max
464 ----------------------------------------------------------------------------*/
465
466
467 /*
468 ------------------------------------------------------------------------------
469 FUNCTION NAME: Lag_max_wrapper
470 ------------------------------------------------------------------------------
471 INPUT AND OUTPUT DEFINITIONS
472
473 Inputs
474 corr = pointer to buffer of correlation values (Word32)
475 scal_sig = pointer to buffer of scaled signal values (Word16)
476 scal_fac = scaled signal factor (Word16)
477 scal_flag = EFR compatible scaling flag (Word16)
478 L_frame = length of frame to compute pitch (Word16)
479 lag_max = maximum lag (Word16)
480 lag_min = minimum lag (Word16)
481 cor_max = pointer to the normalized correlation of selected lag (Word16)
482 rmax = pointer to max(<s[i]*s[j]>), (Word32)
483 r0 = pointer to the residual energy (Word32)
484 dtx = dtx flag; equal to 1, if dtx is enabled, 0, otherwise (Flag)
485 pOverflow = pointer to overflow indicator (Flag)
486
487 Outputs:
488 cor_max contains the newly calculated normalized correlation of the
489 selected lag
490 rmax contains the newly calculated max(<s[i]*s[j]>)
491 r0 contains the newly calculated residual energy
492 pOverflow -> 1 if the math operations called by this routine saturate
493
494 Returns:
495 p_max = lag of the max correlation found (Word16)
496
497 Global Variables Used:
498 None.
499
500 Local Variables Needed:
501 None.
502
503 ------------------------------------------------------------------------------
504 INPUT AND OUTPUT DEFINITIONS (If VAD2 is not defined)
505
506 Inputs
507 vadSt = pointer to a vadState structure
508 corr = pointer to buffer of correlation values (Word32)
509 scal_sig = pointer to buffer of scaled signal values (Word16)
510 scal_fac = scaled signal factor (Word16)
511 scal_flag = EFR compatible scaling flag (Word16)
512 L_frame = length of frame to compute pitch (Word16)
513 lag_max = maximum lag (Word16)
514 lag_min = minimum lag (Word16)
515 cor_max = pointer to the normalized correlation of selected lag (Word16)
516 dtx = dtx flag; equal to 1, if dtx is enabled, 0, otherwise (Flag)
517 pOverflow = pointer to overflow indicator (Flag)
518
519 Outputs:
520 cor_max contains the newly calculated normalized correlation of the
521 selected lag
522 vadSt contains the updated VAD state parameters
523 pOverflow -> 1 if the math operations called by this routine saturate
524
525 Returns:
526 p_max = lag of the max correlation found (Word16)
527
528 Global Variables Used:
529 None.
530
531 Local Variables Needed:
532 None.
533
534 ------------------------------------------------------------------------------
535 FUNCTION DESCRIPTION
536
537 This function provides external access to the local function Lag_max.
538
539 ------------------------------------------------------------------------------
540 REQUIREMENTS
541
542 None
543
544 ------------------------------------------------------------------------------
545 REFERENCES
546
547 pitch_ol.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001
548
549 ------------------------------------------------------------------------------
550 PSEUDO-CODE
551
552 #ifdef VAD2
553 CALL Lag_max(corr = corr
554 scal_sig = scal_sig
555 scal_fac = scal_fac
556 scal_flag = scal_flag
557 L_frame = L_frame
558 lag_max = lag_max
559 lag_min = lag_min
560 cor_max = cor_max
561 rmax = rmax
562 r0 = r0
563 dtx = dtx
564 pOverflow = pOverflow)
565 MODIFYING(nothing)
566 RETURNING(temp)
567
568 #else
569 CALL Lag_max(vadSt = vadSt
570 corr = corr
571 scal_sig = scal_sig
572 scal_fac = scal_fac
573 scal_flag = scal_flag
574 L_frame = L_frame
575 lag_max = lag_max
576 lag_min = lag_min
577 cor_max = cor_max
578 dtx = dtx
579 pOverflow = pOverflow)
580 MODIFYING(nothing)
581 RETURNING(temp)
582
583 #endif
584
585 ------------------------------------------------------------------------------
586 RESOURCES USED [optional]
587
588 When the code is written for a specific target processor the
589 the resources used should be documented below.
590
591 HEAP MEMORY USED: x bytes
592
593 STACK MEMORY USED: x bytes
594
595 CLOCK CYCLES: (cycle count equation for this function) + (variable
596 used to represent cycle count for each subroutine
597 called)
598 where: (cycle count variable) = cycle count for [subroutine
599 name]
600
601 ------------------------------------------------------------------------------
602 CAUTION [optional]
603 [State any special notes, constraints or cautions for users of this function]
604
605 ------------------------------------------------------------------------------
606 */
607
608 #ifdef VAD2
Lag_max_wrapper(Word32 corr[],Word16 scal_sig[],Word16 scal_fac,Word16 scal_flag,Word16 L_frame,Word16 lag_max,Word16 lag_min,Word16 * cor_max,Word32 * rmax,Word32 * r0,Flag dtx,Flag * pOverflow)609 Word16 Lag_max_wrapper( /* o : lag found */
610 Word32 corr[], /* i : correlation vector. */
611 Word16 scal_sig[], /* i : scaled signal. */
612 Word16 scal_fac, /* i : scaled signal factor. */
613 Word16 scal_flag, /* i : if 1 use EFR compatible scaling */
614 Word16 L_frame, /* i : length of frame to compute pitch */
615 Word16 lag_max, /* i : maximum lag */
616 Word16 lag_min, /* i : minimum lag */
617 Word16 *cor_max, /* o : normalized correlation of selected lag */
618 Word32 *rmax, /* o : max(<s[i]*s[j]>) */
619 Word32 *r0, /* o : residual energy */
620 Flag dtx, /* i : dtx flag; use dtx=1, do not use dtx=0 */
621 Flag *pOverflow /* i/o : overflow Flag */
622 )
623 {
624 Word16 temp;
625
626 temp = Lag_max(corr, scal_sig, scal_fac, scal_flag, L_frame, lag_max,
627 lag_min, cor_max, rmax, r0, dtx, pOverflow);
628
629 return(temp);
630 }
631
632 #else
Lag_max_wrapper(vadState * vadSt,Word32 corr[],Word16 scal_sig[],Word16 scal_fac,Word16 scal_flag,Word16 L_frame,Word16 lag_max,Word16 lag_min,Word16 * cor_max,Flag dtx,Flag * pOverflow)633 Word16 Lag_max_wrapper( /* o : lag found */
634 vadState *vadSt, /* i/o : VAD state struct */
635 Word32 corr[], /* i : correlation vector. */
636 Word16 scal_sig[], /* i : scaled signal. */
637 Word16 scal_fac, /* i : scaled signal factor. */
638 Word16 scal_flag, /* i : if 1 use EFR compatible scaling */
639 Word16 L_frame, /* i : length of frame to compute pitch */
640 Word16 lag_max, /* i : maximum lag */
641 Word16 lag_min, /* i : minimum lag */
642 Word16 *cor_max, /* o : normalized correlation of selected lag */
643 Flag dtx, /* i : dtx flag; use dtx=1, do not use dtx=0 */
644 Flag *pOverflow /* i/o : overflow Flag */
645 )
646 {
647 Word16 temp;
648
649 temp = Lag_max(vadSt, corr, scal_sig, scal_fac, scal_flag, L_frame,
650 lag_max, lag_min, cor_max, dtx, pOverflow);
651
652 return(temp);
653 }
654
655 #endif
656
657 /*----------------------------------------------------------------------------
658 ; End Function: Lag_max_wrapper
659 ----------------------------------------------------------------------------*/
660
661 /*
662 ------------------------------------------------------------------------------
663 FUNCTION NAME: Pitch_ol
664 ------------------------------------------------------------------------------
665 INPUT AND OUTPUT DEFINITIONS
666
667 Inputs:
668 vadSt = pointer to a vadState structure
669 mode = data of type enum Mode specifies the mode.
670 signal = pointer to buffer of signal used to compute the open loop
671 pitch
672 where signal[-pit_max] to signal[-1] should be known
673 pit_min = 16 bit value specifies the minimum pitch lag
674 pit_max = 16 bit value specifies the maximum pitch lag
675 L_frame = 16 bit value specifies the length of frame to compute pitch
676 idx = 16 bit value specifies the frame index
677 dtx = Data of type 'Flag' used for dtx. Use dtx=1, do not use dtx=0
678 pOverflow = pointer to overflow indicator (Flag)
679
680 Outputs
681 vadSt = The vadSt state structure may be modified.
682 pOverflow -> 1 if the math operations called by this routine saturate
683
684 Returns:
685 p_max1 = 16 bit value representing the open loop pitch lag.
686
687 Global Variables Used:
688 None.
689
690 Local Variables Needed:
691 None.
692
693 ------------------------------------------------------------------------------
694 FUNCTION DESCRIPTION
695
696 This function computes the open loop pitch lag based on the perceptually
697 weighted speech signal. This is done in the following steps:
698 - find three maxima of the correlation <sw[n],sw[n-T]>,
699 dividing the search range into three parts:
700 pit_min ... 2*pit_min-1
701 2*pit_min ... 4*pit_min-1
702 4*pit_min ... pit_max
703 - divide each maximum by <sw[n-t], sw[n-t]> where t is the delay at
704 that maximum correlation.
705 - select the delay of maximum normalized correlation (among the
706 three candidates) while favoring the lower delay ranges.
707
708
709 ------------------------------------------------------------------------------
710 REQUIREMENTS
711
712 None.
713
714 ------------------------------------------------------------------------------
715 REFERENCES
716
717 pitch_ol.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001
718
719 ------------------------------------------------------------------------------
720 PSEUDO-CODE
721
722 Word16 Pitch_ol ( // o : open loop pitch lag
723 vadState *vadSt, // i/o : VAD state struct
724 enum Mode mode, // i : coder mode
725 Word16 signal[], // i : signal used to compute the open loop pitch
726 // signal[-pit_max] to signal[-1] should be known
727 Word16 pit_min, // i : minimum pitch lag
728 Word16 pit_max, // i : maximum pitch lag
729 Word16 L_frame, // i : length of frame to compute pitch
730 Word16 idx, // i : frame index
731 Flag dtx // i : dtx flag; use dtx=1, do not use dtx=0
732 )
733 {
734 Word16 i, j;
735 Word16 max1, max2, max3;
736 Word16 p_max1, p_max2, p_max3;
737 Word16 scal_flag = 0;
738 Word32 t0;
739 #ifdef VAD2
740 Word32 r01, r02, r03;
741 Word32 rmax1, rmax2, rmax3;
742 #else
743 Word16 corr_hp_max;
744 #endif
745 Word32 corr[PIT_MAX+1], *corr_ptr;
746
747 // Scaled signal
748
749 Word16 scaled_signal[L_FRAME + PIT_MAX];
750 Word16 *scal_sig, scal_fac;
751
752 #ifndef VAD2
753 if (dtx)
754 { // no test() call since this if is only in simulation env
755 // update tone detection
756 if ((sub(mode, MR475) == 0) || (sub(mode, MR515) == 0))
757 {
758 vad_tone_detection_update (vadSt, 1);
759 }
760 else
761 {
762 vad_tone_detection_update (vadSt, 0);
763 }
764 }
765 #endif
766
767 scal_sig = &scaled_signal[pit_max];
768
769 t0 = 0L;
770 for (i = -pit_max; i < L_frame; i++)
771 {
772 t0 = L_mac (t0, signal[i], signal[i]);
773 }
774
775 *--------------------------------------------------------*
776 * Scaling of input signal. *
777 * *
778 * if Overflow -> scal_sig[i] = signal[i]>>3 *
779 * else if t0 < 1^20 -> scal_sig[i] = signal[i]<<3 *
780 * else -> scal_sig[i] = signal[i] *
781 *--------------------------------------------------------*
782
783 *--------------------------------------------------------*
784 * Verification for risk of overflow. *
785 *--------------------------------------------------------*
786
787 if (L_sub (t0, MAX_32) == 0L) // Test for overflow
788 {
789 for (i = -pit_max; i < L_frame; i++)
790 {
791 scal_sig[i] = shr (signal[i], 3);
792 }
793 scal_fac = 3;
794 }
795 else if (L_sub (t0, (Word32) 1048576L) < (Word32) 0)
796 // if (t0 < 2^20)
797 {
798 for (i = -pit_max; i < L_frame; i++)
799 {
800 scal_sig[i] = shl (signal[i], 3);
801 }
802 scal_fac = -3;
803 }
804 else
805 {
806 for (i = -pit_max; i < L_frame; i++)
807 {
808 scal_sig[i] = signal[i];
809 }
810 scal_fac = 0;
811 }
812
813 // calculate all coreelations of scal_sig, from pit_min to pit_max
814 corr_ptr = &corr[pit_max];
815 comp_corr (scal_sig, L_frame, pit_max, pit_min, corr_ptr);
816
817 *--------------------------------------------------------------------*
818 * The pitch lag search is divided in three sections. *
819 * Each section cannot have a pitch multiple. *
820 * We find a maximum for each section. *
821 * We compare the maximum of each section by favoring small lags. *
822 * *
823 * First section: lag delay = pit_max downto 4*pit_min *
824 * Second section: lag delay = 4*pit_min-1 downto 2*pit_min *
825 * Third section: lag delay = 2*pit_min-1 downto pit_min *
826 *--------------------------------------------------------------------*
827
828 // mode dependent scaling in Lag_max
829 if (sub(mode, MR122) == 0)
830 {
831 scal_flag = 1;
832 }
833 else
834 {
835 scal_flag = 0;
836 }
837
838 #ifdef VAD2
839 j = shl (pit_min, 2);
840 p_max1 = Lag_max (corr_ptr, scal_sig, scal_fac, scal_flag, L_frame,
841 pit_max, j, &max1, &rmax1, &r01, dtx);
842
843 i = sub (j, 1);
844 j = shl (pit_min, 1);
845 p_max2 = Lag_max (corr_ptr, scal_sig, scal_fac, scal_flag, L_frame,
846 i, j, &max2, &rmax2, &r02, dtx);
847
848 i = sub (j, 1);
849 p_max3 = Lag_max (corr_ptr, scal_sig, scal_fac, scal_flag, L_frame,
850 i, pit_min, &max3, &rmax3, &r03, dtx);
851 #else
852 j = shl (pit_min, 2);
853 p_max1 = Lag_max (vadSt, corr_ptr, scal_sig, scal_fac, scal_flag, L_frame,
854 pit_max, j, &max1, dtx);
855
856 i = sub (j, 1);
857 j = shl (pit_min, 1);
858 p_max2 = Lag_max (vadSt, corr_ptr, scal_sig, scal_fac, scal_flag, L_frame,
859 i, j, &max2, dtx);
860
861 i = sub (j, 1);
862 p_max3 = Lag_max (vadSt, corr_ptr, scal_sig, scal_fac, scal_flag, L_frame,
863 i, pit_min, &max3, dtx);
864
865 if (dtx)
866 { // no test() call since this if is only in simulation env
867 if (sub(idx, 1) == 0)
868 {
869 // calculate max high-passed filtered correlation of all lags
870 hp_max (corr_ptr, scal_sig, L_frame, pit_max, pit_min, &corr_hp_max);
871
872 // update complex background detector
873 vad_complex_detection_update(vadSt, corr_hp_max);
874 }
875 }
876 #endif
877
878 *--------------------------------------------------------------------*
879 * Compare the 3 sections maximum, and favor small lag. *
880 *--------------------------------------------------------------------*
881
882 if (sub (mult (max1, THRESHOLD), max2) < 0)
883 {
884 max1 = max2;
885 p_max1 = p_max2;
886 #ifdef VAD2
887 if (dtx)
888 {
889 rmax1 = rmax2;
890 r01 = r02;
891 #endif
892 }
893 if (sub (mult (max1, THRESHOLD), max3) < 0)
894 {
895 p_max1 = p_max3;
896 #ifdef VAD2
897 if (dtx)
898 {
899 rmax1 = rmax3;
900 r01 = r03;
901 }
902 #endif
903 }
904
905 #ifdef VAD2
906 if (dtx)
907 {
908 vadSt->L_Rmax = L_add(vadSt->L_Rmax, rmax1); // Save max correlation
909 vadSt->L_R0 = L_add(vadSt->L_R0, r01); // Save max energy
910 }
911 #endif
912
913 return (p_max1);
914 }
915
916 ------------------------------------------------------------------------------
917 RESOURCES USED [optional]
918
919 When the code is written for a specific target processor the
920 the resources used should be documented below.
921
922 HEAP MEMORY USED: x bytes
923
924 STACK MEMORY USED: x bytes
925
926 CLOCK CYCLES: (cycle count equation for this function) + (variable
927 used to represent cycle count for each subroutine
928 called)
929 where: (cycle count variable) = cycle count for [subroutine
930 name]
931
932 ------------------------------------------------------------------------------
933 CAUTION [optional]
934 [State any special notes, constraints or cautions for users of this function]
935
936 ------------------------------------------------------------------------------
937 */
938
Pitch_ol(vadState * vadSt,enum Mode mode,Word16 signal[],Word16 pit_min,Word16 pit_max,Word16 L_frame,Word16 idx,Flag dtx,Flag * pOverflow)939 Word16 Pitch_ol( /* o : open loop pitch lag */
940 vadState *vadSt, /* i/o : VAD state struct */
941 enum Mode mode, /* i : coder mode */
942 Word16 signal[], /* i : signal used to compute the open loop pitch */
943 /* signal[-pit_max] to signal[-1] should be known */
944 Word16 pit_min, /* i : minimum pitch lag */
945 Word16 pit_max, /* i : maximum pitch lag */
946 Word16 L_frame, /* i : length of frame to compute pitch */
947 Word16 idx, /* i : frame index */
948 Flag dtx, /* i : dtx flag; use dtx=1, do not use dtx=0 */
949 Flag *pOverflow /* i/o : overflow Flag */
950 )
951 {
952 Word16 i;
953 Word16 j;
954 Word16 max1;
955 Word16 max2;
956 Word16 max3;
957 Word16 p_max1;
958 Word16 p_max2;
959 Word16 p_max3;
960 Word16 scal_flag = 0;
961 Word32 t0;
962 Word32 mul;
963
964 #ifdef VAD2
965 Word32 r01;
966 Word32 r02;
967 Word32 r03;
968 Word32 rmax1;
969 Word32 rmax2;
970 Word32 rmax3;
971 #else
972 Word16 corr_hp_max;
973 #endif
974 Word32 corr[PIT_MAX+1];
975 Word32 *corr_ptr;
976
977 /* Scaled signal */
978
979 Word16 scaled_signal[L_FRAME + PIT_MAX];
980 Word16 *scal_sig;
981 Word16 *p_signal;
982 Word16 scal_fac;
983 Word32 L_temp;
984
985 #ifndef VAD2
986 if (dtx)
987 { /* no test() call since this if is only in simulation env */
988 /* update tone detection */
989 if ((mode == MR475) || (mode == MR515))
990 {
991 vad_tone_detection_update(vadSt, 1, pOverflow);
992 }
993 else
994 {
995 vad_tone_detection_update(vadSt, 0, pOverflow);
996 }
997 }
998 #endif
999
1000
1001 t0 = 0L;
1002 p_signal = &signal[-pit_max];
1003
1004 for (i = -pit_max; i < L_frame; i++)
1005 {
1006 __builtin_mul_overflow(*p_signal, *p_signal, &mul);
1007 __builtin_add_overflow(t0, mul << 1, &t0);
1008 p_signal++;
1009 if (t0 < 0)
1010 {
1011 t0 = MAX_32;
1012 break;
1013 }
1014
1015 }
1016
1017 /*--------------------------------------------------------*
1018 * Scaling of input signal. *
1019 * *
1020 * if Overflow -> scal_sig[i] = signal[i]>>3 *
1021 * else if t0 < 1^20 -> scal_sig[i] = signal[i]<<3 *
1022 * else -> scal_sig[i] = signal[i] *
1023 *--------------------------------------------------------*/
1024
1025 /*--------------------------------------------------------*
1026 * Verification for risk of overflow. *
1027 *--------------------------------------------------------*/
1028
1029 scal_sig = &scaled_signal[0];
1030 p_signal = &signal[-pit_max];
1031
1032 if (t0 == MAX_32) /* Test for overflow */
1033 {
1034
1035 for (i = (pit_max + L_frame) >> 1; i != 0; i--)
1036 {
1037 *(scal_sig++) = (Word16)(((Word32) * (p_signal++) >> 3));
1038 *(scal_sig++) = (Word16)(((Word32) * (p_signal++) >> 3));
1039 }
1040
1041 if ((pit_max + L_frame) & 1)
1042 {
1043 *(scal_sig) = (Word16)(((Word32) * (p_signal) >> 3));
1044 }
1045
1046 scal_fac = 3;
1047 }
1048 else if (t0 < (Word32)1048576L)
1049 /* if (t0 < 2^20) */
1050 {
1051 for (i = (pit_max + L_frame) >> 1; i != 0; i--)
1052 {
1053 *(scal_sig++) = (Word16)(((Word32) * (p_signal++) << 3));
1054 *(scal_sig++) = (Word16)(((Word32) * (p_signal++) << 3));
1055 }
1056
1057 if ((pit_max + L_frame) & 1)
1058 {
1059 *(scal_sig) = (Word16)(((Word32) * (p_signal) << 3));
1060 }
1061 scal_fac = -3;
1062 }
1063 else
1064 {
1065
1066 memcpy(scal_sig, p_signal, (L_frame + pit_max)*sizeof(*signal));
1067 scal_fac = 0;
1068 }
1069
1070 /* calculate all coreelations of scal_sig, from pit_min to pit_max */
1071 corr_ptr = &corr[pit_max];
1072
1073 scal_sig = &scaled_signal[pit_max];
1074
1075 comp_corr(scal_sig, L_frame, pit_max, pit_min, corr_ptr);
1076
1077 /*--------------------------------------------------------------------*
1078 * The pitch lag search is divided in three sections. *
1079 * Each section cannot have a pitch multiple. *
1080 * We find a maximum for each section. *
1081 * We compare the maximum of each section by favoring small lags. *
1082 * *
1083 * First section: lag delay = pit_max downto 4*pit_min *
1084 * Second section: lag delay = 4*pit_min-1 downto 2*pit_min *
1085 * Third section: lag delay = 2*pit_min-1 downto pit_min *
1086 *--------------------------------------------------------------------*/
1087
1088 /* mode dependent scaling in Lag_max */
1089
1090 if (mode == MR122)
1091 {
1092 scal_flag = 1;
1093 }
1094 else
1095 {
1096 scal_flag = 0;
1097 }
1098
1099 #ifdef VAD2
1100 L_temp = ((Word32)pit_min) << 2;
1101 if (L_temp != (Word32)((Word16) L_temp))
1102 {
1103 *pOverflow = 1;
1104 j = (pit_min > 0) ? MAX_16 : MIN_16;
1105 }
1106 else
1107 {
1108 j = (Word16)L_temp;
1109 }
1110
1111 p_max1 = Lag_max(corr_ptr, scal_sig, scal_fac, scal_flag, L_frame,
1112 pit_max, j, &max1, &rmax1, &r01, dtx, pOverflow);
1113
1114 i = j - 1;
1115
1116 j = pit_min << 1;
1117
1118 p_max2 = Lag_max(corr_ptr, scal_sig, scal_fac, scal_flag, L_frame,
1119 i, j, &max2, &rmax2, &r02, dtx, pOverflow);
1120
1121 i = j - 1;
1122
1123 p_max3 = Lag_max(corr_ptr, scal_sig, scal_fac, scal_flag, L_frame,
1124 i, pit_min, &max3, &rmax3, &r03, dtx, pOverflow);
1125
1126 #else
1127 L_temp = ((Word32)pit_min) << 2;
1128 if (L_temp != (Word32)((Word16) L_temp))
1129 {
1130 *pOverflow = 1;
1131 j = (pit_min > 0) ? MAX_16 : MIN_16;
1132 }
1133 else
1134 {
1135 j = (Word16)L_temp;
1136 }
1137
1138 p_max1 = Lag_max(vadSt, corr_ptr, scal_sig, scal_fac, scal_flag, L_frame,
1139 pit_max, j, &max1, dtx, pOverflow);
1140
1141 i = j - 1;
1142
1143
1144 j = pit_min << 1;
1145
1146
1147 p_max2 = Lag_max(vadSt, corr_ptr, scal_sig, scal_fac, scal_flag, L_frame,
1148 i, j, &max2, dtx, pOverflow);
1149
1150 i = j - 1;
1151 p_max3 = Lag_max(vadSt, corr_ptr, scal_sig, scal_fac, scal_flag, L_frame,
1152 i, pit_min, &max3, dtx, pOverflow);
1153
1154 if (dtx)
1155 { /* no test() call since this if is only in simulation env */
1156
1157 if (idx == 1)
1158 {
1159 /* calculate max high-passed filtered correlation of all lags */
1160 hp_max(corr_ptr, scal_sig, L_frame, pit_max, pit_min, &corr_hp_max,
1161 pOverflow);
1162
1163 /* update complex background detector */
1164 vad_complex_detection_update(vadSt, corr_hp_max);
1165 }
1166 }
1167 #endif
1168
1169 /*--------------------------------------------------------------------*
1170 * Compare the 3 sections maximum, and favor small lag. *
1171 *--------------------------------------------------------------------*/
1172
1173 i = mult(max1, THRESHOLD, pOverflow);
1174
1175 if (i < max2)
1176 {
1177 max1 = max2;
1178 p_max1 = p_max2;
1179
1180 #ifdef VAD2
1181 if (dtx)
1182 {
1183 rmax1 = rmax2;
1184 r01 = r02;
1185 }
1186 #endif
1187 }
1188
1189 i = mult(max1, THRESHOLD, pOverflow);
1190
1191 if (i < max3)
1192 {
1193 p_max1 = p_max3;
1194
1195 #ifdef VAD2
1196 if (dtx)
1197 {
1198 rmax1 = rmax3;
1199 r01 = r03;
1200 }
1201 #endif
1202 }
1203
1204 #ifdef VAD2
1205 if (dtx)
1206 {
1207 /* Save max correlation */
1208 vadSt->L_Rmax = L_add(vadSt->L_Rmax, rmax1, pOverflow);
1209 /* Save max energy */
1210 vadSt->L_R0 = L_add(vadSt->L_R0, r01, pOverflow);
1211 }
1212 #endif
1213
1214 return (p_max1);
1215 }
1216