ss_ins.c

   1 /*
   2
   3     Ann Hell Ex Machina - Music Software
   4     Copyright (C) 2003/2007 Angel Ortega <angel@triptico.com>
   5
   6     ss_ins.c - Software synthesizer's instruments
   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 /*******************
  40         Code
  41 ********************/
  42
  43 /**
  44  * ss_ins_init - Initializes an instrument.
  45  * @i: the instrument
  46  *
  47  * Initializes an instrument structure.
  48  */
  49 void ss_ins_init(struct ss_ins * i)
  50 {
  51         memset(i, '\0', sizeof(struct ss_ins));
  52
  53         /* default channels: stereo left and right, full volume */
  54         ss_ins_set_channel(i, 0, 1.0);
  55         ss_ins_set_channel(i, 1, 1.0);
  56
  57         /* sustain shouldn't be 0 to avoid end of note clicks */
  58         ss_ins_set_sustain(i, 50.0);
  59         ss_ins_set_attack(i, 0.0);
  60         ss_ins_set_vibrato(i, 0.0, 0.0);
  61         ss_ins_set_portamento(i, 0.0);
  62 }
  63
  64
  65 /**
  66  * ss_ins_disable - Disables an instrument.
  67  * @i: the instrument
  68  *
  69  * Disables an instrument. From now on, no more notes can be played
  70  * on this instrument. If no note are left sounding, ss_ins_frame()
  71  * will return immediately.
  72  */
  73 void ss_ins_disable(struct ss_ins * i)
  74 {
  75         i->disabled = 1;
  76 }
  77
  78
  79 /**
  80  * ss_ins_add_layer - Adds a layer to an instrument.
  81  * @i: the instrument
  82  * @w: wave describing the layer
  83  *
  84  * Adds a layer to an instrument.
  85  *
  86  * Returns 0 if the layer was added successfully.
  87  */
  88 void ss_ins_add_layer(struct ss_ins * i, struct ss_wave * w)
  89 {
  90         /* grow layers */
  91         GROW(i->layers, i->n_layers, struct ss_wave *);
  92
  93         i->layers[i->n_layers] = w;
  94
  95         i->n_layers++;
  96 }
  97
  98
  99 /**
 100  * ss_ins_find_layer - Finds a layer inside an instrument
 101  * @i: the instrument
 102  * @freq: the desired frequency
 103  * @off: pointer to element offset to start searching
 104  *
 105  * Finds a layer inside the @i instrument with a matching @freq, starting
 106  * from the layer number pointed by @off. If a matching layer is found, its
 107  * struct ss_wave is returned and @off is left pointing to the next layer
 108  * (allowing it to be used as an enumerator). If no layer is found, NULL
 109  * is returned.
 110  */
 111 struct ss_wave * ss_ins_find_layer(struct ss_ins * i, double freq, int * off)
 112 {
 113         int n = 0;
 114         struct ss_wave * w = NULL;
 115
 116         /* if off is NULL, point to the first layer */
 117         if(off == NULL) off = &n;
 118
 119         /* find a matching layer, starting from *off */
 120         for(;*off < i->n_layers;(*off)++)
 121         {
 122                 w = i->layers[*off];
 123
 124                 if(freq >= w->min_freq && freq <= w->max_freq)
 125                         break;
 126         }
 127
 128         /* passed the end; none found */
 129         if(*off == i->n_layers)
 130                 w = NULL;
 131         else
 132                 (*off)++;
 133
 134         return(w);
 135 }
 136
 137
 138 /**
 139  * ss_ins_set_channel - Sets the volume for an instrument's channel.
 140  * @i: the instrument
 141  * @channel: channel number
 142  * @vol: volume
 143  *
 144  * Sets the volume for an instrument's channel. If the channel does
 145  * not exist, it's created and space allocated for it in the volume and
 146  * effect dynamic arrays.
 147  */
 148 void ss_ins_set_channel(struct ss_ins * i, int channel, sample_t vol)
 149 {
 150         /* if channel is new, alloc space for it */
 151         if(channel <= i->n_channels)
 152         {
 153                 int n;
 154
 155                 GROW(i->vols, channel, sample_t);
 156                 GROW(i->effs, channel, struct ss_eff *);
 157
 158                 /* fill newly allocated space */
 159                 for(n = i->n_channels;n <= channel;n++)
 160                 {
 161                         i->vols[n] = 1.0;
 162                         i->effs[n] = NULL;
 163                 }
 164
 165                 i->n_channels = channel + 1;
 166         }
 167
 168         /* store volume */
 169         i->vols[channel] = vol;
 170 }
 171
 172
 173 /**
 174  * ss_ins_set_sustain - Sets the sustain for an instrument.
 175  * @i: the instrument
 176  * @sustain: the sustain time in milliseconds
 177  *
 178  * Sets the sustain for an instrument. @sustain is expressed in
 179  * milliseconds.
 180  */
 181 void ss_ins_set_sustain(struct ss_ins * i, double sustain)
 182 {
 183         i->sustain = sustain;
 184 }
 185
 186
 187 /**
 188  * ss_ins_set_attack - Sets the attack for an instrument.
 189  * @i: the instrument
 190  * @attack: the attack time in milliseconds
 191  *
 192  * Sets the attack for an instrument. @attack is expressed in
 193  * milliseconds.
 194  */
 195 void ss_ins_set_attack(struct ss_ins * i, double attack)
 196 {
 197         i->attack = attack;
 198 }
 199
 200
 201 /**
 202  * ss_ins_set_vibrato - Sets the vibrato for an instrument.
 203  * @i: the instrument
 204  * @depth: vibrato depth in msecs
 205  * @freq: vibrato frequency in Hzs
 206  *
 207  * Sets the vibrato for an instrument. @depth is expressed in
 208  * milliseconds and @freq in Hzs.
 209  */
 210 void ss_ins_set_vibrato(struct ss_ins * i, double depth, double freq)
 211 {
 212         i->vib_depth = depth;
 213         i->vib_freq = freq;
 214 }
 215
 216
 217 /**
 218  * ss_ins_set_portamento - Sets portamento for an instrument.
 219  * @i: the instrument
 220  * @portamento: portamento value
 221  *
 222  * Sets portamento for an instrument.
 223  */
 224 void ss_ins_set_portamento(struct ss_ins * i, double portamento)
 225 {
 226         i->portamento = portamento;
 227 }
 228
 229
 230 /**
 231  * ss_ins_play - Plays a note given the desired wave.
 232  * @i: the instrument
 233  * @freq: frequency
 234  * @vol: volume
 235  * @note_id: note id
 236  * @w: the wave
 237  *
 238  * Orders the instrument to start playing a note, given a specific wave.
 239  * The wave is usually one of the instrument's layers, but it doesn't
 240  * have to.
 241  *
 242  * Returns -1 if the instrument is disabled, -2 if no free generators
 243  * were found, or 0 if everything went ok.
 244  */
 245 int ss_ins_play(struct ss_ins * i, double freq, sample_t vol, int note_id,
 246         struct ss_wave * w)
 247 {
 248         struct ss_gen * g;
 249
 250         /* if the instrument is disabled, no more notes are allowed */
 251         if(i->disabled) return(-1);
 252
 253         /* get a free generator, or fail */
 254         if((g = ss_gen_alloc(&i->gens)) == NULL)
 255                 return(-2);
 256
 257         /* start the generator */
 258         ss_gen_play(g, freq, vol, note_id, w);
 259
 260         /* set generator parameters */
 261         ss_gen_sustain(g, i->sustain);
 262         ss_gen_attack(g, i->attack);
 263         ss_gen_vibrato(g, i->vib_depth, i->vib_freq);
 264         ss_gen_portamento(g, i->portamento);
 265
 266         return(1);
 267 }
 268
 269
 270 /**
 271  * ss_ins_note_on - Plays a note.
 272  * @i: the instrument
 273  * @note: MIDI note to be played
 274  * @vol: note volume
 275  * @note_id: note id
 276  *
 277  * Locates a layer to play a note, and starts generators to
 278  * play it. The @note is expressed as a MIDI note and the
 279  * desired volume (from 0 to 1) stored in @vol. The note @id
 280  * should be a positive, unique identifier for this note; no two
 281  * simultaneously playing notes should share this id.
 282  *
 283  * Returns the number of generators that were activated.
 284  */
 285 int ss_ins_note_on(struct ss_ins * i, int note, sample_t vol, int note_id)
 286 {
 287         int n, g;
 288         struct ss_wave * w;
 289         double freq;
 290
 291         freq = ss_note_frequency(note);
 292
 293         for(n = g = 0;(w=ss_ins_find_layer(i, freq, &n)) != NULL;g++)
 294         {
 295                 if(ss_ins_play(i, freq, vol, note_id, w) < 0)
 296                         break;
 297         }
 298
 299         return(g);
 300 }
 301
 302
 303 /**
 304  * ss_ins_note_off - Releases a note.
 305  * @i: the instrument
 306  * @note_id: the id of the note to be released
 307  *
 308  * Releases a note. The generators associated to it will enter release mode.
 309  */
 310 void ss_ins_note_off(struct ss_ins * i, int note_id)
 311 {
 312         struct ss_gen * g;
 313
 314         /* releases all generators with that note_id */
 315         for(g = i->gens;g != NULL;g = g->next)
 316         {
 317                 if(g->note_id == note_id)
 318                         ss_gen_release(g);
 319         }
 320 }
 321
 322
 323 /**
 324  * ss_ins_frame - Generates a frame of samples.
 325  * @i: the instrument
 326  * @frame: array where the output samples will be stored
 327  *
 328  * Generates a frame of samples mixing all the active generators
 329  * of a track.
 330  *
 331  * Returns 0 if the instrument is disabled and is no longer
 332  * emitting sound, or 1 otherwise.
 333  */
 334 int ss_ins_frame(struct ss_ins * i, sample_t frame[])
 335 {
 336         struct ss_gen * g;
 337         struct ss_gen * t;
 338         int n;
 339         sample_t l_frame[SS_MAX_CHANNELS];
 340
 341         /* if instrument is disabled and there is no more generators, exit */
 342         if(i->disabled && i->gens == NULL)
 343         {
 344                 /* reset all effects */
 345                 for(n = 0;n < i->n_channels;n++)
 346                         ss_eff_off(&i->effs[n]);
 347
 348                 return(0);
 349         }
 350
 351         /* resets this local frame */
 352         ss_output_init_frame(l_frame);
 353
 354         /* loops through the generators */
 355         for(g = i->gens;g != NULL;g = t)
 356         {
 357                 t = g->next;
 358
 359                 /* if the generator has stopped, free it */
 360                 if(ss_gen_frame(g, i->n_channels, l_frame))
 361                         ss_gen_free(&i->gens, g);
 362         }
 363
 364         /* loops through the effects and remixes */
 365         for(n = 0;n < i->n_channels;n++)
 366                 frame[n] += ss_eff_process(i->effs[n],
 367                         l_frame[n] * i->vols[n]);
 368
 369         return(1);
 370 }