?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed typo in RELEASE_NOTES.
[ahxm.git] / ss_song.c
blobe3604ddbf5f8cc2cb520e4744e57aae8afeda9e8
1 /*
2
3 Ann Hell Ex Machina - Music Software
4 Copyright (C) 2003/2007 Angel Ortega <angel@triptico.com>
5
6 ss_song.c - Software synth song event stream management
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 "ahxm.h"
34
35 /*******************
36 Data
37 ********************/
38
39 struct ss_ev_generic
40 {
41 song_ev_type type; /* event type */
42 int frame; /* frame number (time) */
43 int trk_id; /* track id */
44 int event_id; /* event id */
45 };
46
47 struct ss_ev_note_off
48 {
49 song_ev_type type; /* SONG_EV_NOTE_OFF */
50 int frame;
51 int trk_id;
52 int event_id;
53 int note_id; /* note id */
54 };
55
56 struct ss_ev_note_on
57 {
58 song_ev_type type; /* SONG_EV_NOTE_ON */
59 int frame;
60 int trk_id;
61 int event_id;
62 int note_id; /* note id */
63 int note; /* MIDI-like note */
64 sample_t vol; /* volume */
65 };
66
67 struct ss_ev_ss_sustain
68 {
69 song_ev_type type; /* SONG_EV_SS_SUSTAIN */
70 int frame;
71 int trk_id;
72 int event_id;
73 double sustain; /* sustain time (in frames) */
74 };
75
76 struct ss_ev_ss_attack
77 {
78 song_ev_type type; /* SONG_EV_SS_ATTACK */
79 int frame;
80 int trk_id;
81 int event_id;
82 double attack; /* attack time (in frames) */
83 };
84
85 struct ss_ev_ss_vibrato
86 {
87 song_ev_type type; /* SONG_EV_SS_VIBRATO */
88 int frame;
89 int trk_id;
90 int event_id;
91 double vib_depth; /* vibrato depth (in msecs) */
92 double vib_freq; /* vibrato frequency (in Hzs) */
93 };
94
95 struct ss_ev_ss_portamento
96 {
97 song_ev_type type; /* SONG_EV_SS_PORTAMENTO */
98 int frame;
99 int trk_id;
100 int event_id;
101 double portamento; /* portamento */
102 };
103
104 struct ss_ev_ss_channel
105 {
106 song_ev_type type; /* SONG_EV_SS_CHANNEL */
107 int frame;
108 int trk_id;
109 int event_id;
110 int channel; /* channel */
111 sample_t vol; /* volume */
112 };
113
114 struct ss_ev_ss_wav
115 {
116 song_ev_type type; /* SONG_EV_SS_WAV */
117 int frame;
118 int trk_id;
119 int event_id;
120 char * file; /* path to .wav file */
121 int base; /* MIDI-like base note */
122 int min; /* MIDI-like minimum note */
123 int max; /* MIDI-like maximum note */
124 double loop_start; /* loop start */
125 double loop_end; /* loop end */
126 int first_channel; /* first channel to start spreading */
127 int skip_channels; /* channels to skip when spreading */
128 };
129
130 struct ss_ev_ss_pat
131 {
132 song_ev_type type; /* SONG_EV_SS_PAT */
133 int frame;
134 int trk_id;
135 int event_id;
136 char * file; /* path to .pat file */
137 };
138
139 struct ss_ev_tempo
140 {
141 song_ev_type type; /* SONG_EV_TEMPO */
142 int frame;
143 int trk_id;
144 int event_id;
145 double tempo; /* tempo in bmp */
146 };
147
148 struct ss_ev_pitch_stretch
149 {
150 song_ev_type type; /* SONG_EV_SS_PITCH_STRETCH */
151 int frame;
152 int trk_id;
153 int event_id;
154 int note_id; /* note id */
155 int note; /* MIDI-like note (to find the wave) */
156 double len; /* note length (1: whole note) */
157 sample_t vol; /* note volume (1: full volume) */
158 };
159
160 struct ss_ev_print_wave_tempo
161 {
162 song_ev_type type; /* SONG_EV_SS_PRINT_WAVE_TEMPO */
163 int frame;
164 int trk_id;
165 int event_id;
166 int note_id; /* note id */
167 int note; /* MIDI-like note (to find the wave) */
168 double len; /* note length (1: whole note) */
169 };
170
171 struct ss_ev_ss_eff
172 {
173 song_ev_type type; /* effect type */
174 int frame;
175 int trk_id;
176 int event_id;
177 int channel; /* channel */
178 double size; /* size of effect */
179 sample_t gain; /* gain */
180 double depth; /* depth */
181 double freq; /* freq */
182 double phase; /* phase */
183 sample_t initial; /* initial vol */
184 sample_t final; /* final vol */
185 };
186
187 struct ss_ev_song_info
188 {
189 song_ev_type type; /* SONG_EV_SONG_INFO */
190 int frame;
191 int trk_id;
192 int event_id;
193 char * author; /* track author */
194 char * name; /* track name */
195 };
196
197 union ss_ev
198 {
199 struct ss_ev_generic generic;
200 struct ss_ev_note_on note_on;
201 struct ss_ev_note_off note_off;
202 struct ss_ev_ss_sustain ss_sustain;
203 struct ss_ev_ss_attack ss_attack;
204 struct ss_ev_ss_vibrato ss_vibrato;
205 struct ss_ev_ss_portamento ss_portamento;
206 struct ss_ev_ss_channel ss_channel;
207 struct ss_ev_ss_wav ss_wav;
208 struct ss_ev_ss_pat ss_pat;
209 struct ss_ev_ss_eff ss_eff;
210 struct ss_ev_tempo tempo;
211 struct ss_ev_pitch_stretch ss_pitch_stretch;
212 struct ss_ev_print_wave_tempo ss_print_wave_tempo;
213 struct ss_ev_song_info song_info;
214 };
215
216 /* the softsynth song stream */
217
218 static union ss_ev * ss_song = NULL;
219 static int n_ss_ev = 0;
220
221
222 /* the instruments */
223
224 struct ss_ins ss_song_ins[SS_MAX_INSTRUMENTS];
225
226 /*******************
227 Code
228 ********************/
229
230 static void add_ss_ev(union ss_ev * e)
231 /* adds a softsynth song event */
232 {
233 GROW(ss_song, n_ss_ev, union ss_ev);
234
235 /* store */
236 memcpy(&ss_song[n_ss_ev], e, sizeof(union ss_ev));
237
238 n_ss_ev++;
239 }
240
241
242 static int ss_ev_cmp(const void * v1, const void * v2)
243 /* softsynth song event compare function for qsort() */
244 {
245 struct ss_ev_generic * e1;
246 struct ss_ev_generic * e2;
247 int ret;
248
249 e1 = (struct ss_ev_generic *)v1; e2 = (struct ss_ev_generic *)v2;
250
251 ret = e1->frame - e2->frame;
252
253 if(ret == 0)
254 ret = e1->type - e2->type;
255
256 if(ret == 0)
257 ret = e1->event_id - e2->event_id;
258
259 return(ret);
260 }
261
262
263 static void ss_song_convert_events(int * n_channels)
264 /* converts generic song_ev events to softsynth events */
265 {
266 int note_id = 1;
267 union song_ev * e;
268 union ss_ev sse;
269 int frame, frame_ac, f_frame;
270 double fpw, time_ac, time_ac_m;
271 int num, den;
272 int n;
273
274 *n_channels = -1;
275
276 /* resets the ss stream */
277 if(ss_song != NULL)
278 {
279 free(ss_song);
280 ss_song = NULL;
281 }
282
283 n_ss_ev = 0;
284
285 /* sorts the song */
286 song_sort();
287
288 fpw = 0;
289 frame = frame_ac = f_frame = 0;
290 time_ac = time_ac_m = 0;
291 num = den = 4;
292
293 /* travels the song events generating softsynth song events */
294 for(n = 0;n < n_song_ev;n++)
295 {
296 /* gets the song event */
297 e = &song[n];
298
299 /* calculates the frame */
300 frame = ((e->generic.time - time_ac) * fpw) + frame_ac;
301
302 /* generic event data */
303 sse.generic.type = e->generic.type;
304 sse.generic.frame = frame;
305 sse.generic.trk_id = e->generic.trk_id;
306 sse.generic.event_id = e->generic.event_id;
307
308 switch(e->generic.type)
309 {
310 case SONG_EV_TEMPO:
311
312 /* updates accumulations */
313 frame_ac = frame;
314 time_ac = e->generic.time;
315
316 /* calculates frames-per-whole based on new tempo */
317 fpw = (double) ss_frequency * 60.0;
318 fpw /= e->tempo.tempo / 4.0;
319
320 /* adds an event */
321 sse.tempo.tempo = e->tempo.tempo;
322 add_ss_ev(&sse);
323
324 break;
325
326 case SONG_EV_METER:
327
328 /* just store the values */
329 num = e->meter.num;
330 den = e->meter.den;
331 time_ac_m = e->meter.time;
332
333 break;
334
335 case SONG_EV_MEASURE:
336
337 song_test_measure_boundary(e->measure.time - time_ac_m,
338 num, den, e->measure.line);
339 break;
340
341 case SONG_EV_NOTE:
342
343 /* convert to note on / off pairs */
344
345 sse.note_on.type = SONG_EV_NOTE_ON;
346 sse.note_on.note_id = note_id++;
347 sse.note_on.note = e->note.note;
348 sse.note_on.vol = e->note.vol;
349
350 add_ss_ev(&sse);
351
352 frame += (int)(e->note.len * fpw);
353
354 sse.note_off.type = SONG_EV_NOTE_OFF;
355 sse.note_off.frame = frame;
356
357 add_ss_ev(&sse);
358 break;
359
360 case SONG_EV_BACK:
361
362 /* move the cursor back */
363
364 frame_ac -= (int)(e->back.len * fpw);
365
366 break;
367
368 case SONG_EV_SS_PITCH_STRETCH:
369
370 sse.ss_pitch_stretch.note_id = note_id++;
371 sse.ss_pitch_stretch.note = e->ss_pitch_stretch.note;
372 sse.ss_pitch_stretch.len = e->ss_pitch_stretch.len;
373 sse.ss_pitch_stretch.vol = e->ss_pitch_stretch.vol;
374
375 add_ss_ev(&sse);
376
377 frame += (int)(e->ss_pitch_stretch.len * fpw);
378
379 sse.note_off.type = SONG_EV_NOTE_OFF;
380 sse.note_off.frame = frame;
381
382 add_ss_ev(&sse);
383 break;
384
385 case SONG_EV_SS_PRINT_WAVE_TEMPO:
386
387 sse.ss_print_wave_tempo.note = e->ss_print_wave_tempo.note;
388 sse.ss_print_wave_tempo.len = e->ss_print_wave_tempo.len;
389
390 add_ss_ev(&sse);
391 break;
392
393 case SONG_EV_SS_WAV:
394
395 sse.ss_wav.file = e->ss_wav.file;
396 sse.ss_wav.base = e->ss_wav.base;
397 sse.ss_wav.min = e->ss_wav.min;
398 sse.ss_wav.max = e->ss_wav.max;
399 sse.ss_wav.loop_start = e->ss_wav.loop_start;
400 sse.ss_wav.loop_end = e->ss_wav.loop_end;
401 sse.ss_wav.first_channel = e->ss_wav.first_channel;
402 sse.ss_wav.skip_channels = e->ss_wav.skip_channels;
403
404 add_ss_ev(&sse);
405 break;
406
407 case SONG_EV_SS_PAT:
408
409 sse.ss_pat.file = e->ss_pat.file;
410
411 add_ss_ev(&sse);
412 break;
413
414 case SONG_EV_SS_SUSTAIN:
415
416 sse.ss_sustain.sustain = e->ss_sustain.sustain;
417
418 add_ss_ev(&sse);
419 break;
420
421 case SONG_EV_SS_ATTACK:
422
423 sse.ss_attack.attack = e->ss_attack.attack;
424
425 add_ss_ev(&sse);
426 break;
427
428 case SONG_EV_SS_VIBRATO:
429
430 sse.ss_vibrato.vib_depth = e->ss_vibrato.vib_depth;
431 sse.ss_vibrato.vib_freq = e->ss_vibrato.vib_freq;
432
433 add_ss_ev(&sse);
434 break;
435
436 case SONG_EV_SS_PORTAMENTO:
437
438 sse.ss_portamento.portamento = e->ss_portamento.portamento;
439
440 add_ss_ev(&sse);
441 break;
442
443 case SONG_EV_SS_CHANNEL:
444
445 sse.ss_channel.channel = e->ss_channel.channel;
446 sse.ss_channel.vol = e->ss_channel.vol;
447
448 /* count channels */
449 if(*n_channels < e->ss_channel.channel)
450 *n_channels = e->ss_channel.channel;
451
452 add_ss_ev(&sse);
453 break;
454
455 case SONG_EV_SS_EFF_DELAY:
456 case SONG_EV_SS_EFF_ECHO:
457 case SONG_EV_SS_EFF_COMB:
458 case SONG_EV_SS_EFF_ALLPASS:
459 case SONG_EV_SS_EFF_FLANGER:
460 case SONG_EV_SS_EFF_WOBBLE:
461 case SONG_EV_SS_EFF_SQWOBBLE:
462 case SONG_EV_SS_EFF_HFWOBBLE:
463 case SONG_EV_SS_EFF_FADER:
464 case SONG_EV_SS_EFF_REVERB:
465 case SONG_EV_SS_EFF_FOLDBACK:
466 case SONG_EV_SS_EFF_ATAN:
467 case SONG_EV_SS_EFF_DISTORT:
468 case SONG_EV_SS_EFF_OVERDRIVE:
469 case SONG_EV_SS_EFF_OFF:
470
471 sse.ss_eff.channel = e->ss_eff.channel;
472 sse.ss_eff.size = e->ss_eff.size;
473 sse.ss_eff.gain = e->ss_eff.gain;
474 sse.ss_eff.depth = e->ss_eff.depth;
475 sse.ss_eff.freq = e->ss_eff.freq;
476 sse.ss_eff.phase = e->ss_eff.phase;
477 sse.ss_eff.initial = e->ss_eff.initial;
478 sse.ss_eff.final = e->ss_eff.final;
479
480 add_ss_ev(&sse);
481 break;
482
483 case SONG_EV_SONG_INFO:
484
485 sse.song_info.author = e->song_info.author;
486 sse.song_info.name = e->song_info.name;
487
488 add_ss_ev(&sse);
489 break;
490
491 case SONG_EV_EOT:
492
493 add_ss_ev(&sse);
494 break;
495
496 case SONG_EV_MIDI_CHANNEL:
497 case SONG_EV_MIDI_PROGRAM:
498
499 /* ignored */
500 break;
501
502 case SONG_EV_NOTE_ON:
503 case SONG_EV_NOTE_OFF:
504 case SONG_EV_END:
505
506 /* never found in generic song streams */
507 break;
508 }
509
510 /* store the further frame seen */
511 if(f_frame < frame) f_frame = frame;
512 }
513
514 /* generates an end of event mark, a time after the last one */
515 sse.generic.type = SONG_EV_END;
516 sse.generic.frame = f_frame + ss_frequency;
517 sse.generic.event_id = -1;
518 add_ss_ev(&sse);
519
520 /* finally sort */
521 qsort(ss_song, n_ss_ev, sizeof(union ss_ev), ss_ev_cmp);
522
523 /* count one more */
524 (*n_channels)++;
525 }
526
527
528 static void ss_song_trace_events(void)
529 {
530 union ss_ev * e;
531 int n;
532
533 printf("** SOFTWARE SYNTHESIZER EVENT DUMP **\n\n");
534 printf("%10s %5s %5s Event and information\n",
535 "Frame", "Track", "Ev.ID");
536 printf("------------------------------------------------------------\n");
537
538 for(n = 0, e = ss_song;n < n_ss_ev;n++, e++)
539 {
540 printf("%10d %5d %5d ",
541 e->generic.frame, e->generic.trk_id, e->generic.event_id);
542
543 switch(e->generic.type)
544 {
545 case SONG_EV_TEMPO:
546
547 printf("SONG_EV_TEMPO ");
548 printf("%lf", e->tempo.tempo);
549 break;
550
551 case SONG_EV_SS_SUSTAIN:
552
553 printf("SONG_EV_SS_SUSTAIN ");
554 printf("SUSTAIN:%lf", e->ss_sustain.sustain);
555 break;
556
557 case SONG_EV_SS_ATTACK:
558
559 printf("SONG_EV_SS_ATTACK ");
560 printf("ATTACK:%lf", e->ss_attack.attack);
561 break;
562
563 case SONG_EV_SS_VIBRATO:
564
565 printf("SONG_EV_SS_VIBRATO ");
566 printf("DEPTH:%lf FREQ:%lf",
567 e->ss_vibrato.vib_depth,
568 e->ss_vibrato.vib_freq);
569 break;
570
571 case SONG_EV_SS_PORTAMENTO:
572
573 printf("SONG_EV_SS_PORTAMENTO ");
574 printf("VALUE:%lf",
575 e->ss_portamento.portamento);
576 break;
577
578 case SONG_EV_SS_CHANNEL:
579
580 printf("SONG_EV_SS_CHANNEL ");
581 printf("CHANNEL:%d VOL:%lf",
582 e->ss_channel.channel,
583 e->ss_channel.vol);
584 break;
585
586 case SONG_EV_SS_WAV:
587
588 printf("SONG_EV_SS_WAV ");
589 printf("FILE:'%s' BASE:%d MIN:%d MAX:%d START:%lf END:%lf",
590 e->ss_wav.file, e->ss_wav.base,
591 e->ss_wav.min, e->ss_wav.max,
592 e->ss_wav.loop_start, e->ss_wav.loop_end);
593 break;
594
595 case SONG_EV_SS_PAT:
596
597 printf("SONG_EV_SS_PAT ");
598 printf("FILE:'%s'", e->ss_pat.file);
599 break;
600
601 case SONG_EV_SS_EFF_DELAY:
602
603 printf("SONG_EV_SS_EFF_DELAY ");
604 printf("CHANNEL:%d ", e->ss_eff.channel);
605 printf("SIZE:%lf ", e->ss_eff.size);
606 break;
607
608 case SONG_EV_SS_EFF_ECHO:
609
610 printf("SONG_EV_SS_EFF_ECHO ");
611 printf("CHANNEL:%d ", e->ss_eff.channel);
612 printf("SIZE:%lf ", e->ss_eff.size);
613 printf("GAIN:%f ", e->ss_eff.gain);
614 break;
615
616 case SONG_EV_SS_EFF_COMB:
617
618 printf("SONG_EV_SS_EFF_COMB ");
619 printf("CHANNEL:%d ", e->ss_eff.channel);
620 printf("SIZE:%lf ", e->ss_eff.size);
621 printf("GAIN:%f ", e->ss_eff.gain);
622 break;
623
624 case SONG_EV_SS_EFF_ALLPASS:
625
626 printf("SONG_EV_SS_EFF_ALLPASS ");
627 printf("CHANNEL:%d ", e->ss_eff.channel);
628 printf("SIZE:%lf ", e->ss_eff.size);
629 printf("GAIN:%f ", e->ss_eff.gain);
630 break;
631
632 case SONG_EV_SS_EFF_FLANGER:
633
634 printf("SONG_EV_SS_EFF_FLANGER ");
635 printf("CHANNEL:%d ", e->ss_eff.channel);
636 printf("SIZE:%lf ", e->ss_eff.size);
637 printf("GAIN:%f ", e->ss_eff.gain);
638 printf("DEPTH:%lf ", e->ss_eff.depth);
639 printf("FREQ:%lf PHASE:%lf", e->ss_eff.freq,
640 e->ss_eff.phase);
641 break;
642
643 case SONG_EV_SS_EFF_WOBBLE:
644
645 printf("SONG_EV_SS_EFF_WOBBLE ");
646 printf("CHANNEL:%d ", e->ss_eff.channel);
647 printf("FREQ:%lf PHASE:%lf GAIN:%lf", e->ss_eff.freq,
648 e->ss_eff.phase, e->ss_eff.gain);
649 break;
650
651 case SONG_EV_SS_EFF_SQWOBBLE:
652
653 printf("SONG_EV_SS_EFF_SQWOBBLE ");
654 printf("CHANNEL:%d ", e->ss_eff.channel);
655 printf("FREQ:%lf PHASE:%lf", e->ss_eff.freq,
656 e->ss_eff.phase);
657 break;
658
659 case SONG_EV_SS_EFF_HFWOBBLE:
660
661 printf("SONG_EV_SS_EFF_HFWOBBLE ");
662 printf("CHANNEL:%d ", e->ss_eff.channel);
663 printf("FREQ:%lf PHASE:%lf", e->ss_eff.freq,
664 e->ss_eff.phase);
665 break;
666
667 case SONG_EV_SS_EFF_FADER:
668
669 printf("SONG_EV_SS_EFF_FADER ");
670 printf("CHANNEL:%d ", e->ss_eff.channel);
671 printf("SIZE:%lf ", e->ss_eff.size);
672 printf("INITIAL:%f FINAL:%f", e->ss_eff.initial,
673 e->ss_eff.final);
674 break;
675
676 case SONG_EV_SS_EFF_REVERB:
677
678 printf("SONG_EV_SS_EFF_REVERB ");
679 printf("CHANNEL:%d ", e->ss_eff.channel);
680 break;
681
682 case SONG_EV_SS_EFF_FOLDBACK:
683
684 printf("SONG_EV_SS_EFF_FOLDBACK ");
685 printf("CHANNEL:%d THRESHOLD:%f", e->ss_eff.channel,
686 e->ss_eff.gain);
687 break;
688
689 case SONG_EV_SS_EFF_ATAN:
690
691 printf("SONG_EV_SS_EFF_ATAN ");
692 printf("CHANNEL:%d GAIN:%f", e->ss_eff.channel,
693 e->ss_eff.gain);
694 break;
695
696 case SONG_EV_SS_EFF_DISTORT:
697
698 printf("SONG_EV_SS_EFF_DISTORT ");
699 printf("CHANNEL:%d GAIN:%f", e->ss_eff.channel,
700 e->ss_eff.gain);
701 break;
702
703 case SONG_EV_SS_EFF_OVERDRIVE:
704
705 printf("SONG_EV_SS_EFF_OVERDRIVE ");
706 printf("CHANNEL:%d GAIN:%f", e->ss_eff.channel,
707 e->ss_eff.gain);
708 break;
709
710 case SONG_EV_SS_EFF_OFF:
711
712 printf("SONG_EV_SS_EFF_OFF ");
713 printf("CHANNEL:%d ", e->ss_eff.channel);
714 break;
715
716 case SONG_EV_SS_PITCH_STRETCH:
717
718 printf("SONG_EV_SS_PITCH_STRETCH ");
719 printf("MIDI:%d LEN:%lf VOL:%f",
720 e->ss_pitch_stretch.note,
721 e->ss_pitch_stretch.len,
722 e->ss_pitch_stretch.vol);
723
724 break;
725
726 case SONG_EV_SS_PRINT_WAVE_TEMPO:
727
728 printf("SONG_EV_SS_PRINT_WAVE_TEMPO ");
729 printf("MIDI:%d LEN:%lf",
730 e->ss_print_wave_tempo.note,
731 e->ss_print_wave_tempo.len);
732 break;
733
734 case SONG_EV_SONG_INFO:
735
736 printf("SONG_EV_SONG_INFO ");
737 printf("AUTHOR:'%s' NAME:'%s'",
738 e->song_info.author,
739 e->song_info.name);
740 break;
741
742 case SONG_EV_NOTE_ON:
743
744 printf("SONG_EV_NOTE_ON ");
745 printf("ID:%d MIDI:%d VOL:%f",
746 e->note_on.note_id, e->note_on.note,
747 e->note_on.vol);
748 break;
749
750 case SONG_EV_NOTE_OFF:
751
752 printf("SONG_EV_NOTE_OFF ");
753 printf("ID:%d", e->note_off.note_id);
754 break;
755
756 case SONG_EV_EOT:
757
758 printf("SONG_EV_EOT ");
759 break;
760
761 case SONG_EV_END:
762
763 printf("SONG_EV_END ");
764 break;
765
766 default:
767 printf("** Unexpected type: %d",
768 e->generic.type);
769 }
770
771 printf("\n");
772 }
773
774 printf("\n");
775 }
776
777
778 static union ss_ev * process_this_frame_events(union ss_ev * e, int skip_frames)
779 /* process the events attached to this frame */
780 {
781 static double tempo = 120.0;
782 static int frame = 0;
783
784 /* from the beginning? */
785 if(e == NULL)
786 {
787 e = ss_song;
788 tempo = 120.0;
789 frame = 0;
790 }
791
792 if(verbose >= 1)
793 {
794 if(frame % ss_frequency == 0)
795 {
796 int m = frame / ss_frequency;
797 printf("[%02d:%02d]\r", m / 60, m % 60);
798 fflush(stdout);
799 }
800 }
801
802 while(e != NULL && e->generic.frame == frame)
803 {
804 struct ss_ins * i;
805 struct ss_wave * w;
806 double freq;
807
808 if(e->generic.type == SONG_EV_NOTE_ON ||
809 e->generic.type == SONG_EV_NOTE_OFF ||
810 e->generic.type == SONG_EV_SS_PITCH_STRETCH)
811 {
812 if(frame < skip_frames)
813 {
814 e++;
815 frame = e->generic.frame;
816 continue;
817 }
818 }
819
820 /* take the instrument */
821 if(e->generic.trk_id < 0)
822 i = NULL;
823 else
824 i = &ss_song_ins[e->generic.trk_id];
825
826 switch(e->generic.type)
827 {
828 case SONG_EV_NOTE_ON:
829
830 if(ss_ins_note_on(i, e->note_on.note,
831 e->note_on.vol, e->note_on.note_id) < 0 &&
832 verbose >= 1)
833 printf("ss_ins_note_on error: track %d note %d\n",
834 e->note_on.trk_id, e->note_on.note);
835
836 break;
837
838 case SONG_EV_NOTE_OFF:
839
840 ss_ins_note_off(i, e->note_off.note_id);
841
842 break;
843
844 case SONG_EV_SS_SUSTAIN:
845
846 ss_ins_set_sustain(i, e->ss_sustain.sustain);
847
848 break;
849
850 case SONG_EV_SS_ATTACK:
851
852 ss_ins_set_attack(i, e->ss_attack.attack);
853
854 break;
855
856 case SONG_EV_SS_VIBRATO:
857
858 ss_ins_set_vibrato(i, e->ss_vibrato.vib_depth,
859 e->ss_vibrato.vib_freq);
860
861 break;
862
863 case SONG_EV_SS_PORTAMENTO:
864
865 ss_ins_set_portamento(i,
866 (e->ss_portamento.portamento * 44100.0)
867 / ((double) ss_frequency * 1000000.0));
868
869 break;
870
871 case SONG_EV_SS_CHANNEL:
872
873 ss_ins_set_channel(i, e->ss_channel.channel,
874 e->ss_channel.vol);
875
876 break;
877
878 case SONG_EV_SS_WAV:
879
880 w = ss_load_wav_file(e->ss_wav.file,
881 ss_note_frequency(e->ss_wav.base),
882 ss_note_frequency(e->ss_wav.min),
883 ss_note_frequency(e->ss_wav.max),
884 e->ss_wav.loop_start, e->ss_wav.loop_end,
885 e->ss_wav.first_channel, e->ss_wav.skip_channels);
886
887 /* fail if can't open wav */
888 if(w == NULL)
889 {
890 printf("Can't load wav '%s'\n", e->ss_wav.file);
891 e = NULL;
892 }
893 else
894 ss_ins_add_layer(i, w);
895
896 break;
897
898 case SONG_EV_SS_PAT:
899
900 if(ss_load_pat_file(i, e->ss_pat.file) < 0)
901 {
902 printf("Can't load pat '%s'\n", e->ss_pat.file);
903 e = NULL;
904 }
905
906 break;
907
908 case SONG_EV_SS_EFF_DELAY:
909
910 ss_eff_delay(&i->effs[e->ss_eff.channel], e->ss_eff.size);
911 break;
912
913 case SONG_EV_SS_EFF_ECHO:
914
915 ss_eff_echo(&i->effs[e->ss_eff.channel],
916 e->ss_eff.size, e->ss_eff.gain);
917 break;
918
919 case SONG_EV_SS_EFF_COMB:
920
921 ss_eff_comb(&i->effs[e->ss_eff.channel],
922 e->ss_eff.size, e->ss_eff.gain);
923 break;
924
925 case SONG_EV_SS_EFF_ALLPASS:
926
927 ss_eff_allpass(&i->effs[e->ss_eff.channel],
928 e->ss_eff.size, e->ss_eff.gain);
929 break;
930
931 case SONG_EV_SS_EFF_FLANGER:
932
933 ss_eff_flanger(&i->effs[e->ss_eff.channel],
934 e->ss_eff.size, e->ss_eff.gain,
935 e->ss_eff.depth, e->ss_eff.freq,
936 e->ss_eff.phase);
937 break;
938
939 case SONG_EV_SS_EFF_WOBBLE:
940
941 ss_eff_wobble(&i->effs[e->ss_eff.channel],
942 e->ss_eff.freq, e->ss_eff.phase,
943 e->ss_eff.gain);
944
945 break;
946
947 case SONG_EV_SS_EFF_SQWOBBLE:
948
949 ss_eff_square_wobble(&i->effs[e->ss_eff.channel],
950 e->ss_eff.freq, e->ss_eff.phase);
951
952 break;
953
954 case SONG_EV_SS_EFF_HFWOBBLE:
955
956 ss_eff_half_wobble(&i->effs[e->ss_eff.channel],
957 e->ss_eff.freq, e->ss_eff.phase);
958
959 break;
960
961 case SONG_EV_SS_EFF_FADER:
962
963 ss_eff_fader(&i->effs[e->ss_eff.channel],
964 e->ss_eff.size, e->ss_eff.initial,
965 e->ss_eff.final);
966 break;
967
968 case SONG_EV_SS_EFF_REVERB:
969
970 ss_eff_reverb(&i->effs[e->ss_eff.channel]);
971 break;
972
973 case SONG_EV_SS_EFF_FOLDBACK:
974
975 ss_eff_foldback(&i->effs[e->ss_eff.channel],
976 e->ss_eff.gain);
977 break;
978
979 case SONG_EV_SS_EFF_ATAN:
980
981 ss_eff_atan(&i->effs[e->ss_eff.channel],
982 e->ss_eff.gain);
983 break;
984
985 case SONG_EV_SS_EFF_DISTORT:
986
987 ss_eff_distort(&i->effs[e->ss_eff.channel],
988 e->ss_eff.gain);
989 break;
990
991 case SONG_EV_SS_EFF_OVERDRIVE:
992
993 ss_eff_overdrive(&i->effs[e->ss_eff.channel],
994 e->ss_eff.gain);
995 break;
996
997 case SONG_EV_SS_EFF_OFF:
998
999 ss_eff_off(&i->effs[e->ss_eff.channel]);
1000 break;
1001
1002 case SONG_EV_TEMPO:
1003
1004 /* just store the last tempo */
1005 tempo = e->tempo.tempo;
1006 break;
1007
1008 case SONG_EV_SS_PITCH_STRETCH:
1009
1010 /* find the wave */
1011 freq = ss_note_frequency(e->ss_pitch_stretch.note);
1012 w = ss_ins_find_layer(i, freq, NULL);
1013
1014 /* calculate optimal frequency */
1015 freq = ss_pitch_from_tempo(w, tempo,
1016 e->ss_pitch_stretch.len);
1017
1018 /* play the note */
1019 if(ss_ins_play(i, freq, e->ss_pitch_stretch.vol,
1020 e->ss_pitch_stretch.note_id, w) < 0 &&
1021 verbose >= 1)
1022 printf("ss_ins_play error: track %d freq %f\n",
1023 e->ss_pitch_stretch.trk_id, freq);
1024
1025 break;
1026
1027 case SONG_EV_SS_PRINT_WAVE_TEMPO:
1028
1029 /* find the wave */
1030 freq = ss_note_frequency(e->ss_print_wave_tempo.note);
1031 w = ss_ins_find_layer(i, freq, NULL);
1032
1033 /* print the optimal tempo */
1034 printf("Optimal tempo: %lf\n",
1035 ss_tempo_from_wave(w,
1036 e->ss_print_wave_tempo.note,
1037 e->ss_print_wave_tempo.len));
1038
1039 break;
1040
1041 case SONG_EV_SONG_INFO:
1042
1043 /* add a new song (track) */
1044 cue_file_song_info(frame, e->song_info.author,
1045 e->song_info.name);
1046 break;
1047
1048 case SONG_EV_EOT:
1049
1050 /* end of track; trigger possible cleaning */
1051 ss_ins_disable(i);
1052 break;
1053
1054 case SONG_EV_END:
1055
1056 e = NULL;
1057 break;
1058
1059 case SONG_EV_BACK:
1060 case SONG_EV_MIDI_CHANNEL:
1061 case SONG_EV_MIDI_PROGRAM:
1062 case SONG_EV_NOTE:
1063 case SONG_EV_METER:
1064 case SONG_EV_MEASURE:
1065
1066 /* never found in ss song streams */
1067 break;
1068 }
1069
1070 /* next event */
1071 if(e) e++;
1072 }
1073
1074 frame++;
1075
1076 return(e);
1077 }
1078
1079
1080 int ss_song_render(int skip_secs, char * driver, char * devfile)
1081 {
1082 int n, i = 0;
1083 sample_t output[SS_MAX_CHANNELS];
1084 int skip_frames;
1085 int n_channels;
1086 union ss_ev * e = NULL;
1087
1088 /* convert the song to ss events */
1089 ss_song_convert_events(&n_channels);
1090
1091 if(verbose >= 2)
1092 printf("Tracks: %d Channels: %d Events: %d\n",
1093 n_song_tracks, n_channels, n_ss_ev);
1094
1095 if(trace)
1096 {
1097 ss_song_trace_events();
1098 return(0);
1099 }
1100
1101 /* set the number of channels, unless forced */
1102 if(ss_nchannels == -1)
1103 ss_nchannels = n_channels > 0 ? n_channels : 2;
1104
1105 if(ss_output_open(driver, devfile) < 0)
1106 {
1107 printf("Error: can't init driver\n");
1108 return(2);
1109 }
1110
1111 /* init the generators */
1112 ss_gen_init();
1113
1114 /* init the instruments */
1115 for(n = 0;n < n_song_tracks;n++)
1116 ss_ins_init(&ss_song_ins[n]);
1117
1118 /* calculate the frame to start playing */
1119 skip_frames = skip_secs * ss_frequency;
1120
1121 /* main loop */
1122 do
1123 {
1124 /* process all events in this frame */
1125 /* if((e = process_this_frame_events(e, skip_frames)) == NULL)
1126 break;*/
1127 e = process_this_frame_events(e, skip_frames);
1128
1129 /* reset frame samples */
1130 ss_output_init_frame(output);
1131
1132 /* generate output from all instruments */
1133 for(n = i = 0;n < n_song_tracks;n++)
1134 i += ss_ins_frame(&ss_song_ins[n], output);
1135
1136 /* dump to sampling driver */
1137 ss_output_write(output);
1138 } while(i);
1139
1140 if(verbose >= 1) printf("\n");
1141
1142 ss_output_close();
1143
1144 return(0);
1145 }
Ann Hell Ex Machina (music writing software)