annhell.h

   1 /*
   2
   3     Ann Hell Ex Machina - Music Software
   4     Copyright (C) 2003/2005 Angel Ortega <angel@triptico.com>
   5
   6     This program is free software; you can redistribute it and/or
   7     modify it under the terms of the GNU General Public License
   8     as published by the Free Software Foundation; either version 2
   9     of the License, or (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19
  20     http://www.triptico.com
  21
  22 */
  23
  24 /* HARD LIMITS */
  25
  26 #ifndef SS_MAX_CHANNELS
  27 #define SS_MAX_CHANNELS 16
  28 #endif
  29
  30 #ifndef SS_MAX_GENERATORS
  31 #define SS_MAX_GENERATORS 256
  32 #endif
  33
  34 /* STRUCTURES */
  35
  36 /* waves */
  37
  38 struct ss_wave
  39 {
  40         double size;            /* size in frames */
  41         int n_channels;         /* # of channels */
  42         float ** wave;          /* the PCM waves */
  43         int s_rate;             /* original sample rate */
  44
  45         double loop_start;      /* start of loop (-1, no loop) */
  46         double loop_end;        /* end of loop */
  47
  48         double base_freq;       /* base frequency */
  49         double min_freq;        /* minimum frequency */
  50         double max_freq;        /* maximum frequency */
  51 };
  52
  53 /* generators */
  54
  55 struct ss_gen
  56 {
  57         int note_id;            /* note ID */
  58         float vol;              /* volume */
  59         struct ss_wave * w;     /* the wave data */
  60
  61         double cursor;          /* offset to next sample */
  62         double inc;             /* increment (frequency) */
  63
  64         int sustain;            /* number of frames to play after release */
  65         float dvol;             /* volume decrement in sustain */
  66
  67         double vibrato;         /* vibrato oscillator */
  68         double vib_depth;       /* vibrato depth */
  69         double vib_inc;         /* increment for vibrato oscillator */
  70
  71         double portamento;      /* portamento sum to inc */
  72
  73         struct ss_gen * next;
  74         struct ss_gen * prev;
  75 };
  76
  77 /* software syntesizer instruments */
  78
  79 struct ss_ins
  80 {
  81         int n_layers;                   /* # of layers */
  82         struct ss_wave ** layers;       /* layers */
  83
  84         struct ss_gen * gens;           /* generator queue */
  85
  86         int n_channels;                 /* number of channels */
  87         float * vols;                   /* volumes (1 per channel) */
  88         struct ss_eff ** effs;          /* effect chains (1 per channel) */
  89
  90         double sustain;                 /* sustain in msecs */
  91         double vib_depth;               /* vibrato depth */
  92         double vib_freq;                /* vibrato frequency */
  93 };
  94
  95 /* digital effects */
  96
  97 struct ss_eff
  98 {
  99         float * wave;           /* wave buffer */
 100         double size;            /* size of wave */
 101         float gain;             /* effect gain */
 102         float igain;            /* gain increment */
 103
 104         double lfo;             /* lfo value */
 105         double lfo_depth;       /* lfo depth */
 106         double lfo_inc;         /* lfo increment */
 107
 108         double cursor;          /* current buffer position */
 109
 110         float (* func)(struct ss_eff *, float); /* processing function */
 111
 112         struct ss_eff * next;   /* next in chain */
 113 };
 114
 115 /* song events */
 116
 117 typedef enum
 118 {
 119         SONG_EV_TEMPO,
 120         SONG_EV_METER,
 121         SONG_EV_MEASURE,
 122
 123         SONG_EV_SS_SUSTAIN,
 124         SONG_EV_SS_VIBRATO,
 125         SONG_EV_SS_CHANNEL,
 126
 127         SONG_EV_SS_WAV,
 128         SONG_EV_SS_PAT,
 129
 130         SONG_EV_SS_EFF_DELAY,
 131         SONG_EV_SS_EFF_ECHO,
 132         SONG_EV_SS_EFF_COMB,
 133         SONG_EV_SS_EFF_ALLPASS,
 134         SONG_EV_SS_EFF_FLANGER,
 135         SONG_EV_SS_EFF_WOBBLE,
 136         SONG_EV_SS_EFF_SQWOBBLE,
 137         SONG_EV_SS_EFF_FADER,
 138         SONG_EV_SS_EFF_REVERB,
 139         SONG_EV_SS_EFF_OFF,
 140
 141         SONG_EV_MIDI_CHANNEL,
 142         SONG_EV_MIDI_PROGRAM,
 143
 144         SONG_EV_NOTE,
 145         SONG_EV_SS_PITCH_STRETCH,
 146
 147         SONG_EV_NOTE_ON,
 148         SONG_EV_NOTE_OFF,
 149
 150         SONG_EV_END
 151
 152 } song_ev_type;
 153
 154 struct song_ev_generic
 155 {
 156         song_ev_type type;      /* event type */
 157         double time;            /* event time (1: whole note) */
 158         int trk_id;             /* track id */
 159 };
 160
 161 struct song_ev_note
 162 {
 163         song_ev_type type;      /* SONG_EV_NOTE */
 164         double time;
 165         int trk_id;
 166         int note;               /* MIDI-like note */
 167         double len;             /* note length (1: whole note) */
 168         float vol;              /* note volume (1: full volume) */
 169 };
 170
 171 struct song_ev_tempo
 172 {
 173         song_ev_type type;      /* SONG_EV_TEMPO */
 174         double time;
 175         int trk_id;             /* always < 0 */
 176         double tempo;           /* tempo in bpm */
 177 };
 178
 179 struct song_ev_meter
 180 {
 181         song_ev_type type;      /* SONG_EV_METER */
 182         double time;
 183         int trk_id;             /* always < 0 */
 184         int num;                /* meter numerator */
 185         int den;                /* meter denominator */
 186 };
 187
 188 struct song_ev_measure
 189 {
 190         song_ev_type type;      /* SONG_EV_MEASURE */
 191         double time;
 192         int trk_id;
 193         int line;               /* line number */
 194 };
 195
 196 struct song_ev_ss_pitch_stretch
 197 {
 198         song_ev_type type;      /* SONG_EV_SS_PITCH_STRETCH */
 199         double time;
 200         int trk_id;
 201         int note;               /* MIDI-like note (to find the wave) */
 202         double len;             /* note length (1: whole note) */
 203         float vol;              /* note volume (1: full volume) */
 204 };
 205
 206 struct song_ev_ss_sustain
 207 {
 208         song_ev_type type;      /* SONG_EV_SS_SUSTAIN */
 209         double time;
 210         int trk_id;
 211         double sustain;         /* sustain time (in msecs) */
 212 };
 213
 214 struct song_ev_ss_vibrato
 215 {
 216         song_ev_type type;      /* SONG_EV_SS_VIBRATO */
 217         double time;
 218         int trk_id;
 219         double vib_depth;       /* vibrato depth (in msecs) */
 220         double vib_freq;        /* vibrato frequency (in Hzs) */
 221 };
 222
 223 struct song_ev_ss_channel
 224 {
 225         song_ev_type type;      /* SONG_EV_SS_CHANNEL */
 226         double time;
 227         int trk_id;
 228         int channel;            /* channel */
 229         float vol;              /* volume */
 230 };
 231
 232 struct song_ev_ss_wav
 233 {
 234         song_ev_type type;      /* SONG_EV_SS_WAV */
 235         double time;
 236         int trk_id;
 237         char * file;            /* path to .wav file */
 238         int base;               /* MIDI-like base note */
 239         int min;                /* MIDI-like minimum note */
 240         int max;                /* MIDI-like maximum note */
 241         double loop_start;      /* start of loop */
 242         double loop_end;        /* end of loop */
 243 };
 244
 245 struct song_ev_ss_pat
 246 {
 247         song_ev_type type;      /* SONG_EV_SS_PAT */
 248         double time;
 249         int trk_id;
 250         char * file;            /* path to .pat file */
 251 };
 252
 253 struct song_ev_ss_eff
 254 {
 255         song_ev_type type;      /* effect type */
 256         double time;
 257         int trk_id;
 258         int channel;            /* channel */
 259         double size;            /* size of effect */
 260         float gain;             /* gain */
 261         double depth;           /* depth */
 262         double freq;            /* freq */
 263         double phase;           /* phase */
 264         float initial;          /* initial vol */
 265         float final;            /* final vol */
 266 };
 267
 268 struct song_ev_midi_channel
 269 {
 270         song_ev_type type;      /* SONG_EV_MIDI_CHANNEL */
 271         double time;
 272         int trk_id;
 273         int channel;            /* midi channel (1-16) */
 274 };
 275
 276 struct song_ev_midi_program
 277 {
 278         song_ev_type type;      /* SONG_EV_MIDI_PROGRAM */
 279         double time;
 280         int trk_id;
 281         int program;            /* midi program (0-127) */
 282 };
 283
 284 union song_ev
 285 {
 286         struct song_ev_generic generic;
 287
 288         struct song_ev_tempo tempo;
 289         struct song_ev_meter meter;
 290         struct song_ev_measure measure;
 291
 292         struct song_ev_note note;
 293
 294         struct song_ev_ss_pitch_stretch ss_pitch_stretch;
 295         struct song_ev_ss_sustain ss_sustain;
 296         struct song_ev_ss_vibrato ss_vibrato;
 297         struct song_ev_ss_channel ss_channel;
 298
 299         struct song_ev_ss_wav ss_wav;
 300         struct song_ev_ss_pat ss_pat;
 301
 302         struct song_ev_ss_eff ss_eff;
 303
 304         struct song_ev_midi_channel midi_channel;
 305         struct song_ev_midi_program midi_program;
 306 };
 307
 308
 309 /* GLOBALS */
 310
 311 /* in ss_core.c */
 312
 313 extern int ss_frequency;
 314 extern int ss_interpolation;
 315 extern int ss_nchannels;
 316 extern int ss_debug;
 317
 318 /* in ss_output.c */
 319
 320 extern float ss_master_volume;
 321 extern int ss_output_frames;
 322 extern int ss_output_clipped;
 323 extern float ss_optimal_volume;
 324
 325 /* in song.c */
 326
 327 extern union song_ev * song;
 328 extern int n_song_ev;
 329
 330
 331 /* MACROS */
 332
 333 /* milliseconds to frames conversion */
 334 #define MS2F(ms) ((ms / 1000.0) * ss_frequency)
 335
 336
 337 /* PROTOTYPES */
 338
 339 /* in ss_core.c */
 340
 341 double ss_note_frequency(int note);
 342 struct ss_wave * ss_alloc_wave(int size, int n_channels, int s_rate);
 343 float ss_get_sample(float * wave, double size, double offset);
 344 double ss_tempo_from_wave(struct ss_wave * w, int note, double len);
 345 double ss_pitch_from_tempo(struct ss_wave * w, double tempo, double len);
 346
 347 /* in ss_gen.c */
 348
 349 struct ss_gen * ss_gen_alloc(struct ss_gen ** q);
 350 void ss_gen_free(struct ss_gen ** q, struct ss_gen * g);
 351 void ss_gen_sustain(struct ss_gen * g, double sustain);
 352 void ss_gen_vibrato(struct ss_gen * g, double depth, double freq);
 353 void ss_gen_play(struct ss_gen * g, double freq, float vol, int note_id,
 354         struct ss_wave * w);
 355 void ss_gen_release(struct ss_gen * g);
 356 int ss_gen_frame(struct ss_gen * g, int n_channels, float frame[]);
 357
 358 /* in ss_ins.c */
 359
 360 void ss_ins_init(struct ss_ins * i);
 361 void ss_ins_add_layer(struct ss_ins * i, struct ss_wave * w);
 362 struct ss_wave * ss_ins_find_layer(struct ss_ins * i, double freq, int * off);
 363 void ss_ins_set_channel(struct ss_ins * i, int channel, float vol);
 364 void ss_ins_set_sustain(struct ss_ins * i, double sustain);
 365 void ss_ins_set_vibrato(struct ss_ins * i, double depth, double freq);
 366 int ss_ins_play(struct ss_ins * i, double freq, float vol, int note_id,
 367         struct ss_wave * w);
 368 int ss_ins_note_on(struct ss_ins * i, int note, float vol, int note_id);
 369 void ss_ins_note_off(struct ss_ins * i, int note_id);
 370 void ss_ins_frame(struct ss_ins * i, float frame[]);
 371
 372 /* in ss_output.c */
 373
 374 int ss_output_open(char * drvname, char * filename);
 375 void ss_output_init_frame(float samples[]);
 376 int ss_output_write(float samples[]);
 377 void ss_output_close(void);
 378
 379 /* in ss_input.c */
 380
 381 struct ss_wave * ss_load_wav_file(char * file,
 382         double base_freq, double min_freq, double max_freq,
 383         double loop_start, double loop_end);
 384 int ss_load_pat_file(struct ss_ins * i, char * file);
 385
 386 /* in ss_eff.c */
 387
 388 void ss_eff_delay(struct ss_eff ** ec, double size);
 389 void ss_eff_echo(struct ss_eff ** ec, double size, float gain);
 390 void ss_eff_comb(struct ss_eff ** ec, double size, float gain);
 391 void ss_eff_allpass(struct ss_eff ** ec, double size, float gain);
 392 void ss_eff_flanger(struct ss_eff ** ec, double size, float gain,
 393         double depth, double freq, double phase);
 394 void ss_eff_wobble(struct ss_eff ** ec, double freq, double phase);
 395 void ss_eff_square_wobble(struct ss_eff ** ec, double freq, double phase);
 396 void ss_eff_fader(struct ss_eff ** ec, double size, float initial, float final);
 397 void ss_eff_reverb(struct ss_eff ** ec);
 398
 399 float ss_eff_process(struct ss_eff * e, float s);
 400 void ss_eff_off(struct ss_eff ** ec);
 401
 402 /* in song.c */
 403
 404 void song_clear(void);
 405 void add_song_ev(union song_ev * ev);
 406 void song_sort(void);
 407
 408 /* in ss_song.c */
 409
 410 int ss_song_render(void);
 411
 412 /* in midi_song.c */
 413
 414 int midi_song_play(void);
 415
 416 /* in compiler.y */
 417
 418 int compile(char * code);
 419 int compile_file(char * file);