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