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