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 /* debug level */
  52 int _debug=1;
  53
  54 /*******************
  55         Code
  56 ********************/
  57
  58 /**
  59  * note_frequency - MIDI note to frequency converter
  60  * @note: the MIDI note
  61  *
  62  * Accepts a MIDI note number (range 0 to 127) and
  63  * returns its frequency in Hz.
  64  */
  65 double note_frequency(int note)
  66 {
  67         int n;
  68
  69         if(!VALID_NOTE(note))
  70                 return(0);
  71
  72         /* builds the table if empty */
  73         if(_note_frequency[0] == 0.0)
  74         {
  75                 for(n=0;n < NUM_NOTES;n++)
  76                         _note_frequency[n]=(_middle_A_freq / 32.0) *
  77                         pow(2.0, (((double)n - 9.0) / 12.0));
  78         }
  79
  80         return(_note_frequency[note]);
  81 }
  82
  83
  84 /**
  85  * _get_sample - Reads a sample from a wave buffer.
  86  * @wave: the wave PCM data
  87  * @size: size of the wave in samples
  88  * @offset: sample number to be returned
  89  *
  90  * Returns the sample number @offset from the @wave buffer
  91  * of @size size, doing interpolation if @offset
  92  * is not an integer.
  93  */
  94 float _get_sample(float * wave, double size, double offset)
  95 {
  96         float d, s1, s2, r;
  97         int o;
  98
  99         /* take care of wrappings */
 100         if(offset < 0) offset += size;
 101
 102         o=(int) offset;
 103
 104         switch(_interpolation)
 105         {
 106         case 0:
 107                 /* no interpolation */
 108                 r=wave[o];
 109                 break;
 110
 111         case 1:
 112                 /* linear interpolation */
 113                 if(offset > size - 2)
 114                         r=wave[o];
 115                 else
 116                 {
 117                         d=(float)(offset - floor(offset));
 118                         s1=wave[o];
 119                         s2=(wave[o + 1] - s1) * d;
 120
 121                         r=s1 + s2;
 122                 }
 123
 124                 break;
 125
 126         case 2:
 127                 /* cubic spline (borrowed from timidity) */
 128                 if(offset < 1 || offset > size - 3)
 129                         r=wave[o];
 130                 else
 131                 {
 132                         float s0, s3, t;
 133
 134                         s0=wave[o - 1];
 135                         s1=wave[o];
 136                         s2=wave[o + 1];
 137                         s3=wave[o + 2];
 138
 139                         t=s2;
 140
 141                         d=(float)(offset - floor(offset));
 142
 143                         s2=(6.0 * s2 +
 144                                 ((5.0 * s3 - 11.0 * s2 + 7.0 * s1 - s0) / 4.0) *
 145                                         (d + 1.0) * (d - 1.0)) * d;
 146
 147                         s1=((6.0 * s1 +
 148                                 ((5.0 * s0 - 11.0 * s1 + 7.0 * t - s3) / 4.0) *
 149                                         d * (d - 2.0)) * (1.0 - d) + s2) / 6.0;
 150
 151                         r=s1;
 152                 }
 153
 154                 break;
 155
 156         case 3:
 157                 /* lagrange (borrowed from timidity) */
 158                 if(offset < 1 || offset > size - 3)
 159                         r=wave[o];
 160                 else
 161                 {
 162                         float s0, s3;
 163
 164                         s0=wave[o - 1];
 165                         s1=wave[o];
 166                         s2=wave[o + 1];
 167                         s3=wave[o + 2];
 168
 169                         d=(float)(offset - floor(offset));
 170
 171                         s3 += -3.0 * s2 + 3.0 * s1 - s0;
 172                         s3 *= (d - 2.0) / 6.0;
 173                         s3 += s2 - 2.0 * s1 + s0;
 174                         s3 *= (d - 1.0) / 2.0;
 175                         s3 += s1 - s0;
 176                         s3 *= d;
 177                         s3 += s0;
 178
 179                         r=s3;
 180                 }
 181
 182                 break;
 183         }
 184
 185         return(r);
 186 }
 187
 188
 189 float get_sample(struct ss_wave * w, int channel, double offset)
 190 {
 191         return(_get_sample(w->wave[channel], w->size, offset));
 192 }
 193
 194
 195 /**
 196  * wave_resample - Resamples a wave.
 197  * @freq: original frequency of the wave
 198  * @size: size of the wave in samples
 199  * @n_channels: number of channels
 200  * @wave: the wave PCM data
 201  *
 202  * Resamples the @wave from its original @freq frequency to
 203  * the global output frequency. The resampled wave is stored
 204  * in @wave.
 205  *
 206  * Returns the conversion ratio; the original size (and other
 207  * pointers to the data as loop starts and ends) should be
 208  * divided by this number to match the new wave.
 209  */
 210 double wave_resample(int freq, double size, int n_channels, float * wave[])
 211 {
 212         double ratio;
 213         int new_size;
 214         float * old_wave;
 215         int n,m;
 216         double i;
 217
 218         ratio=(double) freq / (double) _frequency;
 219         new_size=(int)(size / ratio);
 220
 221         printf("wave_resample: ratio %f\n", (float)ratio);
 222
 223         for(n=0;n < n_channels;n++)
 224         {
 225                 old_wave=wave[n];
 226                 wave[n]=(float *) malloc(new_size * sizeof(float));
 227 /*
 228                 for(m=i=0;m < new_size;m++,i+=ratio)
 229                         wave[n][m]=get_sample(old_wave, size, i);
 230 */
 231                 /* free the old wave */
 232                 free(old_wave);
 233         }
 234
 235         return(ratio);
 236 }
 237
 238
 239 /**
 240  * tempo_from_wave - Calculates a tempo from a wave
 241  * @w: the wave
 242  * @note: note to calculate the tempo from
 243  * @len: whole notes the tempo should match
 244  *
 245  * Calculates the optimal tempo for the @w wave, playing the @note,
 246  * to last @len whole notes.
 247  */
 248 double tempo_from_wave(struct ss_wave * w, int note, double len)
 249 {
 250         double d;
 251
 252         d=note_frequency(note) / w->base_freq;
 253
 254         /* get the length of a whole, in seconds */
 255         d *= w->size / w->s_rate;
 256
 257         /* convert to minutes */
 258         d *= 60.0;
 259
 260         /* convert to the desired whole notes */
 261         d *= len;
 262
 263         return(d);
 264 }
 265
 266
 267 /**
 268  * pitch_from_wave - Calculates a pitch from a wave
 269  * @w: the wave
 270  * @tempo: current tempo
 271  * @len: desired length in whole notes
 272  *
 273  * Calculates the optimal frequency (pitch) for the @w wave, at @tempo,
 274  * to last @len whole notes.
 275  */
 276 double pitch_from_wave(struct ss_wave * w, double tempo, double len)
 277 {
 278         double d;
 279
 280         /* calculate number of seconds the wave lasts */
 281         d=w->size / (double) w->s_rate;
 282
 283         /* convert to minutes, then to wpms */
 284         d /= 60.0;
 285         d *= (tempo / 4.0);
 286
 287         return(w->base_freq * d * len);
 288 }