FreeBSD/Linux Kernel Cross Reference
sys/sys/midiio.h

     /*      $NetBSD: midiio.h,v 1.16 2015/09/06 06:01:02 dholland Exp $     */
     
     /*-
      * Copyright (c) 1998 The NetBSD Foundation, Inc.
      * All rights reserved.
      *
      * This code is derived from software contributed to The NetBSD Foundation
      * by Lennart Augustsson (augustss@NetBSD.org) and (native API structures
      * and macros) Chapman Flack (chap@NetBSD.org).
     *
     * 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.
     *
     * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     * ``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 FOUNDATION OR CONTRIBUTORS
     * 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 _SYS_MIDIIO_H_
    #define _SYS_MIDIIO_H_
    
    /*
     * The API defined here produces events compatible with the OSS MIDI API at
     * the binary level.
     */
    
    #include <machine/endian_machdep.h>
    #include <sys/ioccom.h>
    
    /*
     * ioctl() commands for /dev/midi##
     * XXX is directly frobbing an MPU401 even supported? isn't it just run
     * in UART mode?
     */
    typedef struct {
            unsigned        char cmd;
            char            nr_args, nr_returns;
            unsigned char   data[30];
    } mpu_command_rec;
    
    #define MIDI_PRETIME            _IOWR('m', 0, int)
    #define MIDI_MPUMODE            _IOWR('m', 1, int)
    #define MIDI_MPUCMD             _IOWR('m', 2, mpu_command_rec)
    
    
    /* The MPU401 command acknowledge and active sense command */
    #define MIDI_ACK        0xfe
    
    
    /* Sequencer */
    #define SEQUENCER_RESET                 _IO  ('Q', 0)
    #define SEQUENCER_SYNC                  _IO  ('Q', 1)
    #define SEQUENCER_INFO                  _IOWR('Q', 2, struct synth_info)
    #define SEQUENCER_CTRLRATE              _IOWR('Q', 3, int)
    #define SEQUENCER_GETOUTCOUNT           _IOR ('Q', 4, int)
    #define SEQUENCER_GETINCOUNT            _IOR ('Q', 5, int)
    /*#define SEQUENCER_PERCMODE            _IOW ('Q', 6, int)*/
    /*#define SEQUENCER_TESTMIDI            _IOW ('Q', 8, int)*/
    #define SEQUENCER_RESETSAMPLES          _IOW ('Q', 9, int)
    /*
     * The sequencer at present makes no distinction between a 'synth' and a 'midi'.
     * This is actually a cleaner layering than OSS: devices that are onboard
     * synths just attach midi(4) via midisyn and present an ordinary MIDI face to
     * the system. At present the same number is returned for NRSYNTHS and NRMIDIS
     * but don't believe both, or you'll think you have twice as many devices as
     * you really have. The MIDI_INFO ioctl isn't implemented; use SEQUENCER_INFO
     * (which corresponds to OSS's SYNTH_INFO) to get information on any kind of
     * device, though the struct synth_info it uses has some members that only
     * pertain to synths (and get filled in with fixed, probably wrong values,
     * anyway).
     */
    #define SEQUENCER_NRSYNTHS              _IOR ('Q',10, int)
    #define SEQUENCER_NRMIDIS               _IOR ('Q',11, int)
    /*#define SEQUENCER_MIDI_INFO           _IOWR('Q',12, struct midi_info)*/
    #define SEQUENCER_THRESHOLD             _IOW ('Q',13, int)
    #define SEQUENCER_MEMAVL                _IOWR('Q',14, int)
    /*#define SEQUENCER_FM_4OP_ENABLE               _IOW ('Q',15, int)*/
    #define SEQUENCER_PANIC                 _IO  ('Q',17)
    #define SEQUENCER_OUTOFBAND             _IOW ('Q',18, struct seq_event_rec)
    #define SEQUENCER_GETTIME               _IOR ('Q',19, int)
    /*#define SEQUENCER_ID                  _IOWR('Q',20, struct synth_info)*/
    /*#define SEQUENCER_CONTROL             _IOWR('Q',21, struct synth_control)*/
    /*#define SEQUENCER_REMOVESAMPLE                _IOWR('Q',22, struct remove_sample)*/
    
    #if 0
   typedef struct synth_control {
           int     devno;          /* Synthesizer # */
           char    data[4000];     /* Device specific command/data record */
   } synth_control;
   
   typedef struct remove_sample {
           int     devno;          /* Synthesizer # */
           int     bankno;         /* MIDI bank # (0=General MIDI) */
           int     instrno;        /* MIDI instrument number */
   } remove_sample;
   #endif
   
   #define CMDSIZE 8
   typedef struct seq_event_rec {
           u_char  arr[CMDSIZE];
   } seq_event_rec;
   
   struct synth_info {
           char    name[30];
           int     device;
           int     synth_type;
   #define SYNTH_TYPE_FM                   0
   #define SYNTH_TYPE_SAMPLE               1
   #define SYNTH_TYPE_MIDI                 2
   
           int     synth_subtype;
   #define SYNTH_SUB_FM_TYPE_ADLIB         0x00
   #define SYNTH_SUB_FM_TYPE_OPL3          0x01
   #define SYNTH_SUB_MIDI_TYPE_MPU401      0x401
   
   #define SYNTH_SUB_SAMPLE_TYPE_BASIC     0x10
   #define SYNTH_SUB_SAMPLE_TYPE_GUS       SAMPLE_TYPE_BASIC
   
           int     nr_voices;
           int     instr_bank_size;
           u_int   capabilities;
   #define SYNTH_CAP_OPL3                  0x00000002
   #define SYNTH_CAP_INPUT                 0x00000004
   };
   
   /* Sequencer timer */
   #define SEQUENCER_TMR_TIMEBASE          _IOWR('T', 1, int)
   #define SEQUENCER_TMR_START             _IO  ('T', 2)
   #define SEQUENCER_TMR_STOP              _IO  ('T', 3)
   #define SEQUENCER_TMR_CONTINUE          _IO  ('T', 4)
   #define SEQUENCER_TMR_TEMPO             _IOWR('T', 5, int)
   #define SEQUENCER_TMR_SOURCE            _IOWR('T', 6, int)
   #  define SEQUENCER_TMR_INTERNAL        0x00000001
   #if 0
   #  define SEQUENCER_TMR_EXTERNAL        0x00000002
   #  define SEQUENCER_TMR_MODE_MIDI       0x00000010
   #  define SEQUENCER_TMR_MODE_FSK        0x00000020
   #  define SEQUENCER_TMR_MODE_CLS        0x00000040
   #  define SEQUENCER_TMR_MODE_SMPTE      0x00000080
   #endif
   #define SEQUENCER_TMR_METRONOME         _IOW ('T', 7, int)
   #define SEQUENCER_TMR_SELECT            _IOW ('T', 8, int)
   
   
   #define MIDI_CTRL_BANK_SELECT_MSB       0
   #define MIDI_CTRL_MODULATION_MSB        1
   #define MIDI_CTRL_BREATH_MSB            2
   #define MIDI_CTRL_FOOT_MSB              4
   #define MIDI_CTRL_PORTAMENTO_TIME_MSB   5
   #define MIDI_CTRL_DATA_ENTRY_MSB        6
   #define MIDI_CTRL_CHANNEL_VOLUME_MSB    7
   #define MIDI_CTRL_BALANCE_MSB           8
   #define MIDI_CTRL_PAN_MSB               10
   #define MIDI_CTRL_EXPRESSION_MSB        11
   #define MIDI_CTRL_EFFECT_1_MSB          12
   #define MIDI_CTRL_EFFECT_2_MSB          13
   #define MIDI_CTRL_GENERAL_PURPOSE_1_MSB 16
   #define MIDI_CTRL_GENERAL_PURPOSE_2_MSB 17
   #define MIDI_CTRL_GENERAL_PURPOSE_3_MSB 18
   #define MIDI_CTRL_GENERAL_PURPOSE_4_MSB 19
   #define MIDI_CTRL_BANK_SELECT_LSB       32
   #define MIDI_CTRL_MODULATION_LSB        33
   #define MIDI_CTRL_BREATH_LSB            34
   #define MIDI_CTRL_FOOT_LSB              36
   #define MIDI_CTRL_PORTAMENTO_TIME_LSB   37
   #define MIDI_CTRL_DATA_ENTRY_LSB        38
   #define MIDI_CTRL_CHANNEL_VOLUME_LSB    39
   #define MIDI_CTRL_BALANCE_LSB           40
   #define MIDI_CTRL_PAN_LSB               42
   #define MIDI_CTRL_EXPRESSION_LSB        43
   #define MIDI_CTRL_EFFECT_1_LSB          44
   #define MIDI_CTRL_EFFECT_2_LSB          45
   #define MIDI_CTRL_GENERAL_PURPOSE_1_LSB 48
   #define MIDI_CTRL_GENERAL_PURPOSE_2_LSB 49
   #define MIDI_CTRL_GENERAL_PURPOSE_3_LSB 50
   #define MIDI_CTRL_GENERAL_PURPOSE_4_LSB 51
   #define MIDI_CTRL_HOLD_1                64
   #define MIDI_CTRL_PORTAMENTO            65
   #define MIDI_CTRL_SOSTENUTO             66
   #define MIDI_CTRL_SOFT_PEDAL            67
   #define MIDI_CTRL_LEGATO                68
   #define MIDI_CTRL_HOLD_2                69
   #define MIDI_CTRL_SOUND_VARIATION       70
   #define MIDI_CTRL_HARMONIC_INTENSITY    71
   #define MIDI_CTRL_RELEASE_TIME          72
   #define MIDI_CTRL_ATTACK_TIME           73
   #define MIDI_CTRL_BRIGHTNESS            74
   #define MIDI_CTRL_DECAY_TIME            75
   #define MIDI_CTRL_VIBRATO_RATE          76
   #define MIDI_CTRL_VIBRATO_DEPTH         77
   #define MIDI_CTRL_VIBRATO_DELAY         78
   #define MIDI_CTRL_VIBRATO_DECAY         MIDI_CTRL_VIBRATO_DELAY /*deprecated*/
   #define MIDI_CTRL_SOUND_10              79
   #define MIDI_CTRL_GENERAL_PURPOSE_5     80
   #define MIDI_CTRL_GENERAL_PURPOSE_6     81
   #define MIDI_CTRL_GENERAL_PURPOSE_7     82
   #define MIDI_CTRL_GENERAL_PURPOSE_8     83
   #define MIDI_CTRL_PORTAMENTO_CONTROL    84
   #define MIDI_CTRL_EFFECT_DEPTH_1        91
   #define MIDI_CTRL_EFFECT_DEPTH_2        92
   #define MIDI_CTRL_EFFECT_DEPTH_3        93
   #define MIDI_CTRL_EFFECT_DEPTH_4        94
   #define MIDI_CTRL_EFFECT_DEPTH_5        95
   #define MIDI_CTRL_RPN_INCREMENT         96
   #define MIDI_CTRL_RPN_DECREMENT         97
   #define MIDI_CTRL_NRPN_LSB              98
   #define MIDI_CTRL_NRPN_MSB              99
   #define MIDI_CTRL_RPN_LSB               100
   #define MIDI_CTRL_RPN_MSB               101
   #define MIDI_CTRL_SOUND_OFF             120
   #define MIDI_CTRL_RESET                 121
   #define MIDI_CTRL_LOCAL                 122
   #define MIDI_CTRL_NOTES_OFF             123
   #define MIDI_CTRL_ALLOFF                MIDI_CTRL_NOTES_OFF /*deprecated*/
   #define MIDI_CTRL_OMNI_OFF              124
   #define MIDI_CTRL_OMNI_ON               125
   #define MIDI_CTRL_POLY_OFF              126
   #define MIDI_CTRL_POLY_ON               127
   
   #define MIDI_BEND_NEUTRAL       (1<<13)
   
   #define MIDI_RPN_PITCH_BEND_SENSITIVITY 0
   #define MIDI_RPN_CHANNEL_FINE_TUNING    1
   #define MIDI_RPN_CHANNEL_COARSE_TUNING  2
   #define MIDI_RPN_TUNING_PROGRAM_CHANGE  3
   #define MIDI_RPN_TUNING_BANK_SELECT     4
   #define MIDI_RPN_MODULATION_DEPTH_RANGE 5
   
   #define MIDI_NOTEOFF            0x80
   #define MIDI_NOTEON             0x90
   #define MIDI_KEY_PRESSURE       0xA0
   #define MIDI_CTL_CHANGE         0xB0
   #define MIDI_PGM_CHANGE         0xC0
   #define MIDI_CHN_PRESSURE       0xD0
   #define MIDI_PITCH_BEND         0xE0
   #define MIDI_SYSTEM_PREFIX      0xF0
   
   #define MIDI_IS_STATUS(d) ((d) >= 0x80)
   #define MIDI_IS_COMMON(d) ((d) >= 0xf0)
   
   #define MIDI_SYSEX_START        0xF0
   #define MIDI_SYSEX_END          0xF7
   
   #define MIDI_GET_STATUS(d) ((d) & 0xf0)
   #define MIDI_GET_CHAN(d) ((d) & 0x0f)
   
   #define MIDI_HALF_VEL 64
   
   #define SEQ_LOCAL               0x80
   #define SEQ_TIMING              0x81
   #define SEQ_CHN_COMMON          0x92
   #define SEQ_CHN_VOICE           0x93
   #define SEQ_SYSEX               0x94
   #define SEQ_FULLSIZE            0xfd
   
   #define SEQ_MK_CHN_VOICE(e, unit, cmd, chan, key, vel) (\
       (e)->arr[0] = SEQ_CHN_VOICE, (e)->arr[1] = (unit), (e)->arr[2] = (cmd),\
       (e)->arr[3] = (chan), (e)->arr[4] = (key), (e)->arr[5] = (vel),\
       (e)->arr[6] = 0, (e)->arr[7] = 0)
   #define SEQ_MK_CHN_COMMON(e, unit, cmd, chan, p1, p2, w14) (\
       (e)->arr[0] = SEQ_CHN_COMMON, (e)->arr[1] = (unit), (e)->arr[2] = (cmd),\
       (e)->arr[3] = (chan), (e)->arr[4] = (p1), (e)->arr[5] = (p2),\
       *(short*)&(e)->arr[6] = (w14))
   
   #if _BYTE_ORDER == _BIG_ENDIAN
   /* big endian */
   #define SEQ_PATCHKEY(id) (0xfd00|id)
   #else
   /* little endian */
   #define SEQ_PATCHKEY(id) ((id<<8)|0xfd)
   #endif
   struct sysex_info {
           uint16_t        key;    /* Use SYSEX_PATCH or MAUI_PATCH here */
   #define SEQ_SYSEX_PATCH SEQ_PATCHKEY(0x05)
   #define SEQ_MAUI_PATCH  SEQ_PATCHKEY(0x06)
           int16_t device_no;      /* Synthesizer number */
           int32_t len;            /* Size of the sysex data in bytes */
           u_char  data[1];        /* Sysex data starts here */
   };
   #define SEQ_SYSEX_HDRSIZE ((u_long)((struct sysex_info *)0)->data)
   
   typedef unsigned char sbi_instr_data[32];
   struct sbi_instrument {
           uint16_t key;   /* FM_PATCH or OPL3_PATCH */
   #define SBI_FM_PATCH    SEQ_PATCHKEY(0x01)
   #define SBI_OPL3_PATCH  SEQ_PATCHKEY(0x03)
           int16_t         device;
           int32_t         channel;
           sbi_instr_data  operators;
   };
   
   #define TMR_RESET               0       /* beware: not an OSS event */
   #define TMR_WAIT_REL            1       /* Time relative to the prev time */
   #define TMR_WAIT_ABS            2       /* Absolute time since TMR_START */
   #define TMR_STOP                3
   #define TMR_START               4
   #define TMR_CONTINUE            5
   #define TMR_TEMPO               6
   #define TMR_ECHO                8
   #define TMR_CLOCK               9       /* MIDI clock */
   #define TMR_SPP                 10      /* Song position pointer */
   #define TMR_TIMESIG             11      /* Time signature */
   
   /* Old sequencer definitions */
   #define SEQOLD_CMDSIZE 4
   
   #define SEQOLD_NOTEOFF          0
   #define SEQOLD_NOTEON           1
   #define SEQOLD_WAIT             TMR_WAIT_ABS
   #define SEQOLD_PGMCHANGE        3
   #define SEQOLD_SYNCTIMER        TMR_START
   #define SEQOLD_MIDIPUTC         5
   #define SEQOLD_ECHO             TMR_ECHO
   #define SEQOLD_AFTERTOUCH       9
   #define SEQOLD_CONTROLLER       10
   #define SEQOLD_PRIVATE          0xfe
   #define SEQOLD_EXTENDED         0xff
   
   /*
    * The 'midipitch' data type, used in the kernel between the midisyn layer and
    * onboard synth drivers, and in userland as parameters to the MIDI Tuning Spec
    * (RP-012) universal-system-exclusive messages. It is a MIDI key number shifted
    * left to accommodate 14 bit sub-semitone resolution. In this representation,
    * tuning and bending adjustments are simple addition and subtraction.
    */
   typedef int32_t midipitch_t;
   
   /*
    * Nominal conversions between midipitches and key numbers. (Beware that these
    * are the nominal, standard correspondences, but whole point of the MIDI Tuning
    * Spec is that you can set things up so the hardware might render key N at
    * actual pitch MIDIPITCH_FROM_KEY(N)+c for some correction c.)
    */
   #define MIDIPITCH_FROM_KEY(k) ((k)<<14)
   #define MIDIPITCH_TO_KEY(mp) (((mp)+(1<<13))>>14)
   
   #define MIDIPITCH_MAX (MIDIPITCH_FROM_KEY(128)-2) /* ...(128)-1 is reserved */
   #define MIDIPITCH_OCTAVE  196608
   #define MIDIPITCH_SEMITONE 16384
   #define MIDIPITCH_CENT       164 /* this, regrettably, is inexact. */
   
   /*
    * For rendering, convert a midipitch (after all tuning adjustments) to Hz.
    * The conversion is DEFINED as MIDI key 69.00000 (A) === 440 Hz equal tempered
    * always. Alternate tunings are obtained by adjusting midipitches.
    *
    * The midihz18_t (Hz shifted left for 18-bit sub-Hz resolution) covers the
    * full midipitch range without losing 21-bit precision, as the lowest midipitch
    * is ~8 Hz (~3 bits left of radix point, 18 right) and for the highest the
    * result still fits in a uint32.
    */
   typedef uint32_t midihz18_t;
   
   #define MIDIHZ18_TO_HZ(h18) ((h18)>>18) /* truncates! ok for dbg msgs maybe */
   
   #ifndef _KERNEL
   /*
    * With floating point in userland, can also manipulate midipitches as
    * floating-point fractional MIDI key numbers (tuning adjustments are still
    * additive), and hz18 as fractional Hz (adjustments don't add in this form).
    */
   #include <math.h>
   #define MIDIPITCH_TO_FRKEY(mp) (scalbn((mp),-14))
   #define MIDIPITCH_FROM_FRKEY(frk) ((midipitch_t)round(scalbn((frk),14)))
   #define MIDIHZ18_TO_FRHZ(h18) (scalbn((h18),-18))
   #define MIDIHZ18_FROM_FRHZ(frh) ((midihz18_t)round(scalbn((frh),18)))
   
   #define MIDIPITCH_TO_FRHZ(mp) (440*pow(2,(MIDIPITCH_TO_FRKEY((mp))-69)/12))
   #define MIDIPITCH_FROM_FRHZ(fhz) \
                                  MIDIPITCH_FROM_FRKEY(69+12*log((fhz)/440)/log(2))
   #define MIDIPITCH_TO_HZ18(mp) MIDIHZ18_FROM_FRHZ(MIDIPITCH_TO_FRHZ((mp)))
   #define MIDIPITCH_FROM_HZ18(h18) MIDIPITCH_FROM_FRHZ(MIDIHZ18_TO_FRHZ((h18)))
   
   #else /* no fp in kernel; only an accurate to-hz18 conversion is implemented */
   
   extern midihz18_t midisyn_mp2hz18(midipitch_t);
   #define MIDIPITCH_TO_HZ18(mp) (midisyn_mp2hz18((mp)))
   
   #endif /* _KERNEL */
   
   
   /*
    * A native API for the /dev/music sequencer device follows. The event
    * structures are OSS events at the level of bytes, but for developing or
    * porting applications some macros and documentation are needed to generate
    * and dissect the events; here they are. For porting existing OSS applications,
    * sys/soundcard.h can be extended to supply the usual OSS macros, defining them
    * in terms of these.
    */
   
   /*
    * TODO: determine OSS compatible structures for TMR_RESET and TMR_CLOCK,
    *       OSS values of EV_SYSTEM, SNDCTL_SEQ_ACTSENSE_ENABLE,
    *       SNDCTL_SEQ_TIMING_ENABLE, and SNDCTL_SEQ_RT_ENABLE.
    * (TMR_RESET may be a NetBSD extension: it is generated in sequencer.c and
    * has no args. To be corrected if a different definition is found anywhere.)
    */
   typedef union {
   
   #define _EVT_HDR \
           uint8_t tag
   
           _EVT_HDR;
   
   #define _LOCAL_HDR \
           _EVT_HDR; \
           uint8_t op
   
           struct { _LOCAL_HDR; } local;
   
           struct {
                   _LOCAL_HDR;
                   uint16_t _zero;
                   uint32_t devmask;
           } l_startaudio;
   
   /* define a constructor for local evts - someday when we support any */
   
   #define _TIMING_HDR \
           _LOCAL_HDR; \
           uint16_t _zeroh
           struct { _TIMING_HDR; } timing;
           
           struct {
                   _TIMING_HDR;
                   uint32_t divisions;
           } t_WAIT_REL, t_WAIT_ABS;
           
           struct {
                   _TIMING_HDR;
                   uint32_t _zero;
           } t_STOP, t_START, t_CONTINUE, t_RESET;
           
           struct {
                   _TIMING_HDR;
                   uint32_t bpm; /* unambiguously, (MIDI clocks/minute)/24 */
           } t_TEMPO;
           
           struct {
                   _TIMING_HDR;
                   uint32_t cookie;
           } t_ECHO;
           
           struct {
                   _TIMING_HDR;
                   uint32_t midibeat; /* in low 14 bits; midibeat: 6 MIDI clocks */
           } t_SPP;
           
           struct {
                   _TIMING_HDR;
   #if _BYTE_ORDER == _BIG_ENDIAN
                   uint8_t numerator;
                   uint8_t lg2denom;
                   uint8_t clks_per_click;
                   uint8_t dsq_per_24clks;
   #elif _BYTE_ORDER == _LITTLE_ENDIAN
                   uint8_t dsq_per_24clks;
                   uint8_t clks_per_click;
                   uint8_t lg2denom;
                   uint8_t numerator;
   #else
   #error "unexpected _BYTE_ORDER"
   #endif
           } t_TIMESIG;
           
           struct { /* use this only to implement OSS compatibility macro */
                   _TIMING_HDR;
                   uint32_t signature;
           } t_osscompat_timesig;
           
   
   #define _COMMON_HDR \
           _EVT_HDR; \
           uint8_t device; \
           uint8_t op; \
           uint8_t channel
   
           struct { _COMMON_HDR; } common;
   
           struct {
                   _COMMON_HDR;
                   uint8_t controller;
                   uint8_t _zero;
                   uint16_t value;
           } c_CTL_CHANGE;
           
           struct {
                   _COMMON_HDR;
                   uint8_t program;
                   uint8_t _zero0;
                   uint16_t _zero1;
           } c_PGM_CHANGE;
           
           struct {
                   _COMMON_HDR;
                   uint8_t pressure;
                   uint8_t _zero0;
                   uint16_t _zero1;
           } c_CHN_PRESSURE;
           
           struct {
                   _COMMON_HDR;
                   uint8_t _zero0;
                   uint8_t _zero1;
                   uint16_t value;
           } c_PITCH_BEND;
   
   #define _VOICE_HDR \
           _COMMON_HDR; \
           uint8_t key
   
           struct { _VOICE_HDR; }  voice;
   
           struct {
                   _VOICE_HDR;
                   uint8_t velocity;
                   uint16_t _zero;
           } c_NOTEOFF, c_NOTEON;
   
           struct {
                   _VOICE_HDR;
                   uint8_t pressure;
                   uint16_t _zero;
           } c_KEY_PRESSURE;
   
           struct {
                   _EVT_HDR;
                   uint8_t device;
                   uint8_t buffer[6];
           } sysex;
   
           struct {
                   _EVT_HDR;
                   uint8_t device;
                   uint8_t status;
                   uint8_t data[2];
           } system;
           
           struct {
                   _EVT_HDR;
                   uint8_t byte;
                   uint8_t device;
                   uint8_t _zero0;
                   uint32_t _zero1;
           } putc; /* a seqold event that's still needed at times, ugly as 'tis */
   
           struct {
                   _EVT_HDR;
                   uint8_t byte[7];
           } unknown; /* for debug/display */
   
   #undef _VOICE_HDR
   #undef _COMMON_HDR
   #undef _TIMING_HDR
   #undef _LOCAL_HDR
   #undef _EVT_HDR
           
   } __packed seq_event_t;
   
   #define _SEQ_TAG_NOTEOFF        SEQ_CHN_VOICE
   #define _SEQ_TAG_NOTEON         SEQ_CHN_VOICE
   #define _SEQ_TAG_KEY_PRESSURE   SEQ_CHN_VOICE
   
   #define _SEQ_TAG_CTL_CHANGE     SEQ_CHN_COMMON
   #define _SEQ_TAG_PGM_CHANGE     SEQ_CHN_COMMON
   #define _SEQ_TAG_CHN_PRESSURE   SEQ_CHN_COMMON
   #define _SEQ_TAG_PITCH_BEND     SEQ_CHN_COMMON
   
   #if __STDC_VERSION__ >= 199901L
   
   #define SEQ_MK_EVENT(_member,_tag,...)                                  \
   (seq_event_t){ ._member = { .tag = (_tag), __VA_ARGS__ } }
   
   #define SEQ_MK_TIMING(_op,...)                                          \
   SEQ_MK_EVENT(t_##_op, SEQ_TIMING, .op = TMR_##_op, __VA_ARGS__)
   
   #define SEQ_MK_CHN(_op,...)                                             \
   SEQ_MK_EVENT(c_##_op, _SEQ_TAG_##_op, .op = MIDI_##_op, __VA_ARGS__)
   
   #define SEQ_MK_SYSEX(_dev,...)                                          \
   SEQ_MK_EVENT(sysex, 0x94, .device=(_dev),                               \
                .buffer={0xff, 0xff, 0xff, 0xff, 0xff, 0xff, __VA_ARGS__})
   
   #else /* assume gcc 2.95.3 */
   
   #define SEQ_MK_EVENT(_member,_tag,_args...)                             \
   (seq_event_t){ ._member = { .tag = (_tag), _args } }
   
   #define SEQ_MK_TIMING(_op,_args...)                                             \
   SEQ_MK_EVENT(t_##_op, SEQ_TIMING, .op = TMR_##_op, _args)
   
   #define SEQ_MK_CHN(_op,_args...)                                        \
   SEQ_MK_EVENT(c_##_op, _SEQ_TAG_##_op, .op = MIDI_##_op, _args)
   
   #define SEQ_MK_SYSEX(_dev,_args...)                                             \
   SEQ_MK_EVENT(sysex, 0x94, .device=(_dev),                               \
                .buffer={0xff, 0xff, 0xff, 0xff, 0xff, 0xff, _args})
   
   #endif /* c99 vs. gcc 2.95.3 */
   
   #if 0
   #include <fcntl.h>
   #include <stdio.h>
   int
   main(int argc, char **argv)
   {
           int i;
           int fd;
           seq_event_t e;
           
           /* simple usage example (add a buffer to reduce syscall overhead) */
           fd = open("/dev/music", O_RDWR);
           write(fd, &SEQ_MK_TIMING(START), sizeof (seq_event_t));
           
           read(fd, &e, sizeof e);
           switch ( e.tag ) {
           case SEQ_CHN_VOICE:
                   switch ( e.voice.op ) {
                   case MIDI_NOTEON:
                           printf("Note on, dev=%d chn=%d key=%d vel=%d\n",
                               e.c_NOTEON.device, e.c_NOTEON.channel,
                               e.c_NOTEON.key, e.c_NOTEON.velocity);
                   }
           }
   
           /* all the macros: */
           e = SEQ_MK_TIMING(START);
           e = SEQ_MK_TIMING(STOP);
           e = SEQ_MK_TIMING(CONTINUE);
           /*
            * Wait until the specified number of divisions from the timer start
            * (abs) or the preceding event (rel). The number of divisions to a
            * beat or to a MIDI clock is determined by the timebase (set by
            * ioctl). The tempo is expressed in beats per minute, where a beat
            * is always 24 MIDI clocks (and usually equated to a quarter note,
            * but that can be changed with timesig)--that is, tempo is
            * (MIDI clocks per minute)/24. The timebase is the number of divisions
            * in a beat--that is, the number of divisions that make up 24 MIDI
            * clocks--so the timebase is 24*(divisions per MIDI clock). The MThd
            * header in a SMF gives the 'natural' timebase for the file; if the
            * timebase is set accordingly, then the delay values appearing in the
            * tracks are in terms of divisions, and can be used as WAIT_REL
            * arguments without modification.
            */
           e = SEQ_MK_TIMING(WAIT_ABS, .divisions=192);
           e = SEQ_MK_TIMING(WAIT_REL, .divisions=192);
           /*
            * The 'beat' in bpm is 24 MIDI clocks (usually a quarter note but
            * changeable with timesig).
            */
           e = SEQ_MK_TIMING(TEMPO, .bpm=84);
           /*
            * An ECHO event on output appears on input at the appointed time; the
            * cookie can be anything of interest to the application. Can be used
            * in schemes to get some control over latency.
            */
           e = SEQ_MK_TIMING(ECHO, .cookie=0xfeedface);
           /*
            * A midibeat is smaller than a beat. It is six MIDI clocks, or a fourth
            * of a beat, or a sixteenth note if the beat is a quarter. SPP is a
            * request to position at the requested midibeat from the start of the
            * sequence. [sequencer does not at present implement SPP]
            */
           e = SEQ_MK_TIMING(SPP, .midibeat=128);
           /*
            * numerator and lg2denom describe the time signature as it would
            * appear on a staff, where lg2denom of 0,1,2,3... corresponds to
            * denominator of 1,2,4,8... respectively. So the example below
            * corresponds to 4/4. dsq_per_24clks defines the relationship of
            * MIDI clocks to note values, by specifying the number of
            * demisemiquavers (32nd notes) represented by 24 MIDI clocks.
            * The default is 8 demisemiquavers, or a quarter note.
            * clks_per_click can configure a metronome (for example, the MPU401
            * had such a feature in intelligent mode) to click every so many
            * MIDI clocks. The 24 in this example would give a click every quarter
            * note. [sequencer does not at present implement TIMESIG]
            */
           e = SEQ_MK_TIMING(TIMESIG, .numerator=4, .lg2denom=2,
                                      .clks_per_click=24, .dsq_per_24clks=8);
           /*
            * This example declares 6/8 time where the beat (24 clocks) is the
            * eighth note, but the metronome clicks every dotted quarter (twice
            * per measure):
            */
           e = SEQ_MK_TIMING(TIMESIG, .numerator=6, .lg2denom=3,
                                      .clks_per_click=72, .dsq_per_24clks=4);
           /*
            * An alternate declaration for 6/8 where the beat (24 clocks) is now
            * the dotted quarter and corresponds to the metronome click:
            */
           e = SEQ_MK_TIMING(TIMESIG, .numerator=6, .lg2denom=3,
                                      .clks_per_click=24, .dsq_per_24clks=12);
           /*
            * It would also be possible to keep the default correspondence of
            * 24 clocks to the quarter note (8 dsq), and still click the metronome
            * each dotted quarter:
            */
           e = SEQ_MK_TIMING(TIMESIG, .numerator=6, .lg2denom=3,
                                      .clks_per_click=36, .dsq_per_24clks=8);
   
           e = SEQ_MK_CHN(NOTEON,  .device=1, .channel=0, .key=60, .velocity=64);
           e = SEQ_MK_CHN(NOTEOFF, .device=1, .channel=0, .key=60, .velocity=64);
           e = SEQ_MK_CHN(KEY_PRESSURE, .device=1, .channel=0, .key=60,
                                        .pressure=64);
           
           /*
            * sequencer does not at present implement CTL_CHANGE well. The API
            * provides for a 14-bit value where you give the controller index
            * of the controller MSB and sequencer will split the 14-bit value to
            * the controller MSB and LSB for you--but it doesn't; it ignores the
            * high bits of value and writes the low bits whether you have specified
            * MSB or LSB. That would not be hard to fix but for the fact that OSS
            * itself seems to suffer from the same mixup (and its behavior differs
            * with whether the underlying device is an onboard synth or a MIDI
            * link!) so there is surely a lot of code that relies on it being
            * broken :(.
            * (Note: as the OSS developers have ceased development of the
            * /dev/music API as of OSS4, it would be possible given a complete
            * list of the events defined in OSS4 to add some new ones for native
            * use without fear of future conflict, such as a better ctl_change.)
            */
           e = SEQ_MK_CHN(CTL_CHANGE, .device=1, .channel=0,
                          .controller=MIDI_CTRL_EXPRESSION_MSB, .value=8192);/*XX*/
           /*
            * The way you really have to do it:
            */
           e = SEQ_MK_CHN(CTL_CHANGE, .device=1, .channel=0,
                          .controller=MIDI_CTRL_EXPRESSION_MSB, .value=8192>>7);
           e = SEQ_MK_CHN(CTL_CHANGE, .device=1, .channel=0,
                          .controller=MIDI_CTRL_EXPRESSION_LSB, .value=8192&0x7f);
   
           e = SEQ_MK_CHN(PGM_CHANGE,   .device=1, .channel=0, .program=51);
           e = SEQ_MK_CHN(CHN_PRESSURE, .device=1, .channel=0, .pressure=64);
           e = SEQ_MK_CHN(PITCH_BEND,   .device=1, .channel=0, .value=8192);
           
           /*
            * A SYSEX event carries up to six bytes of a system exclusive message.
            * The first such message must begin with MIDI_SYSEX_START (0xf0), the
            * last must end with MIDI_SYSEX_END (0xf7), and only the last may carry
            * fewer than 6 bytes. To supply message bytes in the macro, you must
            * prefix the first with [0]= as shown. The macro's first argument is
            * the device.
            */
           e = SEQ_MK_SYSEX(1,[0]=MIDI_SYSEX_START,1,2,MIDI_SYSEX_END);
           /*
            * In some cases it may be easier to use the macro only to initialize
            * the event, and fill in the message bytes later. The code that fills
            * in the message does not need to store 0xff following the SYSEX_END.
            */
           e = SEQ_MK_SYSEX(1);
           for ( i = 0; i < 3; ++ i )
                   e.sysex.buffer[i] = i;
           /*
            * It would be nice to think the old /dev/sequencer MIDIPUTC event
            * obsolete, but it is still needed (absent any better API) by any MIDI
            * file player that will implement the ESCAPED events that may occur in
            * SMF. Sorry. Here's how to use it:
            */
           e = SEQ_MK_EVENT(putc, SEQOLD_MIDIPUTC, .device=1, .byte=42);
           
           printf("confirm event size: %d (should be 8)\n", sizeof (seq_event_t));
           return 0;
   }
   #endif /* 0 */
   
   #endif /* !_SYS_MIDIIO_H_ */

Cache object: 4d21c24b97f376f02ef767dc15c3a300