Kurzweil 1000 Series Developer Information
Kurzweil Music Systems, Inc.
Contents of this package: 1. 2. 3. 4. Kurzweil 1000 Series MIDI Implementation Kurzweil 1000 Series MIDI System Exclusive Messages Kurzweil 1000 Series Binary Data Transfer Protocol How to talk to the K1000 over MIDI. Kurzweil 1000 Series Object Overview Describes the basic structure of K1000 binary objects. Illustrated!
Kurzweil 1000 Series MIDI Implementation
1st Edition: March 88 MIDI Modes The 1000 series currently supports three modes of MIDI reception: Omni On/Poly, Omni Off/Poly and Multi. In Omni On mode, the channel number is ignored. In Omni Off (aka Poly) mode, only messages received on the basic channel are recognized. In Multi mode, all enabled MIDI channels are recognized. Note Ons and Offs NOTE: The 1000 series products (in fact, all Kurzweil products) refer to Middle C (MIDI key number 60) as C4, in contrast to numerous software products which mistakenly call it C3. This is, as far as we know, an international standard to which weve been adhering since before we ever heard of MIDI. Included with this document is an appendix which lists the key numbers and their proper names. The 1000 series responds to the entire range of MIDI key numbers although the actual, playable range depends on the selected program. (E.g., some of the sampled instruments have natural ranges which do not cover the entire keyboard.) It is also possible to restrict the MIDI key range on an individual MIDI channel via the master parameters. In general most programs respond over the range C0 (=12) thru C8 (=108). The 1000 series also allows multi-layered programs, in which a single MIDI Note On may start multiple voices in the instrument. This technique is provided to allow creation of complex timbres from combinations of raw sounds; there is no efficiency gain by using layers. I.e., it takes the instrument just as long to start four layers from a single MIDI note on as it does to start four individual notes. The lowest octave of key numbers, C-1 (=0) thru B-1 (=11), is available to control the intonation table reference key. When used with a suitable MIDI controller, this allows chromatic modulation in real-time while using a nonequally tempered intonation. In the K1000 keyboard instrument, Note Offs are transmitted using the MIDI Note Off message $8x kkk vvv. This can cause problems with certain simple minded MIDI processors (such as the Yamaha MEP4) which transpose the MIDI stream by only altering key numbers in Note On messages ($9x) on the assumption that the MIDI controller is sending Note Offs as zero velocity Note Ons. Currently, there is no solution to this problem but future versions of the software will add a master parameter to select the type of Note Off (real Note Off or zero velocity Note On) which is transmitted. There is a layer-level parameter which allows the Note Off message to be ignored. This is provided so that programs can be created which play through their envelopes completely, until each note decays to silence. If the envelope doesnt decay, the note will sustain indefinitely. In 1000 series software, both attack and release velocity are available (in normal and inverse form) as internal control sources; programs can be created which respond to these parameters. When a note is started, its release velocity is set to zero (and inverse release velocity is set to one). When the Note Off is received, the actual release velocity becomes available. Zero velocity Note Ons which are received are treated as Note Offs with a velocity of 64. Program Changes The 1000 series responds to the full range of MIDI program change numbers. The numbers are mapped through an editable list (selected by the master parameter RxPMap) which selects the real, internal program number. Program

