seq.c

   1 /*
   2    Cantaveria - action adventure platform game
   3    Copyright (C) 2009 2010 Evan Rinehart
   4
   5    This program is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU General Public License
   7    as published by the Free Software Foundation; either version 2
   8    of the License, or (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to
  17
  18    The Free Software Foundation, Inc.
  19    51 Franklin Street, Fifth Floor
  20    Boston, MA  02110-1301, USA
  21
  22    evanrinehart@gmail.com
  23 */
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26
  27 #include <list.h>
  28 #include <util.h>
  29 #include <audio.h>
  30 #include <midi.h>
  31 #include <seq.h>
  32
  33 int tick;
  34 int terr;
  35 int loop_start;
  36 int enable = 0;
  37
  38 int bpm = 120;
  39 int tpb = 384;
  40
  41 //event lists
  42 list* sequence;
  43 list* blank_events;
  44 list* immediate_events;
  45
  46 list* next_event;
  47 list* event_after_loop;
  48
  49
  50
  51 void advance_event(event* now){
  52         if(now->type == EVX_LOOPEND){
  53                 next_event = event_after_loop;
  54                 tick = loop_start;
  55         }
  56         else{
  57                 next_event = next_event->next;
  58         }
  59 }
  60
  61 event* dequeue_event(){
  62         if(next_event == NULL) return NULL;
  63
  64         event* e = next_event->item;
  65         if(e->tick <= tick){
  66                 advance_event(e);
  67
  68                 if(e->type == EVX_TEMPOCHANGE){
  69                         bpm = e->val1;
  70                 }
  71
  72                 if(e->type == EVX_TICKSPERBEAT){
  73                         tpb = e->val1;
  74                 }
  75
  76                 if(e->type == EVX_LOOPSTART){
  77                         loop_start = e->tick;
  78                         event_after_loop = next_event;
  79                 }
  80
  81                 return e;
  82         }
  83         else{
  84                 return NULL;
  85         }
  86 }
  87
  88 int samples_until_next(int max){
  89         int N = 2646000;
  90         int D = bpm*tpb;
  91
  92         if(next_event == NULL) return max;
  93
  94         event* e = next_event->item;
  95         if(e->tick - tick > max * D / N) return max;
  96
  97         int d = (e->tick-tick)*N/D;
  98         return d < max ? d : max;
  99 }
 100
 101 event* seq_advance(int max, int* used){
 102         int N = bpm*tpb;     // bpm * tpb
 103         int D = 2646000;   // srate * 60
 104         event* e;
 105
 106         int u = samples_until_next(max);
 107
 108         if(!enable){
 109                 *used = max;
 110                 return NULL;
 111         }
 112
 113         *used = u;
 114         e = dequeue_event();
 115
 116         terr += N * u;
 117         tick += terr/D;
 118         terr %= D;
 119
 120         return e;
 121 }
 122
 123
 124
 125
 126 /* *** */
 127 static event* make_event(int type, int chan, int val1, int val2){
 128         event* e;
 129         if(blank_events->next){
 130                 e = pop(blank_events);
 131         }
 132         else{
 133                 e = xmalloc(sizeof(event));
 134         }
 135
 136         e->type = type;
 137         e->chan = chan;
 138         e->val1= val1;
 139         e->val2= val2;
 140         e->tick = 0;
 141         return e;
 142 }
 143
 144 void recycle_event(event* e){
 145         push(blank_events, e);
 146 }
 147
 148
 149 void seq_instant(int type, int chan, int val1, int val2){
 150         event* e = make_event(type, chan, val1, val2);
 151         audio_lock();
 152                 append(immediate_events, e);
 153         audio_unlock();
 154 }
 155
 156
 157 void seq_play_sound(int id){
 158         seq_instant(0x90, 15, id, 0);
 159 }
 160
 161
 162
 163 event* seq_get_immediate(){
 164         event* e = pop(immediate_events);
 165         if(e != NULL){
 166                 recycle_event(e);
 167                 return e;
 168         }
 169         else{
 170                 return NULL;
 171         }
 172 }
 173
 174
 175
 176 void seq_enqueue(int when, int type, int chan, int val1, int val2){
 177         event* e = make_event(type, chan, val1, val2);
 178         e->tick = when;
 179         seq_append(e);
 180 }
 181
 182 void seq_clear(){
 183         list* ptr = sequence->next;
 184         while(ptr){
 185                 free(ptr->item);
 186                 ptr = ptr->next;
 187         }
 188         recycle(sequence);
 189         sequence = empty();
 190 }
 191
 192
 193 void seq_append(event* e){
 194         append(sequence, e);
 195 }
 196
 197 void seq_init(){
 198         blank_events = empty();
 199         immediate_events = empty();
 200         sequence = empty();
 201
 202         loop_start = 0;
 203
 204         next_event = sequence->next;
 205 }
 206
 207 void seq_load(list* events){
 208         audio_lock();
 209                 tick = 0;
 210                 terr = 0;
 211                 sequence = events;
 212                 next_event = sequence->next;
 213                 event_after_loop = next_event;
 214                 loop_start = 0;
 215         audio_unlock();
 216 }
 217
 218 void seq_seek(list* target){
 219         event* e = target->item;
 220         audio_lock();
 221                 next_event = target;
 222                 tick = e->tick;
 223         audio_unlock();
 224 }
 225
 226 list* seq_tell(){
 227         return next_event;
 228 }
 229
 230 void seq_enable(){
 231         enable = 1;
 232 }
 233
 234 void seq_disable(){
 235         seq_instant(EVX_MUSICCUT, 0, 0, 0);
 236         enable = 0;
 237 }
 238
 239