core.c

   1 /*
   2
   3     Ann Hell Ex Machina - Music Software
   4     Copyright (C) 2003/2004 Angel Ortega <angel@triptico.com>
   5
   6     core.c - Core functions
   7
   8     This program is free software; you can redistribute it and/or
   9     modify it under the terms of the GNU General Public License
  10     as published by the Free Software Foundation; either version 2
  11     of the License, or (at your option) any later version.
  12
  13     This program is distributed in the hope that it will be useful,
  14     but WITHOUT ANY WARRANTY; without even the implied warranty of
  15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16     GNU General Public License for more details.
  17
  18     You should have received a copy of the GNU General Public License
  19     along with this program; if not, write to the Free Software
  20     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  21
  22     http://www.triptico.com
  23
  24 */
  25
  26 #include "config.h"
  27
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <math.h>
  31
  32 #include "core.h"
  33
  34 /*******************
  35         Data
  36 ********************/
  37
  38 /* main output frequency */
  39 int _frequency=44100;
  40
  41 /* interpolation type: 0, none; 1, linear; 2, cubic spline; 3, lagrange */
  42 int _interpolation=1;
  43
  44 /* output channels */
  45 int _n_channels=2;
  46
  47 /* note frequencies */
  48 double _middle_A_freq=440.0;
  49 static double _note_frequency[NUM_NOTES];
  50
  51 /*******************
  52         Code
  53 ********************/
  54
  55 /**
  56  * note_frequency - MIDI note to frequency converter
  57  * @note: the MIDI note
  58  *
  59  * Accepts a MIDI note number (range 0 to 127) and
  60  * returns its frequency in Hz.
  61  */
  62 double note_frequency(int note)
  63 {
  64         int n;
  65
  66         if(!VALID_NOTE(note))
  67                 return(0);
  68
  69         /* builds the table if empty */
  70         if(_note_frequency[0] == 0.0)
  71         {
  72                 for(n=0;n < NUM_NOTES;n++)
  73                         _note_frequency[n]=(_middle_A_freq / 32.0) *
  74                         pow(2.0, (((double)n - 9.0) / 12.0));
  75         }
  76
  77         return(_note_frequency[note]);
  78 }
  79
  80
  81 /**
  82  * get_sample - Reads a sample from a wave buffer.
  83  * @wave: the wave PCM data
  84  * @size: size of the wave in samples
  85  * @offset: sample number to be returned
  86  *
  87  * Returns the sample number @offset from the @wave buffer
  88  * of @size size, doing interpolation if @offset
  89  * is not an integer.
  90  */
  91 float get_sample(float * wave, double size, double offset)
  92 {
  93         float d, s1, s2, r;
  94         int o;
  95
  96         o=(int) offset;
  97
  98         switch(_interpolation)
  99         {
 100         case 0:
 101                 /* no interpolation */
 102                 r=wave[o];
 103                 break;
 104
 105         case 1:
 106                 /* linear interpolation */
 107                 d=(float)(offset - floor(offset));
 108                 s1=wave[o];
 109                 if(offset + 1 > size) o=0; else o++;
 110                 s2=(wave[o] - s1) * d;
 111
 112                 r=s1 + s2;
 113                 break;
 114
 115         case 2:
 116                 /* cubic spline (borrowed from timidity) */
 117                 if(offset < 1 || offset > size - 2)
 118                         r=wave[o];
 119                 else
 120                 {
 121                         float s0, s3, t;
 122
 123                         s0=wave[o - 1];
 124                         s1=wave[o];
 125                         s2=wave[o + 1];
 126                         s3=wave[o + 2];
 127
 128                         t=s2;
 129
 130                         d=(float)(offset - floor(offset));
 131
 132                         s2=(6.0 * s2 +
 133                                 ((5.0 * s3 - 11.0 * s2 + 7.0 * s1 - s0) / 4.0) *
 134                                         (d + 1.0) * (d - 1.0)) * d;
 135
 136                         s1=((6.0 * s1 +
 137                                 ((5.0 * s0 - 11.0 * s1 + 7.0 * t - s3) / 4.0) *
 138                                         d * (d - 2.0)) * (1.0 - d) + s2) / 6.0;
 139
 140                         r=s1;
 141                 }
 142
 143                 break;
 144
 145         case 3:
 146                 /* lagrange (borrowed from timidity) */
 147                 if(offset < 1 || offset > size - 2)
 148                         r=wave[o];
 149                 else
 150                 {
 151                         float s0, s3;
 152
 153                         s0=wave[o - 1];
 154                         s1=wave[o];
 155                         s2=wave[o + 1];
 156                         s3=wave[o + 2];
 157
 158                         d=(float)(offset - floor(offset));
 159
 160                         s3 += -3.0 * s2 + 3.0 * s1 - s0;
 161                         s3 *= (d - 2.0) / 6.0;
 162                         s3 += s2 - 2.0 * s1 + s0;
 163                         s3 *= (d - 1.0) / 2.0;
 164                         s3 += s1 - s0;
 165                         s3 *= d;
 166                         s3 += s0;
 167
 168                         r=s3;
 169                 }
 170
 171                 break;
 172         }
 173
 174         return(r);
 175 }
 176
 177
 178 /**
 179  * wave_resample - Resamples a wave.
 180  * @freq: original frequency of the wave
 181  * @size: size of the wave in samples
 182  * @n_channels: number of channels
 183  * @wave: the wave PCM data
 184  *
 185  * Resamples the @wave from its original @freq frequency to
 186  * the global output frequency. The resampled wave is stored
 187  * in @wave.
 188  *
 189  * Returns the conversion ratio; the original size (and other
 190  * pointers to the data as loop starts and ends) should be
 191  * divided by this number to match the new wave.
 192  */
 193 double wave_resample(int freq, double size, int n_channels, float * wave[])
 194 {
 195         double ratio;
 196         int new_size;
 197         float * old_wave;
 198         int n,m;
 199         double i;
 200
 201         ratio=(double) freq / (double) _frequency;
 202         new_size=(int)(size / ratio);
 203
 204         printf("wave_resample: ratio %f\n", (float)ratio);
 205
 206         for(n=0;n < n_channels;n++)
 207         {
 208                 old_wave=wave[n];
 209                 wave[n]=(float *) malloc(new_size * sizeof(float));
 210
 211                 for(m=i=0;m < new_size;m++,i+=ratio)
 212                         wave[n][m]=get_sample(old_wave, size, i);
 213
 214                 /* free the old wave */
 215                 free(old_wave);
 216         }
 217
 218         return(ratio);
 219 }