ss_ins.c

   1 /*
   2
   3     Ann Hell Ex Machina - Music Software
   4     Copyright (C) 2003/2004 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 "core.h"
  34 #include "ss_gen.h"
  35 #include "ss_ins.h"
  36
  37 /*******************
  38         Data
  39 ********************/
  40
  41 /*******************
  42         Code
  43 ********************/
  44
  45 void ss_ins_init(struct ss_ins * i, int trk_id)
  46 {
  47         float vol[2]={ 1, 1 };
  48
  49         memset(i, '\0', sizeof(struct ss_ins));
  50
  51         /* stores the track ID */
  52         i->trk_id=trk_id;
  53
  54         /* sets the default channel mapping */
  55         ss_ins_set_channel_map(i, 2, vol);
  56
  57         /* sets an 1% of frequency as sustain to avoid
  58            end of note clicks */
  59         ss_ins_set_sustain(i, _frequency / 100);
  60 }
  61
  62
  63 /**
  64  * ss_ins_add_layer - Adds a layer to an instrument.
  65  * @i: the instrument
  66  * @base_freq: base frequency
  67  * @min_freq: minimum frequency this layer serves
  68  * @max_freq: maximum frequency this layer serves
  69  * @n_channels: number of channels in wave
  70  * @wave: the wave PCM data
  71  * @size: size of the wave in samples
  72  * @s_rate: sample rate of the wave (frequency)
  73  * @loop_start: sample number of the start of the loop (-1, no loop)
  74  * @loop_end: sample number of the end of the loop
  75  *
  76  * Adds a layer to an instrument. The instrument will use this layer
  77  * when asked to play a note in a range from @min_freq to @max_freq,
  78  * using @base_freq as a base to calculate the final frequency. Layer
  79  * frequencies can overlap.
  80  *
  81  * Returns 0 if the layer was added successfully.
  82  */
  83 int ss_ins_add_layer(struct ss_ins * i, struct ss_wave * w)
  84 {
  85         struct ss_wave * l;
  86
  87         /* grow layers */
  88         i->layers=(struct ss_wave *) realloc(i->layers,
  89                 (i->n_layers + 1) * sizeof(struct ss_wave));
  90
  91         l=&i->layers[i->n_layers];
  92
  93         memcpy(l, w, sizeof(struct ss_wave));
  94
  95         i->n_layers++;
  96
  97         return(0);
  98 }
  99
 100
 101 /**
 102  * ss_ins_set_channel_map - Sets the channel map for an instrument
 103  * @i: the instrument
 104  * @n_channels: number of channels in vol
 105  * @vol: the channel volumes
 106  *
 107  * Sets the current channel map for an instrument. @vol holds volume values
 108  * for upto @n_channels channels. The volume for the rest of channels
 109  * (upto CHANNELS) is set to 0.
 110  */
 111 void ss_ins_set_channel_map(struct ss_ins * i, int n_channels, float vol[])
 112 {
 113         int n;
 114
 115         for(n=0;n < n_channels;n++)
 116                 i->vol[n] = vol[n];
 117
 118         for(;n < CHANNELS;n++)
 119                 i->vol[n] = 0.0;
 120 }
 121
 122
 123 /**
 124  * ss_ins_set_sustain - Sets the sustain for an instrument
 125  * @i: the instrument
 126  * @sustain: the sustain time
 127  *
 128  * Sets the sustain for an instrument. @sustain is expressed in frames.
 129  */
 130 void ss_ins_set_sustain(struct ss_ins * i, int sustain)
 131 {
 132         i->sustain=sustain;
 133 }
 134
 135
 136 /**
 137  * ss_ins_note_on - Plays a note.
 138  * @i: the instrument
 139  * @note: MIDI note to be played
 140  * @vol: note volume
 141  * @id: note id
 142  *
 143  * Locates a layer to play a note, and starts generators to
 144  * play it. The @note is expressed as a MIDI note and the
 145  * desired volume (from 0 to 1) stored in @vol. The note @id
 146  * should be a unique identifier for this note; no two simultaneously
 147  * playing notes should share this id.
 148  *
 149  * The channels of the found layers are distributed sequentially by
 150  * using the instrument's channel map, skipping those with a volume
 151  * of 0.0. So, for example, for a stereo layer with channels L and R
 152  * and 6 channel output with volumes of 1 1 1 0 1 0, the channel
 153  * mapping distribution will be L R L 0 R 0. If you want the fifth
 154  * channel to be L, just use a virtually unhearable volume of 0.0001
 155  * for the fourth one (but greater than 0).
 156  *
 157  * Returns the number of generators that were activated.
 158  */
 159 int ss_ins_note_on(struct ss_ins * i, int note, float vol, int note_id)
 160 {
 161         int n, m, f;
 162         struct ss_wave * l;
 163         struct ss_wave w;
 164         float vols[CHANNELS];
 165         double note_freq;
 166         int notes=0;
 167         struct ss_gen * g;
 168
 169         note_freq=note_frequency(note);
 170
 171         /* loop layers */
 172         for(n=0;n < i->n_layers;n++)
 173         {
 174                 l=&i->layers[n];
 175
 176                 if(note_freq < l->min_freq || note_freq > l->max_freq)
 177                         continue;
 178
 179                 /* get a free generator, or fail */
 180                 if((g=_ss_gen_get_free()) == NULL)
 181                         break;
 182
 183                 /* enqueue the generator to this ins. queue */
 184                 ss_gen_enqueue(&i->gens, g);
 185
 186                 memcpy(&w, l, sizeof(struct ss_wave));
 187
 188                 /* assign the channels and their volumes */
 189                 for(f=m=0;f < CHANNELS;f++)
 190                 {
 191                         if(i->vol[f] > 0.0)
 192                         {
 193                                 /* assign next channel of layer */
 194                                 vols[f]=i->vol[f] * vol;
 195                                 w.wave[f]=l->wave[m++];
 196
 197                                 if(m >= l->n_channels)
 198                                         m=0;
 199                         }
 200                         else
 201                                 w.wave[f]=NULL;
 202                 }
 203
 204                 /* start the generator */
 205                 ss_gen_play(g, note_id, note_freq, vols, &w);
 206
 207                 /* TEST: portamento */
 208                 if(i->trk_id == 2)
 209                         g->portamento=-0.000001;
 210
 211                 notes++;
 212         }
 213
 214         return(notes);
 215 }
 216
 217
 218 /**
 219  * ss_ins_note_off - Releases a note.
 220  * @i: the instrument
 221  * @id: the id of the note to be released
 222  *
 223  * Releases a note. The generators associated to it will enter release mode.
 224  */
 225 void ss_ins_note_off(struct ss_ins * i, int note_id)
 226 {
 227         struct ss_gen * g;
 228
 229         /* releases all generators with that note_id */
 230         for(g=i->gens;g != NULL;g=g->next)
 231         {
 232                 if(g->note_id == note_id)
 233                         ss_gen_release(g);
 234         }
 235 }
 236
 237
 238 /**
 239  * ss_ins_frame - Generates a frame of samples.
 240  * @trk_id: the track
 241  * @sample: array where the output samples will be stored
 242  *
 243  * Generates a frame of samples mixing all the active generators
 244  * of a track.
 245  */
 246 void ss_ins_frame(struct ss_ins * i, float frame[])
 247 {
 248         struct ss_gen * g;
 249
 250         for(g=i->gens;g != NULL;)
 251         {
 252                 if(ss_gen_frame(g, frame))
 253                 {
 254                         struct ss_gen * t;
 255
 256                         /* generator has been freed */
 257
 258                         /* get pointer to next before being
 259                            destroyed by requeueing */
 260                         t=g->next;
 261
 262                         /* generator has been freed; dequeue */
 263                         ss_gen_dequeue(&i->gens, g);
 264
 265                         /* requeue back to free pool */
 266                         ss_gen_enqueue(&_ss_gen_free, g);
 267
 268                         g=t;
 269                 }
 270                 else
 271                         g=g->next;
 272         }
 273 }