src/spectral/filterbank_mel.c

   1 /*
   2   Copyright (C) 2007-2009 Paul Brossier <piem@aubio.org>
   3                       and Amaury Hazan <ahazan@iua.upf.edu>
   4
   5   This file is part of aubio.
   6
   7   aubio is free software: you can redistribute it and/or modify
   8   it under the terms of the GNU General Public License as published by
   9   the Free Software Foundation, either version 3 of the License, or
  10   (at your option) any later version.
  11
  12   aubio is distributed in the hope that it will be useful,
  13   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15   GNU General Public License for more details.
  16
  17   You should have received a copy of the GNU General Public License
  18   along with aubio.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 */
  21
  22 #include "aubio_priv.h"
  23 #include "fmat.h"
  24 #include "fvec.h"
  25 #include "cvec.h"
  26 #include "spectral/filterbank.h"
  27 #include "spectral/filterbank_mel.h"
  28 #include "mathutils.h"
  29
  30 uint_t
  31 aubio_filterbank_set_triangle_bands (aubio_filterbank_t * fb,
  32     const fvec_t * freqs, smpl_t samplerate)
  33 {
  34
  35   fmat_t *filters = aubio_filterbank_get_coeffs (fb);
  36   uint_t n_filters = filters->height, win_s = filters->length;
  37   fvec_t *lower_freqs, *upper_freqs, *center_freqs;
  38   fvec_t *triangle_heights, *fft_freqs;
  39
  40   uint_t fn;                    /* filter counter */
  41   uint_t bin;                   /* bin counter */
  42
  43   smpl_t riseInc, downInc;
  44
  45   /* freqs define the bands of triangular overlapping windows.
  46      throw a warning if filterbank object fb is too short. */
  47   if (freqs->length - 2 > n_filters) {
  48     AUBIO_WRN ("not enough filters, %d allocated but %d requested\n",
  49         n_filters, freqs->length - 2);
  50   }
  51
  52   if (freqs->length - 2 < n_filters) {
  53     AUBIO_WRN ("too many filters, %d allocated but %d requested\n",
  54         n_filters, freqs->length - 2);
  55   }
  56
  57   for (fn = 0; fn < freqs->length; fn++) {
  58     if (freqs->data[fn] < 0) {
  59       AUBIO_ERR("filterbank_mel: freqs must contain only positive values.\n");
  60       return AUBIO_FAIL;
  61     } else if (freqs->data[fn] > samplerate / 2) {
  62       AUBIO_WRN("filterbank_mel: freqs should contain only "
  63           "values < samplerate / 2.\n");
  64     } else if (fn > 0 && freqs->data[fn] < freqs->data[fn-1]) {
  65       AUBIO_ERR("filterbank_mel: freqs should be a list of frequencies "
  66           "sorted from low to high, but freq[%d] < freq[%d-1]\n", fn, fn);
  67       return AUBIO_FAIL;
  68     } else if (fn > 0 && freqs->data[fn] == freqs->data[fn-1]) {
  69       AUBIO_WRN("filterbank_mel: set_triangle_bands received a list "
  70           "with twice the frequency %f\n", freqs->data[fn]);
  71     }
  72   }
  73
  74   /* convenience reference to lower/center/upper frequency for each triangle */
  75   lower_freqs = new_fvec (n_filters);
  76   upper_freqs = new_fvec (n_filters);
  77   center_freqs = new_fvec (n_filters);
  78
  79   /* height of each triangle */
  80   triangle_heights = new_fvec (n_filters);
  81
  82   /* lookup table of each bin frequency in hz */
  83   fft_freqs = new_fvec (win_s);
  84
  85   /* fill up the lower/center/upper */
  86   for (fn = 0; fn < n_filters; fn++) {
  87     lower_freqs->data[fn] = freqs->data[fn];
  88     center_freqs->data[fn] = freqs->data[fn + 1];
  89     upper_freqs->data[fn] = freqs->data[fn + 2];
  90   }
  91
  92   /* compute triangle heights so that each triangle has unit area */
  93   if (aubio_filterbank_get_norm(fb)) {
  94     for (fn = 0; fn < n_filters; fn++) {
  95       triangle_heights->data[fn] =
  96           2. / (upper_freqs->data[fn] - lower_freqs->data[fn]);
  97     }
  98   } else {
  99     fvec_ones (triangle_heights);
 100   }
 101
 102   /* fill fft_freqs lookup table, which assigns the frequency in hz to each bin */
 103   for (bin = 0; bin < win_s; bin++) {
 104     fft_freqs->data[bin] =
 105         aubio_bintofreq (bin, samplerate, (win_s - 1) * 2);
 106   }
 107
 108   /* zeroing of all filters */
 109   fmat_zeros (filters);
 110
 111   /* building each filter table */
 112   for (fn = 0; fn < n_filters; fn++) {
 113
 114     /* skip first elements */
 115     for (bin = 0; bin < win_s - 1; bin++) {
 116       if (fft_freqs->data[bin] <= lower_freqs->data[fn] &&
 117           fft_freqs->data[bin + 1] > lower_freqs->data[fn]) {
 118         bin++;
 119         break;
 120       }
 121     }
 122
 123     /* compute positive slope step size */
 124     riseInc = triangle_heights->data[fn]
 125       / (center_freqs->data[fn] - lower_freqs->data[fn]);
 126
 127     /* compute coefficients in positive slope */
 128     for (; bin < win_s - 1; bin++) {
 129       filters->data[fn][bin] =
 130           (fft_freqs->data[bin] - lower_freqs->data[fn]) * riseInc;
 131
 132       if (fft_freqs->data[bin + 1] >= center_freqs->data[fn]) {
 133         bin++;
 134         break;
 135       }
 136     }
 137
 138     /* compute negative slope step size */
 139     downInc = triangle_heights->data[fn]
 140       / (upper_freqs->data[fn] - center_freqs->data[fn]);
 141
 142     /* compute coefficents in negative slope */
 143     for (; bin < win_s - 1; bin++) {
 144       filters->data[fn][bin] +=
 145           (upper_freqs->data[fn] - fft_freqs->data[bin]) * downInc;
 146
 147       if (filters->data[fn][bin] < 0.) {
 148         filters->data[fn][bin] = 0.;
 149       }
 150
 151       if (fft_freqs->data[bin + 1] >= upper_freqs->data[fn])
 152         break;
 153     }
 154     /* nothing else to do */
 155
 156   }
 157
 158   /* destroy temporarly allocated vectors */
 159   del_fvec (lower_freqs);
 160   del_fvec (upper_freqs);
 161   del_fvec (center_freqs);
 162
 163   del_fvec (triangle_heights);
 164   del_fvec (fft_freqs);
 165
 166   return AUBIO_OK;
 167 }
 168
 169 uint_t
 170 aubio_filterbank_set_mel_coeffs_slaney (aubio_filterbank_t * fb,
 171     smpl_t samplerate)
 172 {
 173   uint_t retval;
 174
 175   /* Malcolm Slaney parameters */
 176   smpl_t lowestFrequency = 133.3333;
 177   smpl_t linearSpacing = 66.66666666;
 178   smpl_t logSpacing = 1.0711703;
 179
 180   uint_t linearFilters = 13;
 181   uint_t logFilters = 27;
 182   uint_t n_filters = linearFilters + logFilters;
 183
 184   uint_t fn;                    /* filter counter */
 185
 186   smpl_t lastlinearCF;
 187
 188   /* buffers to compute filter frequencies */
 189   fvec_t *freqs;
 190
 191   if (samplerate <= 0) {
 192     AUBIO_ERR("filterbank: set_mel_coeffs_slaney samplerate should be > 0\n");
 193     return AUBIO_FAIL;
 194   }
 195
 196   freqs = new_fvec (n_filters + 2);
 197
 198   /* first step: fill all the linear filter frequencies */
 199   for (fn = 0; fn < linearFilters; fn++) {
 200     freqs->data[fn] = lowestFrequency + fn * linearSpacing;
 201   }
 202   lastlinearCF = freqs->data[fn - 1];
 203
 204   /* second step: fill all the log filter frequencies */
 205   for (fn = 0; fn < logFilters + 2; fn++) {
 206     freqs->data[fn + linearFilters] =
 207         lastlinearCF * (POW (logSpacing, fn + 1));
 208   }
 209
 210   /* now compute the actual coefficients */
 211   retval = aubio_filterbank_set_triangle_bands (fb, freqs, samplerate);
 212
 213   /* destroy vector used to store frequency limits */
 214   del_fvec (freqs);
 215
 216   return retval;
 217 }
 218
 219 static uint_t aubio_filterbank_check_freqs (aubio_filterbank_t *fb UNUSED,
 220     smpl_t samplerate, smpl_t *freq_min, smpl_t *freq_max)
 221 {
 222   if (samplerate <= 0) {
 223     AUBIO_ERR("filterbank: set_mel_coeffs samplerate should be > 0\n");
 224     return AUBIO_FAIL;
 225   }
 226   if (*freq_max < 0) {
 227     AUBIO_ERR("filterbank: set_mel_coeffs freq_max should be > 0\n");
 228     return AUBIO_FAIL;
 229   } else if (*freq_max == 0) {
 230     *freq_max = samplerate / 2.;
 231   }
 232   if (*freq_min < 0) {
 233     AUBIO_ERR("filterbank: set_mel_coeffs freq_min should be > 0\n");
 234     return AUBIO_FAIL;
 235   }
 236   return AUBIO_OK;
 237 }
 238
 239 uint_t
 240 aubio_filterbank_set_mel_coeffs (aubio_filterbank_t * fb, smpl_t samplerate,
 241     smpl_t freq_min, smpl_t freq_max)
 242 {
 243   uint_t m, retval;
 244   smpl_t start = freq_min, end = freq_max, step;
 245   fvec_t *freqs;
 246   fmat_t *coeffs = aubio_filterbank_get_coeffs(fb);
 247   uint_t n_bands = coeffs->height;
 248
 249   if (aubio_filterbank_check_freqs(fb, samplerate, &start, &end)) {
 250     return AUBIO_FAIL;
 251   }
 252
 253   start = aubio_hztomel(start);
 254   end = aubio_hztomel(end);
 255
 256   freqs = new_fvec(n_bands + 2);
 257   step = (end - start) / (n_bands + 1);
 258
 259   for (m = 0; m < n_bands + 2; m++)
 260   {
 261     freqs->data[m] = MIN(aubio_meltohz(start + step * m), samplerate/2.);
 262   }
 263
 264   retval = aubio_filterbank_set_triangle_bands (fb, freqs, samplerate);
 265
 266   /* destroy vector used to store frequency limits */
 267   del_fvec (freqs);
 268   return retval;
 269 }
 270
 271 uint_t
 272 aubio_filterbank_set_mel_coeffs_htk (aubio_filterbank_t * fb, smpl_t samplerate,
 273     smpl_t freq_min, smpl_t freq_max)
 274 {
 275   uint_t m, retval;
 276   smpl_t start = freq_min, end = freq_max, step;
 277   fvec_t *freqs;
 278   fmat_t *coeffs = aubio_filterbank_get_coeffs(fb);
 279   uint_t n_bands = coeffs->height;
 280
 281   if (aubio_filterbank_check_freqs(fb, samplerate, &start, &end)) {
 282     return AUBIO_FAIL;
 283   }
 284
 285   start = aubio_hztomel_htk(start);
 286   end = aubio_hztomel_htk(end);
 287
 288   freqs = new_fvec (n_bands + 2);
 289   step = (end - start) / (n_bands + 1);
 290
 291   for (m = 0; m < n_bands + 2; m++)
 292   {
 293     freqs->data[m] = MIN(aubio_meltohz_htk(start + step * m), samplerate/2.);
 294   }
 295
 296   retval = aubio_filterbank_set_triangle_bands (fb, freqs, samplerate);
 297
 298   /* destroy vector used to store frequency limits */
 299   del_fvec (freqs);
 300   return retval;
 301 }