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