ss_core.c

   1 /*
   2
   3     Ann Hell Ex Machina - Music Software
   4     Copyright (C) 2003/2007 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 "ahxm.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 = -1;
  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                 for (n = 0; n < 128; n++)
  73                         note_frequency[n] = (ss_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  * ss_alloc_wave - Allocates a wave structure.
  83  * @size: size in frames
  84  * @n_channels: number of channels
  85  * @s_rate: sampling rate
  86  * @p_size: size of the sound page
  87  *
  88  * Allocates a wave structure. If @p_size is -1, it's assumed to be the
  89  * same as @size (so the sound will live entirely in memory).
  90  */
  91 struct ss_wave *ss_alloc_wave(int size, int n_channels, int s_rate, int p_size)
  92 {
  93         struct ss_wave *w = NULL;
  94
  95         if (p_size == -1)
  96                 p_size = size;
  97
  98         if ((w = (struct ss_wave *) malloc(sizeof(struct ss_wave))) != NULL) {
  99                 memset(w, '\0', sizeof(struct ss_wave));
 100
 101                 w->size = (double) size;
 102                 w->p_size = p_size;
 103                 w->n_channels = n_channels;
 104                 w->s_rate = s_rate;
 105
 106                 /* alloc space for the pointers to the waves */
 107                 w->wave = (sample_t **) malloc(n_channels * sizeof(sample_t *));
 108                 memset(w->wave, '\0', n_channels * sizeof(sample_t *));
 109         }
 110
 111         return w;
 112 }
 113
 114
 115 /**
 116  * ss_free_wave - Frees a wave structure.
 117  * @w: the wave structure
 118  *
 119  * Frees a struct ss_wave allocated by ss_alloc_wave().
 120  */
 121 void ss_free_wave(struct ss_wave *w)
 122 {
 123         if (w->wave != NULL) {
 124                 int n;
 125
 126                 /* frees the buffers */
 127                 for (n = 0; n < w->n_channels; n++)
 128                         if (w->wave[n] != NULL)
 129                                 free(w->wave[n]);
 130
 131                 /* frees the space for the pointers to the waves */
 132                 free(w->wave);
 133
 134                 /* if it has a filename, also free it */
 135                 if (w->filename != NULL)
 136                         free(w->filename);
 137         }
 138
 139         /* frees the wave itself */
 140         free(w);
 141 }
 142
 143
 144 void ss_prepare_wave(struct ss_wave *w)
 145 /* prepares a wave file for usage (creates the page buffers) */
 146 {
 147         int n;
 148
 149         /* alloc space for the waves themselves */
 150         for (n = 0; n < w->n_channels; n++) {
 151                 w->wave[n] = (sample_t *) realloc(w->wave[n], w->p_size * sizeof(sample_t));
 152
 153                 memset(w->wave[n], '\0', w->p_size * sizeof(sample_t));
 154         }
 155 }
 156
 157
 158 static void ss_load_page(struct ss_wave *w, int offset)
 159 /* loads a page from a wave file into memory */
 160 {
 161         FILE *f;
 162         int s;
 163
 164         /* set the offset to some samples behind the
 165            wanted offset (to avoid possible page bounces) */
 166         if ((w->p_offset = offset - 441) < 0)
 167                 w->p_offset = 0;
 168
 169         /* too much page faults for this wave? */
 170         if (w->page_faults >= 8) {
 171                 /* increase space */
 172                 if ((w->p_size *= 2) > (int) w->size) {
 173                         /* if this resize is too much, just
 174                            set it to load the full wave */
 175                         w->p_size = (int) w->size;
 176                         w->p_offset = 0;
 177                 }
 178
 179                 /* trigger a page resizing and restart statistics */
 180                 w->page_faults = 0;
 181         }
 182
 183         if (w->page_faults == 0)
 184                 ss_prepare_wave(w);
 185
 186         if ((f = fopen(w->filename, "r")) == NULL) {
 187                 fprintf(stderr, "Can't open '%s'\n", w->filename);
 188                 return;
 189         }
 190
 191         if (verbose >= 3)
 192                 printf("load_page [%s,%d,%d,%d]\n", w->filename,
 193                        w->p_offset, w->p_size, w->page_faults);
 194
 195         /* calculate the frame size */
 196         s = w->p_offset * (w->bits / 8) * w->n_channels;
 197
 198         /* move there */
 199         fseek(f, w->f_pos + s, SEEK_SET);
 200
 201         /* fill the page */
 202         load_pcm_wave(f, w);
 203
 204         fclose(f);
 205
 206         w->page_faults++;
 207 }
 208
 209
 210 static sample_t ss_pick_sample(struct ss_wave *w, int channel, double offset)
 211 /* picks a sample from a ss_wave, forcing a call to ss_load_page() if
 212    the wanted sample is not in memory */
 213 {
 214         int o;
 215         sample_t *wave;
 216
 217         o = (int) offset;
 218
 219         /* is the wanted sample not in memory? */
 220         if (o < w->p_offset || o > w->p_offset + w->p_size)
 221                 ss_load_page(w, o);
 222
 223         wave = w->wave[channel];
 224         return wave[o - w->p_offset];
 225 }
 226
 227
 228 /**
 229  * ss_get_sample - Reads a sample from a wave.
 230  * @wave: the wave
 231  * @channel: the channel
 232  * @offset: sample number to be returned
 233  *
 234  * Returns the sample number @offset from the @channel of the @wave. @Offset
 235  * can be a non-integer value.
 236  */
 237 sample_t ss_get_sample(struct ss_wave * w, int channel, double offset)
 238 {
 239         sample_t d, t, r = 0.0;
 240         sample_t s0, s1, s2, s3;
 241
 242         /* take care of wrappings */
 243         if (offset < 0)
 244                 offset += w->size;
 245
 246         /* pick sample at offset */
 247         s1 = ss_pick_sample(w, channel, offset);
 248
 249         switch (ss_interpolation) {
 250         case 0:
 251                 /* no interpolation */
 252                 r = s1;
 253                 break;
 254
 255         case 1:
 256                 /* linear interpolation */
 257                 if (offset > w->size - 2)
 258                         r = s1;
 259                 else {
 260                         d = (sample_t) (offset - floor(offset));
 261                         s2 = (ss_pick_sample(w, channel, offset + 1) - s1) * d;
 262
 263                         r = s1 + s2;
 264                 }
 265
 266                 break;
 267
 268         case 2:
 269                 /* cubic spline (borrowed from timidity) */
 270                 if (offset < 1 || offset > w->size - 3)
 271                         r = s1;
 272                 else {
 273                         s0 = ss_pick_sample(w, channel, offset - 1);
 274                         s2 = ss_pick_sample(w, channel, offset + 1);
 275                         s3 = ss_pick_sample(w, channel, offset + 2);
 276
 277                         t = s2;
 278
 279                         d = (sample_t) (offset - floor(offset));
 280
 281                         s2 = (6.0 * s2 +
 282                               ((5.0 * s3 - 11.0 * s2 + 7.0 * s1 - s0) / 4.0) *
 283                               (d + 1.0) * (d - 1.0)) * d;
 284
 285                         s1 = ((6.0 * s1 +
 286                                ((5.0 * s0 - 11.0 * s1 + 7.0 * t - s3) / 4.0) *
 287                                d * (d - 2.0)) * (1.0 - d) + s2) / 6.0;
 288
 289                         r = s1;
 290                 }
 291
 292                 break;
 293
 294         case 3:
 295                 /* lagrange (borrowed from timidity) */
 296                 if (offset < 1 || offset > w->size - 3)
 297                         r = s1;
 298                 else {
 299                         s0 = ss_pick_sample(w, channel, offset - 1);
 300                         s2 = ss_pick_sample(w, channel, offset + 1);
 301                         s3 = ss_pick_sample(w, channel, offset + 2);
 302
 303                         d = (sample_t) (offset - floor(offset));
 304
 305                         s3 += -3.0 * s2 + 3.0 * s1 - s0;
 306                         s3 *= (d - 2.0) / 6.0;
 307                         s3 += s2 - 2.0 * s1 + s0;
 308                         s3 *= (d - 1.0) / 2.0;
 309                         s3 += s1 - s0;
 310                         s3 *= d;
 311                         s3 += s0;
 312
 313                         r = s3;
 314                 }
 315
 316                 break;
 317         }
 318
 319         return r;
 320 }
 321
 322
 323 /**
 324  * ss_tempo_from_wave - Calculates a tempo from a wave
 325  * @w: the wave
 326  * @note: note to calculate the tempo from
 327  * @len: whole notes the tempo should match
 328  *
 329  * Calculates the optimal tempo for the @w wave, playing the @note,
 330  * to last @len whole notes.
 331  */
 332 double ss_tempo_from_wave(struct ss_wave *w, int note, double len)
 333 {
 334         double d;
 335
 336         d = ss_note_frequency(note) / w->base_freq;
 337
 338         /* get the length of a whole, in seconds */
 339         d *= w->s_rate / w->size;
 340
 341         /* convert to minutes */
 342         d *= 60.0;
 343
 344         /* then to bpm,s */
 345         d *= 4.0;
 346         d *= len;
 347
 348         return d;
 349 }
 350
 351
 352 /**
 353  * ss_pitch_from_tempo - Calculates a pitch from a tempo
 354  * @w: the wave
 355  * @tempo: current tempo
 356  * @len: desired length in whole notes
 357  *
 358  * Calculates the optimal frequency (pitch) for the @w wave, at @tempo,
 359  * to last @len whole notes.
 360  */
 361 double ss_pitch_from_tempo(struct ss_wave *w, double tempo, double len)
 362 {
 363         double d;
 364
 365         /* calculate number of seconds the wave lasts */
 366         d = w->size / (double) w->s_rate;
 367
 368         /* convert to minutes, then to wpms */
 369         d /= 60.0;
 370         d *= (tempo / 4.0);
 371
 372         return w->base_freq * d * len;
 373 }