mer feb 12 14:56:57 CET 2003
[asterisk/asterisk.git] / codecs / lpc10 / tbdm.c
1 /*
2
3 $Log$
4 Revision 1.14  2003/02/12 13:59:15  matteo
5 mer feb 12 14:56:57 CET 2003
6
7 Revision 1.1.1.1  2003/02/12 13:59:15  matteo
8 mer feb 12 14:56:57 CET 2003
9
10 Revision 1.2  2000/01/05 08:20:40  markster
11 Some OSS fixes and a few lpc changes to make it actually work
12
13  * Revision 1.1  1996/08/19  22:30:26  jaf
14  * Initial revision
15  *
16
17 */
18
19 #ifdef P_R_O_T_O_T_Y_P_E_S
20 extern int tbdm_(real *speech, integer *lpita, integer *tau, integer *ltau, real *amdf, integer *minptr, integer *maxptr, integer *mintau);
21 /*:ref: difmag_ 14 8 6 4 4 4 4 6 4 4 */
22 #endif
23
24 /*  -- translated by f2c (version 19951025).
25    You must link the resulting object file with the libraries:
26         -lf2c -lm   (in that order)
27 */
28
29 #include "f2c.h"
30
31 /* ********************************************************************** */
32
33 /*      TBDM Version 49 */
34
35 /* $Log$
36  * Revision 1.14  2003/02/12 13:59:15  matteo
37  * mer feb 12 14:56:57 CET 2003
38  *
39 /* Revision 1.1.1.1  2003/02/12 13:59:15  matteo
40 /* mer feb 12 14:56:57 CET 2003
41 /*
42 /* Revision 1.2  2000/01/05 08:20:40  markster
43 /* Some OSS fixes and a few lpc changes to make it actually work
44 /*
45  * Revision 1.1  1996/08/19  22:30:26  jaf
46  * Initial revision
47  * */
48 /* Revision 1.3  1996/03/18  22:14:00  jaf */
49 /* Just added a few comments about which array indices of the arguments */
50 /* are used, and mentioning that this subroutine has no local state. */
51
52 /* Revision 1.2  1996/03/13  14:48:37  jaf */
53 /* Comments added explaining that none of the local variables of this */
54 /* subroutine need to be saved from one invocation to the next. */
55
56 /* Revision 1.1  1996/02/07 14:49:54  jaf */
57 /* Initial revision */
58
59
60 /* ********************************************************************* */
61
62 /*TURBO DIFMAG: Compute High Resolution Average Magnitude Difference Function
63 */
64
65 /* Note: There are several constants in here that appear to depend on a */
66 /* particular TAU table.  That's not a problem for the LPC10 coder, but */
67 /* watch out if you change the contents of TAU in the subroutine ANALYS. */
68
69 /* Input: */
70 /*  SPEECH - Low pass filtered speech */
71 /*           Indices 1 through MAX+LPITA-1 are read, where: */
72 /*           MAX = (TAU(LTAU)-TAU(1))/2+1 */
73 /*           (If TAU(1) .LT. 39, then larger indices could be read */
74 /*           by the last call to DIFMAG below.) */
75 /*  LPITA  - Length of speech buffer */
76 /*  TAU    - Table of lags, sorted in increasing order. */
77 /*           Indices 1 through LTAU read. */
78 /*  LTAU   - Number of lag values to compute */
79 /* Output: */
80 /*  AMDF   - Average Magnitude Difference for each lag in TAU */
81 /*          Indices 1 through LTAU written, and several might then be read.*/
82 /*  MINPTR - Index of minimum AMDF value */
83 /*  MAXPTR - Index of maximum AMDF value within +/- 1/2 octave of min */
84 /*  MINTAU - Lag corresponding to minimum AMDF value */
85
86 /* This subroutine has no local state. */
87
88 /* Subroutine */ int tbdm_(real *speech, integer *lpita, integer *tau, 
89         integer *ltau, real *amdf, integer *minptr, integer *maxptr, integer *
90         mintau)
91 {
92     /* System generated locals */
93     integer i__1, i__2, i__3, i__4;
94
95     /* Local variables */
96     real amdf2[6];
97     integer minp2, ltau2, maxp2, i__;
98     extern /* Subroutine */ int difmag_(real *, integer *, integer *, integer 
99             *, integer *, real *, integer *, integer *);
100     integer minamd, ptr, tau2[6];
101
102 /*      Arguments */
103 /*      REAL SPEECH(LPITA+TAU(LTAU)), AMDF(LTAU) */
104 /*   Stupid TOAST doesn't understand expressions */
105 /*       Local variables that need not be saved */
106 /*       Local state */
107 /*       None */
108 /*   Compute full AMDF using log spaced lags, find coarse minimum */
109     /* Parameter adjustments */
110     --speech;
111     --amdf;
112     --tau;
113
114     /* Function Body */
115     difmag_(&speech[1], lpita, &tau[1], ltau, &tau[*ltau], &amdf[1], minptr, 
116             maxptr);
117     *mintau = tau[*minptr];
118     minamd = amdf[*minptr];
119 /*   Build table containing all lags within +/- 3 of the AMDF minimum */
120 /*    excluding all that have already been computed */
121     ltau2 = 0;
122     ptr = *minptr - 2;
123 /* Computing MAX */
124     i__1 = *mintau - 3;
125 /* Computing MIN */
126     i__3 = *mintau + 3, i__4 = tau[*ltau] - 1;
127     i__2 = min(i__3,i__4);
128     for (i__ = max(i__1,41); i__ <= i__2; ++i__) {
129         while(tau[ptr] < i__) {
130             ++ptr;
131         }
132         if (tau[ptr] != i__) {
133             ++ltau2;
134             tau2[ltau2 - 1] = i__;
135         }
136     }
137 /*   Compute AMDF of the new lags, if there are any, and choose one */
138 /*    if it is better than the coarse minimum */
139     if (ltau2 > 0) {
140         difmag_(&speech[1], lpita, tau2, &ltau2, &tau[*ltau], amdf2, &minp2, &
141                 maxp2);
142         if (amdf2[minp2 - 1] < (real) minamd) {
143             *mintau = tau2[minp2 - 1];
144             minamd = amdf2[minp2 - 1];
145         }
146     }
147 /*   Check one octave up, if there are any lags not yet computed */
148     if (*mintau >= 80) {
149         i__ = *mintau / 2;
150         if ((i__ & 1) == 0) {
151             ltau2 = 2;
152             tau2[0] = i__ - 1;
153             tau2[1] = i__ + 1;
154         } else {
155             ltau2 = 1;
156             tau2[0] = i__;
157         }
158         difmag_(&speech[1], lpita, tau2, &ltau2, &tau[*ltau], amdf2, &minp2, &
159                 maxp2);
160         if (amdf2[minp2 - 1] < (real) minamd) {
161             *mintau = tau2[minp2 - 1];
162             minamd = amdf2[minp2 - 1];
163             *minptr += -20;
164         }
165     }
166 /*   Force minimum of the AMDF array to the high resolution minimum */
167     amdf[*minptr] = (real) minamd;
168 /*   Find maximum of AMDF within 1/2 octave of minimum */
169 /* Computing MAX */
170     i__2 = *minptr - 5;
171     *maxptr = max(i__2,1);
172 /* Computing MIN */
173     i__1 = *minptr + 5;
174     i__2 = min(i__1,*ltau);
175     for (i__ = *maxptr + 1; i__ <= i__2; ++i__) {
176         if (amdf[i__] > amdf[*maxptr]) {
177             *maxptr = i__;
178         }
179     }
180     return 0;
181 } /* tbdm_ */
182