3 Ann Hell Ex Machina - Music Software
4 Copyright (C) 2003/2005 Angel Ortega <angel@triptico.com>
6 ss_song.c - Software synth song event stream management
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.
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.
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.
22 http://www.triptico.com
41 song_ev_type type
; /* event type */
42 int frame
; /* frame number (time) */
43 int trk_id
; /* track id */
48 song_ev_type type
; /* SONG_EV_NOTE_OFF */
51 int note_id
; /* note id */
56 song_ev_type type
; /* SONG_EV_NOTE_ON */
59 int note_id
; /* note id */
60 int note
; /* MIDI-like note */
61 float vol
; /* volume */
64 struct ss_ev_ss_sustain
66 song_ev_type type
; /* SONG_EV_SS_SUSTAIN */
69 double sustain
; /* sustain time (in frames) */
72 struct ss_ev_ss_vibrato
74 song_ev_type type
; /* SONG_EV_SS_VIBRATO */
77 double vib_depth
; /* vibrato depth (in msecs) */
78 double vib_freq
; /* vibrato frequency (in Hzs) */
81 struct ss_ev_ss_channel
83 song_ev_type type
; /* SONG_EV_SS_CHANNEL */
86 int channel
; /* channel */
87 float vol
; /* volume */
92 song_ev_type type
; /* SONG_EV_SS_WAV */
95 char * file
; /* path to .wav file */
96 int base
; /* MIDI-like base note */
97 int min
; /* MIDI-like minimum note */
98 int max
; /* MIDI-like maximum note */
99 double loop_start
; /* loop start */
100 double loop_end
; /* loop end */
105 song_ev_type type
; /* SONG_EV_SS_PAT */
108 char * file
; /* path to .pat file */
113 song_ev_type type
; /* SONG_EV_TEMPO */
116 double tempo
; /* tempo in bmp */
119 struct ss_ev_pitch_stretch
121 song_ev_type type
; /* SONG_EV_SS_PITCH_STRETCH */
124 int note_id
; /* note id */
125 int note
; /* MIDI-like note (to find the wave) */
126 double len
; /* note length (1: whole note) */
127 float vol
; /* note volume (1: full volume) */
130 struct ss_ev_print_wave_tempo
132 song_ev_type type
; /* SONG_EV_SS_PRINT_WAVE_TEMPO */
135 int note_id
; /* note id */
136 int note
; /* MIDI-like note (to find the wave) */
137 double len
; /* note length (1: whole note) */
142 song_ev_type type
; /* effect type */
145 int channel
; /* channel */
146 double size
; /* size of effect */
147 float gain
; /* gain */
148 double depth
; /* depth */
149 double freq
; /* freq */
150 double phase
; /* phase */
151 float initial
; /* initial vol */
152 float final
; /* final vol */
157 struct ss_ev_generic generic
;
158 struct ss_ev_note_on note_on
;
159 struct ss_ev_note_off note_off
;
160 struct ss_ev_ss_sustain ss_sustain
;
161 struct ss_ev_ss_vibrato ss_vibrato
;
162 struct ss_ev_ss_channel ss_channel
;
163 struct ss_ev_ss_wav ss_wav
;
164 struct ss_ev_ss_pat ss_pat
;
165 struct ss_ev_ss_eff ss_eff
;
166 struct ss_ev_tempo tempo
;
167 struct ss_ev_pitch_stretch ss_pitch_stretch
;
168 struct ss_ev_print_wave_tempo ss_print_wave_tempo
;
171 /* the softsynth song stream */
173 static union ss_ev
* ss_song
=NULL
;
174 static int n_ss_ev
=0;
177 /* the instruments */
179 struct ss_ins song_ins
[SS_MAX_INSTRUMENTS
];
184 ********************/
186 static void add_ss_ev(union ss_ev
* e
)
187 /* adds a softsynth song event */
190 ss_song
=(union ss_ev
*)realloc(ss_song
,
191 (n_ss_ev
+ 1) * sizeof(union ss_ev
));
194 memcpy(&ss_song
[n_ss_ev
], e
, sizeof(union ss_ev
));
200 static int ss_ev_cmp(const void * v1
, const void * v2
)
201 /* softsynth song event compare function for qsort() */
203 struct ss_ev_generic
* e1
;
204 struct ss_ev_generic
* e2
;
206 e1
=(struct ss_ev_generic
*)v1
; e2
=(struct ss_ev_generic
*)v2
;
208 if(e1
->frame
== e2
->frame
)
209 return(e1
->type
- e2
->type
);
211 return(e1
->frame
- e2
->frame
);
215 static int ss_song_convert_events(void)
216 /* converts generic song_ev events to softsynth events */
221 int frame
, frame_ac
, f_frame
;
222 double fpw
, time_ac
, time_ac_m
;
227 /* resets the ss stream */
240 frame
=frame_ac
=f_frame
=0;
244 /* travels the song events generating softsynth song events */
245 for(n
=0;n
< n_song_ev
;n
++)
247 /* gets the song event */
250 /* calculates the frame */
251 frame
=((e
->generic
.time
- time_ac
) * fpw
) + frame_ac
;
253 /* generic event data */
254 sse
.generic
.type
=e
->generic
.type
;
255 sse
.generic
.frame
=frame
;
256 sse
.generic
.trk_id
=e
->generic
.trk_id
;
258 /* account the biggest track seen */
259 if(b_track
< e
->generic
.trk_id
) b_track
=e
->generic
.trk_id
;
261 switch(e
->generic
.type
)
265 /* updates accumulations */
267 time_ac
+= e
->generic
.time
;
269 /* calculates frames-per-whole based on new tempo */
270 fpw
=(double) ss_frequency
* 60.0;
271 fpw
/= e
->tempo
.tempo
/ 4.0;
274 sse
.tempo
.tempo
=e
->tempo
.tempo
;
281 /* just store the values */
284 time_ac_m
=e
->meter
.time
;
288 case SONG_EV_MEASURE
:
290 song_test_measure_boundary(e
->measure
.time
- time_ac_m
,
291 num
, den
, e
->measure
.line
);
296 /* convert to note on / off pairs */
298 sse
.note_on
.type
=SONG_EV_NOTE_ON
;
299 sse
.note_on
.note_id
=note_id
++;
300 sse
.note_on
.note
=e
->note
.note
;
301 sse
.note_on
.vol
=e
->note
.vol
;
305 frame
+= (int)(e
->note
.len
* fpw
);
307 sse
.note_off
.type
=SONG_EV_NOTE_OFF
;
308 sse
.note_off
.frame
=frame
;
313 case SONG_EV_SS_PITCH_STRETCH
:
315 sse
.ss_pitch_stretch
.note_id
=note_id
++;
316 sse
.ss_pitch_stretch
.note
=e
->ss_pitch_stretch
.note
;
317 sse
.ss_pitch_stretch
.len
=e
->ss_pitch_stretch
.len
;
318 sse
.ss_pitch_stretch
.vol
=e
->ss_pitch_stretch
.vol
;
322 frame
+= (int)(e
->ss_pitch_stretch
.len
* fpw
);
324 sse
.note_off
.type
=SONG_EV_NOTE_OFF
;
325 sse
.note_off
.frame
=frame
;
330 case SONG_EV_SS_PRINT_WAVE_TEMPO
:
332 sse
.ss_print_wave_tempo
.note
=e
->ss_print_wave_tempo
.note
;
333 sse
.ss_print_wave_tempo
.len
=e
->ss_print_wave_tempo
.len
;
340 sse
.ss_wav
.file
=e
->ss_wav
.file
;
341 sse
.ss_wav
.base
=e
->ss_wav
.base
;
342 sse
.ss_wav
.min
=e
->ss_wav
.min
;
343 sse
.ss_wav
.max
=e
->ss_wav
.max
;
344 sse
.ss_wav
.loop_start
=e
->ss_wav
.loop_start
;
345 sse
.ss_wav
.loop_end
=e
->ss_wav
.loop_end
;
352 sse
.ss_pat
.file
=e
->ss_pat
.file
;
357 case SONG_EV_SS_SUSTAIN
:
359 sse
.ss_sustain
.sustain
=e
->ss_sustain
.sustain
;
364 case SONG_EV_SS_VIBRATO
:
366 sse
.ss_vibrato
.vib_depth
=e
->ss_vibrato
.vib_depth
;
367 sse
.ss_vibrato
.vib_freq
=e
->ss_vibrato
.vib_freq
;
372 case SONG_EV_SS_CHANNEL
:
374 sse
.ss_channel
.channel
=e
->ss_channel
.channel
;
375 sse
.ss_channel
.vol
=e
->ss_channel
.vol
;
380 case SONG_EV_SS_EFF_DELAY
:
381 case SONG_EV_SS_EFF_ECHO
:
382 case SONG_EV_SS_EFF_COMB
:
383 case SONG_EV_SS_EFF_ALLPASS
:
384 case SONG_EV_SS_EFF_FLANGER
:
385 case SONG_EV_SS_EFF_WOBBLE
:
386 case SONG_EV_SS_EFF_SQWOBBLE
:
387 case SONG_EV_SS_EFF_FADER
:
388 case SONG_EV_SS_EFF_REVERB
:
389 case SONG_EV_SS_EFF_OFF
:
391 sse
.ss_eff
.channel
=e
->ss_eff
.channel
;
392 sse
.ss_eff
.size
=e
->ss_eff
.size
;
393 sse
.ss_eff
.gain
=e
->ss_eff
.gain
;
394 sse
.ss_eff
.depth
=e
->ss_eff
.depth
;
395 sse
.ss_eff
.freq
=e
->ss_eff
.freq
;
396 sse
.ss_eff
.phase
=e
->ss_eff
.phase
;
397 sse
.ss_eff
.initial
=e
->ss_eff
.initial
;
398 sse
.ss_eff
.final
=e
->ss_eff
.final
;
403 case SONG_EV_MIDI_CHANNEL
:
404 case SONG_EV_MIDI_PROGRAM
:
409 case SONG_EV_NOTE_ON
:
410 case SONG_EV_NOTE_OFF
:
413 /* never found in generic song streams */
417 /* store the further frame seen */
418 if(f_frame
< frame
) f_frame
=frame
;
421 /* generates an end of event mark, a time after the last one */
422 sse
.generic
.type
=SONG_EV_END
;
423 sse
.generic
.frame
=f_frame
+ ss_frequency
;
427 qsort(ss_song
, n_ss_ev
, sizeof(union ss_ev
), ss_ev_cmp
);
429 /* return the number of tracks */
434 int ss_song_render(int skip_secs
)
440 float output
[SS_MAX_CHANNELS
];
446 /* convert the song to ss events */
447 n_tracks
=ss_song_convert_events();
453 /* init the instruments */
454 for(n
=0;n
< n_tracks
;n
++)
455 ss_ins_init(&song_ins
[n
]);
457 /* calculate the frame to start playing */
458 skip_frames
=skip_secs
* ss_frequency
;
460 /* loop the events */
463 /* process all events for this exact frame */
464 while(e
->generic
.frame
== frame
)
466 /* take the instrument */
467 if(e
->generic
.trk_id
== -1)
470 i
=&song_ins
[e
->generic
.trk_id
];
472 switch(e
->generic
.type
)
474 case SONG_EV_NOTE_ON
:
476 ss_ins_note_on(i
, e
->note_on
.note
,
477 e
->note_on
.vol
, e
->note_on
.note_id
);
481 case SONG_EV_NOTE_OFF
:
483 ss_ins_note_off(i
, e
->note_off
.note_id
);
487 case SONG_EV_SS_SUSTAIN
:
489 ss_ins_set_sustain(i
, e
->ss_sustain
.sustain
);
493 case SONG_EV_SS_VIBRATO
:
495 ss_ins_set_vibrato(i
, e
->ss_vibrato
.vib_depth
,
496 e
->ss_vibrato
.vib_freq
);
500 case SONG_EV_SS_CHANNEL
:
502 ss_ins_set_channel(i
, e
->ss_channel
.channel
,
512 w
=ss_load_wav_file(e
->ss_wav
.file
,
513 ss_note_frequency(e
->ss_wav
.base
),
514 ss_note_frequency(e
->ss_wav
.min
),
515 ss_note_frequency(e
->ss_wav
.max
),
516 e
->ss_wav
.loop_start
,
519 ss_ins_add_layer(i
, w
);
526 ss_load_pat_file(i
, e
->ss_pat
.file
);
529 case SONG_EV_SS_EFF_DELAY
:
531 ss_eff_delay(&i
->effs
[e
->ss_eff
.channel
],
535 case SONG_EV_SS_EFF_ECHO
:
537 ss_eff_echo(&i
->effs
[e
->ss_eff
.channel
],
538 e
->ss_eff
.size
, e
->ss_eff
.gain
);
541 case SONG_EV_SS_EFF_COMB
:
543 ss_eff_comb(&i
->effs
[e
->ss_eff
.channel
],
544 e
->ss_eff
.size
, e
->ss_eff
.gain
);
547 case SONG_EV_SS_EFF_ALLPASS
:
549 ss_eff_allpass(&i
->effs
[e
->ss_eff
.channel
],
550 e
->ss_eff
.size
, e
->ss_eff
.gain
);
553 case SONG_EV_SS_EFF_FLANGER
:
555 ss_eff_flanger(&i
->effs
[e
->ss_eff
.channel
],
556 e
->ss_eff
.size
, e
->ss_eff
.gain
,
557 e
->ss_eff
.depth
, e
->ss_eff
.freq
,
561 case SONG_EV_SS_EFF_WOBBLE
:
563 ss_eff_wobble(&i
->effs
[e
->ss_eff
.channel
],
564 e
->ss_eff
.freq
, e
->ss_eff
.phase
);
568 case SONG_EV_SS_EFF_SQWOBBLE
:
570 ss_eff_square_wobble(&i
->effs
[e
->ss_eff
.channel
],
571 e
->ss_eff
.freq
, e
->ss_eff
.phase
);
575 case SONG_EV_SS_EFF_FADER
:
577 ss_eff_fader(&i
->effs
[e
->ss_eff
.channel
],
578 e
->ss_eff
.size
, e
->ss_eff
.initial
,
582 case SONG_EV_SS_EFF_REVERB
:
584 ss_eff_reverb(&i
->effs
[e
->ss_eff
.channel
]);
587 case SONG_EV_SS_EFF_OFF
:
589 ss_eff_off(&i
->effs
[e
->ss_eff
.channel
]);
594 /* just store the last tempo */
595 tempo
=e
->tempo
.tempo
;
598 case SONG_EV_SS_PITCH_STRETCH
:
605 freq
=ss_note_frequency(e
->ss_pitch_stretch
.note
);
606 w
=ss_ins_find_layer(i
, freq
, NULL
);
608 /* calculate optimal frequency */
609 freq
=ss_pitch_from_tempo(w
, tempo
,
610 e
->ss_pitch_stretch
.len
);
613 ss_ins_play(i
, freq
, e
->ss_pitch_stretch
.vol
,
614 e
->ss_pitch_stretch
.note_id
, w
);
619 case SONG_EV_SS_PRINT_WAVE_TEMPO
:
626 freq
=ss_note_frequency(e
->ss_print_wave_tempo
.note
);
627 w
=ss_ins_find_layer(i
, freq
, NULL
);
629 /* print the optimal tempo */
630 printf("Optimal tempo: %lf\n",
631 ss_tempo_from_wave(w
,
632 e
->ss_print_wave_tempo
.note
,
633 e
->ss_print_wave_tempo
.len
));
643 case SONG_EV_MIDI_CHANNEL
:
644 case SONG_EV_MIDI_PROGRAM
:
647 case SONG_EV_MEASURE
:
649 /* never found in ss song streams */
657 /* reset frame samples */
658 ss_output_init_frame(output
);
660 /* generate output from all instruments */
661 for(n
=0;n
< n_tracks
;n
++)
662 ss_ins_frame(&song_ins
[n
], output
);
664 /* dump to sampling driver */
665 if(frame
>= skip_frames
)
666 ss_output_write(output
);