121 All Controls Off When this message is received, all controls are reset to zero, with the following exceptions: volume (#7 and #39) is set to maximum ($7FFF), balance (#8 and #40) and pan (#10 and #42) are set to center point ($4000). 122 Local Control On/Off This message is only recognized by the K1000 on the basic MIDI channel (it is ignored in rack-mount equipment). 123 All Notes Off The All Notes Off message is recognized in all MIDI modes. In particular, it is not ignored in Omni On mode. This is contrary to the MIDI spec but represents the unanimous opinion of our users. NOTE: most Roland equipment (e.g., MKB-1000, D-50, etc.) sends an All Notes Off message when all the keys are released. In order to deal with this, the 1000 series includes a master parameter which allows you to ignore the all notes off message. We call it the "Roland Switch." And I just discovered (as I am working on this document) that Kawai equipment exhibits the same behavior. 124 Omni Off 125 Omni On When not in Multi Mode, the Omni On/Off messages are recognized on the basic MIDI channel only. In Multi Mode, these messages are ignored. This is contrary to the MIDI spec but represents the unanimous opinion of our users. When the instrument is in edit mode, the following control numbers are also recognized: Data Entry Slider MSB Data Entry Slider LSB Data Increment Data Decrement The data entry slider (control numbers 6 and 38) and the data increment/decrement buttons (control numbers 96 and 97) are recognized when the instrument is in edit mode.
98 Non-Registered Parameter Select LSB 99 Non-Registered Parameter Select MSB When the instrument is in edit mode, the non-registered parameter select MSB selects the edit menu and the LSB selects the parameter within the menu. However, because the menu selection varies based on high or low level editing mode and in some cases (e.g., envelopes) the actual parameter list varies, there is no absolute mapping between select values and actual parameters. Pitch Wheel Currently, the pitch wheel is the only MIDI control which has an internal range which is bipolar (i.e., 1). The actual conversion from MIDI data values to internal form is pitch wheel value = 256 * MSB + 2 * LSB - $4000 Future implementations of the software will provide an absolute value pitch wheel control source with a range of 0 to 1 in both directions, to allow effects to be tied to pitch bending in either direction. Mono and Poly Pressure Both Mono Pressure and Poly Pressure messages are recognized. Internally they are treated as additional control sources but their internal values are derived by a mapping table rather than a direct conversion. Note that both pressure sources are treated as separate entities. Thus it is possible to create programs which have separate responses to

$00 $01 $02 $03 $04 $05 $05 $01 $01 $01 p3
$00 $01 $00 $00 $00 $00 $02 $00 $01 $00 p4
e1, e2, s1, and s2 represent the hexadecimal values indicating the software version of the 1000. e1 and e2 indicate the engine (operating system) software, which is common to all 1000 Series products. s1 and s2 indicate the setup software. It is the setup software which distinguishes a GX from a PX, etc. For both engine and setup software, the first numeral is the major version number, and the second is the subversion, if any. For example, version 1.0 would be represented as $01 $00. Version 2.14 would be $02 $0E.
System Exclusive Messages
Remote Front Panel The remote front panel messages allow control of the 1000 series over MIDI. The format of the message is $F0 $07 <device ID> $64 $01 <buttons> $F7 where $64 is the major product ID (i.e., 1000 series) and <buttons> are any number of button codes: Code $00 $09 $10 $11 $12 $13 $14 $15 $16 $17 $18 $19 $1A $1B $1C $20 $21 $22 $7F Button digit 0. digit 9 play/edit mode/layer chan/menu increment chan/menu decrement chan/menu incr & decr (double press) prog/param increment prog/param decrement prog/param incr & decr (double press) value increment/yes value decrement/no value incr & decr (double press) enter store bank A bank B bank C send display
(K1000 only) (K1000 only)
(K1000 only) (K1000 only) (K1000 only) (K1000 only) (K1000 only)
Whenever the special "send display" button ($7F) is sent, the K1000 responds with $F0 $07 <device ID> $64 $02 <display text> $F7 where <display text> is the contents of the K1000 display as ordinary ASCII characters. Dump Request Message $F0 $F7 This message may be used to request a dump of any object or group of objects in the 1000s memory. The type and ID number select the object to be dumped. A type of $00 means all types and and ID number of $00 means all objects of the requested type. If the RAM-flag is true (i.e., not zero) only objects stored in non-volatile RAM will be dumped. For example, to request a dump of all RAM based programs, use: $F0 $07 <device ID> $64 $03 $00 $50 $00 $00 $01 $F7 $07 <device ID> $64 $03 <type-msb> <type-lsb> <id-msb> <id-lsb> <RAM-flag>
To request a dump of the Master Parameter Table, use: $F0 $07 <device ID> $64 $03 $00 $42 $00 $00 $01 $F7
To request a memory dump (User Objects and RAM), use: $F0 $07 <device ID> $64 $03 $00 $42 $00 $10 $01 $F7
Channel Setup Message $F0 $F7 This message may be used to set the MIDI mode (Omni, Poly, or Multi) and to enable or disable specific MIDI channels. If <chan-a> (or subsequent) = $00, then it signals a mode change. A value of $01 for <mode-a> (or later) indicates Omni mode, $02 is Poly, and $03 is Multi. If <chan-b> or subsequent is $01 through $10 (16), it is read as a MIDI channel number. In this case, the following <mode> byte value determines whether that MIDI channel is active. $00 enables the channel, and $01 disables it. For example, to put the instrument in Multi mode, with channels 1 thru 4 enabled, use: $F0 $07 $01 $05 $09 $0D <device $00 $02 $01 $06 $01 $0A $01 $0E ID> $00 $01 $01 $01 $64 $03 $07 $0B $0F $04 $00 $01 $01 $01 $00 $04 $08 $0C $10 $03 $00 $01 $01 $01 ; ; ; ; ; multi mode enable 1-4 disable 5-8 disable 9-12 disable 12-16 $07 <device ID> $64 $04 <chan-a> <mode-a> <chan-b> <mode-b>.

Binary Data Transfer Protocol
same state. The synchronization process consists of exchanging handshake messages which specify the desired transmission parameters (speed, packet size, etc.). These messages have the form $F0 $07 <dst-ID> <syncN> <src-ID> <xSpeed> <nPacks> <pSizeH> <pSizeL> $F7
The elements of this message are dst-ID The device ID of the destination. SYNC0 ($78) messages may be sent with a device ID of 127 as a general request for sync. syncN The message ID ($78 thru $7B), which includes the partys current synchronization state. src-ID The device ID of the transmitter (0 thru 126). xSpeed The desired transmission speed (1x, 2x, 4x, etc.). nPacks The maximum number of outstanding packets (1 thru 127). pSize The maximum number of eight bit bytes that will be transmitted in a packet (a 14 bit value sent as two seven bit values).
All sync sequences begin at level 0 with both parties transmitting at standard MIDI speed. A party can transmit SYNC0 messages to actively make a connection or it can wait passively for the arrival of a SYNC0 message. When either party receives a SYNC0 message, it should respond by transmitting a SYNC1 message. Here, the transmission parameter negotiation takes place: each party begins by declaring its maximum capability and then lowering its parameters in response to SYNC1 messages from the other party, until a common denominator has been achieved. Then each party switches to level 2. If a speed change is required because the parties have agreed on a higher transmission rate, they switch speeds before transmitting their level 2 messages. Once the parties exchange identical SYNC2 messages, they switch to level three. Once each party has received a valid SYNC3 message, synchronization has been achieved and the exchange stops. Now the parties are able to exchange data packets. Data Packets Each data packet message has the form: $F0 $07 <dst-ID> $7C <src-ID> <pktNum> <pSize> <data.> <chkSum> $F7 The elements are dst-ID The destination device ID (0 thru 126). src-ID The source device ID (0 thru 126). pktNum The packet number. Packet numbers will sequence from 0 to 127. pSize The number of eight bit bytes contained in the packet (two seven bit values concatenated, MSB sent first). Must be between zero and the agreed upon maximum. The actual number of data bytes in the message will be larger (see below). The binary data, transmitted in a seven bit format (see below).
chkSum A fourteen bit check sum accumulated over the data bytes only. The check sum is calculated by rotating the 16 bit sum left one bit and then adding each seven bit value. Only the low seven bits of each byte are transmitted in the packet (i.e., the sign bits are dropped), MSB first.
Binary Data Transmission Format The simplest transmission scheme is "nibble-izing," sending each data byte as two four bit values. This is the easy to read but it doubles the transmission time. The most efficient packing format (short of some exotic compression scheme like Huffman encoding) is to send the low seven bits of each byte, with every seven data bytes followed by one byte containing the seven sign bits. Thus, the seven binary data bytes AAAAaaaa BBBBbbbb CCCCcccc DDDDdddd EEEEeeee FFFFffff GGGGgggg are transmitted as 0AAAaaaa 0BBBbbbb 0CCCcccc 0DDDdddd 0EEEeeee 0FFFffff 0GGGgggg 0ABCDEFG If the number of data bytes is not a multiple of seven, a short chunk is transmitted. E.g., if three bytes are left over AAAAaaaa BBBBbbbb CCCCcccc they are transmitted as 0AAAaaaa 0BBBbbbb 0CCCcccc 00000ABC This scheme requires that the receiver know the length of the stream, either in logical size (i.e., the number of eight bit bytes) or physical size (the number of seven bit bytes). In general, to transmit N eight-bit bytes requires N + (N + 6)/7 seven bit bytes (assuming truncating integer division). Conversely, receiving M seven bit bytes yields 7 * (M / 8) + (M mod 8 - 1) eight bit bytes. Since the packets are delimited by the system exclusive message, their length is self defined. Thus, within the packet itself, we include the size as the number of eight bit bytes contained in the data. While this may seem counter-intuitive, we believe it to be a more convenient number since it represents the size of the buffer into which the data is unpacked (see the attached code samples). Response to Data Packet $F0 $07 <dst-ID> $7E <src-ID> <pktNum> $F7 $F0 $07 <dst-ID> $7F <src-ID> <pktNum> $F7 (ACK) (NAK)

Successfully received packets are ACKed. If an error or timeout occurs during packet reception, the receiving party will transmit a NAK message. Upon receiving a NAK, the transmitting party will re-transmit the incorrect packet. Open Loop Behavior Timeouts during a sync sequence will cause the transmitting party to reduce its requirements to a minimum (lowest speed, one packet, 128 byte packet size) and begin data transmission. Since it knows that the other party did not respond to sync, it can transmit packets at a default rate, without waiting for timeouts on ACKs. Data packets received by party which is not in level three sync are ignored. Thus, a receiver which may operate in either mode needs some kind of front panel control to enable the reception. Bypassing Sync It is also possible to allow a receiver to power up in level 3 sync state (given default parameters of normal MIDI speed, 1 outstanding packet and a reasonable buffer size, say, 128 bytes). This would allow it to transmit and receive data packet messages without going thru the handshake sequence.
Message Summary State SYNC0 SYNC0 other SYNC1 SYNC0 SYNC1 SYNC1 other SYNC2 SYNC2 SYNC2 SYNC3 SYNC3 other SYNC3 SYNC2 SYNC3 DATA DATA ACK NAK xmt timeout retry limit exceeded other match correct error rcv timeout NAK limit exceeded SYNC3 none ACK NAK NAK SYNC0 transmit next re-transmit current re-transmit SYNC0 SYNC0 SYNC0 match mismatch match mismatch timeout SYNC3 SYNC0 SYNC3 SYNC0 none SYNC3 SYNC0 SYNC3 SYNC0 SYNC0 mismatch match timeout SYNC1 SYNC1 SYNC2 none SYNC2 SYNC0 SYNC0 SYNC1 none SYNC1 Message Condition Response Newstate
K1000 Data Transfer Protocol
The higher level protocol consists of a stream of messages which exist at a level above the packet protocol, which simply acts as a delivery vehicle. In the K1000 series expanders, this higher level protocol implements a simple remote file system which allows a remote computer to manipulate the contents of the K1000s object heap memory. Message Format 100 message-id data. Each message begins with its protocol ID byte (in this case, 100, the product ID for the K1000 series) and a message ID. The format of the remaining data is determined by the message type. Messages are divided into two categories, requests and responses. For convenience, request message types are even numbers and the response type for any message is its request type + 1.
In the following, all messages are in eight-bit binary! They must be formatted, then transmitted using the packet protocol described above. Also, the notation [n] indicates the size of the item in bytes. If omitted, the size is one byte. Directory Request/Response type idno type idno size[4] zone[4] name[N]
Used by the remote device to request information about objects contained in the K1000s memory. An idno of zero means all objects of a given type. Size gives the size of the object in bytes, zone identifies the heap space in which the object resides, and name is the name of the object (if it has one) as a NUL-terminated string. The when a request for info about all objects of a given type is received, the K1000 responds with a series of messages. The last of these is a null message (idno of zero) to indicate the end of the list. Dump Request/Response type idno size[4] offset[4] type idno size[4] offset[4] data[N]

with several of tables described below, determine the mapping of MIDI key velocities into loudness and control sources. Demo Song Objects (excerpts from the V5 Software addendum manual) A RAM based SONG (Demo) object is basically a MIDI File, Type 0, with a 1000 Series object header prepended to it. Demo songs may be loaded, named, renumbered, or removed with ObjectMover. A separate program is needed to turn MIDI files into object files. There may be more than one Demo song in an object file, in which case, there would be multiple song headers. All song objects must be word aligned. The Demo player will play them in the order of their resource IDs, in a repeating cycle. It is recommended that your program remove, or truncate, text meta-events from the data stream (to save RAM space). Only the tempo meta-event is interpreted by the 1000. The block size in the object header is the size of all the objects in file, negated. The blockSize must include everything from itself to the end of file, so you will calculate DO_blockSize like this: demoFile->DO_blockSize = -(fileSize - 32); The object size itself is calculated in a similar way. Object size should include all data from the type and id fields, to the end of your song. Because this is a 16 bit field, there is a 64K maximum size for demo objects. The tempo field (DS_tempo) is a precalculated clock increment providing the initial tempo of the song. This is a 32 bit field which is added to the Demo clock every 2 milliseconds. The Demo clock counts off 1/480 of a quarter note times, with a 16 bit fraction. Your program can calculate the clock increment like this: myDemo->DS_tempo = (long)bps * 1048L; Where bpm is the desired "beats per minute" for your song. If you are working from the MIDI files "microseconds per beat" value, the formula becomes: myDemo->DS_tempo = (60000000 / uspb) * 1048L; Following the song header, comes the name field. This name may be any length (up to 64 chars) and must be null terminated. The MIDI File song data starts on the next even address after that. Tables Table objects are actually miscellaneous, one-of-a-kind objects. All tables are variable sized, unnamed objects; the format of the extension data is determined by the particular tables ID number. The following is a list of some of the more interesting tables organized by ID number: # Description Control Source Enumeration Table gives name, type and ID# for both MIDI and internal control sources. Envelope/ASR Time Enumeration. Determines the actual times for envelope and ASR segments. Non-linear. Enumeration of note start delays. Non-linear. Enumeration of LFO rates. Non-linear. Contains offsets into table #27. Enumeration of Envelope Scale Factors. Contains offsets into table #6. Uses 5% resistor value scale. Logarithmic Multiplier Table used to scale envelope rates. Table #5 contains offsets into this table. MIDI control number map. Incoming MIDI control change messages have their control numbers mapped thru this table. Allows re-assignment of controls. Master parameter data. Contains most everything that is editable in the master menu. Snapping a copy of this object captures the entire state of the machine (MIDI channel and mode, program assignments, etc).

Object mapping table (contained in program only). Used by the high-level effects editor to map pseudo parameters to real parameters. Pseudo parameter table (program only). Contains the actual values of the high-level pseudo parameters. Key velocity to loudness curve (combined with velocity map). Key velocity to control source value curve (combined with velocity map). Mono/Poly pressure to control value curve. Default is linear. Volume control table (MIDI control value to loudness). Non-linear. Balance control table. Equal power crossfade curve. LFO phase increments. Table #4 contains offsets into this table. Enumeration of bi-polar envelope segment values. Converts percentages into output levels. Linear. Enumeration of amplitude envelope segment values. Converts percentages into loudness levels. Non-linear.
Note: The master parameter block, which is currently table #16, is soon to become a distinct, named object. Thus, the instrument will be able to store multiple sets of master parameters. We havent decided exactly how to do this, yet, so stay tuned for more info.
K1000 Object Types Type# Hex $42 $44 $45 $46 $47 $48 $49 $4A $4B $4C $4D $4E $4F $50 $51 $52 $53 $54 $55 $56 $57 $5B $5E $5F Description Master Table LFO Shape Sound Block Keyboard Map MIDI Program List Edit Menu Definition Edit Menu Group Edit Menu Entry List Intonation Table Compiled Effects Descriptor (Rcv) Velocity Map Rcv PressMap Editor Descriptor Program Data Block Layer Data Block ASR Parameter Block LFO Parameter Block ENV Parameter Block EFX Parameter Block INVNEG Parameter Block MXR Parameter Block Demo Song Program List Bin Map Named? yes yes yes yes

yes yes yes ? yes yes

yes ? ?

v5 v5 v5

K1000 Database Master Tables ID# Notes: 1. 2. 3. 4. 5. 6. 7. Determines sound engine configuration and bandwidth. Specific to sound engine bandwidth. Determines UART and front panel type. Specific to product. Specific to front panel. Determines initial settings after hard reset. Contains product and version ID numbers. Description Control Source Enumeration ENV/ASR Time Enumeration Delay Time Enumeration LFO Rate Enumeration ENV Ctl Scale Enumeration ENV Ctl Log Multiplier Playback Rate Compensation Table (2) Edit Parameter ID Table Edit Menu Position Table Editor Default Object Table MIDI Control Mapping Table Front Panel Button Table (4,5) Diagnostic Tables (4) Product Configuration Table (3,4,6) Arnold Configuration Table (1) Prototype Master Data Block (5) Velocity to Loudness Curve Velocity to Control Source Curve Pressure to Control Source Curve MIDI Volume Control Table Equal Power Attenuation Curve Playback Rate Table LFO Phase Increment Table ENV Value Enumeration Amp ENV Value Enumeration Amp ENV Attack Shape Curve Where EROM SROM SROM SROM SROM SROM SROM EROM EROM EROM EROM EROM SROM SROM SROM SROM SROM SROM SROM SROM

EROM EROM EROM EROM EROM EROM EROM

/* * */

Types.h
Tuesday, February 23, 1988 7:04 PM
/* * object type numbers */ enum { blockType=64, indexType, tableType, shapeType=68, soundType, keymapType, mlistType, menuType, mngType, melType, itblType, fxType, vmapType, pmapType, editType=79, progType, layerType, asrType, lfoType, envType, efxType, invType, mxrType, songType=91, plistType=94, bmapType, lastType }; #define baseType #define globidno
/* /* /* /* /* /* /* /* /* /* /* /* /* /* /* /* /* /* /* /* /* /* /* /* /* /* /*
64 $40 - ignore */ 65 $41 - internal index */ 66 $42 - Master Table */ 68 $44 - LFO Shape Table (named) */ 69 $45 - Sound Block (named) */ 7a $46 - Keyboard Map (named) */ 71 $47 - MIDI Program List (named) */ 72 $48 - Edit Menu */ 73 $49 - Edit Menu Group */ 74 $4A - Edit Menu Element */ 75 $4B - Intonation Table (named) */ 76 $4C - Compiled Effects */ 77 $4D - (Rcv) Velocity Map (named) */ 78 $4E - Rcv Pressure Map (named), V5 */ 79 $4F - Editor */ 80 $50 - Program Data (named) */ 81 $51 - Layer Data (named) */ 82 $52 - ASR Parameter Block */ 83 $53 - LFO Parameter Block */ 84 $54 - ENV Parameter Block */ 85 $55 - EFX Parameter Block */ 86 $56 - INV/NEG Parameter Block */ 87 $57 - MXR Parameter Block */ 91 $5B - Demo Song (named), V5 */ 94 $5E - Program List, V5 */ 95 $5F - Bin Map, V5 */ keep last! */
blockType 8 /* base id # for globals */

Objects.h

Tuesday, February 23, 1988 7:35 PM
/* * Database definitions for K1000 Database Objects * To insure future compatability, all RFU items must be zero! */ typedef typedef typedef typedef #define char unsigned char int unsigned int nDYNAM sByte; uByte; sWord; uWord; 8 /* /* /* /* signed byte */ unsigned byte */ signed word (a short) */ unsigned word (a short) */
/* # dynamic range marks */
/* * generalized data block header */ typedef struct { uByte gdb_type; uByte gdb_idno; sWord gdb_size; } GDB; /* * extended data block header */ typedef struct { uByte xdb_type; uByte xdb_idno; sWord xdb_rfu; long xdb_size; } XDB; /* * Master data block */ typedef struct { uByte mdb_type; uByte mdb_idno; sWord mdb_size; uByte mdb_mode; uByte mdb_chan; uByte mdb_devI0; uByte mdb_dchan; uByte mdb_velMap; uByte mdb_ctlMap; uByte mdb_flags; uByte mdb_bflags; sByte mdb_tune; sByte mdb_trans; uByte mdb_intTab; uByte mdb_refKey; uByte mdb_txPList; uByte mdb_rxPList; uByte mdb_bbPList; uByte mdb_bbentry; uByte mdb_editPos[4]; sByte mdb_pwRange; sByte mdb_spRange; sByte mdb_dynam; uByte mdb_rfu1; uByte mdb_version[4]; uByte mdb_cprogs[16];

/* = layerType */ /* ID of keymapType object */ /* lowest MIDI key # */
uByte sByte sByte uByte sByte sByte uByte uByte uByte uByte uByte uByte uByte uByte sByte uByte sByte sByte uByte uByte } LDB;
ldb_hikey; ldb_trans; ldb_dtune; ldb_delay; ldb_volume; ldb_stereo; ldb_effect; ldb_nLink; ldb_kflags; ldb_xflags; ldb_enable; ldb_legato; ldb_vflags; ldb_dynam; ldb_keyTilt; ldb_balCtl; ldb_spRange; ldb_pwRange; ldb_lastOut; ldb_rfu[7];
/* /* /* /* /* /* /* /* /* /* /* /* /* /* /* /* /* /* /*
highest MIDI key # */ transpose ( semi-tones) */ detune ( cents) */ */ delay (enum table 23) */ volume adjust (dB) */ stereo position */ compiled effect ID */ compiled effect linkage */ key state flags */ effects flags */ enable switch (enum table #1) */ alt attack switch (enum table #1) */ velocity trigger stuff */ dynamic range (dB) */ amplitude tilt (dB) */ balance control (enum table #1) */ soft pedal range (dB) */ pitch wheel range ( quarter-tones) */ used by compiled effects */
/* * ldb_kflags */ #define ldb_ignRels #define ldb_ignSust #define ldb_ignSost #define ldb_ignSusp /* * ldb_xflags */ #define ldb_pwlDis #define ldb_pwlKey #define ldb_volDis #define ldb_touchDis #define ldb_balRev /* * ldb_vflags */ #define ldb_vt1Level #define ldb_vt1Sense #define ldb_vt2Level #define ldb_vt2Sense

0x01 0x02 0x04 0x08

/* /* /* /*
ignore ignore ignore ignore
key release */ sustain pedal */ sostenuto pedal */ suspend pedal */

0x01 0x02 0x08 0x10 0x20

/* /* /* /* /*
pitch wheel disabled */ pitch bend only key down */ volume control disabled */ touch sense disabled */ */ balance control reversed */

0x07 0x08 0x70 0x80

vtrig vtrig vtrig vtrig

level sense level sense

(fff -> ppp) */ */ */ */
/* * Amplitude control patch block */ typedef struct { uByte type, idno; uByte rfu1[2]; uByte amInput; uByte amDepth; sByte amMin , sByte amMax; uByte rfu2[8]; } AFXB; /* * Pitch control patch block */ typedef struct PFXB { uByte type, idno; uByte rfu1[2]; uByte fmInput; uByte fmDepth;
/* = efxtype,1 */ /* /* /* /* mod mod min max source (enum table #1) */ depth (enum table #1) */ depth (dB) */ depth (dB) */
/* = efxType,2 */ /* mod source (enum table #1 */ /* mod depth (enum table @1) */
sByte sByte uByte uByte sByte sByte uByte } PFXB;
fmMin; fmMax; rfu3; dtCtl; dtMin, dtMax; rfu2[4];
/* min depth (cents) */ /* max depth (cents) */ /* detune control (enum table #1 */ /* min value (cents) */ /* max value (cents) */
/* * Envelope control patch block */ typedef struct ENCB { uByte type, idno; uByte rfu1[2]; struct { uByte rfu; uByte rateCtl; uByte minScale uByte maxScale; } atCtl, dtCtl, rtCtl; } ENCB; /* * ASR parameter block */ typedef struct ASRB { uByte asrb_type; uByte asrb_idno; uByte asrb_flags; uByte asrb_trig; uByte asrb_dtime; uByte asrb_atime; uByte asrb_stime; uByte asrb_rtime; } ASRB; /* * asrb_flags */ #define asrb_hold #define asrb_rept #define asrb_effect /* * LFO parameter block */ typedef struct { uByte lfob_type; uByte lfob_idno; uByte lfob_rfu; uByte lfob_flags; uByte lfob_shape; uByte lfob_rtCtl; uByte lfob_rtMin; uByte lfob_rtMax; } LFOB; /* * lfob_flags */ #define lfob_phase #define lfob_effect

/* = efxType,3 */

/* control (enum table #1) */ /* min rate (enum table #5) */ /* max scale (enum table #5) */ /* attack rate */ /* decay rate */ /* release rate */
/* = asrType */ /* /* /* /* /* trigger input (enum table #1) */ delay time (enum table #2) */ attack time (enum table #2) */ sustain time (unused) */ release time (enum table #2) */

0x01 0x02 0x80

/* hold while trigger on */ /* repeat while trigger on */

/* = lfoType */

ID of shapeType object */ rate control (enum table #1) */ min rate (enum table #4) */ max rate (enum table #4) */

0x03 0x80

/* initial phase (0, 90, 180, 270) */
/* * envelope parameter block */ typedef struct { uByte envb_type; uByte envb_idno; sWord envb_size; uByte envb_naSegs; uByte envb_nrSegs; uByte envb_rfu[2]; } ENVB;
/* = envType */ /* # attack segments */ /* # release segments */
/* * envelope segments immediately follow the header * * for all segments but last * level and time are enumerated * * last segment of each section is special: * * if (level > 0) * jump back and repeat going forward * level is segment # to jump to * time is repeat count (0 means infinite) * * else if (level < 0) * loop back and repeat (ie, backward, then forward) * -level is segment # to stop at and change direction * time is repeat count (0 means infinite) * * else (level == 0) * if (time > 0) * time is decay/release time * else if (attack section) * infinite sustain * else * instant release * */ typedef struct { sByte eseg_level; uByte eseg_time; } ESEG; /* * INV/NEG data block */ typedef struct { uByte invb_type; uByte invb_idno; uByte invb_rfu[2]; uByte inub_inv1in; uByte invb_inv2in; uByte invb_neg1in; uByte invb_neg2in; } IHVB, /* * MXR data block */ typedef struct { uByte mxrb_type; uByte mxrb_ldno; uByte mxrb_rfu[2]; uByte mxrb_in1A; uByte mxrb_in1B;
/* level (enum table #28 or #29) */ /* time (enum table #2) */
/* = invType */ /* input (enum table #1) */
/* = mxrType */ /* input (enum table #1) */
uByte mxrb_in2A; uByte mxrb_in2B; } MXRB; /* * keymap (named) * converts key number and velocity */ typedef struct { uByte kmap_type; uByte kmap_idno; sWord kmap_size; sWord kmap_loKey; sWord kmap_nKeys; sWord kmap_keyOff; sWord kmap_nOctv; sWord kmap_pitch; sWord kmap_cents; uByte kmap_flags; uByte kmap_sound; uByte kmap_rfu1; uByte kmap_level; uByte kmap_timbre[nDYNAM]; uByte kmap_rfu2[4]; } KMAP; /* * kmap_flags */ #define kmap_atten #define kmap_tune
to sound file, pitch, and amplitude /* = keymapType */ /* /* /* /* /* /* low MIDI key # */ # keys - 1 */ offset to key data */ notes/octove */ pitch of lowest key */ cents/key */

/* /* /* /* /* /* /* /* /* /* /* /* /* /* /* /* /* /* /* /* /* /* /* /* /* /* /* /*
control source enum */ ENV/ASR time enum */ layer delay enum */ LFO rate enum */ EMU rate scale factor anum */ log multiplier table */ playback rate compensation */ parameter ID table */ menu position table ID */ default object table */ MIDI control mapping table */ front panel button table */ diagnostic table */ product ID/configuration */ Arnold configuration */ initial master parameters */ object mapping table (program only) */ Pseudo parameters (program only) */ velocity -> attenuation table */ velocity -> control value table */ pressure -> control value table */ volume control table */ balance control table */ playback rate table */ LFO phase increment table */ bi-polar EMU level enumeration */ amplitude EMU level enumeration */ amplitude EMU attack table */
1000 Series Program/Layer Structures

Program

$50 ID size $51

ID size

$53 ID ags shape min rate max

$54 size #aseg #rseg ID

program header name sound layer additional layers, global LFOs, ASRs etc.
layer header name (empty) envelopes local LFOs, ASRs etc.

level1 time1

attack

$52 ags ID trig

. levelN timeN level1 time1. levelN timeN release

delay attack releas

Program Header
12 $ID # output prog # 2 size (bytes) stealing option poly limit 3

Layer Header

$51 keymap ID # detune compiled EFX ID# enable switch keyboard tilt compiled EFX 1 ID # low key # delay compiled EFX link alt start switch balance control 2 size (bytes) high key # volume k-ags v-ags soft pedal range transpose stereo x-ags dynamic range p-wheel range 3

Layer Flags

k-ags ignore suspend ignore sostenuto ignore sustain ignore release

balance sense

touch disable

volume disable

p-wheel key only

p-wheel disable

v-trig #2 sense
velocity trigger #2 level

v-trig #1 sense

velocity trigger #1 level

Diagrams

1000 Series Master Parameter Block
48 $42 velocity map ID transmit prog map p-wheel range program pedal 1 assign ags receive prog map soft-pdl range bin bank prog list dynamic range adj 2 size bags bin bank selection software version stamp program assignment per channel pedal 2 assign wheel up assign wheel dn assign slider assign MIDI Mode master tuning 5 Channel master transpose 6 SysEx ID intonation table ID 7 Display Channel intonation key number

ags +/-dB +/-9 off,1.N low high
miscellaneous ags per channel volume adjust per channel stereo position per channel polyphonicity limit per channel MIDI key number range per channel

1000 Series LFO Tables

LFO Rate Enumeration

type=$42 ID=4

LFO Phase Increment

type=$42 ID=27

LFO Shape Table
type=$44 size (bytes) offset to zeroth entry name (nul-terminated) value[-128]. value[0] ID#
size (bytes) 0 offset to phase incr her tz * 100
size (bytes) phase incr[0]
non-linear table. of phase increments
offset to phase incr her tz * 100

phase incr[2047]

. value[127]
1000 Series Keymap Structure
$46 keymap header keymap name byte per key tuning MSB (types 2 or 3) ID size (bytes) # keys - 1 # notes/octave cents/key # timbre levels low MIDI key # (C4=60) offset to key data pitch of lowest key (cents rel C0 = 0) sound ags block ID
tuning LSB (types 1, 2 or 3)
timbre level map (8bytes) indexed by dyn.mark (fff.ppp) rfu
volume adjust (if header ag set)
sound block IDs (if ID in header is zero)
duplicated for each timbre level
sound le IDs (always present)
1000 Series Sound Block Structure
$45 sound block header base header ID # name offset to 1st header # headers - 1 ID # size (bytes)
sound le headers (indexed by ID #) root key # ags (C4=60) highest pitch (cents rel C0=0) attenuation (2048 * dB / 6)
star ting sample address alternate star ting address natural envelopes star t-of-loop address end-of-loop address + 2 offset to normal envelope offset to alternate envelope
1000 Series Velocity Mapping
Velocity to Loudness Table $42 size 0 ppp pp p mp Loudness mf f ff fff Velocity 127 max min 21 Keyboard Velocity Map $4D ID# size ppp pp p mp mf f ff fff name

PAS/Yamaha Terry Gibbs Vibraphone Scholarship
Legendary vibraphonist Terry Gibbs began his career at the age of 12 after winning the Major Bowes Amateur Hour Contest and subsequently began touring professionally. He performed for many years as a drummer and percussionist until his affinity for bebop motivated him to return to the vibes and subsequently become recognized as one of the best ever to grace the genre of bop. After World War II, Gibbs toured with Buddy Rich, Woody Herman, Louie Bellson, Benny Goodman and formed his own band for the Mel Torme television show. Gibbs led his own bands in the 50s and in 1957 formed the critically acclaimed big band The Dream Band. Throughout his career he has enjoyed world acclaim playing with jazz luminaries, Buddy DeFranco, Charlie Parker, Dizzie Gillespie, Horace Silver, Max Roach, Art Blakey, Elvin Jones and Tito Puente. Terry Gibbs is a Percussive Arts Society Hall of Fame member with 65 albums to his credit, winner of three major jazz polls and creator of over 300 compositions. This scholarship is in honor of the indelible mark Gibbs has left on the world of vibes.
One $1,000 scholarship will be awarded.
Eligibility: The scholarship is open to any full time student registered in an accredited college or university school of music during the 20112012 academic year. Applicant must be a current member of the Percussive Arts Society. Application Materials: All applicants must submit a completed application, a letter of recommendation verifying age and school attendance, and a DVD*. Criteria: The selection(s) within the DVD should represent live jazz vibraphone performance and not be edited The applicant must be visible throughout the submitted performance(s) The ability of the applicant to perform on additional percussion or other instruments is not a consideration for this scholarship. *See application page for DVD submission guidelines. Download an application: www.pas.org/experience/contests.aspx Deadline: All materials must be postmarked by March 15, 2011.
FOR MORE INFORMATION CONTACT PERCUSSIVE ARTS SOCIETY 317.974.4488
Materials must be postmarked by: 03/15/2011
Name ___________________________________________________________________

Checklist

The following materials must be postmarked by March 15, 2011: pCompleted application form. p A letter of recommendation verifying age and school attendance. p1 DVD that is no longer than ten minutes in length.
PAS Member ID _____________________ Expiration Date _____________________
Birth Date _______________________________________________________________
pSend materials to: Percussive Arts Society PAS/Yamaha Terry Gibbs Vibraphone Scholarship 110 W. Washington Street, Suite A Indianapolis, IN 46204
Address _________________________________________________________________
City _____________________________________________________________________

DVD Guidelines

Please strictly adhere to the following video submission guidelines: p DVD should be clearly marked with applicants name and age. p DVD length should not exceed ten minutes. Additional time will not be considered and may negatively affect evaluations of the application. Format: The preferred video format is mp4, although we do accept the following file formats: mp4, 3g2, 3gp, 3gp2, 3gpp, asf, asx, avi, divx, mts, m2t, m2ts, m2v, m4v, mkv, mov, mp4, mpe, mpeg, mpg, ogg, wmv. Do not create any menu options as offered on many DVD creation software programs. Application will be immediately discarded if DVD video format does not follow these guidelines. Resolution: 640x480 for standard definition, 4:3 video 853x480 for widescreen DV 1280x720 for high definition

State/Province __________________________________________________________
Zip Code ________________________________________________________________
Country _________________________________________________________________
E-mail __________________________________________________________________
Phone __________________________________________________________________
School Attending ________________________________________________________ Where did you find out about this contest: p Twitter p Percussive Notes p PAS Email Newsletter p Facebook.com p Percussion News p PASIC Program p PAS Website (www.pas.org)
p Other ____________________________________________