/* $eterna: punk-kin-midi.h,v 1.23 2015/03/24 06:22:44 mrg Exp $ */ /* * Copyright (c) 2014, 2015 Matthew R. Green * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #ifndef MRG_MIDI_PUNK_KIN_MIDI_H #define MRG_MIDI_PUNK_KIN_MIDI_H /* midi stuff for "punk kin" */ /* * 24 notes per beat. we want 8th and then also 3rds of some sort which * demands that we have 24 notes per beat. * * we put the delta afterwards as it's more natural to think about how long * this event is, than how long the previous event took. */ #define NOTES_PER_BEAT (24) #define TEMPO (120) #define NTRACKS (1) #define HDR MRG_MIDI_HEADER(NTRACKS,NOTES_PER_BEAT,TEMPO) #define NOTES_PER_BAR ((NOTES_PER_BEAT) * 4) /* * main synth (*s1) -- runs almost the entire time. * * we start off with just two C's, held for a while (16 bars) but * we change the cutoff1 and cutoff2 values. * P1/P2 - 1/2 bars. TE*() takes on/off delay. */ #define CCVOL(val) CCMSG(0, MICROKORG_XL_AMP_LEVEL, val) #define CCMOD(val) CCMSG(0, MICROKORG_XL_MOD_DEPTH, val) #define CCPAN(val) CCMSG(0, MICROKORG_XL_AMP_PANPOT, val) #define CCATK1(val) CCMSG(0, MICROKORG_XL_EG1_ATTACK, val) // note, delay after on/off #define PMON(c,d) 0x90, c, 0x7f, d #define PMOFF(c,d) 0x80, c, 0x7f, d #define PMX(c,d1,d2) PMON(c,d1), PMOFF(c,d2) #define PM0(x) 0x80, 0, 0, x // note, delay after on/off, pressure #define PMPON(c,d,p) 0x90, c, p, d #define PMPOFF(c,d,p) 0x80, c, p, d // note, delay after on, delay after off, pressure on, pressure off #define PMPX(c,d1,d2,p1,p2) \ PMPON(c,d1,p1), PMPOFF(c,d2,p2) // this version auto-inserts NOTES_BAR_END delays #define PMPXE(c,d1,d2,p1,p2) \ PMPON(c,(d1-NOTES_BAR_END),p1), \ PMPOFF(c,(d2+NOTES_BAR_END),p2) #define P1 \ PM0(NOTES_PER_BAR) #define P2 \ P1, P1 #define P3 \ P1, P1, P1 #define P4 \ P2, P2 #define P8 \ P4, P4 /* p bars of two notes */ #define PM2_NBAR(p,n1,n2) \ PMON(n1,0), PMON(n2,0), \ p, \ PMOFF(n1,0), PMOFF(n2,0) /* one bar of two notes */ #define PM2_1BAR(n1,n2) \ PM2_NBAR(P1,n1,n2) #define PM2_2BAR(n1,n2) \ PM2_NBAR(P2,n1,n2) #define PM2_4BAR(n1,n2) \ PM2_NBAR(P4,n1,n2) #define PM1_8BAR(n) \ PMON(n,0), \ P4, P4, \ PMOFF(n,0) #define PM2_8BAR(n1,n2) \ PM2_NBAR(P8,n1,n2) /* * MOD ideas: * * 1 - fast from high to low, once a beat. * 1a - almost instantly in the first couple of notes * 1b - once every two beats. * 2 - fast local movements (10-20 apart), several beats long with * moving to a new locality (eg, high to low, lwo to mid). * 3 - slow local movements (10-10 apart), with the base shifting * up for several bars, and then down again. * 4 - droning up and down with different intervals: * 4a - 2 beats? * 4b - 1 bar * 4c - 2 bars * 4d - 4 bars */ #if NOTES_PER_BEAT < 8 # error "NOTES_PER_BEAT needs to be a multiple of 8" #endif #define BEAT1_MOD_OP(x, y, op) \ CCMOD((x) op ((y)*0)), PM0(NOTES_PER_BEAT/8), \ CCMOD((x) op ((y)*1)), PM0(NOTES_PER_BEAT/8), \ CCMOD((x) op ((y)*2)), PM0(NOTES_PER_BEAT/8), \ CCMOD((x) op ((y)*3)), PM0(NOTES_PER_BEAT/8), \ CCMOD((x) op ((y)*4)), PM0(NOTES_PER_BEAT/8), \ CCMOD((x) op ((y)*5)), PM0(NOTES_PER_BEAT/8), \ CCMOD((x) op ((y)*6)), PM0(NOTES_PER_BEAT/8), \ CCMOD((x) op ((y)*7)), PM0(NOTES_PER_BEAT/8) #define BEAT1_MOD_FAST_OP(x, y, op) \ CCMOD((x) op ((y)*1)), PM0(NOTES_PER_BEAT/8), \ CCMOD((x) op ((y)*4)), PM0(NOTES_PER_BEAT/8), \ CCMOD((x) op ((y)*7)), PM0(NOTES_PER_BEAT/8), \ CCMOD((x) op ((y)*7)), PM0(NOTES_PER_BEAT/8), \ CCMOD((x) op ((y)*7)), PM0(NOTES_PER_BEAT/8), \ CCMOD((x) op ((y)*7)), PM0(NOTES_PER_BEAT/8), \ CCMOD((x) op ((y)*7)), PM0(NOTES_PER_BEAT/8), \ CCMOD((x) op ((y)*7)), PM0(NOTES_PER_BEAT/8) #define BEAT1_MOD_FALL(x, y) \ BEAT1_MOD_OP(x, y, -) #define BEAT1_MOD_RISE(x, y) \ BEAT1_MOD_OP(x, y, +) #define BEAT1_MOD_FAST_FALL(x, y) \ BEAT1_MOD_FAST_OP(x, y, -) #define BEAT1_MOD_FAST_RISE(x, y) \ BEAT1_MOD_FAST_OP(x, y, +) #define BAR1_MOD_FALL(x, y) \ BEAT1_MOD_FALL((x)+(NOTES_PER_BEAT*0), y), \ BEAT1_MOD_FALL((x)+(NOTES_PER_BEAT*1), y), \ BEAT1_MOD_FALL((x)+(NOTES_PER_BEAT*2), y), \ BEAT1_MOD_FALL((x)+(NOTES_PER_BEAT*3), y) #define BAR1_MOD_RISE(x, y) \ BEAT1_MOD_RISE((x)+(NOTES_PER_BEAT*0), y), \ BEAT1_MOD_RISE((x)+(NOTES_PER_BEAT*1), y), \ BEAT1_MOD_RISE((x)+(NOTES_PER_BEAT*2), y), \ BEAT1_MOD_RISE((x)+(NOTES_PER_BEAT*3), y) #define BEAT1_MOD_JIGGLE_FAST_ALL(x, a1, a2, a3, a4, a5, a6, a7, a8) \ CCMOD((x) + (a1)), PM0(NOTES_PER_BEAT/8), \ CCMOD((x) + (a2)), PM0(NOTES_PER_BEAT/8), \ CCMOD((x) + (a3)), PM0(NOTES_PER_BEAT/8), \ CCMOD((x) + (a4)), PM0(NOTES_PER_BEAT/8), \ CCMOD((x) + (a5)), PM0(NOTES_PER_BEAT/8), \ CCMOD((x) + (a6)), PM0(NOTES_PER_BEAT/8), \ CCMOD((x) + (a7)), PM0(NOTES_PER_BEAT/8), \ CCMOD((x) + (a8)), PM0(NOTES_PER_BEAT/8) #define BEAT1_MOD_JIGGLE_FAST1(x) \ BEAT1_MOD_JIGGLE_FAST_ALL(x, 0, 15, -15, -7, 15, 0, -12, -3) #define BEAT1_MOD_JIGGLE_FAST2(x) \ BEAT1_MOD_JIGGLE_FAST_ALL(x, 0, -15, -15, -12, 5, -13, -15, 15) #define BEAT1_MOD_JIGGLE_FAST3(x) \ BEAT1_MOD_JIGGLE_FAST_ALL(x, 0, 3, -15, -14, -15, 6, -13, 7) #define BEAT1_MOD_JIGGLE_FAST4(x) \ BEAT1_MOD_JIGGLE_FAST_ALL(x, 0, -5, -15, -7, 14, -14, 0, -4) #define BAR1_MOD_JIGGLE_SLOW_ALL(x, a1, a2, a3, a4) \ CCMOD((x) + (a1)), PM0(NOTES_PER_BEAT), \ CCMOD((x) + (a2)), PM0(NOTES_PER_BEAT), \ CCMOD((x) + (a3)), PM0(NOTES_PER_BEAT), \ CCMOD((x) + (a4)), PM0(NOTES_PER_BEAT) #define BAR1_MOD_JIGGLE_SLOW1(x) \ BAR1_MOD_JIGGLE_SLOW_ALL(x, 0, -15, 15, -12) #define BAR1_MOD_JIGGLE_SLOW2(x) \ BAR1_MOD_JIGGLE_SLOW_ALL(x, 0, 12, -11, 15) #define BAR1_MOD_JIGGLE_SLOW3(x) \ BAR1_MOD_JIGGLE_SLOW_ALL(x, 0, 3, -15, -14) #define BAR1_MOD_JIGGLE_SLOW4(x) \ BAR1_MOD_JIGGLE_SLOW_ALL(x, 0, -5, -15, 7) /* mod 1 */ #define BAR1_MOD1_RISE_FALL \ BEAT1_MOD_RISE(0, 18), \ BEAT1_MOD_FALL(127, 18), \ BEAT1_MOD_RISE(0, 18), \ BEAT1_MOD_FALL(127, 18) /* mod 1a */ #define BAR1_MOD1a_INS \ BEAT1_MOD_FAST_RISE(0, 18), \ BEAT1_MOD_FAST_FALL(127, 18), \ BEAT1_MOD_FAST_RISE(0, 18), \ BEAT1_MOD_FAST_FALL(127, 18) #define BAR2_MOD1a_INS \ BAR1_MOD1a_INS, BAR1_MOD1a_INS #define BAR8_MOD1a_INS \ BAR2_MOD1a_INS, BAR2_MOD1a_INS, BAR2_MOD1a_INS, BAR2_MOD1a_INS #define BAR8_MOD1a_B3 \ PM2_NBAR(BAR8_MOD1a_INS,B3,Fsh4) #define BAR8_MOD1a_A3 \ PM2_NBAR(BAR8_MOD1a_INS,A3,E4) #define BAR2_MOD1a_3Fsh3 \ PM2_NBAR(BAR2_MOD1a_INS, Fsh3, Csh4) #define BAR2_MOD1a_3D3 \ PM2_NBAR(BAR2_MOD1a_INS, D3, A3) /* mod 1b */ #define BAR1_MOD1b \ BEAT1_MOD_RISE(0, 9), \ BEAT1_MOD_RISE(64, 9), \ BEAT1_MOD_FALL(127, 9), \ BEAT1_MOD_FALL(64, 9) #define BAR1_MOD1b_INS \ BAR1_MOD1b #define BAR2_MOD1b_INS \ BAR1_MOD1b, BAR1_MOD1b #define BAR8_MOD1b_INS \ BAR2_MOD1b_INS, BAR2_MOD1b_INS, BAR2_MOD1b_INS, BAR2_MOD1b_INS #define BAR8_MOD1b_B3 \ PM2_NBAR(BAR8_MOD1b_INS, B3, Fsh4) #define BAR8_MOD1b_A3 \ PM2_NBAR(BAR8_MOD1b_INS, A3, E4) #define BAR2_MOD1b_3Fsh3 \ PM2_NBAR(BAR2_MOD1b_INS, Fsh3, Csh4) #define BAR2_MOD1b_3D3 \ PM2_NBAR(BAR2_MOD1b_INS, D3, A3) #define BAR1_MOD1a_Fsh3 \ PM2_NBAR(BAR1_MOD1a_INS, Fsh3, Csh4) #define BAR1_MOD1a_D3 \ PM2_NBAR(BAR1_MOD1a_INS, D3, A3) #define BAR1_MOD1b_Fsh3 \ PM2_NBAR(BAR1_MOD1b_INS, Fsh3, Csh4) #define BAR1_MOD1b_D3 \ PM2_NBAR(BAR1_MOD1b_INS, D3, A3) /* mod 2 */ #define BAR1_MOD2_J1(x) \ BEAT1_MOD_JIGGLE_FAST1(x), BEAT1_MOD_JIGGLE_FAST2(x), \ BEAT1_MOD_JIGGLE_FAST3(x), BEAT1_MOD_JIGGLE_FAST4(x) #define BAR1_MOD2_J2(x) \ BEAT1_MOD_JIGGLE_FAST4(x), BEAT1_MOD_JIGGLE_FAST1(x), \ BEAT1_MOD_JIGGLE_FAST3(x), BEAT1_MOD_JIGGLE_FAST2(x) #define BAR1_MOD2_J3(x) \ BEAT1_MOD_JIGGLE_FAST3(x), BEAT1_MOD_JIGGLE_FAST2(x), \ BEAT1_MOD_JIGGLE_FAST4(x), BEAT1_MOD_JIGGLE_FAST1(x) #define BAR1_MOD2_J4(x) \ BEAT1_MOD_JIGGLE_FAST2(x), BEAT1_MOD_JIGGLE_FAST3(x), \ BEAT1_MOD_JIGGLE_FAST1(x), BEAT1_MOD_JIGGLE_FAST4(x) #define BAR1_MOD2a_J1_INS \ BAR1_MOD2_J1(16) #define BAR1_MOD2a_J2_INS \ BAR1_MOD2_J2(16) #define BAR1_MOD2a_J3_INS \ BAR1_MOD2_J3(16) #define BAR1_MOD2a_J4_INS \ BAR1_MOD2_J4(16) #define BAR2_MOD2a_INS \ BAR1_MOD2_J1(16), \ BAR1_MOD2_J2(112) #define BAR2_MOD2b_INS \ BAR1_MOD2_J1(112), \ BAR1_MOD2_J2(64) #define BAR8_MOD2_INS \ BAR1_MOD2_J1(16), \ BAR1_MOD2_J2(112), \ BAR1_MOD2_J1(112), \ BAR1_MOD2_J3(112), \ BAR1_MOD2_J4(112), \ BAR1_MOD2_J4(64), \ BAR1_MOD2_J2(64), \ BAR1_MOD2_J3(16) #define BAR8_MOD2_B3 \ PM2_NBAR(BAR8_MOD2_INS, B3, Fsh4) #define BAR8_MOD2_A3 \ PM2_NBAR(BAR8_MOD2_INS, A3, E4) #define BAR2_MOD2a_3Fsh3 \ PM2_NBAR(BAR2_MOD2a_INS, Fsh3, Csh4) #define BAR2_MOD2a_3D3 \ PM2_NBAR(BAR2_MOD2a_INS, D3, A3) #define BAR2_MOD2b_3Fsh3 \ PM2_NBAR(BAR2_MOD2b_INS, Fsh3, Csh4) #define BAR2_MOD2b_3D3 \ PM2_NBAR(BAR2_MOD2b_INS, D3, A3) #define BAR1_MOD2a_J1_Fsh3 \ PM2_NBAR(BAR1_MOD2a_J1_INS, Fsh3, Csh4) #define BAR1_MOD2a_J1_D3 \ PM2_NBAR(BAR1_MOD2a_J1_INS, D3, A3) #define BAR1_MOD2a_J2_Fsh3 \ PM2_NBAR(BAR1_MOD2a_J2_INS, Fsh3, Csh4) #define BAR1_MOD2a_J2_D3 \ PM2_NBAR(BAR1_MOD2a_J2_INS, D3, A3) #define BAR1_MOD2a_J3_Fsh3 \ PM2_NBAR(BAR1_MOD2a_J3_INS, Fsh3, Csh4) #define BAR1_MOD2a_J3_D3 \ PM2_NBAR(BAR1_MOD2a_J3_INS, D3, A3) #define BAR1_MOD2a_J4_Fsh3 \ PM2_NBAR(BAR1_MOD2a_J4_INS, Fsh3, Csh4) #define BAR1_MOD2a_J4_D3 \ PM2_NBAR(BAR1_MOD2a_J4_INS, D3, A3) /* mod 3 */ #define BAR4_MOD3_INSa \ BAR1_MOD_JIGGLE_SLOW1(16), \ BAR1_MOD_JIGGLE_SLOW2(48), \ BAR1_MOD_JIGGLE_SLOW1(80), \ BAR1_MOD_JIGGLE_SLOW3(112) #define BAR8_MOD3_INSa \ BAR1_MOD_JIGGLE_SLOW1(16), \ BAR1_MOD_JIGGLE_SLOW2(48), \ BAR1_MOD_JIGGLE_SLOW1(80), \ BAR1_MOD_JIGGLE_SLOW3(112), \ BAR1_MOD_JIGGLE_SLOW4(112), \ BAR1_MOD_JIGGLE_SLOW4(96), \ BAR1_MOD_JIGGLE_SLOW1(64), \ BAR1_MOD_JIGGLE_SLOW3(32) #define BAR8_MOD3_INSb \ BAR1_MOD_JIGGLE_SLOW1(32), \ BAR1_MOD_JIGGLE_SLOW2(80), \ BAR1_MOD_JIGGLE_SLOW1(112), \ BAR1_MOD_JIGGLE_SLOW3(96), \ BAR1_MOD_JIGGLE_SLOW4(32), \ BAR1_MOD_JIGGLE_SLOW4(80), \ BAR1_MOD_JIGGLE_SLOW1(112), \ BAR1_MOD_JIGGLE_SLOW3(4) #define BAR4_MOD3a_A3 \ PM2_NBAR(BAR4_MOD3_INSa, A3, E4) #define BAR8_MOD3a_B3 \ PM2_NBAR(BAR8_MOD3_INSa, B3, Fsh4) #define BAR8_MOD3a_A3 \ PM2_NBAR(BAR8_MOD3_INSa, A3, E4) #define BAR8_MOD3a_E3 \ PM2_NBAR(BAR8_MOD3_INSa, E3, B3) #define BAR8_MOD3b_B3 \ PM2_NBAR(BAR8_MOD3_INSb, B3, Fsh4) #define BAR8_MOD3b_A3 \ PM2_NBAR(BAR8_MOD3_INSb, A3, E4) #define BAR8_MOD3b_E3 \ PM2_NBAR(BAR8_MOD3_INSb, E3, B3) /* mod 4a: 2 beats */ #define BAR1_MOD4a \ BEAT1_MOD_RISE(0, 8), \ BEAT1_MOD_RISE(64, 8), \ BEAT1_MOD_FALL(127, 8), \ BEAT1_MOD_FALL(63, 8) #define BAR1_MOD4a_INS \ BAR1_MOD4a #define BAR4_MOD4a_INS \ BAR1_MOD4a_INS, BAR1_MOD4a_INS, BAR1_MOD4a_INS, BAR1_MOD4a_INS #define BAR8_MOD4a_INS \ BAR4_MOD4a_INS, BAR4_MOD4a_INS #define BAR1_MOD4a_Fsh3 \ PM2_NBAR(BAR1_MOD4a_INS,Fsh3,Csh4) #define BAR1_MOD4a_D3 \ PM2_NBAR(BAR1_MOD4a_INS,D3,A3) #define BAR4_MOD4a_B3 \ PM2_NBAR(BAR4_MOD4a_INS,B3,Fsh4) #define BAR4_MOD4a_A3 \ PM2_NBAR(BAR4_MOD4a_INS,A3,E4) #define BAR8_MOD4a_B3 \ PM2_NBAR(BAR8_MOD4a_INS,B3,Fsh4) #define BAR8_MOD4a_A3 \ PM2_NBAR(BAR8_MOD4a_INS,A3,E4) /* mod 4b: 1 bar */ #define BAR2_MOD4b \ BAR1_MOD_RISE(0, 4), \ BAR1_MOD_FALL(127, 4) #define BAR4_MOD4b_INS \ BAR2_MOD4b, BAR2_MOD4b #define BAR8_MOD4b_INS \ BAR4_MOD4b_INS, BAR4_MOD4b_INS #define BAR8_MOD4b_B3 \ PM2_NBAR(BAR8_MOD4b_INS, B3, Fsh4) #define BAR8_MOD4b_A3 \ PM2_NBAR(BAR8_MOD4b_INS, A3, E4) #define BAR4_MOD4b_B3 \ PM2_NBAR(BAR4_MOD4b_INS, B3, Fsh4) #define BAR4_MOD4b_A3 \ PM2_NBAR(BAR4_MOD4b_INS, A3, E4) /* mod 4c: 2 bars */ #define BAR4_MOD4c \ BAR1_MOD_RISE(0, 2), \ BAR1_MOD_RISE(64, 2), \ BAR1_MOD_FALL(127, 2), \ BAR1_MOD_FALL(63, 2) #define BAR8_MOD4c_INS \ BAR4_MOD4c, BAR4_MOD4c #define BAR8_MOD4c_B3 \ PM2_NBAR(BAR8_MOD4c_INS, B3, Fsh4) #define BAR8_MOD4c_A3 \ PM2_NBAR(BAR8_MOD4c_INS, A3, E4) #define BAR8_MOD4c_E3 \ PM2_NBAR(BAR8_MOD4c_INS, E3, B3) /* mod 4d: 4 bars */ #define BAR8_MOD4d_INS \ BAR1_MOD_RISE(0, 1), \ BAR1_MOD_RISE(32, 1), \ BAR1_MOD_RISE(64, 1), \ BAR1_MOD_RISE(96, 1), \ BAR1_MOD_FALL(127, 1), \ BAR1_MOD_FALL(95, 1), \ BAR1_MOD_FALL(63, 1), \ BAR1_MOD_FALL(31, 1) #define BAR8_MOD4d_B3 \ PM2_NBAR(BAR8_MOD4d_INS, B3, Fsh4) #define BAR8_MOD4d_A3 \ PM2_NBAR(BAR8_MOD4d_INS, A3, E4) #define BAR8_MOD4d_E3 \ PM2_NBAR(BAR8_MOD4d_INS, E3, B3) #define BAR8_FandD_END_1 \ BAR1_MOD1a_Fsh3, BAR1_MOD1a_D3, BAR1_MOD1b_Fsh3, BAR1_MOD1b_D3, \ BAR1_MOD2a_J1_Fsh3, BAR1_MOD2a_J2_D3, BAR1_MOD2a_J3_Fsh3, BAR1_MOD2a_J4_D3 #define BAR8_FandD_END_2 \ BAR1_MOD2a_J3_Fsh3, BAR1_MOD2a_J4_D3, BAR1_MOD1b_Fsh3, BAR1_MOD1b_D3, \ BAR1_MOD1a_Fsh3, BAR1_MOD1a_D3, BAR1_MOD2a_J1_Fsh3, BAR1_MOD2a_J2_D3 #define BAR8_FandD_END_3 \ BAR1_MOD4a_Fsh3, BAR1_MOD2a_J4_D3, BAR1_MOD1b_Fsh3, BAR1_MOD4a_D3, \ BAR1_MOD1a_Fsh3, BAR1_MOD4a_D3, BAR1_MOD4a_Fsh3, BAR1_MOD2a_J2_D3 #define BAR8_FandD_END_4 \ BAR1_MOD2a_J3_Fsh3, BAR1_MOD4a_D3, BAR1_MOD1b_Fsh3, BAR1_MOD1b_D3, \ BAR1_MOD4a_Fsh3, BAR1_MOD1a_D3, BAR1_MOD1a_Fsh3, BAR1_MOD2a_J2_D3 #define BAR8_2B3 \ PM2_8BAR(B3, Fsh4) /* bring the volume up over 8 bars from 16 to 127. */ #define INTRO_CCVOL_BEAT(x) \ CCVOL((x)+0), PM0(NOTES_PER_BEAT/4), \ CCVOL((x)+1), PM0(NOTES_PER_BEAT/4), \ CCVOL((x)+2), PM0(NOTES_PER_BEAT/4), \ CCVOL((x)+3), PM0(NOTES_PER_BEAT/4) #define INTRO_CCVOL_BAR(x) \ INTRO_CCVOL_BEAT((x) + 0), \ INTRO_CCVOL_BEAT((x) + 4), \ INTRO_CCVOL_BEAT((x) + 8), \ INTRO_CCVOL_BEAT((x) + 12) #define INTRO_CCVOL \ INTRO_CCVOL_BAR(16), \ INTRO_CCVOL_BAR(32), \ INTRO_CCVOL_BAR(48), \ INTRO_CCVOL_BAR(64), \ INTRO_CCVOL_BAR(80), \ INTRO_CCVOL_BAR(96), \ INTRO_CCVOL_BAR(112), \ P1 static unsigned char main_sample[] = { HDR, CCVOL(16), // b001-b008, open coded BAR8_2B3 with volume increases inserted PMON(B3,0), PMON(Fsh4,0), INTRO_CCVOL, PMOFF(B3,0), PMOFF(Fsh4,0), // b009-b032 BAR8_2B3, BAR8_2B3, BAR8_MOD1a_B3, // b033-b048 BAR8_MOD1a_A3, BAR8_MOD1a_B3, // b049-b064 BAR8_MOD1b_B3, BAR8_MOD1b_A3, // b065-b080 BAR8_MOD2_B3, BAR8_MOD2_A3, // b081-b096 BAR8_MOD3a_E3, BAR8_MOD3b_E3, // b097-b112 BAR8_MOD4a_B3, BAR8_MOD4b_B3, // b113-b128 BAR8_MOD4c_A3, BAR8_MOD4d_B3, // b129-b136 BAR4_MOD3a_A3, BAR4_MOD4a_B3, // b137-b144 BAR4_MOD4b_A3, BAR4_MOD4b_B3, // b145-b152 BAR4_MOD4b_A3, BAR4_MOD4a_B3, // b153-b156 BAR4_MOD4b_B3, // b157-b164 BAR8_MOD4c_E3, // b165-b172 BAR2_MOD1a_3Fsh3, BAR2_MOD1b_3D3, BAR2_MOD1b_3Fsh3, BAR2_MOD1b_3D3, // b173-b180 BAR2_MOD2a_3Fsh3, BAR2_MOD2a_3D3, BAR2_MOD2b_3Fsh3, BAR2_MOD2b_3D3, // b181-b188 BAR8_MOD4d_E3, // b189-b204 BAR8_FandD_END_1, BAR8_FandD_END_2, // b205-b221 BAR8_FandD_END_3, BAR8_FandD_END_4, // b222-b229 BAR1_MOD1b_Fsh3, CCVOL(112), BAR1_MOD1a_D3, CCVOL(96), BAR1_MOD1a_Fsh3, CCVOL(80), BAR1_MOD1b_D3, CCVOL(64), BAR1_MOD2a_J1_Fsh3, CCVOL(48), BAR1_MOD2a_J2_D3, CCVOL(32), BAR1_MOD1b_Fsh3, PMON(D3,0), PMON(A3,0), P1, // b230-b237 P4, P2, PMOFF(D3,0), PMOFF(A3,0), P2, CCVOL(0), P2, MRG_MIDI_TRAILER }; /* bass synth */ /* eventually make more interesting: - starts at b5? quiet? - intro just root note - go for simple root/4/5 root/5/4 sequences - build up before first E moment - extend from: 1 x 2 x 3 x 4 x 1 ---------------------------------------------- -B-------B-------B-------B-------------------- -A-------A-------A-------A-------------------- to add eg: 1 x 2 x 3 x 4 x 1 m1:----------------------------B---------------- m2:---------------------------B-B--------------- m3:------------------------------B-------------- m4:----------------B---B-------B---------------- style additions. */ static unsigned char bass_synth_sample[] = { HDR, CCVOL(127), P4, #define NOTES_BAR_END 2 #define NOTES_PER_BAR_HELD (NOTES_PER_BAR - NOTES_BAR_END) #define NOTES_PER_EIGHTH (NOTES_PER_BEAT/8) #define BAR1_PMPX(c,p) \ PMPX(c,NOTES_PER_BAR_HELD,NOTES_BAR_END,p,p) #define BAR2_PMPX(c,p1,p2) \ BAR1_PMPX(c,p1), BAR1_PMPX(c,p2) #define BAR4_PMPX(c,p1,p2,p3,p4) \ BAR2_PMPX(c,p1,p2), BAR2_PMPX(c,p3,p4) #define BAR1_PMP(c) \ BAR1_PMPX(c,0x7f) #define BAR2_PMP(c) \ BAR2_PMPX(c,0x7f,0x7f) #define BAR4_PMP(c) \ BAR4_PMPX(c,0x7f,0x7f,0x7f,0x7f) #define BAR1_m1_d (NOTES_PER_EIGHTH * 4) #define BAR1_m1_dSTART (NOTES_PER_BAR - BAR1_m1_d) #define BAR1_PMP_m1(c) \ PMPXE(c,BAR1_m1_dSTART,0,0x7f,0x7f), \ PMPXE(c,BAR1_m1_d ,0,0x70,0x70) #define BAR1_m2_d (NOTES_PER_EIGHTH * 3) #define BAR1_m2_dMID (NOTES_PER_EIGHTH * 2) #define BAR1_m2_dSTART (NOTES_PER_BAR - BAR1_m2_d - BAR1_m2_dMID) #define BAR1_PMP_m2(c) \ PMPXE(c,BAR1_m2_dSTART,0,0x7f,0x7f), \ PMPXE(c,BAR1_m2_dMID ,0,0x70,0x70), \ PMPXE(c,BAR1_m2_d ,0,0x70,0x70) #define BAR1_m3_d (NOTES_PER_EIGHTH * 2) #define BAR1_m3_dSTART (NOTES_PER_BAR - BAR1_m3_d) #define BAR1_PMP_m3(c) \ PMPXE(c,BAR1_m3_dSTART,0,0x7f,0x7f), \ PMPXE(c,BAR1_m3_d ,0,0x70,0x70) // 1 x 2 x 3 x 4 x 1 // m4:----------------B---B-------B---------------- #define BAR1_m4_d (NOTES_PER_EIGHTH * 4) #define BAR1_m4_dMID (NOTES_PER_EIGHTH * 4) #define BAR1_m4_dMID2 (NOTES_PER_EIGHTH * 8) #define BAR1_m4_dSTART (NOTES_PER_BAR - BAR1_m4_d - BAR1_m4_dMID - BAR1_m4_dMID2) #define BAR1_PMP_m4(c) \ PMPXE(c,BAR1_m4_dSTART,0,0x7f,0x7f), \ PMPXE(c,BAR1_m4_dMID ,0,0x70,0x70), \ PMPXE(c,BAR1_m4_dMID2 ,0,0x70,0x70), \ PMPXE(c,BAR1_m4_d ,0,0x70,0x70) #define BAR4_m1(c) \ BAR1_PMP(c), BAR1_PMP(c), BAR1_PMP(c), BAR1_PMP_m1(c) #define BAR4_m2(c) \ BAR1_PMP(c), BAR1_PMP(c), BAR1_PMP(c), BAR1_PMP_m2(c) #define BAR4_m3(c) \ BAR1_PMP(c), BAR1_PMP(c), BAR1_PMP(c), BAR1_PMP_m3(c) #define BAR4_m4(c) \ BAR1_PMP(c), BAR1_PMP(c), BAR1_PMP(c), BAR1_PMP_m4(c) // b005-b008 BAR4_PMPX(B4,0x40,0x40,0x40,0x40), // b009-b032 BAR4_PMPX(B4,0x40,0x42,0x44,0x46), BAR4_PMPX(B4,0x48,0x4a,0x4c,0x4e), BAR4_PMPX(B4,0x50,0x40,0x45,0x49), BAR4_PMPX(B4,0x58,0x55,0x59,0x60), BAR4_PMPX(B4,0x60,0x64,0x68,0x6c), BAR4_PMPX(B4,0x70,0x70,0x70,0x70), // b033-b080 BAR4_PMP(A4), BAR4_PMP(A4), BAR4_PMP(B4), BAR4_PMP(B4), //BAR4_PMP(B4), BAR4_m1(B4), P4, P4, BAR4_PMP(A4), BAR4_m1(A4), BAR4_PMP(B4), BAR4_m2(B4), BAR4_PMP(A4), BAR4_m3(A4), // b081-b096 BAR4_m2(E5), BAR4_m2(E5), BAR4_m1(E5), P4, // BAR4_m3(E5), // b097-b112 BAR4_PMP(B4), BAR4_m1(B4), BAR4_PMP(B4), BAR4_m1(B4), // b113-b128 BAR4_PMP(A4), BAR4_m2(A4), BAR4_PMP(B4), BAR4_m2(B4), // b129-b136 BAR4_PMP(A4), BAR4_m3(B4), // b137-b144 BAR4_m4(A4), BAR4_m4(B4), // b145-b152 BAR4_m3(A4), //BAR4_m3(B4), P4, // b153-b156 BAR4_m4(B4), // b157-b164 BAR4_m2(E5), BAR4_m4(E5), // b165-b172 BAR2_PMP(Fsh5), BAR2_PMP(D5), BAR2_PMP(Fsh5), BAR2_PMP(D5), // b173-b180 BAR2_PMP(Fsh5), BAR2_PMP(D5), BAR2_PMP(Fsh5), BAR2_PMP(D5), // b181-b188 BAR4_PMP(E5), BAR4_PMP(E5), // b189-b204 BAR1_PMP(Fsh5), BAR1_PMP(D5), BAR1_PMP(Fsh5), BAR1_PMP(D5), BAR1_PMP(Fsh5), BAR1_PMP(D5), BAR1_PMP(Fsh5), BAR1_PMP(D5), BAR1_PMP(Fsh5), BAR1_PMP(D5), BAR1_PMP(Fsh5), BAR1_PMP(D5), BAR1_PMP(Fsh5), BAR1_PMP(D5), BAR1_PMP(Fsh5), BAR1_PMP(D5), // b205-b221 BAR1_PMP(Fsh5), BAR1_PMP(D5), BAR1_PMP(Fsh5), BAR1_PMP(D5), BAR1_PMP(Fsh5), BAR1_PMP(D5), BAR1_PMP(Fsh5), BAR1_PMP(D5), BAR1_PMP(Fsh5), BAR1_PMP(D5), BAR1_PMP(Fsh5), BAR1_PMP(D5), BAR1_PMP(Fsh5), BAR1_PMP(D5), BAR1_PMP(Fsh5), BAR1_PMP(D5), // b222-b229 BAR1_PMP(Fsh5), CCVOL(112), BAR1_PMP(D5), CCVOL(96), BAR1_PMP(Fsh5), CCVOL(80), BAR1_PMP(D5), CCVOL(64), BAR1_PMP(Fsh5), CCVOL(48), BAR1_PMP(D5), CCVOL(32), BAR1_PMP(Fsh5), BAR1_PMP(D5), // b230-b237 P4, P2, P2, P2, MRG_MIDI_TRAILER }; /* * one bar is 96 (NOTES_PER_BEAT*4) notes, we play 1/4ths, * ie, NOTES_PER_BEAT/4 (6). */ #define NOTES_PER_Q (NOTES_PER_BEAT/4) #define PMQ(x,p) \ PMPX(x, NOTES_PER_Q, 0, p, 0x7f) #define PMQ4(x1,x2,x3,x4) \ PMQ(x1,0x7f), \ PMQ(x2,0x40), \ PMQ(x3,0x60), \ PMQ(x4,0x40) #define BAR1_ARPY_B5_1 \ PMQ4(Fsh6, Dsh6, B5, Fsh5), \ PMQ4(Dsh6, B5, Fsh5, Dsh5), \ PMQ4(B5, Fsh5, Dsh5, B4), \ PMQ4(Fsh5, Dsh5, B4, Fsh4) #define BAR2_ARPY_B5_1 \ PMQ4(Dsh5, B4, Fsh4, Dsh4), \ PMQ4(B4, Fsh4, Dsh4, B3), \ PMQ4(Fsh4, Dsh4, B3, Fsh3), \ PMQ4(Dsh4, B3, Fsh3, Dsh3) static unsigned char arpy_piano_sample[] = { HDR, // b001-b008 P8, // b009-b032 P8, P8, P8, // b033-b048 P8, P8, // b049-b064 #if 0 //BAR8_MOD1b_B3, //BAR8_MOD1b_A3, BAR1 #else P8, P8, #endif // b065-b080 #if 0 //BAR8_MOD2_B3, //BAR8_MOD2_A3, BAR1_ARPY_B5_1, #else P8, P8, #endif // b081-b096 P8, P8, // b097-b112 P8, P8, // b113-b128 P8, P8, // b129-b136 P8, // b137-b144 P8, // b145-b152 P8, // b153-b156 P4, // b157-b164 P4, // b165-b172 P8, // b173-b180 P8, // b181-b188 P8, // b189-b204 P8, P8, // b205-b221 P8, P8, // b222-b229 P8, // b230-b237 P8, MRG_MIDI_TRAILER }; static unsigned char test_sample[] = { HDR, CCVOL(127), P1, BAR4_PMPX(B4,0x40,0x40,0x40,0x40), //BAR1_PMP(A4), BAR1_PMP(A4), BAR1_PMP(A4), //BAR1_PMP_m1(A4), //BAR1_PMP(A4), BAR1_PMP(A4), BAR1_PMP(A4), //BAR1_PMP_m2(A4), //BAR1_PMP(A4), BAR1_PMP(A4), BAR1_PMP(A4), //BAR1_PMP_m4(A4), P1, MRG_MIDI_TRAILER }; static unsigned char simple_sample[] = { HDR, PMX(C4, 8, 0), PMX(B3, 8, 0), PMX(A3, 8, 0), PMX(G3, 8, 0), MRG_MIDI_TRAILER }; #undef BEAT1_MOD_OP #undef BEAT1_MOD_FAST_OP #undef BEAT1_MOD_FALL #undef BEAT1_MOD_RISE #undef BEAT1_MOD_FAST_FALL #undef BEAT1_MOD_FAST_RISE #undef BAR1_MOD_FALL #undef BAR1_MOD_RISE #undef BEAT1_MOD_JIGGLE_FAST_ALL #undef BEAT1_MOD_JIGGLE_FAST1 #undef BEAT1_MOD_JIGGLE_FAST2 #undef BEAT1_MOD_JIGGLE_FAST3 #undef BEAT1_MOD_JIGGLE_FAST4 #undef BAR1_MOD_JIGGLE_SLOW_ALL #undef BAR1_MOD_JIGGLE_SLOW1 #undef BAR1_MOD_JIGGLE_SLOW2 #undef BAR1_MOD_JIGGLE_SLOW3 #undef BAR1_MOD_JIGGLE_SLOW4 #undef BAR1_MOD1_RISE_FALL #undef BAR1_MOD1a_INS #undef BAR2_MOD1a_INS #undef BAR8_MOD1a_INS #undef BAR8_MOD1a_B3 #undef BAR8_MOD1a_A3 #undef BAR2_MOD1a_3Fsh3 #undef BAR2_MOD1a_3D3 #undef BAR1_MOD1b #undef BAR1_MOD1b_INS #undef BAR2_MOD1b_INS #undef BAR8_MOD1b_INS #undef BAR8_MOD1b_B3 #undef BAR8_MOD1b_A3 #undef BAR2_MOD1b_3Fsh3 #undef BAR2_MOD1b_3D3 #undef BAR1_MOD2_J1 #undef BAR1_MOD2_J2 #undef BAR1_MOD2_J3 #undef BAR1_MOD2_J4 #undef BAR1_MOD2a_J1_INS #undef BAR1_MOD2a_J2_INS #undef BAR1_MOD2a_J3_INS #undef BAR1_MOD2a_J4_INS #undef BAR2_MOD2a_INS #undef BAR2_MOD2b_INS #undef BAR8_MOD2_INS #undef BAR8_MOD2_B3 #undef BAR8_MOD2_A3 #undef BAR2_MOD2a_3Fsh3 #undef BAR2_MOD2a_3D3 #undef BAR2_MOD2b_3Fsh3 #undef BAR2_MOD2b_3D3 #undef BAR1_MOD2a_J1_Fsh3 #undef BAR1_MOD2a_J1_D3 #undef BAR1_MOD2a_J2_Fsh3 #undef BAR1_MOD2a_J2_D3 #undef BAR1_MOD2a_J3_Fsh3 #undef BAR1_MOD2a_J3_D3 #undef BAR1_MOD2a_J4_Fsh3 #undef BAR1_MOD2a_J4_D3 #undef BAR8_MOD3_INSa #undef BAR8_MOD3_INSb #undef BAR8_MOD3a_B3 #undef BAR8_MOD3a_A3 #undef BAR8_MOD3a_E3 #undef BAR8_MOD3b_B3 #undef BAR8_MOD3b_A3 #undef BAR8_MOD3b_E3 #undef BAR1_MOD4a #undef BAR1_MOD4a_INS #undef BAR4_MOD4a_INS #undef BAR8_MOD4a_INS #undef BAR1_MOD4a_Fsh3 #undef BAR1_MOD4a_D3 #undef BAR4_MOD4a_B3 #undef BAR4_MOD4a_A3 #undef BAR8_MOD4a_B3 #undef BAR8_MOD4a_A3 #undef BAR2_MOD4b #undef BAR4_MOD4b_INS #undef BAR8_MOD4b_INS #undef BAR8_MOD4b_B3 #undef BAR8_MOD4b_A3 #undef BAR4_MOD4b_B3 #undef BAR4_MOD4b_A3 #undef BAR4_MOD4c #undef BAR8_MOD4c_INS #undef BAR8_MOD4c_B3 #undef BAR8_MOD4c_A3 #undef BAR8_MOD4c_E3 #undef BAR8_MOD4d_INS #undef BAR8_MOD4d_B3 #undef BAR8_MOD4d_A3 #undef BAR8_MOD4d_E3 #undef BAR1_MOD1a_Fsh3 #undef BAR1_MOD1a_D3 #undef BAR1_MOD1b_Fsh3 #undef BAR1_MOD1b_D3 #undef BAR8_FandD_END_1 #undef BAR8_FandD_END_2 #undef BAR8_FandD_END_3 #undef BAR8_FandD_END_4 #undef BAR8_2B3 #undef INTRO_CCVOL_BEAT #undef INTRO_CCVOL_BAR #undef CCVOL #undef CCMOD #undef CCPAN #undef PMON #undef PMOFF #undef PMX #undef PM0 #undef PM2_NBAR #undef PM2_1BAR #undef PM2_2BAR #undef PM2_4BAR #undef PM2_8BAR #undef P1 #undef P2 #undef P3 #undef P4 #undef P8 /* all the samples */ static midi_sample main_punk_kin_midi_sample = { .name = "main", .sample = main_sample, .len = sizeof main_sample, .func = NULL, }; static midi_sample bass_synth_punk_kin_midi_sample = { .name = "bass_synth", .sample = bass_synth_sample, .len = sizeof bass_synth_sample, .func = NULL, }; static midi_sample arpy_piano_punk_kin_midi_sample = { .name = "arpy_piano", .sample = arpy_piano_sample, .len = sizeof arpy_piano_sample, .func = NULL, }; static midi_sample test_punk_kin_midi_sample = { .name = "test", .sample = test_sample, .len = sizeof test_sample, .func = NULL, }; static midi_sample simple_punk_kin_midi_sample = { .name = "simple", .sample = simple_sample, .len = sizeof simple_sample, .func = NULL, }; #define MRG_MIDI_SAMPLES \ &main_punk_kin_midi_sample, \ &bass_synth_punk_kin_midi_sample, \ &simple_punk_kin_midi_sample, \ &arpy_piano_punk_kin_midi_sample, \ &test_punk_kin_midi_sample, #endif /* MRG_MIDI_PUNK_KIN_MIDI_H */ #if 0 static unsigned char xxx_sample[] = { HDR, // b001-b008 // b009-b032 // b033-b048 // b049-b064 // b065-b080 // b081-b096 // b097-b112 // b113-b128 // b129-b136 // b137-b144 // b145-b152 // b153-b156 // b157-b164 // b165-b172 // b173-b180 // b181-b188 // b189-b204 // b205-b221 // b222-b229 // b230-b237 MRG_MIDI_TRAILER }; #endif