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