instrument.c

   1 /*
   2
   3     PROGRAM_NAME PROGRAM_VERSION - PROGRAM_DESCRIPTION
   4
   5     Copyright (C) 2003 Angel Ortega <angel@triptico.com>
   6
   7     This program is free software; you can redistribute it and/or
   8     modify it under the terms of the GNU General Public License
   9     as published by the Free Software Foundation; either version 2
  10     of the License, or (at your option) any later version.
  11
  12     This program is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15     GNU General Public License for more details.
  16
  17     You should have received a copy of the GNU General Public License
  18     along with this program; if not, write to the Free Software
  19     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20
  21     http://www.triptico.com
  22
  23 */
  24
  25 #include "config.h"
  26
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <math.h>
  30
  31 #include "generator.h"
  32 #include "instrument.h"
  33
  34 /*******************
  35         Data
  36 ********************/
  37
  38 /* note frequencies */
  39
  40 double _middle_A_freq=440.0;
  41
  42 double _note_frequency[NUM_NOTES];
  43
  44 /*******************
  45         Code
  46 ********************/
  47
  48 void build_note_frequencies(void)
  49 {
  50         int n;
  51
  52         for(n=0;n < NUM_NOTES;n++)
  53                 _note_frequency[n]=(_middle_A_freq / 32.0) *
  54                         pow(2.0, (((double)n - 9.0) / 12.0));
  55 }
  56
  57
  58 void init_instrument(struct instrument * i)
  59 {
  60         memset(i, '\0', sizeof(struct instrument));
  61 }
  62
  63
  64 int add_instrument_layer(struct instrument * i, int base_note,
  65         int min_note, int max_note, int * lwave, int * rwave,
  66         int size, int loop_start, int loop_end, int sustain)
  67 {
  68         struct layer * l;
  69
  70         if(i->n_layers == LAYERS_PER_INSTR)
  71                 return(0);
  72
  73         l=&i->layers[i->n_layers];
  74
  75         l->base_note=base_note;
  76         l->min_note=min_note;
  77         l->max_note=max_note;
  78         l->lwave=lwave;
  79         l->rwave=rwave;
  80         l->size=size;
  81         l->loop_start=loop_start;
  82         l->loop_end=loop_end;
  83         l->sustain=sustain;
  84
  85         i->n_layers++;
  86
  87         return(1);
  88 }
  89
  90
  91 int instrument_play_note(struct instrument * i, int note, double lvol, double rvol)
  92 {
  93         int n;
  94         struct layer * l;
  95         struct generator * g;
  96         double inc;
  97
  98         /* test if note is already playing */
  99         if(i->note_gen[note])
 100                 return(0);
 101
 102         /* find a layer containing the note */
 103         for(n=0;n < i->n_layers;n++)
 104         {
 105                 l=&i->layers[n];
 106
 107                 if(l->min_note <= note && l->max_note >= note)
 108                         break;
 109         }
 110
 111         /* no layer to play this note; fail */
 112         if(n == i->n_layers) return(0);
 113
 114         /* find now an empty generator */
 115         for(n=0;n < GENERATORS_PER_INSTR;n++)
 116         {
 117                 g=&i->generators[n];
 118
 119                 if(g->mode == GEN_MODE_FREE)
 120                         break;
 121         }
 122
 123         /* no free generator; also fail */
 124         if(n == GENERATORS_PER_INSTR)
 125                 return(0);
 126
 127         /* store the generator */
 128         i->note_gen[note]=n + 1;
 129
 130         /* calculate increment */
 131         inc=_note_frequency[note] / _note_frequency[l->base_note];
 132
 133         /* start the generator */
 134         generator_play(g, l->lwave, l->rwave, l->size, inc,
 135                 l->loop_start, l->loop_end, lvol, rvol, l->sustain);
 136
 137         return(1);
 138 }
 139
 140
 141 int instrument_release_note(struct instrument * i, int note)
 142 {
 143         int n;
 144         struct generator * g;
 145
 146         /* do nothing is this note is not playing */
 147         if((n=i->note_gen[note])==0)
 148                 return(1);
 149
 150         /* release generator */
 151         g=&i->generators[n - 1];
 152         generator_release(g);
 153
 154         /* detach the generator to the note (though it can
 155            still be generating sound because of sustain and such) */
 156         i->note_gen[note]=0;
 157
 158         return(1);
 159 }
 160
 161
 162 void generate_instrument(struct instrument * i, int * lsample, int * rsample)
 163 {
 164         int n;
 165
 166         for(n=0;n < GENERATORS_PER_INSTR;n++)
 167                 generator(&i->generators[n], lsample, rsample);
 168 }