ss_core.c

   1 /*
   2
   3     Ann Hell Ex Machina - Music Software
   4     Copyright (C) 2003/2005 Angel Ortega <angel@triptico.com>
   5
   6     ss_core.c - Softsynth 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 <string.h>
  31 #include <math.h>
  32
  33 #include "annhell.h"
  34
  35 /*******************
  36         Data
  37 ********************/
  38
  39 /* main output frequency */
  40 int ss_frequency = 44100;
  41
  42 /* interpolation type: 0, none; 1, linear; 2, cubic spline; 3, lagrange */
  43 int ss_interpolation = 3;
  44
  45 /* output channels */
  46 int ss_nchannels = 2;
  47
  48 /* note frequencies */
  49 double ss_middle_A_freq = 440.0;
  50 static double note_frequency[128];
  51
  52 /*******************
  53         Code
  54 ********************/
  55
  56 /**
  57  * ss_note_frequency - MIDI note to frequency converter
  58  * @note: the MIDI note
  59  *
  60  * Accepts a MIDI note number (range 0 to 127) and
  61  * returns its frequency in Hz.
  62  */
  63 double ss_note_frequency(int note)
  64 {
  65         int n;
  66
  67         if(note < 0 || note > 127)
  68                 return(0);
  69
  70         /* builds the table if empty */
  71         if(note_frequency[0] == 0.0)
  72         {
  73                 for(n = 0;n < 128;n++)
  74                         note_frequency[n] = (ss_middle_A_freq / 32.0) *
  75                         pow(2.0, (((double)n - 9.0) / 12.0));
  76         }
  77
  78         return(note_frequency[note]);
  79 }
  80
  81
  82 /**
  83  * ss_alloc_wave - Allocates a wave structure.
  84  * @size: size in frames
  85  * @n_channels: number of channels
  86  * @s_rate: sampling rate
  87  * @p_size: size of the sound page
  88  *
  89  * Allocates a wave structure. If @p_size is -1, it's assumed to be the
  90  * same as @size (so the sound will live entirely in memory).
  91  */
  92 struct ss_wave * ss_alloc_wave(int size, int n_channels, int s_rate, int p_size)
  93 {
  94         struct ss_wave * w = NULL;
  95
  96         if(p_size == -1) p_size = size;
  97
  98         if((w = (struct ss_wave *)malloc(sizeof(struct ss_wave))) != NULL)
  99         {
 100                 memset(w, '\0', sizeof(struct ss_wave));
 101
 102                 w->size = (double) size;
 103                 w->p_size = p_size;
 104                 w->n_channels = n_channels;
 105                 w->s_rate = s_rate;
 106
 107                 /* alloc space for the pointers to the waves */
 108                 w->wave = (sample_t **)malloc(n_channels * sizeof(sample_t *));
 109                 memset(w->wave, '\0', n_channels * sizeof(sample_t *));
 110         }
 111
 112         return(w);
 113 }
 114
 115
 116 /**
 117  * ss_free_wave - Frees a wave structure.
 118  * @w: the wave structure
 119  *
 120  * Frees a struct ss_wave allocated by ss_alloc_wave().
 121  */
 122 void ss_free_wave(struct ss_wave * w)
 123 {
 124         if(w->wave != NULL)
 125         {
 126                 int n;
 127
 128                 /* frees the buffers */
 129                 for(n = 0;n < w->n_channels;n++)
 130                         if(w->wave[n] != NULL)
 131                                 free(w->wave[n]);
 132
 133                 /* frees the space for the pointers to the waves */
 134                 free(w->wave);
 135
 136                 /* if it has a filename, also free it */
 137                 if(w->filename != NULL) free(w->filename);
 138         }
 139
 140         /* frees the wave itself */
 141         free(w);
 142 }
 143
 144
 145 void ss_prepare_wave(struct ss_wave * w)
 146 /* prepares a wave file for usage (creates the page buffers) */
 147 {
 148         int n;
 149
 150         /* if the buffers exist, do nothing */
 151         if(w->wave[0] != NULL)
 152                 return;
 153
 154         /* alloc space for the waves themselves */
 155         for(n = 0;n < w->n_channels;n++)
 156         {
 157                 w->wave[n] = (sample_t *)malloc(w->p_size * sizeof(sample_t));
 158                 memset(w->wave[n], '\0', w->p_size * sizeof(sample_t));
 159         }
 160 }
 161
 162
 163 static void ss_load_page(struct ss_wave * w, int offset)
 164 /* loads a page from a wave file into memory */
 165 {
 166         FILE * f;
 167         int s;
 168
 169         ss_prepare_wave(w);
 170
 171         /* read the page from disk */
 172         f = fopen(w->filename, "r");
 173
 174         /* calculate the frame size */
 175         w->p_offset = offset;
 176         s = offset * (w->bits / 8) * w->n_channels;
 177
 178         /* move there */
 179         fseek(f, w->f_pos + s, SEEK_SET);
 180
 181         /* fill the page */
 182         load_pcm_wave(f, w);
 183
 184         fclose(f);
 185 }
 186
 187
 188 static sample_t ss_pick_sample(struct ss_wave * w, int channel, double offset)
 189 /* picks a sample from a ss_wave, forcing a call to ss_load_page() if
 190    the wanted sample is not in memory */
 191 {
 192         int o;
 193         sample_t * wave;
 194
 195         o = (int) offset;
 196
 197         /* is the wanted sample not in memory? */
 198         if(o < w->p_offset || o > w->p_offset + w->p_size)
 199                 ss_load_page(w, o);
 200
 201         wave = w->wave[channel];
 202         return(wave[o - w->p_offset]);
 203 }
 204
 205
 206 /**
 207  * ss_get_sample - Reads a sample from a wave.
 208  * @wave: the wave
 209  * @channel: the channel
 210  * @offset: sample number to be returned
 211  *
 212  * Returns the sample number @offset from the @channel of the @wave. @Offset
 213  * can be a non-integer value.
 214  */
 215 sample_t ss_get_sample(struct ss_wave * w, int channel, double offset)
 216 {
 217         sample_t d, t, r = 0.0;
 218         sample_t s0, s1, s2, s3;
 219
 220         /* take care of wrappings */
 221         if(offset < 0) offset += w->size;
 222
 223         /* pick sample at offset */
 224         s1 = ss_pick_sample(w, channel, offset);
 225
 226         switch(ss_interpolation)
 227         {
 228         case 0:
 229                 /* no interpolation */
 230                 r = s1;
 231                 break;
 232
 233         case 1:
 234                 /* linear interpolation */
 235                 if(offset > w->size - 2)
 236                         r = s1;
 237                 else
 238                 {
 239                         d = (sample_t)(offset - floor(offset));
 240                         s2 = (ss_pick_sample(w, channel, offset + 1) - s1) * d;
 241
 242                         r = s1 + s2;
 243                 }
 244
 245                 break;
 246
 247         case 2:
 248                 /* cubic spline (borrowed from timidity) */
 249                 if(offset < 1 || offset > w->size - 3)
 250                         r = s1;
 251                 else
 252                 {
 253                         s0 = ss_pick_sample(w, channel, offset - 1);
 254                         s2 = ss_pick_sample(w, channel, offset + 1);
 255                         s3 = ss_pick_sample(w, channel, offset + 2);
 256
 257                         t = s2;
 258
 259                         d = (sample_t)(offset - floor(offset));
 260
 261                         s2 = (6.0 * s2 +
 262                                 ((5.0 * s3 - 11.0 * s2 + 7.0 * s1 - s0) / 4.0) *
 263                                         (d + 1.0) * (d - 1.0)) * d;
 264
 265                         s1 = ((6.0 * s1 +
 266                                 ((5.0 * s0 - 11.0 * s1 + 7.0 * t - s3) / 4.0) *
 267                                         d * (d - 2.0)) * (1.0 - d) + s2) / 6.0;
 268
 269                         r = s1;
 270                 }
 271
 272                 break;
 273
 274         case 3:
 275                 /* lagrange (borrowed from timidity) */
 276                 if(offset < 1 || offset > w->size - 3)
 277                         r = s1;
 278                 else
 279                 {
 280                         s0 = ss_pick_sample(w, channel, offset - 1);
 281                         s2 = ss_pick_sample(w, channel, offset + 1);
 282                         s3 = ss_pick_sample(w, channel, offset + 2);
 283
 284                         d = (sample_t)(offset - floor(offset));
 285
 286                         s3 += -3.0 * s2 + 3.0 * s1 - s0;
 287                         s3 *= (d - 2.0) / 6.0;
 288                         s3 += s2 - 2.0 * s1 + s0;
 289                         s3 *= (d - 1.0) / 2.0;
 290                         s3 += s1 - s0;
 291                         s3 *= d;
 292                         s3 += s0;
 293
 294                         r = s3;
 295                 }
 296
 297                 break;
 298         }
 299
 300         return(r);
 301 }
 302
 303
 304 /**
 305  * ss_tempo_from_wave - Calculates a tempo from a wave
 306  * @w: the wave
 307  * @note: note to calculate the tempo from
 308  * @len: whole notes the tempo should match
 309  *
 310  * Calculates the optimal tempo for the @w wave, playing the @note,
 311  * to last @len whole notes.
 312  */
 313 double ss_tempo_from_wave(struct ss_wave * w, int note, double len)
 314 {
 315         double d;
 316
 317         d = ss_note_frequency(note) / w->base_freq;
 318
 319         /* get the length of a whole, in seconds */
 320         d *= w->s_rate / w->size;
 321
 322         /* convert to minutes */
 323         d *= 60.0;
 324
 325         /* then to bpm,s */
 326         d *= 4.0;
 327         d *= len;
 328
 329         return(d);
 330 }
 331
 332
 333 /**
 334  * ss_pitch_from_tempo - Calculates a pitch from a tempo
 335  * @w: the wave
 336  * @tempo: current tempo
 337  * @len: desired length in whole notes
 338  *
 339  * Calculates the optimal frequency (pitch) for the @w wave, at @tempo,
 340  * to last @len whole notes.
 341  */
 342 double ss_pitch_from_tempo(struct ss_wave * w, double tempo, double len)
 343 {
 344         double d;
 345
 346         /* calculate number of seconds the wave lasts */
 347         d = w->size / (double) w->s_rate;
 348
 349         /* convert to minutes, then to wpms */
 350         d /= 60.0;
 351         d *= (tempo / 4.0);
 352
 353         return(w->base_freq * d * len);
 354 }