instrument.c

   1 /*
   2
   3     Ann Hell Ex Machina - Music Software
   4     Copyright (C) 2003 Angel Ortega <angel@triptico.com>
   5
   6     instrument.c - 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 "generator.h"
  35 #include "instrument.h"
  36
  37 /*******************
  38         Data
  39 ********************/
  40
  41 /* note frequencies */
  42
  43 double _middle_A_freq=440.0;
  44
  45 double _note_frequency[NUM_NOTES];
  46
  47 /*******************
  48         Code
  49 ********************/
  50
  51 static void _build_note_frequencies(void)
  52 {
  53         int n;
  54         static int _built=0;
  55
  56         if(_built)
  57                 return;
  58
  59         for(n=0;n < NUM_NOTES;n++)
  60                 _note_frequency[n]=(_middle_A_freq / 32.0) *
  61                         pow(2.0, (((double)n - 9.0) / 12.0));
  62
  63         _built=1;
  64 }
  65
  66
  67 void init_instrument(struct instrument * i)
  68 {
  69         float vol[2]={ 1, 1 };
  70
  71         memset(i, '\0', sizeof(struct instrument));
  72
  73         /* sets the default channel mapping */
  74         instrument_set_channel_map(i, 2, vol);
  75
  76         /* sets an 1% of frequency as sustain to avoid
  77            end of note clicks */
  78         instrument_set_sustain(i, _frequency / 100);
  79 }
  80
  81
  82 /**
  83  * add_instrument_layer - Adds a layer to an instrument.
  84  * @i: the instrument
  85  * @base_note: MIDI note number for the base note
  86  * @min_note: minimum MIDI note number
  87  * @max_note: maximum MIDI note number
  88  * @n_channels: number of channels in wave
  89  * @wave: the wave PCM data
  90  * @size: size of the wave in samples
  91  * @loop_start: sample number of the start of the loop (-1, no loop)
  92  * @loop_end: sample number of the end of the loop
  93  *
  94  * Adds a layer to an instrument. The instrument will use this layer
  95  * when asked to play a note in a range from @min_note to @max_note,
  96  * using @base_note as a base to calculate the final frequency. Notes
  97  * are expressed as MIDI notes (in a range from 0 to 127).
  98  *
  99  * Returns -1 if the instrument has already the maximum number of
 100  * layers (controlled by the LAY_PER_INSTR constant), or 0 if
 101  * everything went OK.
 102  */
 103 int add_instrument_layer(struct instrument * i,
 104         int base_note, int min_note, int max_note,
 105         int n_channels, float * wave[],
 106         double size, double loop_start, double loop_end)
 107 {
 108         int n;
 109         struct layer * l;
 110
 111         _build_note_frequencies();
 112
 113         /* out of layers? */
 114         if(i->n_layers == LAY_PER_INSTR)
 115                 return(-1);
 116
 117         l=&i->layers[i->n_layers];
 118
 119         l->base_note=base_note;
 120         l->min_note=min_note;
 121         l->max_note=max_note;
 122
 123         l->n_channels=n_channels;
 124
 125         for(n=0;n < l->n_channels;n++)
 126                 l->wave[n]=wave[n];
 127
 128         l->size=size;
 129         l->loop_start=loop_start;
 130         l->loop_end=loop_end;
 131
 132         i->n_layers++;
 133
 134         return(0);
 135 }
 136
 137
 138 void instrument_set_channel_map(struct instrument * i,
 139         int n_channels, float vol[])
 140 {
 141         int n;
 142
 143         for(n=0;n < n_channels;n++)
 144                 i->vol[n] = vol[n];
 145
 146         for(;n < CHANNELS;n++)
 147                 i->vol[n] = 0.0;
 148 }
 149
 150
 151 void instrument_set_sustain(struct instrument * i, int sustain)
 152 {
 153         i->sustain=sustain;
 154 }
 155
 156
 157 /**
 158  * instrument_note_on - Plays a note.
 159  * @i: the instrument
 160  * @note: MIDI note to be played
 161  * @vol: note volume
 162  * @id: note id
 163  *
 164  * Locates a layer to play a note, and starts a generator to
 165  * play it. The @note is expressed as a MIDI note and the
 166  * desired volume (from 0 to 1) stored in @vol. The note @id
 167  * should be a unique identifier for this note; no two simultaneously
 168  * playing notes should share this id (you can use @note as @id
 169  * if you don't plan to play the same note at the same time).
 170  *
 171  * The channels of the found layer are distributed sequentially by
 172  * using the instrument's channel map, skipping those with a volume
 173  * of 0.0. So, for example, for a stereo layer with channels L and R
 174  * and 6 channel output with volumes of 1 1 1 0 1 0, the channel
 175  * mapping distribution will be L R L 0 R 0. If you want the fifth
 176  * channel to be L, just use a virtually unhearable volume of 0.0001
 177  * (but greater than 0).
 178  *
 179  * Returns -1 if the note is already playing, -2 if no layer was found
 180  * to play that note, -3 if the instrument went out of generators, or
 181  * 0 if everything went OK.
 182  */
 183 int instrument_note_on(struct instrument * i, int note, float vol, int id)
 184 {
 185         int n, m, f;
 186         struct layer * l=NULL;
 187         struct generator * g=NULL;
 188         double inc;
 189         float vols[CHANNELS];
 190         float * wave[CHANNELS];
 191
 192         /* test if note is already playing */
 193         for(n=0,f=-1;n < GEN_PER_INSTR;n++)
 194         {
 195                 if(i->id_gen[n] == id + 1)
 196                         return(-1);
 197
 198                 /* if a free generator is found, store it */
 199                 if(f == -1 && i->generators[n].mode == GEN_MODE_FREE)
 200                         f=n;
 201         }
 202
 203         /* if no generator is free, fail */
 204         if(f == -1)
 205                 return(-3);
 206
 207         /* find a layer containing the note */
 208         for(n=0;n < i->n_layers;n++)
 209         {
 210                 l=&i->layers[n];
 211
 212                 if(l->min_note <= note && l->max_note >= note)
 213                         break;
 214         }
 215
 216         /* no layer to play this note; fail */
 217         if(l == NULL || n == i->n_layers) return(-2);
 218
 219         /* get generator and mark as used */
 220         i->id_gen[f]=id + 1;
 221         g=&i->generators[f];
 222
 223         /* calculate increment */
 224         inc=_note_frequency[note] / _note_frequency[l->base_note];
 225
 226         /* assign the channels and their volumes */
 227         for(n=m=0;n < CHANNELS;n++)
 228         {
 229                 if(i->vol[n])
 230                 {
 231                         /* assign next channel of layer */
 232                         vols[n]=i->vol[n] * vol;
 233                         wave[n]=l->wave[m++];
 234
 235                         if(m >= l->n_channels)
 236                                 m=0;
 237                 }
 238                 else
 239                         wave[n]=NULL;
 240         }
 241
 242         /* start the generator */
 243         generator_play(g, wave, vols, l->size, inc,
 244                 l->loop_start, l->loop_end, i->sustain);
 245
 246         return(0);
 247 }
 248
 249
 250 /**
 251  * instrument_note_off - Releases a note.
 252  * @i: the instrument
 253  * @id: the id of the note to be released
 254  *
 255  * Releases a note.
 256  *
 257  * Returns -2 if note is not being played, or the output from
 258  * generator_release() in any other case (that should probably
 259  * be 0 or 1, meaning both OK).
 260  */
 261 int instrument_note_off(struct instrument * i, int id)
 262 {
 263         int n;
 264         struct generator * g;
 265
 266         /* find the generator that is playing this note */
 267         for(n=0;n < GEN_PER_INSTR;n++)
 268         {
 269                 if(i->id_gen[n] == id + 1)
 270                         break;
 271         }
 272
 273         /* if note is not being played, return */
 274         if(n == GEN_PER_INSTR)
 275                 return(-2);
 276
 277         /* detach the generator from the note (though it can
 278            still generate sound because of sustain and such) */
 279         i->id_gen[n]=0;
 280
 281         /* release generator */
 282         g=&i->generators[n];
 283         return(generator_release(g));
 284 }
 285
 286
 287 /**
 288  * generate_instrument - Generates a frame of samples.
 289  * @i: the instrument
 290  * @sample: array where the output samples will be stored
 291  *
 292  * Generates a frame of samples mixing all the active generators
 293  * of an instrument.
 294  */
 295 void generate_instrument(struct instrument * i, float sample[])
 296 {
 297         int n;
 298
 299         for(n=0;n < GEN_PER_INSTR;n++)
 300                 generator(&i->generators[n], sample);
 301 }