xref: /netbsd/sys/sys/midiio.h (revision 74422c2f)

/*	$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_ */