src/seq.h

   1 /*
   2    Epichord - a midi sequencer
   3    Copyright (C) 2008  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
  23 #ifndef seq_h
  24 #define seq_h
  25
  26 #define MIDI_NOTE_OFF 0x80
  27 #define MIDI_NOTE_ON 0x90
  28 #define MIDI_AFTERTOUCH 0xA0
  29 #define MIDI_CONTROLLER_CHANGE 0xB0
  30 #define MIDI_PROGRAM_CHANGE 0xC0
  31 #define MIDI_CHANNEL_PRESSURE 0xD0
  32 #define MIDI_PITCH_WHEEL 0xE0
  33
  34 #define MAX_TRACK_NAME 256
  35
  36 #include <stdio.h>
  37 struct mevent {
  38
  39   public:
  40   int tick;
  41
  42   int type;
  43   int value1;
  44   int value2;
  45   int dur; //for note on events
  46
  47   //struct mevent* off; //for note on events
  48   //int off_index; //used when reloading
  49
  50   struct mevent* prev;
  51   struct mevent* next;
  52
  53   int selected;
  54   int modified;
  55
  56   mevent(){
  57     type = -1;
  58     //off = NULL;
  59     prev = NULL;
  60     next = NULL;
  61     dur = 32;
  62     selected = 0;
  63     modified = 0;
  64   }
  65
  66   mevent(int ztype, int ztick, int zv1){
  67     //off=NULL;
  68     prev=NULL;
  69     next=NULL;
  70     dur = 32;
  71     type=ztype;
  72     tick=ztick;
  73     value1=zv1;
  74     value2=0x7f;
  75     selected = 0;
  76     modified = 0;
  77   }
  78
  79   mevent(mevent* e){
  80     type = e->type;
  81     tick = e->tick;
  82     value1 = e->value1;
  83     value2 = e->value2;
  84     dur = e->dur;
  85     //off = e->off;
  86     prev = e->prev;
  87     next = e->next;
  88     selected = e->selected;
  89     modified = e->modified;
  90   }
  91
  92 };
  93
  94 struct pattern {
  95   public:
  96   struct mevent* events;
  97   struct pattern* next;
  98   int ref_c;
  99
 100   unsigned char r1,g1,b1;//main color
 101   unsigned char r2,g2,b2;//bottom color
 102   unsigned char r3,g3,b3;//top color
 103   unsigned char rx,gx,bx;//xray color
 104
 105   float h, s, v; //color
 106
 107   void regen_colors();
 108
 109   pattern();
 110   pattern(pattern* p);
 111   ~pattern();
 112 };
 113
 114
 115
 116 struct layerstack {
 117   pattern** array;
 118   pattern* ptr;
 119
 120   int index;
 121   int total;
 122   int memsize;
 123
 124   int ref_c;
 125
 126   pattern* push_new();
 127   void push_new(pattern* p);
 128   pattern* next();
 129   pattern* prev();
 130   void reallocate();
 131
 132   layerstack(){};
 133   layerstack(pattern* p);
 134   ~layerstack();
 135 };
 136
 137
 138 struct seqpat {
 139   int track;
 140   int tick;
 141   int dur;
 142   struct pattern* p;
 143   struct mevent* skip;
 144   struct seqpat* prev;
 145   struct seqpat* next;
 146
 147   layerstack* layers;
 148
 149  // unsigned char color[3][3];
 150   int selected;
 151   int modified;
 152   int record_flag;//0=on record, erase/save. 1=dont
 153   int rhandle;
 154   int lhandle;
 155
 156   int scrollx, scrolly;
 157
 158   void restate();
 159   void apply_erase();
 160   void apply_layer();
 161   void next_layer();
 162   void prev_layer();
 163   int layer_index();
 164   int layer_total();
 165   void record_check(int mode);
 166   void autocomplete();
 167
 168   seqpat(){
 169     p = NULL;
 170     skip = NULL;
 171     prev = NULL;
 172     next = NULL;
 173     dur=0;
 174     selected=0;
 175     modified=0;
 176     rhandle=0;
 177     lhandle=0;
 178     record_flag=1;
 179     layers = NULL;
 180   }
 181
 182   seqpat(int ztrack, int ztick, int zdur, pattern* zp){
 183     p = zp;
 184     p->ref_c++;
 185     track = ztrack;
 186     dur = zdur;
 187     tick = ztick;
 188     skip = NULL;
 189     prev = NULL;
 190     next = NULL;
 191     selected = 0;
 192     modified = 0;
 193     rhandle = 0;
 194     lhandle = 0;
 195     record_flag = 1;
 196     layers = NULL;
 197   }
 198
 199   seqpat(seqpat* zs){
 200     p = zs->p;
 201     p->ref_c++;
 202     track = zs->track;
 203     dur = zs->dur;
 204     tick = zs->tick;
 205     if(p){p->ref_c++;}
 206
 207     skip = p->events;
 208     prev = zs->prev;
 209     next = zs->next;
 210
 211     scrollx = zs->scrollx;
 212     scrolly = zs->scrolly;
 213
 214     selected = zs->selected;
 215     modified = zs->modified;
 216
 217     rhandle = 0;
 218     lhandle = 0;
 219     record_flag = 1;
 220     layers = NULL;
 221   }
 222
 223   seqpat(seqpat* zs, pattern* zp){
 224     p = zp;
 225     p->ref_c++;
 226     track = zs->track;
 227     dur = zs->dur;
 228     tick = zs->tick;
 229     if(p){p->ref_c++;}
 230
 231     skip = p->events;
 232     prev = zs->prev;
 233     next = zs->next;
 234
 235     scrollx = zs->scrollx;
 236     scrolly = zs->scrolly;
 237
 238     selected = zs->selected;
 239     modified = zs->modified;
 240
 241     rhandle=0;
 242     lhandle=0;
 243     record_flag=1;
 244     layers = NULL;
 245   }
 246
 247   ~seqpat(){
 248      if(p){
 249        p->ref_c--;
 250        if(p->ref_c == 0){
 251          delete p;
 252        }
 253      }
 254      if(layers){
 255        layers->ref_c--;
 256        if(layers->ref_c == 0){
 257          delete layers;
 258        }
 259      }
 260    }
 261 };
 262
 263
 264
 265
 266
 267
 268
 269 struct track {
 270   int port;
 271   int chan;
 272   int prog;
 273   int bank;
 274   int mute;
 275   int solo;
 276   int vol;
 277   int pan;
 278   char name[MAX_TRACK_NAME];
 279   int alive;
 280   seqpat* head;
 281   seqpat* skip;
 282
 283   int modified;
 284
 285   void restate();
 286
 287   track(){
 288     port = 0;
 289     chan = 0;
 290     prog = 0;
 291     bank = 0;
 292     mute = 0;
 293     solo = 0;
 294     vol = 127;
 295     pan = 64;
 296     name[0] = '\0';
 297     alive = 1;
 298     head = new seqpat(0,0,0,new pattern());
 299     head->tick = 0;
 300     skip = head;
 301     modified = 0;
 302   }
 303
 304   ~track(){
 305     seqpat* s = head;
 306     seqpat* next;
 307     while(s){
 308       next = s->next;
 309       delete s;
 310       s = next;
 311     }
 312   }
 313 };
 314
 315
 316
 317
 318
 319 template <class T>
 320 void tswap(T* old, T* nu){
 321   nu->next = old->next;
 322   nu->prev = old->prev;
 323
 324   if(old->prev){
 325     old->prev->next = nu; //'atomic'
 326   }
 327   if(old->next){
 328     old->next->prev = nu; //prev ptrs are only read by gui thread
 329   }
 330 }
 331
 332 template <class T>
 333 void tremove(T* old){
 334   if(old->prev){
 335     old->prev->next = old->next; //'atomic'
 336   }
 337   if(old->next){
 338     old->next->prev = old->prev; //prev ptrs are only read by gui thread
 339   }
 340 }
 341
 342 template <class T>
 343 void tinsert(T* targ, T* nu){
 344   nu->prev = targ;
 345   nu->next = targ->next;
 346
 347   targ->next = nu; //'atomic'
 348   if(nu->next){
 349     nu->next->prev = nu; //prev ptrs are only read by gui thread
 350   }
 351 }
 352
 353 template <class T>
 354 T* tfind(T* begin, int tick){
 355   T* ptr = begin;
 356   while(ptr->next){
 357     if(ptr->next->tick > tick){
 358       break;
 359     }
 360     ptr = ptr->next;
 361   }
 362   return ptr;
 363 }
 364
 365 mevent* find_off(mevent* e);
 366
 367
 368 class Command {
 369
 370   public:
 371
 372   virtual void undo() {}
 373   virtual void redo() {}
 374
 375 };
 376
 377 void set_undo(Command* c);
 378 void push_undo(int n);
 379 void do_undo();
 380 void do_redo();
 381
 382 int clear_undos(int number);
 383
 384
 385
 386 class CreateSeqpat : public Command {
 387   protected:
 388     seqpat* s;
 389
 390   public:
 391
 392     CreateSeqpat(){}
 393     CreateSeqpat(int track, int tick, seqpat* zs, int copy);
 394
 395     ~CreateSeqpat(){
 396       if(s->p->ref_c-- == 0){
 397         delete s->p;
 398       }
 399       delete s;
 400     }
 401
 402     void redo();
 403     void undo();
 404 };
 405
 406 class CreateSeqpatBlank : public CreateSeqpat {
 407
 408   public:
 409
 410     CreateSeqpatBlank(int track, int tick, int len);
 411
 412 };
 413
 414
 415 class DeleteSeqpat : public Command {
 416     seqpat* s;
 417
 418   public:
 419
 420     DeleteSeqpat(seqpat* zs){
 421       s = zs;
 422     }
 423
 424     void redo();
 425     void undo();
 426 };
 427
 428 class ResizeSeqpat : public Command {
 429     seqpat* s1;
 430     seqpat* s2;
 431
 432   public:
 433
 434     ResizeSeqpat(seqpat* zs, int dur){
 435       s1 = zs;
 436       s2 = new seqpat(zs);
 437       s2->dur = dur;
 438     }
 439     ~ResizeSeqpat(){
 440       delete s2;
 441     }
 442
 443     void redo();
 444     void undo();
 445 };
 446
 447 class MoveSeqpat : public Command {
 448     seqpat* s;
 449     seqpat *targ1, *targ2;
 450     int track1, track2;
 451     int tick1, tick2;
 452
 453   public:
 454
 455     MoveSeqpat(seqpat* zs, int track, int tick);
 456
 457     void redo();
 458     void undo();
 459 };
 460
 461 class SplitSeqpat : public Command {
 462     seqpat* s;
 463     pattern* p1;
 464     pattern* p2;
 465
 466   public:
 467
 468     SplitSeqpat(seqpat* zs){
 469       s = zs;
 470       p1 = s->p;
 471       p2 = new pattern();
 472       p2->ref_c = 1;
 473     }
 474
 475     SplitSeqpat(){
 476       if(--(p2->ref_c) == 0){
 477         delete p2;
 478       }
 479     }
 480
 481     void redo();
 482     void undo();
 483 };
 484
 485
 486
 487
 488 class CreateNote : public Command {
 489     pattern* p;
 490     mevent* e1;
 491     mevent* e2;
 492
 493   public:
 494
 495     CreateNote(pattern* zp, int note, int vel, int tick, int dur){
 496       p = zp;
 497       e1 = new mevent(MIDI_NOTE_ON, tick, note);
 498       e1->dur = dur;
 499       e1->value2 = vel;
 500       e2 = new mevent(MIDI_NOTE_OFF, tick+dur, note);
 501       e2->value2 = 0;
 502       //e->off = new mevent(MIDI_NOTE_OFF, tick+dur, note);
 503     }
 504     ~CreateNote(){
 505       //delete e->off;
 506       delete e1;
 507       delete e2;
 508     }
 509
 510     void redo();
 511     void undo();
 512 };
 513
 514 class CreateNoteOn : public Command {
 515     pattern* p;
 516     mevent* e1;
 517
 518   public:
 519
 520     CreateNoteOn(pattern* zp, int note, int vel, int tick, int dur){
 521       p = zp;
 522       e1 = new mevent(MIDI_NOTE_ON, tick, note);
 523       e1->value2 = vel;
 524       e1->dur = dur;
 525     }
 526     ~CreateNoteOn(){
 527       delete e1;
 528     }
 529
 530     void redo();
 531     void undo();
 532 };
 533
 534 class CreateNoteOff : public Command {
 535     pattern* p;
 536     mevent* e1;
 537     mevent* e2;
 538
 539     int dur1;
 540     int dur2;
 541
 542   public:
 543
 544     CreateNoteOff(pattern* zp, int note, int vel, int tick);
 545     ~CreateNoteOff(){
 546       delete e2;
 547     }
 548
 549     void redo();
 550     void undo();
 551 };
 552
 553 class DeleteNote : public Command {
 554     pattern* p;
 555     mevent* e1;
 556     mevent* e2;
 557
 558   public:
 559
 560     DeleteNote(pattern* zp, mevent* ze){
 561       p = zp;
 562       e1 = ze;
 563       e2 = find_off(e1);
 564     }
 565
 566     void redo();
 567     void undo();
 568 };
 569
 570 class MoveNote : public Command {
 571     pattern* p;
 572     mevent* e1;
 573     mevent* e2;
 574     int t1;
 575     int t2;
 576     int note1;
 577     int note2;
 578
 579     void arrive(int t);
 580
 581   public:
 582
 583     MoveNote(pattern* zp, mevent* ze, int zt, int znote){
 584       p = zp;
 585       e1 = ze;
 586       e2 = find_off(e1);
 587       note1 = ze->value1;
 588       note2 = znote;
 589       t1 = ze->tick;
 590       t2 = zt;
 591     }
 592
 593     void redo();
 594     void undo();
 595 };
 596
 597
 598 class ResizeNote : public Command {
 599   pattern* p;
 600   mevent* l1;
 601   mevent* l2;
 602   mevent* r1;
 603   mevent* r2;
 604
 605   public:
 606
 607   ResizeNote(pattern* zp, mevent* ze, int dur);
 608   ~ResizeNote(){
 609     delete l2;
 610     delete r2;
 611   }
 612
 613   void redo();
 614   void undo();
 615
 616 };
 617
 618
 619
 620 class CreateEvent : public Command {
 621     pattern* p;
 622     mevent* e;
 623
 624   public:
 625
 626     CreateEvent(pattern* zp, int type, int tick, int value1, int value2){
 627       p = zp;
 628       e = new mevent(type,tick,value1);
 629       e->value2 = value2;
 630       e->prev = tfind<mevent>(zp->events,tick);
 631       e->next = e->prev->next;
 632     }
 633     ~CreateEvent(){
 634       delete e;
 635     }
 636
 637     void redo();
 638     void undo();
 639 };
 640
 641 class DeleteEvent : public Command {
 642     mevent* e;
 643
 644   public:
 645
 646     DeleteEvent(mevent* ze){
 647       e = ze;
 648     }
 649
 650     void redo();
 651     void undo();
 652 };
 653
 654 class ChangeEvent : public Command {
 655     mevent* e1;
 656     mevent* e2;
 657
 658   public:
 659
 660     ChangeEvent(mevent* ze, int zv1, int zv2){
 661       e1 = ze;
 662       e2 = new mevent(ze);
 663       e2->value1 = zv1;
 664       e2->value2 = zv2;
 665     }
 666
 667     void redo();
 668     void undo();
 669 };
 670
 671
 672
 673 int init_seq();
 674
 675 int play_seq(int cur_tick, void (*dispatch_event)(mevent*, int port, int tick));
 676 int set_seq_pos(int new_tick);
 677
 678 void set_rec_track(int t);
 679 int get_rec_track();
 680
 681 int set_default_hsv_value(float v);
 682
 683 void set_undo(Command* c);
 684 void undo_push(int n);
 685 void do_undo();
 686 void do_redo();
 687
 688 void pattern_clear();
 689 void reset_record_flags();
 690
 691
 692 //encodes data in e as a midi event placed in buf
 693 int midi_encode(mevent* e, int chan, unsigned char* buf, size_t* n);
 694
 695 //decodes midi data and creates a new mevent
 696 int midi_decode(char* buf, mevent* e);
 697
 698 #endif