ss_gen.c

   1 /*
   2
   3     Ann Hell Ex Machina - Music Software
   4     Copyright (C) 2003/2007 Angel Ortega <angel@triptico.com>
   5
   6     ss_gen.c - Software syntesizer's sound generators
   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 /* maximum number of generators */
  40 int ss_gen_num = SS_MAX_GENERATORS;
  41
  42 /* generator pool */
  43 static struct ss_gen * ss_gen_pool = NULL;
  44
  45 /* free generator queue */
  46 static struct ss_gen * ss_gen_free_queue = NULL;
  47
  48
  49 /*******************
  50         Code
  51 ********************/
  52
  53 static void ss_gen_enqueue(struct ss_gen ** q, struct ss_gen * g)
  54 /* Enqueues a generator in a generator queue */
  55 {
  56         g->prev = NULL;
  57         g->next = *q;
  58
  59         if(*q != NULL)
  60                 (*q)->prev = g;
  61
  62         *q = g;
  63 }
  64
  65
  66 void ss_gen_init(void)
  67 /* inits the generator pool */
  68 {
  69         int n;
  70
  71         ss_gen_pool = (struct ss_gen *) realloc(ss_gen_pool, ss_gen_num *
  72                         sizeof(struct ss_gen));
  73
  74         memset(ss_gen_pool, '\0', ss_gen_num * sizeof(struct ss_gen));
  75
  76         /* enqueue all into the free generator queue */
  77         for(n = 0;n < ss_gen_num;n++)
  78                 ss_gen_enqueue(&ss_gen_free_queue, &ss_gen_pool[n]);
  79 }
  80
  81
  82 static struct ss_gen * ss_gen_dequeue(struct ss_gen ** q, struct ss_gen * g)
  83 /* Dequeues a generator from a generator queue */
  84 {
  85         if(g->prev != NULL)
  86                 g->prev->next = g->next;
  87         else
  88                 *q = g->next;
  89
  90         if(g->next != NULL)
  91                 g->next->prev = g->prev;
  92
  93         return(g);
  94 }
  95
  96
  97 static struct ss_gen * ss_gen_pop(struct ss_gen ** q)
  98 /* gets the first enqueued generator from q */
  99 {
 100         struct ss_gen * g = NULL;
 101
 102         if(*q != NULL)
 103                 g = ss_gen_dequeue(q, *q);
 104
 105         return(g);
 106 }
 107
 108
 109 /**
 110  * ss_gen_alloc - Allocs and enqueues a generator
 111  * @q: queue where the generator will be enqueued
 112  *
 113  * Allocs and enqueues a generator into the @q queue.
 114  *
 115  * The new generator is returned, or NULL if the
 116  * generator pool is empty.
 117  */
 118 struct ss_gen * ss_gen_alloc(struct ss_gen ** q)
 119 {
 120         struct ss_gen * g;
 121
 122         if((g = ss_gen_pop(&ss_gen_free_queue)) != NULL)
 123                 ss_gen_enqueue(q, g);
 124
 125         return(g);
 126 }
 127
 128
 129 /**
 130  * ss_gen_free - Dequeues a generator and frees it
 131  * @q: the queue holding the generator
 132  * @g: the generator
 133  *
 134  * Dequeues a generator and sends it back to the generator pool.
 135  */
 136 void ss_gen_free(struct ss_gen ** q, struct ss_gen * g)
 137 {
 138         ss_gen_enqueue(&ss_gen_free_queue, ss_gen_dequeue(q, g));
 139 }
 140
 141
 142 /**
 143  * ss_gen_sustain - Sets sustain for a generator
 144  * @g: the generator
 145  * @sustain: sustain time in msecs
 146  *
 147  * Sets sustain for a generator, where @sustain is expressed
 148  * in milliseconds.
 149  */
 150 void ss_gen_sustain(struct ss_gen * g, double sustain)
 151 {
 152         g->sustain = MS2F(sustain);
 153 }
 154
 155
 156 /**
 157  * ss_gen_attack - Sets attack for a generator
 158  * @g: the generator
 159  * @attack: attack time in msecs
 160  *
 161  * Sets attack for a generator, where @attack is expressed
 162  * in milliseconds.
 163  */
 164 void ss_gen_attack(struct ss_gen * g, double attack)
 165 {
 166         if((g->attack = MS2F(attack)) > 0)
 167         {
 168                 /* calculates the delta volume */
 169                 g->davol = g->vol / (sample_t) g->attack;
 170
 171                 g->vol = 0.0;
 172         }
 173 }
 174
 175
 176 /**
 177  * ss_gen_vibrato - Sets vibrato for a generator
 178  * @g: the generator
 179  * @depth: vibrato depth in msecs
 180  * @freq: vibrato frequency
 181  *
 182  * Sets vibrato for a generator, with a @depth expressed in
 183  * milliseconds and a frequency @freq expressed in hzs.
 184  */
 185 void ss_gen_vibrato(struct ss_gen * g, double depth, double freq)
 186 {
 187         /* good freq: 6 Hz (0.001) */
 188         /* good depth: 1/6 semitone (20, 30 frames) */
 189
 190         g->vib_depth = MS2F(depth);
 191         g->vib_inc = ( 6.28 * freq ) / (double)ss_frequency;
 192         g->vibrato = 0.0;
 193 }
 194
 195
 196 /**
 197  * ss_gen_portamento - Sets portamento for a generator
 198  * @g: the generator
 199  * @portamento: portamento value
 200  *
 201  * Sets portamento for a generator, where @portamento is an
 202  * increment to the internal cursor of the wave. This value must
 203  * be very small. Negative values will make the frequency slide
 204  * down and positive slide up.
 205  */
 206 void ss_gen_portamento(struct ss_gen * g, double portamento)
 207 {
 208         g->portamento = portamento;
 209 }
 210
 211
 212 /**
 213  * ss_gen_play - Activates a generator.
 214  * @g: generator
 215  * @freq: frequency of the sound to be generated
 216  * @vol: volume
 217  * @note_id: note id
 218  * @w: the wave
 219  *
 220  * Activates a generator, usually as a response for a 'note on'
 221  * message from an upper level. The wave @w holds all the sample
 222  * data (PCM data, base frequency, etc.), @freq is the desired
 223  * frequency, @vol the volume and @note_id a positive, unique
 224  * identifier for the note.
 225  */
 226 void ss_gen_play(struct ss_gen * g, double freq, sample_t vol, int note_id,
 227         struct ss_wave * w)
 228 {
 229         /* store data */
 230         g->note_id = note_id;
 231         g->vol = vol;
 232         g->w = w;
 233
 234         /* start from the beginning */
 235         g->cursor = 0;
 236
 237         /* calculate increment */
 238         g->inc = freq / w->base_freq;
 239         g->inc *= (double) w->s_rate / (double) ss_frequency;
 240
 241         /* default sustain, vibrato and portamento */
 242         ss_gen_sustain(g, 50.0);
 243         ss_gen_attack(g, 0.0);
 244         ss_gen_vibrato(g, 0.0, 0.0);
 245         ss_gen_portamento(g, 0.0);
 246 }
 247
 248
 249 /**
 250  * ss_gen_release - Releases a generator.
 251  * @g: the generator
 252  *
 253  * Releases a generator, usually as a response for a 'note off'
 254  * message from an upper level. The generator enters SS_GEN_RELEASED
 255  * mode, which starts generating sustain data until it's over.
 256  */
 257 void ss_gen_release(struct ss_gen * g)
 258 {
 259         /* note needs not be tracked anymore */
 260         g->note_id = -1;
 261
 262         /* calculates the delta volume */
 263         g->dsvol = g->vol / (sample_t) g->sustain;
 264 }
 265
 266
 267 /**
 268  * ss_gen_frame - Generates a frame of samples.
 269  * @g: the generator
 270  * @n_channels: the desired number of channels
 271  * @frame: array where the output samples will be stored
 272  *
 273  * Generates a frame of samples from the @g generator, that will be stored
 274  * in the @frame array. If @n_channels is greater than the number
 275  * of channels the generator has, they are sequentially spread.
 276  *
 277  * Returns non-zero if the generator is stopped and should be freed.
 278  */
 279 int ss_gen_frame(struct ss_gen * g, int n_channels, sample_t frame[])
 280 {
 281         int n, m;
 282         int to_free = 0;
 283         double v;
 284         sample_t l_frame[SS_MAX_CHANNELS];
 285         struct ss_wave * w;
 286
 287         v = g->cursor;
 288         w = g->w;
 289
 290         /* process attack */
 291         if(g->attack)
 292         {
 293                 g->vol += g->davol;
 294                 g->attack--;
 295         }
 296
 297         /* process vibrato */
 298         if(g->vib_inc)
 299         {
 300                 g->vibrato += g->vib_inc;
 301                 v += sin(g->vibrato) * g->vib_depth;
 302         }
 303
 304         /* add samples to frame */
 305         for(n = 0;n < w->n_channels;n++)
 306                 l_frame[n] = ss_get_sample(w, n, v) * g->vol;
 307
 308         /* spread the frame into n_channels */
 309         for(n = w->first_channel, m = 0;n < n_channels;n++, m++)
 310         {
 311                 frame[n] += l_frame[m % w->n_channels];
 312
 313                 n += w->skip_channels;
 314         }
 315
 316         /* increment pointer */
 317         g->cursor += g->inc;
 318
 319         /* test loop boundaries */
 320         if(g->cursor > w->loop_end)
 321         {
 322                 /* loop mode? */
 323                 if(w->loop_start < 0)
 324                         to_free = 1;
 325                 else
 326                         g->cursor = w->loop_start;
 327         }
 328
 329         /* process sustain */
 330         if(g->note_id == -1)
 331         {
 332                 g->vol -= g->dsvol;
 333
 334                 if(--g->sustain <= 0)
 335                         to_free = 1;
 336         }
 337
 338         /* process portamento */
 339         g->inc += g->portamento;
 340
 341         return(to_free);
 342 }