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