MultiMedia/radium/common/nsmtracker.h

   1 /* Copyright 2000 Kjetil S. Matheussen
   2
   3 This program is free software; you can redistribute it and/or
   4 modify it under the terms of the GNU General Public License
   5 as published by the Free Software Foundation; either version 2
   6 of the License, or (at your option) any later version.
   7
   8 This program is distributed in the hope that it will be useful,
   9 but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 GNU General Public License for more details.
  12
  13 You should have received a copy of the GNU General Public License
  14 along with this program; if not, write to the Free Software
  15 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA. */
  16
  17
  18
  19
  20
  21 /******************************************************************
  22   Main header file for the tracker. Each struct often has a source-
  23   file with the same, or nearly the same, name.
  24
  25   Note, the files OS_Visual.h and OS_Semaphores.h are OS spesific
  26   and must be put into their respective directories. The other
  27   OS_*.h files are not.
  28 ******************************************************************/
  29
  30 #ifndef TRACKER_DEFINE
  31 #define TRACKER_DEFINE 1
  32
  33 #ifdef __cplusplus
  34 #  define LANGSPEC "C"
  35 #else
  36 #  define LANGSPEC
  37 #endif
  38
  39
  40 #include <limits.h>
  41 #include <stdint.h>
  42 #include <stdbool.h>
  43 #include "debug_proc.h"
  44 #include "memory_proc.h"
  45 #include "nsmtracker_events.h"
  46 #include "OS_error_proc.h"
  47 #include <OS_Semaphores.h>
  48
  49
  50 /* Unfortunately, AmigaOS has one absolute address that is legal to
  51    read from; 4, which often fools MuForce to not report a faulty
  52    address. By inserting SDB at all 4 offsets, we
  53    never read from 4 if a pointer is NULL.
  54 */
  55 #ifdef SYSBASEDEBUG
  56 #  define SDB int sysbasedebug;
  57 #else
  58 #  define SDB
  59 #endif
  60
  61 /* Next two lines must be placed in its own OS_depend file later. */
  62 typedef uint32_t uint_32;       /* A type that should be 64 bits, but may be 32 if 64 is _really_ slow or 64 is not available. */
  63                            /* uint_32 is allways loaded/saved as 64, and converted to 64 bit if uint_32 is 32 bit. */
  64 #define MAX_UINT32 65534  /* Sqr(max(uint_32))-1 (rounded down)*/
  65
  66 typedef int32_t STime;          /* Time can be negative. */
  67 typedef STime NInt;
  68 #define PFREQ 48000                     /* Subseconds for STime */
  69 //#define PFREQ 1200
  70
  71 #define MAXBLOCKRELTIME 6.0f
  72 #define MINBLOCKRELTIME 0.001f
  73
  74 #include <OS_Visual.h>
  75
  76
  77
  78 #ifdef max
  79 #undef max
  80 #endif
  81
  82 #define max(a,b) (((a)>(b))?(a):(b))
  83
  84 #ifdef min
  85 #undef min
  86 #endif
  87
  88 #define min(a,b) (((a)<(b))?(a):(b))
  89
  90 #ifdef abs
  91 #undef abs
  92 #endif
  93
  94 #define abs(a) ((a)<0?(-(a)):(a))
  95
  96 #define boundaries(a,b,c) (min(max((a),(b)),(c)))
  97
  98
  99 /*********************************************************************
 100         placement.h
 101 *********************************************************************/
 102
 103
 104
 105 struct Placement{
 106         int line;
 107         SDB
 108         uint_32 counter;
 109         uint_32 dividor;
 110 };
 111 typedef struct Placement Place;
 112
 113
 114 /*********************************************************************
 115         list.h
 116 *********************************************************************/
 117
 118
 119 struct ListHeader1{
 120         struct ListHeader1 *next;
 121    SDB
 122         NInt num;
 123 };
 124
 125 struct ListHeader3{
 126         struct ListHeader3 *next;
 127    SDB
 128         Place p;
 129 };
 130
 131 #define Tline l.p.line
 132 #define Tcounter l.p.counter
 133 #define Tdividor l.p.dividor
 134
 135
 136 struct ListHeaderP{
 137         struct ListHeaderP *next;
 138    SDB
 139         STime time;
 140 };
 141
 142
 143 /*********************************************************************
 144         velocities.h
 145 *********************************************************************/
 146
 147
 148
 149 struct Velocities{
 150         struct ListHeader3 l;
 151
 152         int velocity;
 153 };
 154 #define NextVelocity(a) ((struct Velocities *)((a)->l.next))
 155
 156
 157
 158 /*********************************************************************
 159         notes.h
 160 *********************************************************************/
 161
 162
 163 struct Notes{
 164         struct ListHeader3 l;
 165
 166         int note;
 167         int cents;
 168         int velocity;
 169
 170         Place end;
 171         int velocity_end;
 172
 173         struct Velocities *velocities;
 174
 175         int noend;
 176 };
 177 #define NextNote(a) ((struct Notes *)((a)->l.next))
 178
 179
 180
 181 /*********************************************************************
 182         patch.h
 183 *********************************************************************/
 184
 185 struct Tracks;
 186
 187 struct Patch{
 188         struct ListHeader1 l;
 189         char *name;
 190         int minvel;
 191         int maxvel;
 192         int standardvel;
 193         void (*playnote)(int notenum,int velocity,struct Tracks *track,struct Notes *note);
 194         void (*changevelocity)(int velocity,struct Tracks *track,struct Notes *note);
 195         void (*stopnote)(int notenum,int velocity,struct Tracks *track,struct Notes *note);
 196         void (*closePatch)(void);
 197
 198         void *patchdata;                // Free use by the instrument plug-in.
 199
 200         void (*changeTrackPan)(int newpan,struct Tracks *track);
 201 };
 202 #define PATCH_FAILED 0
 203 #define PATCH_SUCCESS 1
 204 #define NextPatch(a) ((struct Patch *)((a)->l.next))
 205
 206 /*********************************************************************
 207         fx.h
 208 *********************************************************************/
 209
 210
 211 struct FX{
 212         struct ListHeader1 l;
 213         char *name;
 214         int color;
 215         void (*configureFX)(struct FX *fx,struct Tracks *track);
 216         int min;
 217         int max;
 218         void (*treatFX)(struct FX *fx,int val,struct Tracks *track,int skip);
 219         void (*closeFX)(struct FX *fx,struct Tracks *track);
 220         void *fxdata;   //Free use for the instrument plug-in.
 221         void (*SaveFX)(struct FX *fx,struct Tracks *track);
 222 };
 223 #define FX_FAILED 0
 224 #define FX_SUCCESS 1
 225
 226
 227 /*********************************************************************
 228         instruments.h
 229 *********************************************************************/
 230
 231 struct Tracker_Windows;
 232 struct Instruments{
 233         struct ListHeader1 l;
 234
 235         struct Patch *patches;
 236
 237         char *instrumentname;
 238         int (*getMaxVelocity)(struct Tracks *track);
 239         int (*getFX)(struct Tracker_Windows *window,struct Tracks *track,struct FX *fx);
 240         int (*getPatch)(struct Tracker_Windows *window,ReqType reqtype,struct Tracks *track,struct Patch *patch);
 241         void (*treatSpecialCommand)(char *command,struct Tracks *track);
 242         void (*CloseInstrument)(struct Instruments *instrument);
 243         void (*SelectTrackInstrument)(struct Tracks *track,struct Instruments *instrument);
 244         void (*StopPlaying)(struct Instruments *instrument);
 245         int (*getStandardVelocity)(struct Tracks *track);
 246         void (*PP_Update)(struct Instruments *instrument,struct Patch *patch);
 247         void *(*CopyInstrumentData)(struct Tracks *track);              //Necesarry for undo.
 248
 249         void (*PlayFromStartHook)(struct Instruments *instrument);
 250
 251         void *(*LoadFX)(struct FX *fx,struct Tracks *track);
 252 };
 253 #define INSTRUMENT_FAILED 0
 254 #define INSTRUMENT_SUCCESS 1
 255 #define NextInstrument(a) ((struct Instruments *)((a)->l.next))
 256
 257
 258
 259 /*********************************************************************
 260         stops.h
 261 *********************************************************************/
 262
 263
 264 struct Stops{
 265         struct ListHeader3 l;
 266 };
 267 #define NextStop(a) ((struct Stops *)((a)->l.next))
 268
 269
 270
 271 /*********************************************************************
 272         fxnodelines.h
 273 *********************************************************************/
 274
 275
 276 struct FXNodeLines{
 277         struct ListHeader3 l;
 278         int val;
 279 };
 280 #define NextFXNodeLine(a) ((struct FXNodeLines *)((a)->l.next))
 281
 282
 283 struct FXs{
 284         struct ListHeader1 l;   /* l.num=fxnum */
 285         struct FX *fx;
 286         struct FXNodeLines *fxnodelines;
 287 };
 288 #define NextFX(a) ((struct FXs *)((a)->l.next))
 289
 290
 291
 292 /*********************************************************************
 293         tracks.h
 294 *********************************************************************/
 295 struct Tracks{
 296         struct ListHeader1 l;
 297
 298         struct Notes *notes;
 299         struct Stops *stops;
 300         int onoff;                                                      /* 1=on, 0=off */
 301         int relvol;
 302
 303         char *trackname;
 304         struct Instruments *instrument; /* Only referenced. */
 305         struct Patch *patch;
 306         struct FXs *fxs;
 307
 308         void *instrumentdata;                   /* Free use for the instrument plug-in. */
 309
 310         int pan;
 311         int volume;
 312
 313         bool panonoff;
 314         bool volumeonoff;
 315 };
 316 #define NextTrack(a) (struct Tracks *)((a)->l.next)
 317
 318 #define MAXTRACKVOL 1000
 319 #define MAXTRACKPAN 1000
 320
 321 /*********************************************************************
 322         area.h
 323 *********************************************************************/
 324
 325
 326
 327 typedef struct{
 328         int x,x2;
 329 }Area;
 330
 331 typedef struct{
 332         int y,y2;
 333 }YArea;
 334
 335 typedef struct{
 336         int width;
 337         int x,x2;
 338 }WArea;
 339
 340
 341 /*********************************************************************
 342         trackreallines.h
 343 *********************************************************************/
 344
 345
 346
 347 struct TrackReallineElements{
 348         struct TrackReallineElements *next;
 349    SDB
 350         int type;
 351         int subtype;
 352         int y1,y2;
 353         int x1,x2;
 354         void *pointer;                                                                  /* Only referenced. */
 355 };
 356 /************* Types: */
 357 #define TRE_THISNOTELINES 0
 358 #define TRE_VELLINECENTS 0x5
 359 #define TRE_VELLINENODE 0x10
 360 #define TRE_VELLINE 0x20
 361 #define TRE_VELLINESTART 0x30
 362 #define TRE_VELLINEEND 0x40
 363 #define TRE_STOPLINE 0x90
 364 #define TRE_REALSTARTSTOP 0xa0
 365
 366 /* Subtype for 0-0x40 is
 367    the same as subtrack for the note.
 368 */
 369
 370
 371 struct TrackRealline{
 372         int note;                                                                               /* Is 0 if no note. */
 373    SDB
 374         struct TrackReallineElements *trackreallineelements;
 375 };
 376 #define NOTE_MUL 128
 377 #define NOTE_STP 129
 378 #define NOTE_MUR 130
 379
 380 /*********************************************************************
 381         wfxnodes.h
 382 *********************************************************************/
 383
 384
 385 typedef struct TrackReallineElements WFXNodes;
 386 /*
 387 struct WFXNodes{
 388         struct WFXNodes *next;
 389    SDB
 390         unsigned char type;
 391         unsigned char subtype;                                          // not used.
 392         unsigned char y1,y2;
 393         unsigned short x1,x2;
 394         void *pointer;                                                                  // Only referenced.
 395 };
 396 */
 397 /************* Types: */
 398 #define TRE_FXNODE 0x50
 399 #define TRE_FXLINE 0x60
 400
 401
 402 /*********************************************************************
 403         tbox.h
 404 *********************************************************************/
 405 struct TBoxstruct{
 406         int x1,y1,x2,y2;
 407 };
 408 typedef struct TBoxstruct TBox;
 409
 410
 411 /*********************************************************************
 412         wtracks.h
 413 *********************************************************************/
 414
 415 struct WTracks{
 416         struct ListHeader1 l;
 417 //      l.num=wtracknum;
 418
 419         int x,y,x2,y2;                                          /* GFX area. */
 420
 421         int notesonoff;                                 /* notearea and placementarea on/off. */
 422         int notelength;                                 /* Number of characters the notes is. Usually 2 or 3. */
 423         Area notearea;                                          /* These are all parts of the GFX area. */
 424         int fxonoff;                                            /* FX area on/off */
 425         int fxwidth;                                            /* is fxarea.x2-fxarea.x */
 426         Area fxarea;
 427
 428         int l_num_vel;                                          /* Last drawn number of velocity lines showed sim. */
 429         int num_vel;                                            /* Max number of velocity lines showed simultaniously. */
 430
 431         struct Tracks *track;                   /* Only referenced. wtracknum=track->tracknum */
 432
 433         struct TrackRealline *trackreallines;
 434         WFXNodes **wfxnodes;
 435
 436         TBox pan;
 437         TBox volume;
 438
 439         TBox panonoff;
 440         TBox volumeonoff;
 441
 442 };
 443 #define NextWTrack(a) ((struct WTracks *)((a)->l.next))
 444
 445
 446
 447 /*********************************************************************
 448         lpb.h
 449 *********************************************************************/
 450
 451
 452 struct LPBs{
 453         struct ListHeader3 l;
 454         int lpb;
 455 };
 456 #define NextLPB(a) (struct LPBs *)((a)->l.next)
 457
 458 struct WLPBs{
 459         int lpb;
 460         int type;                                       /* 0=normal, 1=below positioned, 2=mul. */
 461
 462         struct LPBs *LPB;                       /* Only referenced. */
 463 };
 464 #define LPB_NORMAL 0
 465 #define LPB_BELOW 1
 466 #define LPB_MUL 2
 467
 468
 469
 470 /*********************************************************************
 471         tempos.h
 472 *********************************************************************/
 473
 474
 475 struct Tempos{
 476         struct ListHeader3 l;
 477         int tempo;
 478 };
 479 #define NextTempo(a) (struct Tempos *)((a)->l.next)
 480
 481 struct WTempos{
 482         int tempo;
 483         int type;                                                       /* 0=normal, 1=below positioned, 2=mul. */
 484    SDB
 485         struct Tempos *Tempo;                   /* Only referenced. */
 486 };
 487 /* Types */
 488 #define TEMPO_NORMAL 0
 489 #define TEMPO_BELOW 1
 490 #define TEMPO_MUL 2
 491
 492
 493
 494 /*********************************************************************
 495         temponodes.h
 496 *********************************************************************/
 497
 498
 499
 500 struct TempoNodes{
 501         struct ListHeader3 l;
 502         float reltempo;
 503 };
 504 #define NextTempoNode(a) ((struct TempoNodes *)((a)->l.next))
 505
 506 typedef struct TrackReallineElements WTempoNodes;
 507 /*
 508 struct WTempoNodes{
 509         struct WTempoNodes *next;
 510         unsigned char type;
 511         unsigned char subtype;                  // Currently not used.
 512         unsigned char y1,y2;
 513         unsigned short x1,x2;
 514
 515         void *temponode;        // Only referenced.
 516 };
 517 */
 518 /* Types */
 519 #define TEMPONODE_NODE 0
 520 #define TEMPONODE_LINE 1
 521
 522
 523 /*********************************************************************
 524         time.h
 525 *********************************************************************/
 526
 527 struct STimeChanges{
 528         struct ListHeader3 l;
 529         STime time;
 530
 531         float tempo1;                   // tempo (tempo*lpb) at this->l.p
 532         float rel;                              // reltempo for this->l.p
 533         float deltarel;         // rel+deltarel is reltempo for this->l.next->l.p
 534 };
 535 #define NextSTimeChange(a) (struct STimeChanges *)((a)->l.next)
 536
 537
 538 struct STimes{                                                                  /* One element for each line. */
 539         STime time;                                                                     /* Start-time for the line. */
 540    SDB
 541         struct STimeChanges *timechanges;
 542 };
 543
 544
 545 /*********************************************************************
 546         blocks.h
 547 *********************************************************************/
 548
 549
 550 struct Blocks{
 551         struct ListHeader1 l;
 552
 553         char *name;
 554
 555         NInt num_tracks;
 556         int num_lines;
 557
 558         struct Tracks *tracks;
 559         struct LPBs   *lpbs;
 560         struct Tempos *tempos;
 561         struct TempoNodes *temponodes;
 562         struct TempoNodes *lasttemponode;
 563
 564         struct STimes *times;                   /* Pointer to array. Last element (times[num_lines]) is the playtime of the block. */
 565
 566         float reltempo;                                 /* factor that the tempo is multiplied with when playing this block. */
 567
 568 };
 569 #define NextBlock(a) (struct Blocks *)((a)->l.next)
 570
 571
 572
 573 /*********************************************************************
 574         localzooms.h
 575 *********************************************************************/
 576
 577
 578 struct LocalZooms{
 579         struct ListHeader3 l;
 580 //      struct LocalZooms *next;                /* Next on the same level. */
 581 //      int line;                                                       /* The same type of line that note has. */
 582 //      uint_32 counter;                                        /* Same type of counter that line has. */
 583 //      uint_32 dividor;                                        /* Same type of dividor that line has. */
 584
 585         int zoomline;                                           /* The linetype that is showed in the editor. */
 586         int level;
 587         int realline;
 588
 589         struct LocalZooms *uplevel;     /* Contains 'num_newlines' # of elements. */
 590 };
 591 #define NextLocalZoom(a) ((struct LocalZooms *)((a)->l.next))
 592
 593
 594
 595 /*********************************************************************
 596         wblocks.h
 597 *********************************************************************/
 598
 599
 600 struct WBlocks{
 601         struct ListHeader1 l;
 602
 603         int tempotrackonoff;                            /* 1=on, 0=off */
 604         int temponodetrackonoff;                /* 1=on, 0=off */
 605
 606         TBox a;
 607 //      int x,y,x2,y2;                                          /* GFX area. */
 608
 609         TBox t;
 610 //      int tx,ty,tx2,ty2;                              /* lines, nodes, etc. GFX area. */
 611
 612         WArea zoomlevelarea;
 613         WArea linenumarea;
 614         WArea lpbTypearea;
 615         WArea lpbarea;
 616         WArea tempoTypearea;
 617         WArea tempoarea;
 618         WArea temponodearea;
 619
 620         YArea linearea;
 621
 622         int maxwtracksize;                                      /* The size of the widest wtrack. */
 623
 624         int num_visiblelines;
 625
 626         int top_realline;
 627
 628         int curr_realline;
 629         int till_curr_realline;                         /* The player-routine sets this on. */
 630
 631         int bot_realline;
 632
 633         struct Blocks *block;                   /* Only referenced. wblocknum=block->blocknum */
 634
 635         struct LocalZooms *localzooms;
 636         struct LocalZooms **reallines;
 637         int num_reallines;
 638         int num_reallines_last;
 639
 640         struct WTracks *wtracks;
 641         struct WTracks *wtrack;                 /* Current track. Only referenced. */
 642
 643         char *title;                                            /* Window title. */
 644
 645         NInt left_track;                                        /* The leftmost visible track. */
 646         int left_subtrack;
 647         NInt right_track;                                       /* The rightmost visible track. */
 648         int right_subtrack;
 649
 650         struct WTempos *wtempos;
 651         WTempoNodes **wtemponodes;
 652         struct WLPBs *wlpbs;
 653         float reltempomax;
 654
 655         bool isranged;
 656         NInt rangex1;
 657         NInt rangex2;
 658         NInt rangey1;
 659         NInt rangey2;
 660
 661         bool isgfxdatahere;
 662
 663         TBox reltempo;
 664
 665 };
 666 #define NextWBlock(a) (struct WBlocks *)((a)->l.next)
 667
 668
 669
 670 /*********************************************************************
 671         slider.h
 672 *********************************************************************/
 673
 674
 675 struct Slider{
 676         int show;
 677         int width;
 678         int x,x2;
 679         int lx,lx2;
 680 };
 681
 682
 683 /*********************************************************************
 684        blts.h
 685 ********************************************************************/
 686
 687 typedef struct{
 688
 689   /* Used by Blt_blt Blt_mark */
 690   bool blt_do;
 691   int x1;int x2;
 692   int startrealline;
 693   int endrealline;
 694
 695   /* Used by Blt_clearNotUsedVisible and Blt_markVisible */
 696   bool clear_do;
 697   int v_x1;int v_x2;
 698   int v_y1;int v_y2;
 699 }Blt;
 700
 701
 702 /*********************************************************************
 703         windows.h
 704 *********************************************************************/
 705 #include "mouse.h"
 706
 707 struct Tracker_Windows{
 708         struct ListHeader1 l;
 709
 710         struct OS_visual *os_visual;
 711         int x,y;                                                                /* Where window is placed. (for amiga: screen-pos)*/
 712         int width,height;                                       /* Size of area to use. */
 713         char *fontname;
 714         int fontID;                                                     /* System spesific. For amiga: fontsize. */
 715         int fontTags;                                           /* System spesific. For amiga: nothing. */
 716         int fontwidth,fontheight;               /* Proportional fonts not so very allowed. */
 717
 718         NInt curr_track;
 719         int curr_track_sub;                             /* -1=note, 0,1,2,...,n=vel */
 720         NInt curr_block;
 721
 722         int maxwtracksize;                                      /* The size of the widest wtrack for all wblocks. */
 723
 724         struct Slider bottomslider;
 725         struct Slider leftslider;
 726         struct Slider rightslider;
 727         TBox resizebox;
 728
 729         bool playalong;                                 /* If true, this window allso shows whats being played
 730                                                                                            if any other window is playing. default=true. */
 731
 732         struct WBlocks *wblock;                 /* Current wblock. Only referenced. */
 733         struct WBlocks *wblocks;
 734
 735         struct TEventFIFO *TELroot;
 736         struct TEventFIFO *TELlast;
 737         uint32_t event_treat;           /* Chooses which event type(s) to treat. (0=all)*/
 738         int dontbuffer;
 739
 740         struct MouseAction curraction;
 741         struct MouseAction prevaction;
 742
 743         int org_fontheight;
 744         char *h_fontname;
 745         int h_fontID;                                                   /* System spesific. For amiga: fontsize. */
 746         int h_fontTags;                                         /* System spesific. For amiga: nothing. */
 747         int h_fontwidth;
 748
 749         bool textborder;
 750
 751         int minnodesize;
 752
 753   int num_pixmapdefs;
 754   int *pixmapdefs;
 755   int *pixmapdefs_calc;
 756
 757   Blt blt;
 758 };
 759 #define NextWindow(a) (struct Tracker_Windows *)((a)->l.next)
 760
 761 /* curr_track types */
 762 #define TEMPONODETRACK -1
 763 #define TEMPOTRACK -2
 764 #define LPBTRACK -3
 765 #define LINENUMBTRACK -4
 766
 767
 768 /*********************************************************************
 769         song.h
 770 *********************************************************************/
 771
 772
 773 struct Song{
 774         struct Tracker_Windows *tracker_windows;
 775         struct Blocks *blocks;
 776         struct Blocks **playlist;                       /* This variable is just temporarily. Later, the playlist will be much more advanced. */
 777         struct Instruments *instruments;
 778
 779         NInt num_blocks;
 780         int length;                                                             /* Playlist length. */
 781         char *songname;
 782
 783         NInt maxtracks;                                         /* The highest number of tracks in a block. (changed when exceeding) */
 784 };
 785
 786
 787
 788 /*********************************************************************
 789         root.h
 790 *********************************************************************/
 791
 792
 793 struct Root{
 794         struct Song *song;
 795         struct Instruments *def_instrument; /* Default instrument. */
 796
 797
 798         int curr_playlist;
 799         NInt curr_block;
 800
 801         bool setfirstpos;
 802
 803         int clearall;
 804
 805         int tempo;                      /* Standard tempo. */
 806         int lpb;                                /* Standard lpb. */
 807
 808         float quantitize;
 809         int keyoct;
 810         int standardvel;
 811
 812         bool editonoff;
 813         bool scrollplayonoff;
 814 };
 815
 816 #endif
 817
 818
 819
 820
 821
 822
 823
 824
 825
 826
 827