mirror of
https://github.com/Fishwaldo/Star64_linux.git
synced 2025-06-25 16:11:45 +00:00
[ALSA] Remove xxx_t typedefs: Sequencer
Modules: ALSA sequencer Remove xxx_t typedefs from the core sequencer codes. Signed-off-by: Takashi Iwai <tiwai@suse.de>
This commit is contained in:
Takashi Iwai
Jaroslav Kysela
parent
6ac77bc180
commit
c7e0b5bf9f
33 changed files with 1358 additions and 1274 deletions
|
|
@ -35,13 +35,13 @@
|
|||
*/
|
||||
|
||||
/** system messages
|
||||
* event data type = #sndrv_seq_result_t
|
||||
* event data type = #snd_seq_result
|
||||
*/
|
||||
#define SNDRV_SEQ_EVENT_SYSTEM 0
|
||||
#define SNDRV_SEQ_EVENT_RESULT 1
|
||||
|
||||
/** note messages (channel specific)
|
||||
* event data type = #sndrv_seq_ev_note
|
||||
* event data type = #snd_seq_ev_note
|
||||
*/
|
||||
#define SNDRV_SEQ_EVENT_NOTE 5
|
||||
#define SNDRV_SEQ_EVENT_NOTEON 6
|
||||
|
|
@ -49,7 +49,7 @@
|
|||
#define SNDRV_SEQ_EVENT_KEYPRESS 8
|
||||
|
||||
/** control messages (channel specific)
|
||||
* event data type = #sndrv_seq_ev_ctrl
|
||||
* event data type = #snd_seq_ev_ctrl
|
||||
*/
|
||||
#define SNDRV_SEQ_EVENT_CONTROLLER 10
|
||||
#define SNDRV_SEQ_EVENT_PGMCHANGE 11
|
||||
|
|
@ -60,7 +60,7 @@
|
|||
#define SNDRV_SEQ_EVENT_REGPARAM 16 /**< 14 bit RPN address + 14 bit unsigned value */
|
||||
|
||||
/** synchronisation messages
|
||||
* event data type = #sndrv_seq_ev_ctrl
|
||||
* event data type = #snd_seq_ev_ctrl
|
||||
*/
|
||||
#define SNDRV_SEQ_EVENT_SONGPOS 20 /* Song Position Pointer with LSB and MSB values */
|
||||
#define SNDRV_SEQ_EVENT_SONGSEL 21 /* Song Select with song ID number */
|
||||
|
|
@ -69,7 +69,7 @@
|
|||
#define SNDRV_SEQ_EVENT_KEYSIGN 24 /* SMF Key Signature event */
|
||||
|
||||
/** timer messages
|
||||
* event data type = sndrv_seq_ev_queue_control_t
|
||||
* event data type = snd_seq_ev_queue_control
|
||||
*/
|
||||
#define SNDRV_SEQ_EVENT_START 30 /* midi Real Time Start message */
|
||||
#define SNDRV_SEQ_EVENT_CONTINUE 31 /* midi Real Time Continue message */
|
||||
|
|
@ -95,7 +95,7 @@
|
|||
#define SNDRV_SEQ_EVENT_OSS 51 /* OSS raw event */
|
||||
|
||||
/** system status messages (broadcast for subscribers)
|
||||
* event data type = sndrv_seq_addr_t
|
||||
* event data type = snd_seq_addr
|
||||
*/
|
||||
#define SNDRV_SEQ_EVENT_CLIENT_START 60 /* new client has connected */
|
||||
#define SNDRV_SEQ_EVENT_CLIENT_EXIT 61 /* client has left the system */
|
||||
|
|
@ -105,13 +105,13 @@
|
|||
#define SNDRV_SEQ_EVENT_PORT_CHANGE 65 /* port status/info has changed */
|
||||
|
||||
/** port connection changes
|
||||
* event data type = sndrv_seq_connect_t
|
||||
* event data type = snd_seq_connect
|
||||
*/
|
||||
#define SNDRV_SEQ_EVENT_PORT_SUBSCRIBED 66 /* ports connected */
|
||||
#define SNDRV_SEQ_EVENT_PORT_UNSUBSCRIBED 67 /* ports disconnected */
|
||||
|
||||
/** synthesizer events
|
||||
* event data type = sndrv_seq_eve_sample_control_t
|
||||
* event data type = snd_seq_eve_sample_control
|
||||
*/
|
||||
#define SNDRV_SEQ_EVENT_SAMPLE 70 /* sample select */
|
||||
#define SNDRV_SEQ_EVENT_SAMPLE_CLUSTER 71 /* sample cluster select */
|
||||
|
|
@ -162,7 +162,7 @@
|
|||
/* 119-129: reserved */
|
||||
|
||||
/* 130-139: variable length events
|
||||
* event data type = sndrv_seq_ev_ext
|
||||
* event data type = snd_seq_ev_ext
|
||||
* (SNDRV_SEQ_EVENT_LENGTH_VARIABLE must be set)
|
||||
*/
|
||||
#define SNDRV_SEQ_EVENT_SYSEX 130 /* system exclusive data (variable length) */
|
||||
|
|
@ -186,18 +186,18 @@
|
|||
#define SNDRV_SEQ_EVENT_NONE 255
|
||||
|
||||
|
||||
typedef unsigned char sndrv_seq_event_type_t;
|
||||
typedef unsigned char snd_seq_event_type_t;
|
||||
|
||||
/** event address */
|
||||
struct sndrv_seq_addr {
|
||||
struct snd_seq_addr {
|
||||
unsigned char client; /**< Client number: 0..255, 255 = broadcast to all clients */
|
||||
unsigned char port; /**< Port within client: 0..255, 255 = broadcast to all ports */
|
||||
};
|
||||
|
||||
/** port connection */
|
||||
struct sndrv_seq_connect {
|
||||
struct sndrv_seq_addr sender;
|
||||
struct sndrv_seq_addr dest;
|
||||
struct snd_seq_connect {
|
||||
struct snd_seq_addr sender;
|
||||
struct snd_seq_addr dest;
|
||||
};
|
||||
|
||||
|
||||
|
|
@ -226,7 +226,7 @@ struct sndrv_seq_connect {
|
|||
|
||||
|
||||
/* note event */
|
||||
struct sndrv_seq_ev_note {
|
||||
struct snd_seq_ev_note {
|
||||
unsigned char channel;
|
||||
unsigned char note;
|
||||
unsigned char velocity;
|
||||
|
|
@ -235,7 +235,7 @@ struct sndrv_seq_ev_note {
|
|||
};
|
||||
|
||||
/* controller event */
|
||||
struct sndrv_seq_ev_ctrl {
|
||||
struct snd_seq_ev_ctrl {
|
||||
unsigned char channel;
|
||||
unsigned char unused1, unused2, unused3; /* pad */
|
||||
unsigned int param;
|
||||
|
|
@ -243,59 +243,59 @@ struct sndrv_seq_ev_ctrl {
|
|||
};
|
||||
|
||||
/* generic set of bytes (12x8 bit) */
|
||||
struct sndrv_seq_ev_raw8 {
|
||||
struct snd_seq_ev_raw8 {
|
||||
unsigned char d[12]; /* 8 bit value */
|
||||
};
|
||||
|
||||
/* generic set of integers (3x32 bit) */
|
||||
struct sndrv_seq_ev_raw32 {
|
||||
struct snd_seq_ev_raw32 {
|
||||
unsigned int d[3]; /* 32 bit value */
|
||||
};
|
||||
|
||||
/* external stored data */
|
||||
struct sndrv_seq_ev_ext {
|
||||
struct snd_seq_ev_ext {
|
||||
unsigned int len; /* length of data */
|
||||
void *ptr; /* pointer to data (note: maybe 64-bit) */
|
||||
} __attribute__((packed));
|
||||
|
||||
/* Instrument cluster type */
|
||||
typedef unsigned int sndrv_seq_instr_cluster_t;
|
||||
typedef unsigned int snd_seq_instr_cluster_t;
|
||||
|
||||
/* Instrument type */
|
||||
struct sndrv_seq_instr {
|
||||
sndrv_seq_instr_cluster_t cluster;
|
||||
struct snd_seq_instr {
|
||||
snd_seq_instr_cluster_t cluster;
|
||||
unsigned int std; /* the upper byte means a private instrument (owner - client #) */
|
||||
unsigned short bank;
|
||||
unsigned short prg;
|
||||
};
|
||||
|
||||
/* sample number */
|
||||
struct sndrv_seq_ev_sample {
|
||||
struct snd_seq_ev_sample {
|
||||
unsigned int std;
|
||||
unsigned short bank;
|
||||
unsigned short prg;
|
||||
};
|
||||
|
||||
/* sample cluster */
|
||||
struct sndrv_seq_ev_cluster {
|
||||
sndrv_seq_instr_cluster_t cluster;
|
||||
struct snd_seq_ev_cluster {
|
||||
snd_seq_instr_cluster_t cluster;
|
||||
};
|
||||
|
||||
/* sample position */
|
||||
typedef unsigned int sndrv_seq_position_t; /* playback position (in samples) * 16 */
|
||||
typedef unsigned int snd_seq_position_t; /* playback position (in samples) * 16 */
|
||||
|
||||
/* sample stop mode */
|
||||
enum sndrv_seq_stop_mode {
|
||||
enum {
|
||||
SAMPLE_STOP_IMMEDIATELY = 0, /* terminate playing immediately */
|
||||
SAMPLE_STOP_VENVELOPE = 1, /* finish volume envelope */
|
||||
SAMPLE_STOP_LOOP = 2 /* terminate loop and finish wave */
|
||||
};
|
||||
|
||||
/* sample frequency */
|
||||
typedef int sndrv_seq_frequency_t; /* playback frequency in HZ * 16 */
|
||||
typedef int snd_seq_frequency_t; /* playback frequency in HZ * 16 */
|
||||
|
||||
/* sample volume control; if any value is set to -1 == do not change */
|
||||
struct sndrv_seq_ev_volume {
|
||||
struct snd_seq_ev_volume {
|
||||
signed short volume; /* range: 0-16383 */
|
||||
signed short lr; /* left-right balance; range: 0-16383 */
|
||||
signed short fr; /* front-rear balance; range: 0-16383 */
|
||||
|
|
@ -303,22 +303,22 @@ struct sndrv_seq_ev_volume {
|
|||
};
|
||||
|
||||
/* simple loop redefinition */
|
||||
struct sndrv_seq_ev_loop {
|
||||
struct snd_seq_ev_loop {
|
||||
unsigned int start; /* loop start (in samples) * 16 */
|
||||
unsigned int end; /* loop end (in samples) * 16 */
|
||||
};
|
||||
|
||||
struct sndrv_seq_ev_sample_control {
|
||||
struct snd_seq_ev_sample_control {
|
||||
unsigned char channel;
|
||||
unsigned char unused1, unused2, unused3; /* pad */
|
||||
union {
|
||||
struct sndrv_seq_ev_sample sample;
|
||||
struct sndrv_seq_ev_cluster cluster;
|
||||
sndrv_seq_position_t position;
|
||||
enum sndrv_seq_stop_mode stop_mode;
|
||||
sndrv_seq_frequency_t frequency;
|
||||
struct sndrv_seq_ev_volume volume;
|
||||
struct sndrv_seq_ev_loop loop;
|
||||
struct snd_seq_ev_sample sample;
|
||||
struct snd_seq_ev_cluster cluster;
|
||||
snd_seq_position_t position;
|
||||
int stop_mode;
|
||||
snd_seq_frequency_t frequency;
|
||||
struct snd_seq_ev_volume volume;
|
||||
struct snd_seq_ev_loop loop;
|
||||
unsigned char raw8[8];
|
||||
} param;
|
||||
};
|
||||
|
|
@ -326,82 +326,82 @@ struct sndrv_seq_ev_sample_control {
|
|||
|
||||
|
||||
/* INSTR_BEGIN event */
|
||||
struct sndrv_seq_ev_instr_begin {
|
||||
struct snd_seq_ev_instr_begin {
|
||||
int timeout; /* zero = forever, otherwise timeout in ms */
|
||||
};
|
||||
|
||||
struct sndrv_seq_result {
|
||||
struct snd_seq_result {
|
||||
int event; /* processed event type */
|
||||
int result;
|
||||
};
|
||||
|
||||
|
||||
struct sndrv_seq_real_time {
|
||||
struct snd_seq_real_time {
|
||||
unsigned int tv_sec; /* seconds */
|
||||
unsigned int tv_nsec; /* nanoseconds */
|
||||
};
|
||||
|
||||
typedef unsigned int sndrv_seq_tick_time_t; /* midi ticks */
|
||||
typedef unsigned int snd_seq_tick_time_t; /* midi ticks */
|
||||
|
||||
union sndrv_seq_timestamp {
|
||||
sndrv_seq_tick_time_t tick;
|
||||
struct sndrv_seq_real_time time;
|
||||
union snd_seq_timestamp {
|
||||
snd_seq_tick_time_t tick;
|
||||
struct snd_seq_real_time time;
|
||||
};
|
||||
|
||||
struct sndrv_seq_queue_skew {
|
||||
struct snd_seq_queue_skew {
|
||||
unsigned int value;
|
||||
unsigned int base;
|
||||
};
|
||||
|
||||
/* queue timer control */
|
||||
struct sndrv_seq_ev_queue_control {
|
||||
struct snd_seq_ev_queue_control {
|
||||
unsigned char queue; /* affected queue */
|
||||
unsigned char pad[3]; /* reserved */
|
||||
union {
|
||||
signed int value; /* affected value (e.g. tempo) */
|
||||
union sndrv_seq_timestamp time; /* time */
|
||||
union snd_seq_timestamp time; /* time */
|
||||
unsigned int position; /* sync position */
|
||||
struct sndrv_seq_queue_skew skew;
|
||||
struct snd_seq_queue_skew skew;
|
||||
unsigned int d32[2];
|
||||
unsigned char d8[8];
|
||||
} param;
|
||||
};
|
||||
|
||||
/* quoted event - inside the kernel only */
|
||||
struct sndrv_seq_ev_quote {
|
||||
struct sndrv_seq_addr origin; /* original sender */
|
||||
struct snd_seq_ev_quote {
|
||||
struct snd_seq_addr origin; /* original sender */
|
||||
unsigned short value; /* optional data */
|
||||
struct sndrv_seq_event *event; /* quoted event */
|
||||
struct snd_seq_event *event; /* quoted event */
|
||||
} __attribute__((packed));
|
||||
|
||||
|
||||
/* sequencer event */
|
||||
struct sndrv_seq_event {
|
||||
sndrv_seq_event_type_t type; /* event type */
|
||||
struct snd_seq_event {
|
||||
snd_seq_event_type_t type; /* event type */
|
||||
unsigned char flags; /* event flags */
|
||||
char tag;
|
||||
|
||||
unsigned char queue; /* schedule queue */
|
||||
union sndrv_seq_timestamp time; /* schedule time */
|
||||
union snd_seq_timestamp time; /* schedule time */
|
||||
|
||||
|
||||
struct sndrv_seq_addr source; /* source address */
|
||||
struct sndrv_seq_addr dest; /* destination address */
|
||||
struct snd_seq_addr source; /* source address */
|
||||
struct snd_seq_addr dest; /* destination address */
|
||||
|
||||
union { /* event data... */
|
||||
struct sndrv_seq_ev_note note;
|
||||
struct sndrv_seq_ev_ctrl control;
|
||||
struct sndrv_seq_ev_raw8 raw8;
|
||||
struct sndrv_seq_ev_raw32 raw32;
|
||||
struct sndrv_seq_ev_ext ext;
|
||||
struct sndrv_seq_ev_queue_control queue;
|
||||
union sndrv_seq_timestamp time;
|
||||
struct sndrv_seq_addr addr;
|
||||
struct sndrv_seq_connect connect;
|
||||
struct sndrv_seq_result result;
|
||||
struct sndrv_seq_ev_instr_begin instr_begin;
|
||||
struct sndrv_seq_ev_sample_control sample;
|
||||
struct sndrv_seq_ev_quote quote;
|
||||
struct snd_seq_ev_note note;
|
||||
struct snd_seq_ev_ctrl control;
|
||||
struct snd_seq_ev_raw8 raw8;
|
||||
struct snd_seq_ev_raw32 raw32;
|
||||
struct snd_seq_ev_ext ext;
|
||||
struct snd_seq_ev_queue_control queue;
|
||||
union snd_seq_timestamp time;
|
||||
struct snd_seq_addr addr;
|
||||
struct snd_seq_connect connect;
|
||||
struct snd_seq_result result;
|
||||
struct snd_seq_ev_instr_begin instr_begin;
|
||||
struct snd_seq_ev_sample_control sample;
|
||||
struct snd_seq_ev_quote quote;
|
||||
} data;
|
||||
};
|
||||
|
||||
|
|
@ -409,72 +409,77 @@ struct sndrv_seq_event {
|
|||
/*
|
||||
* bounce event - stored as variable size data
|
||||
*/
|
||||
struct sndrv_seq_event_bounce {
|
||||
struct snd_seq_event_bounce {
|
||||
int err;
|
||||
struct sndrv_seq_event event;
|
||||
struct snd_seq_event event;
|
||||
/* external data follows here. */
|
||||
};
|
||||
|
||||
#define sndrv_seq_event_bounce_ext_data(ev) ((void*)((char *)(ev)->data.ext.ptr + sizeof(sndrv_seq_event_bounce_t)))
|
||||
#ifdef __KERNEL__
|
||||
|
||||
/* helper macro */
|
||||
#define snd_seq_event_bounce_ext_data(ev) ((void*)((char *)(ev)->data.ext.ptr + sizeof(struct snd_seq_event_bounce)))
|
||||
|
||||
/*
|
||||
* type check macros
|
||||
*/
|
||||
/* result events: 0-4 */
|
||||
#define sndrv_seq_ev_is_result_type(ev) ((ev)->type < 5)
|
||||
#define snd_seq_ev_is_result_type(ev) ((ev)->type < 5)
|
||||
/* channel specific events: 5-19 */
|
||||
#define sndrv_seq_ev_is_channel_type(ev) ((ev)->type >= 5 && (ev)->type < 20)
|
||||
#define snd_seq_ev_is_channel_type(ev) ((ev)->type >= 5 && (ev)->type < 20)
|
||||
/* note events: 5-9 */
|
||||
#define sndrv_seq_ev_is_note_type(ev) ((ev)->type >= 5 && (ev)->type < 10)
|
||||
#define snd_seq_ev_is_note_type(ev) ((ev)->type >= 5 && (ev)->type < 10)
|
||||
/* control events: 10-19 */
|
||||
#define sndrv_seq_ev_is_control_type(ev) ((ev)->type >= 10 && (ev)->type < 20)
|
||||
#define snd_seq_ev_is_control_type(ev) ((ev)->type >= 10 && (ev)->type < 20)
|
||||
/* queue control events: 30-39 */
|
||||
#define sndrv_seq_ev_is_queue_type(ev) ((ev)->type >= 30 && (ev)->type < 40)
|
||||
#define snd_seq_ev_is_queue_type(ev) ((ev)->type >= 30 && (ev)->type < 40)
|
||||
/* system status messages */
|
||||
#define sndrv_seq_ev_is_message_type(ev) ((ev)->type >= 60 && (ev)->type < 69)
|
||||
#define snd_seq_ev_is_message_type(ev) ((ev)->type >= 60 && (ev)->type < 69)
|
||||
/* sample messages */
|
||||
#define sndrv_seq_ev_is_sample_type(ev) ((ev)->type >= 70 && (ev)->type < 79)
|
||||
#define snd_seq_ev_is_sample_type(ev) ((ev)->type >= 70 && (ev)->type < 79)
|
||||
/* user-defined messages */
|
||||
#define sndrv_seq_ev_is_user_type(ev) ((ev)->type >= 90 && (ev)->type < 99)
|
||||
#define snd_seq_ev_is_user_type(ev) ((ev)->type >= 90 && (ev)->type < 99)
|
||||
/* fixed length events: 0-99 */
|
||||
#define sndrv_seq_ev_is_fixed_type(ev) ((ev)->type < 100)
|
||||
#define snd_seq_ev_is_fixed_type(ev) ((ev)->type < 100)
|
||||
/* instrument layer events: 100-129 */
|
||||
#define sndrv_seq_ev_is_instr_type(ev) ((ev)->type >= 100 && (ev)->type < 130)
|
||||
#define snd_seq_ev_is_instr_type(ev) ((ev)->type >= 100 && (ev)->type < 130)
|
||||
/* variable length events: 130-139 */
|
||||
#define sndrv_seq_ev_is_variable_type(ev) ((ev)->type >= 130 && (ev)->type < 140)
|
||||
#define snd_seq_ev_is_variable_type(ev) ((ev)->type >= 130 && (ev)->type < 140)
|
||||
/* reserved for kernel */
|
||||
#define sndrv_seq_ev_is_reserved(ev) ((ev)->type >= 150)
|
||||
#define snd_seq_ev_is_reserved(ev) ((ev)->type >= 150)
|
||||
|
||||
/* direct dispatched events */
|
||||
#define sndrv_seq_ev_is_direct(ev) ((ev)->queue == SNDRV_SEQ_QUEUE_DIRECT)
|
||||
#define snd_seq_ev_is_direct(ev) ((ev)->queue == SNDRV_SEQ_QUEUE_DIRECT)
|
||||
|
||||
/*
|
||||
* macros to check event flags
|
||||
*/
|
||||
/* prior events */
|
||||
#define sndrv_seq_ev_is_prior(ev) (((ev)->flags & SNDRV_SEQ_PRIORITY_MASK) == SNDRV_SEQ_PRIORITY_HIGH)
|
||||
#define snd_seq_ev_is_prior(ev) (((ev)->flags & SNDRV_SEQ_PRIORITY_MASK) == SNDRV_SEQ_PRIORITY_HIGH)
|
||||
|
||||
/* event length type */
|
||||
#define sndrv_seq_ev_length_type(ev) ((ev)->flags & SNDRV_SEQ_EVENT_LENGTH_MASK)
|
||||
#define sndrv_seq_ev_is_fixed(ev) (sndrv_seq_ev_length_type(ev) == SNDRV_SEQ_EVENT_LENGTH_FIXED)
|
||||
#define sndrv_seq_ev_is_variable(ev) (sndrv_seq_ev_length_type(ev) == SNDRV_SEQ_EVENT_LENGTH_VARIABLE)
|
||||
#define sndrv_seq_ev_is_varusr(ev) (sndrv_seq_ev_length_type(ev) == SNDRV_SEQ_EVENT_LENGTH_VARUSR)
|
||||
#define snd_seq_ev_length_type(ev) ((ev)->flags & SNDRV_SEQ_EVENT_LENGTH_MASK)
|
||||
#define snd_seq_ev_is_fixed(ev) (snd_seq_ev_length_type(ev) == SNDRV_SEQ_EVENT_LENGTH_FIXED)
|
||||
#define snd_seq_ev_is_variable(ev) (snd_seq_ev_length_type(ev) == SNDRV_SEQ_EVENT_LENGTH_VARIABLE)
|
||||
#define snd_seq_ev_is_varusr(ev) (snd_seq_ev_length_type(ev) == SNDRV_SEQ_EVENT_LENGTH_VARUSR)
|
||||
|
||||
/* time-stamp type */
|
||||
#define sndrv_seq_ev_timestamp_type(ev) ((ev)->flags & SNDRV_SEQ_TIME_STAMP_MASK)
|
||||
#define sndrv_seq_ev_is_tick(ev) (sndrv_seq_ev_timestamp_type(ev) == SNDRV_SEQ_TIME_STAMP_TICK)
|
||||
#define sndrv_seq_ev_is_real(ev) (sndrv_seq_ev_timestamp_type(ev) == SNDRV_SEQ_TIME_STAMP_REAL)
|
||||
#define snd_seq_ev_timestamp_type(ev) ((ev)->flags & SNDRV_SEQ_TIME_STAMP_MASK)
|
||||
#define snd_seq_ev_is_tick(ev) (snd_seq_ev_timestamp_type(ev) == SNDRV_SEQ_TIME_STAMP_TICK)
|
||||
#define snd_seq_ev_is_real(ev) (snd_seq_ev_timestamp_type(ev) == SNDRV_SEQ_TIME_STAMP_REAL)
|
||||
|
||||
/* time-mode type */
|
||||
#define sndrv_seq_ev_timemode_type(ev) ((ev)->flags & SNDRV_SEQ_TIME_MODE_MASK)
|
||||
#define sndrv_seq_ev_is_abstime(ev) (sndrv_seq_ev_timemode_type(ev) == SNDRV_SEQ_TIME_MODE_ABS)
|
||||
#define sndrv_seq_ev_is_reltime(ev) (sndrv_seq_ev_timemode_type(ev) == SNDRV_SEQ_TIME_MODE_REL)
|
||||
#define snd_seq_ev_timemode_type(ev) ((ev)->flags & SNDRV_SEQ_TIME_MODE_MASK)
|
||||
#define snd_seq_ev_is_abstime(ev) (snd_seq_ev_timemode_type(ev) == SNDRV_SEQ_TIME_MODE_ABS)
|
||||
#define snd_seq_ev_is_reltime(ev) (snd_seq_ev_timemode_type(ev) == SNDRV_SEQ_TIME_MODE_REL)
|
||||
|
||||
/* queue sync port */
|
||||
#define sndrv_seq_queue_sync_port(q) ((q) + 16)
|
||||
#define snd_seq_queue_sync_port(q) ((q) + 16)
|
||||
|
||||
#endif /* __KERNEL__ */
|
||||
|
||||
/* system information */
|
||||
struct sndrv_seq_system_info {
|
||||
struct snd_seq_system_info {
|
||||
int queues; /* maximum queues count */
|
||||
int clients; /* maximum clients count */
|
||||
int ports; /* maximum ports per client */
|
||||
|
|
@ -486,7 +491,7 @@ struct sndrv_seq_system_info {
|
|||
|
||||
|
||||
/* system running information */
|
||||
struct sndrv_seq_running_info {
|
||||
struct snd_seq_running_info {
|
||||
unsigned char client; /* client id */
|
||||
unsigned char big_endian; /* 1 = big-endian */
|
||||
unsigned char cpu_mode; /* 4 = 32bit, 8 = 64bit */
|
||||
|
|
@ -502,11 +507,10 @@ struct sndrv_seq_running_info {
|
|||
|
||||
|
||||
/* client types */
|
||||
enum sndrv_seq_client_type {
|
||||
NO_CLIENT = 0,
|
||||
USER_CLIENT = 1,
|
||||
KERNEL_CLIENT = 2
|
||||
};
|
||||
typedef int __bitwise snd_seq_client_type_t;
|
||||
#define NO_CLIENT ((__force snd_seq_client_type_t) 0)
|
||||
#define USER_CLIENT ((__force snd_seq_client_type_t) 1)
|
||||
#define KERNEL_CLIENT ((__force snd_seq_client_type_t) 2)
|
||||
|
||||
/* event filter flags */
|
||||
#define SNDRV_SEQ_FILTER_BROADCAST (1<<0) /* accept broadcast messages */
|
||||
|
|
@ -514,9 +518,9 @@ enum sndrv_seq_client_type {
|
|||
#define SNDRV_SEQ_FILTER_BOUNCE (1<<2) /* accept bounce event in error */
|
||||
#define SNDRV_SEQ_FILTER_USE_EVENT (1<<31) /* use event filter */
|
||||
|
||||
struct sndrv_seq_client_info {
|
||||
struct snd_seq_client_info {
|
||||
int client; /* client number to inquire */
|
||||
enum sndrv_seq_client_type type; /* client type */
|
||||
snd_seq_client_type_t type; /* client type */
|
||||
char name[64]; /* client name */
|
||||
unsigned int filter; /* filter flags */
|
||||
unsigned char multicast_filter[8]; /* multicast filter bitmap */
|
||||
|
|
@ -528,7 +532,7 @@ struct sndrv_seq_client_info {
|
|||
|
||||
|
||||
/* client pool size */
|
||||
struct sndrv_seq_client_pool {
|
||||
struct snd_seq_client_pool {
|
||||
int client; /* client number to inquire */
|
||||
int output_pool; /* outgoing (write) pool size */
|
||||
int input_pool; /* incoming (read) pool size */
|
||||
|
|
@ -552,13 +556,13 @@ struct sndrv_seq_client_pool {
|
|||
#define SNDRV_SEQ_REMOVE_IGNORE_OFF (1<<8) /* Do not flush off events */
|
||||
#define SNDRV_SEQ_REMOVE_TAG_MATCH (1<<9) /* Restrict to events with given tag */
|
||||
|
||||
struct sndrv_seq_remove_events {
|
||||
struct snd_seq_remove_events {
|
||||
unsigned int remove_mode; /* Flags that determine what gets removed */
|
||||
|
||||
union sndrv_seq_timestamp time;
|
||||
union snd_seq_timestamp time;
|
||||
|
||||
unsigned char queue; /* Queue for REMOVE_DEST */
|
||||
struct sndrv_seq_addr dest; /* Address for REMOVE_DEST */
|
||||
struct snd_seq_addr dest; /* Address for REMOVE_DEST */
|
||||
unsigned char channel; /* Channel for REMOVE_DEST */
|
||||
|
||||
int type; /* For REMOVE_EVENT_TYPE */
|
||||
|
|
@ -607,8 +611,8 @@ struct sndrv_seq_remove_events {
|
|||
#define SNDRV_SEQ_PORT_FLG_TIMESTAMP (1<<1)
|
||||
#define SNDRV_SEQ_PORT_FLG_TIME_REAL (1<<2)
|
||||
|
||||
struct sndrv_seq_port_info {
|
||||
struct sndrv_seq_addr addr; /* client/port numbers */
|
||||
struct snd_seq_port_info {
|
||||
struct snd_seq_addr addr; /* client/port numbers */
|
||||
char name[64]; /* port name */
|
||||
|
||||
unsigned int capability; /* port capability bits */
|
||||
|
|
@ -631,7 +635,7 @@ struct sndrv_seq_port_info {
|
|||
#define SNDRV_SEQ_QUEUE_FLG_SYNC (1<<0) /* sync enabled */
|
||||
|
||||
/* queue information */
|
||||
struct sndrv_seq_queue_info {
|
||||
struct snd_seq_queue_info {
|
||||
int queue; /* queue id */
|
||||
|
||||
/*
|
||||
|
|
@ -647,11 +651,11 @@ struct sndrv_seq_queue_info {
|
|||
};
|
||||
|
||||
/* queue info/status */
|
||||
struct sndrv_seq_queue_status {
|
||||
struct snd_seq_queue_status {
|
||||
int queue; /* queue id */
|
||||
int events; /* read-only - queue size */
|
||||
sndrv_seq_tick_time_t tick; /* current tick */
|
||||
struct sndrv_seq_real_time time; /* current time */
|
||||
snd_seq_tick_time_t tick; /* current tick */
|
||||
struct snd_seq_real_time time; /* current time */
|
||||
int running; /* running state of queue */
|
||||
int flags; /* various flags */
|
||||
char reserved[64]; /* for the future */
|
||||
|
|
@ -659,7 +663,7 @@ struct sndrv_seq_queue_status {
|
|||
|
||||
|
||||
/* queue tempo */
|
||||
struct sndrv_seq_queue_tempo {
|
||||
struct snd_seq_queue_tempo {
|
||||
int queue; /* sequencer queue */
|
||||
unsigned int tempo; /* current tempo, us/tick */
|
||||
int ppq; /* time resolution, ticks/quarter */
|
||||
|
|
@ -675,12 +679,12 @@ struct sndrv_seq_queue_tempo {
|
|||
#define SNDRV_SEQ_TIMER_MIDI_TICK 2 /* Midi Timer Tick (TICK event) */
|
||||
|
||||
/* queue timer info */
|
||||
struct sndrv_seq_queue_timer {
|
||||
struct snd_seq_queue_timer {
|
||||
int queue; /* sequencer queue */
|
||||
int type; /* source timer type */
|
||||
union {
|
||||
struct {
|
||||
struct sndrv_timer_id id; /* ALSA's timer ID */
|
||||
struct snd_timer_id id; /* ALSA's timer ID */
|
||||
unsigned int resolution; /* resolution in Hz */
|
||||
} alsa;
|
||||
} u;
|
||||
|
|
@ -688,7 +692,7 @@ struct sndrv_seq_queue_timer {
|
|||
};
|
||||
|
||||
|
||||
struct sndrv_seq_queue_client {
|
||||
struct snd_seq_queue_client {
|
||||
int queue; /* sequencer queue */
|
||||
int client; /* sequencer client */
|
||||
int used; /* queue is used with this client
|
||||
|
|
@ -702,9 +706,9 @@ struct sndrv_seq_queue_client {
|
|||
#define SNDRV_SEQ_PORT_SUBS_TIMESTAMP (1<<1)
|
||||
#define SNDRV_SEQ_PORT_SUBS_TIME_REAL (1<<2)
|
||||
|
||||
struct sndrv_seq_port_subscribe {
|
||||
struct sndrv_seq_addr sender; /* sender address */
|
||||
struct sndrv_seq_addr dest; /* destination address */
|
||||
struct snd_seq_port_subscribe {
|
||||
struct snd_seq_addr sender; /* sender address */
|
||||
struct snd_seq_addr dest; /* destination address */
|
||||
unsigned int voices; /* number of voices to be allocated (0 = don't care) */
|
||||
unsigned int flags; /* modes */
|
||||
unsigned char queue; /* input time-stamp queue (optional) */
|
||||
|
|
@ -716,12 +720,12 @@ struct sndrv_seq_port_subscribe {
|
|||
#define SNDRV_SEQ_QUERY_SUBS_READ 0
|
||||
#define SNDRV_SEQ_QUERY_SUBS_WRITE 1
|
||||
|
||||
struct sndrv_seq_query_subs {
|
||||
struct sndrv_seq_addr root; /* client/port id to be searched */
|
||||
struct snd_seq_query_subs {
|
||||
struct snd_seq_addr root; /* client/port id to be searched */
|
||||
int type; /* READ or WRITE */
|
||||
int index; /* 0..N-1 */
|
||||
int num_subs; /* R/O: number of subscriptions on this port */
|
||||
struct sndrv_seq_addr addr; /* R/O: result */
|
||||
struct snd_seq_addr addr; /* R/O: result */
|
||||
unsigned char queue; /* R/O: result */
|
||||
unsigned int flags; /* R/O: result */
|
||||
char reserved[64]; /* for future use */
|
||||
|
|
@ -778,72 +782,72 @@ struct sndrv_seq_query_subs {
|
|||
#define SNDRV_SEQ_INSTR_FREE_CMD_SINGLE 3
|
||||
|
||||
/* size of ROM/RAM */
|
||||
typedef unsigned int sndrv_seq_instr_size_t;
|
||||
typedef unsigned int snd_seq_instr_size_t;
|
||||
|
||||
/* INSTR_INFO */
|
||||
|
||||
struct sndrv_seq_instr_info {
|
||||
struct snd_seq_instr_info {
|
||||
int result; /* operation result */
|
||||
unsigned int formats[8]; /* bitmap of supported formats */
|
||||
int ram_count; /* count of RAM banks */
|
||||
sndrv_seq_instr_size_t ram_sizes[16]; /* size of RAM banks */
|
||||
snd_seq_instr_size_t ram_sizes[16]; /* size of RAM banks */
|
||||
int rom_count; /* count of ROM banks */
|
||||
sndrv_seq_instr_size_t rom_sizes[8]; /* size of ROM banks */
|
||||
snd_seq_instr_size_t rom_sizes[8]; /* size of ROM banks */
|
||||
char reserved[128];
|
||||
};
|
||||
|
||||
/* INSTR_STATUS */
|
||||
|
||||
struct sndrv_seq_instr_status {
|
||||
struct snd_seq_instr_status {
|
||||
int result; /* operation result */
|
||||
sndrv_seq_instr_size_t free_ram[16]; /* free RAM in banks */
|
||||
snd_seq_instr_size_t free_ram[16]; /* free RAM in banks */
|
||||
int instrument_count; /* count of downloaded instruments */
|
||||
char reserved[128];
|
||||
};
|
||||
|
||||
/* INSTR_FORMAT_INFO */
|
||||
|
||||
struct sndrv_seq_instr_format_info {
|
||||
struct snd_seq_instr_format_info {
|
||||
char format[16]; /* format identifier - SNDRV_SEQ_INSTR_ID_* */
|
||||
unsigned int len; /* max data length (without this structure) */
|
||||
};
|
||||
|
||||
struct sndrv_seq_instr_format_info_result {
|
||||
struct snd_seq_instr_format_info_result {
|
||||
int result; /* operation result */
|
||||
char format[16]; /* format identifier */
|
||||
unsigned int len; /* filled data length (without this structure) */
|
||||
};
|
||||
|
||||
/* instrument data */
|
||||
struct sndrv_seq_instr_data {
|
||||
struct snd_seq_instr_data {
|
||||
char name[32]; /* instrument name */
|
||||
char reserved[16]; /* for the future use */
|
||||
int type; /* instrument type */
|
||||
union {
|
||||
char format[16]; /* format identifier */
|
||||
struct sndrv_seq_instr alias;
|
||||
struct snd_seq_instr alias;
|
||||
} data;
|
||||
};
|
||||
|
||||
/* INSTR_PUT/GET, data are stored in one block (extended), header + data */
|
||||
|
||||
struct sndrv_seq_instr_header {
|
||||
struct snd_seq_instr_header {
|
||||
union {
|
||||
struct sndrv_seq_instr instr;
|
||||
sndrv_seq_instr_cluster_t cluster;
|
||||
struct snd_seq_instr instr;
|
||||
snd_seq_instr_cluster_t cluster;
|
||||
} id; /* instrument identifier */
|
||||
unsigned int cmd; /* get/put/free command */
|
||||
unsigned int flags; /* query flags (only for get) */
|
||||
unsigned int len; /* real instrument data length (without header) */
|
||||
int result; /* operation result */
|
||||
char reserved[16]; /* for the future */
|
||||
struct sndrv_seq_instr_data data; /* instrument data (for put/get result) */
|
||||
struct snd_seq_instr_data data; /* instrument data (for put/get result) */
|
||||
};
|
||||
|
||||
/* INSTR_CLUSTER_SET */
|
||||
|
||||
struct sndrv_seq_instr_cluster_set {
|
||||
sndrv_seq_instr_cluster_t cluster; /* cluster identifier */
|
||||
struct snd_seq_instr_cluster_set {
|
||||
snd_seq_instr_cluster_t cluster; /* cluster identifier */
|
||||
char name[32]; /* cluster name */
|
||||
int priority; /* cluster priority */
|
||||
char reserved[64]; /* for the future use */
|
||||
|
|
@ -851,8 +855,8 @@ struct sndrv_seq_instr_cluster_set {
|
|||
|
||||
/* INSTR_CLUSTER_GET */
|
||||
|
||||
struct sndrv_seq_instr_cluster_get {
|
||||
sndrv_seq_instr_cluster_t cluster; /* cluster identifier */
|
||||
struct snd_seq_instr_cluster_get {
|
||||
snd_seq_instr_cluster_t cluster; /* cluster identifier */
|
||||
char name[32]; /* cluster name */
|
||||
int priority; /* cluster priority */
|
||||
char reserved[64]; /* for the future use */
|
||||
|
|
@ -864,44 +868,44 @@ struct sndrv_seq_instr_cluster_get {
|
|||
|
||||
#define SNDRV_SEQ_IOCTL_PVERSION _IOR ('S', 0x00, int)
|
||||
#define SNDRV_SEQ_IOCTL_CLIENT_ID _IOR ('S', 0x01, int)
|
||||
#define SNDRV_SEQ_IOCTL_SYSTEM_INFO _IOWR('S', 0x02, struct sndrv_seq_system_info)
|
||||
#define SNDRV_SEQ_IOCTL_RUNNING_MODE _IOWR('S', 0x03, struct sndrv_seq_running_info)
|
||||
#define SNDRV_SEQ_IOCTL_SYSTEM_INFO _IOWR('S', 0x02, struct snd_seq_system_info)
|
||||
#define SNDRV_SEQ_IOCTL_RUNNING_MODE _IOWR('S', 0x03, struct snd_seq_running_info)
|
||||
|
||||
#define SNDRV_SEQ_IOCTL_GET_CLIENT_INFO _IOWR('S', 0x10, struct sndrv_seq_client_info)
|
||||
#define SNDRV_SEQ_IOCTL_SET_CLIENT_INFO _IOW ('S', 0x11, struct sndrv_seq_client_info)
|
||||
#define SNDRV_SEQ_IOCTL_GET_CLIENT_INFO _IOWR('S', 0x10, struct snd_seq_client_info)
|
||||
#define SNDRV_SEQ_IOCTL_SET_CLIENT_INFO _IOW ('S', 0x11, struct snd_seq_client_info)
|
||||
|
||||
#define SNDRV_SEQ_IOCTL_CREATE_PORT _IOWR('S', 0x20, struct sndrv_seq_port_info)
|
||||
#define SNDRV_SEQ_IOCTL_DELETE_PORT _IOW ('S', 0x21, struct sndrv_seq_port_info)
|
||||
#define SNDRV_SEQ_IOCTL_GET_PORT_INFO _IOWR('S', 0x22, struct sndrv_seq_port_info)
|
||||
#define SNDRV_SEQ_IOCTL_SET_PORT_INFO _IOW ('S', 0x23, struct sndrv_seq_port_info)
|
||||
#define SNDRV_SEQ_IOCTL_CREATE_PORT _IOWR('S', 0x20, struct snd_seq_port_info)
|
||||
#define SNDRV_SEQ_IOCTL_DELETE_PORT _IOW ('S', 0x21, struct snd_seq_port_info)
|
||||
#define SNDRV_SEQ_IOCTL_GET_PORT_INFO _IOWR('S', 0x22, struct snd_seq_port_info)
|
||||
#define SNDRV_SEQ_IOCTL_SET_PORT_INFO _IOW ('S', 0x23, struct snd_seq_port_info)
|
||||
|
||||
#define SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT _IOW ('S', 0x30, struct sndrv_seq_port_subscribe)
|
||||
#define SNDRV_SEQ_IOCTL_UNSUBSCRIBE_PORT _IOW ('S', 0x31, struct sndrv_seq_port_subscribe)
|
||||
#define SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT _IOW ('S', 0x30, struct snd_seq_port_subscribe)
|
||||
#define SNDRV_SEQ_IOCTL_UNSUBSCRIBE_PORT _IOW ('S', 0x31, struct snd_seq_port_subscribe)
|
||||
|
||||
#define SNDRV_SEQ_IOCTL_CREATE_QUEUE _IOWR('S', 0x32, struct sndrv_seq_queue_info)
|
||||
#define SNDRV_SEQ_IOCTL_DELETE_QUEUE _IOW ('S', 0x33, struct sndrv_seq_queue_info)
|
||||
#define SNDRV_SEQ_IOCTL_GET_QUEUE_INFO _IOWR('S', 0x34, struct sndrv_seq_queue_info)
|
||||
#define SNDRV_SEQ_IOCTL_SET_QUEUE_INFO _IOWR('S', 0x35, struct sndrv_seq_queue_info)
|
||||
#define SNDRV_SEQ_IOCTL_GET_NAMED_QUEUE _IOWR('S', 0x36, struct sndrv_seq_queue_info)
|
||||
#define SNDRV_SEQ_IOCTL_GET_QUEUE_STATUS _IOWR('S', 0x40, struct sndrv_seq_queue_status)
|
||||
#define SNDRV_SEQ_IOCTL_GET_QUEUE_TEMPO _IOWR('S', 0x41, struct sndrv_seq_queue_tempo)
|
||||
#define SNDRV_SEQ_IOCTL_SET_QUEUE_TEMPO _IOW ('S', 0x42, struct sndrv_seq_queue_tempo)
|
||||
#define SNDRV_SEQ_IOCTL_GET_QUEUE_OWNER _IOWR('S', 0x43, struct sndrv_seq_queue_owner)
|
||||
#define SNDRV_SEQ_IOCTL_SET_QUEUE_OWNER _IOW ('S', 0x44, struct sndrv_seq_queue_owner)
|
||||
#define SNDRV_SEQ_IOCTL_GET_QUEUE_TIMER _IOWR('S', 0x45, struct sndrv_seq_queue_timer)
|
||||
#define SNDRV_SEQ_IOCTL_SET_QUEUE_TIMER _IOW ('S', 0x46, struct sndrv_seq_queue_timer)
|
||||
#define SNDRV_SEQ_IOCTL_CREATE_QUEUE _IOWR('S', 0x32, struct snd_seq_queue_info)
|
||||
#define SNDRV_SEQ_IOCTL_DELETE_QUEUE _IOW ('S', 0x33, struct snd_seq_queue_info)
|
||||
#define SNDRV_SEQ_IOCTL_GET_QUEUE_INFO _IOWR('S', 0x34, struct snd_seq_queue_info)
|
||||
#define SNDRV_SEQ_IOCTL_SET_QUEUE_INFO _IOWR('S', 0x35, struct snd_seq_queue_info)
|
||||
#define SNDRV_SEQ_IOCTL_GET_NAMED_QUEUE _IOWR('S', 0x36, struct snd_seq_queue_info)
|
||||
#define SNDRV_SEQ_IOCTL_GET_QUEUE_STATUS _IOWR('S', 0x40, struct snd_seq_queue_status)
|
||||
#define SNDRV_SEQ_IOCTL_GET_QUEUE_TEMPO _IOWR('S', 0x41, struct snd_seq_queue_tempo)
|
||||
#define SNDRV_SEQ_IOCTL_SET_QUEUE_TEMPO _IOW ('S', 0x42, struct snd_seq_queue_tempo)
|
||||
#define SNDRV_SEQ_IOCTL_GET_QUEUE_OWNER _IOWR('S', 0x43, struct snd_seq_queue_owner)
|
||||
#define SNDRV_SEQ_IOCTL_SET_QUEUE_OWNER _IOW ('S', 0x44, struct snd_seq_queue_owner)
|
||||
#define SNDRV_SEQ_IOCTL_GET_QUEUE_TIMER _IOWR('S', 0x45, struct snd_seq_queue_timer)
|
||||
#define SNDRV_SEQ_IOCTL_SET_QUEUE_TIMER _IOW ('S', 0x46, struct snd_seq_queue_timer)
|
||||
/* XXX
|
||||
#define SNDRV_SEQ_IOCTL_GET_QUEUE_SYNC _IOWR('S', 0x53, struct sndrv_seq_queue_sync)
|
||||
#define SNDRV_SEQ_IOCTL_SET_QUEUE_SYNC _IOW ('S', 0x54, struct sndrv_seq_queue_sync)
|
||||
#define SNDRV_SEQ_IOCTL_GET_QUEUE_SYNC _IOWR('S', 0x53, struct snd_seq_queue_sync)
|
||||
#define SNDRV_SEQ_IOCTL_SET_QUEUE_SYNC _IOW ('S', 0x54, struct snd_seq_queue_sync)
|
||||
*/
|
||||
#define SNDRV_SEQ_IOCTL_GET_QUEUE_CLIENT _IOWR('S', 0x49, struct sndrv_seq_queue_client)
|
||||
#define SNDRV_SEQ_IOCTL_SET_QUEUE_CLIENT _IOW ('S', 0x4a, struct sndrv_seq_queue_client)
|
||||
#define SNDRV_SEQ_IOCTL_GET_CLIENT_POOL _IOWR('S', 0x4b, struct sndrv_seq_client_pool)
|
||||
#define SNDRV_SEQ_IOCTL_SET_CLIENT_POOL _IOW ('S', 0x4c, struct sndrv_seq_client_pool)
|
||||
#define SNDRV_SEQ_IOCTL_REMOVE_EVENTS _IOW ('S', 0x4e, struct sndrv_seq_remove_events)
|
||||
#define SNDRV_SEQ_IOCTL_QUERY_SUBS _IOWR('S', 0x4f, struct sndrv_seq_query_subs)
|
||||
#define SNDRV_SEQ_IOCTL_GET_SUBSCRIPTION _IOWR('S', 0x50, struct sndrv_seq_port_subscribe)
|
||||
#define SNDRV_SEQ_IOCTL_QUERY_NEXT_CLIENT _IOWR('S', 0x51, struct sndrv_seq_client_info)
|
||||
#define SNDRV_SEQ_IOCTL_QUERY_NEXT_PORT _IOWR('S', 0x52, struct sndrv_seq_port_info)
|
||||
#define SNDRV_SEQ_IOCTL_GET_QUEUE_CLIENT _IOWR('S', 0x49, struct snd_seq_queue_client)
|
||||
#define SNDRV_SEQ_IOCTL_SET_QUEUE_CLIENT _IOW ('S', 0x4a, struct snd_seq_queue_client)
|
||||
#define SNDRV_SEQ_IOCTL_GET_CLIENT_POOL _IOWR('S', 0x4b, struct snd_seq_client_pool)
|
||||
#define SNDRV_SEQ_IOCTL_SET_CLIENT_POOL _IOW ('S', 0x4c, struct snd_seq_client_pool)
|
||||
#define SNDRV_SEQ_IOCTL_REMOVE_EVENTS _IOW ('S', 0x4e, struct snd_seq_remove_events)
|
||||
#define SNDRV_SEQ_IOCTL_QUERY_SUBS _IOWR('S', 0x4f, struct snd_seq_query_subs)
|
||||
#define SNDRV_SEQ_IOCTL_GET_SUBSCRIPTION _IOWR('S', 0x50, struct snd_seq_port_subscribe)
|
||||
#define SNDRV_SEQ_IOCTL_QUERY_NEXT_CLIENT _IOWR('S', 0x51, struct snd_seq_client_info)
|
||||
#define SNDRV_SEQ_IOCTL_QUERY_NEXT_PORT _IOWR('S', 0x52, struct snd_seq_port_info)
|
||||
|
||||
#endif /* __SOUND_ASEQUENCER_H */
|
||||
|
|
|
|||
|
|
@ -21,9 +21,6 @@
|
|||
*
|
||||
*/
|
||||
|
||||
typedef struct snd_seq_device snd_seq_device_t;
|
||||
typedef struct snd_seq_dev_ops snd_seq_dev_ops_t;
|
||||
|
||||
/*
|
||||
* registered device information
|
||||
*/
|
||||
|
|
@ -36,7 +33,7 @@ typedef struct snd_seq_dev_ops snd_seq_dev_ops_t;
|
|||
|
||||
struct snd_seq_device {
|
||||
/* device info */
|
||||
snd_card_t *card; /* sound card */
|
||||
struct snd_card *card; /* sound card */
|
||||
int device; /* device number */
|
||||
char id[ID_LEN]; /* driver id */
|
||||
char name[80]; /* device name */
|
||||
|
|
@ -44,7 +41,7 @@ struct snd_seq_device {
|
|||
void *driver_data; /* private data for driver */
|
||||
int status; /* flag - read only */
|
||||
void *private_data; /* private data for the caller */
|
||||
void (*private_free)(snd_seq_device_t *device);
|
||||
void (*private_free)(struct snd_seq_device *device);
|
||||
struct list_head list; /* link to next device */
|
||||
};
|
||||
|
||||
|
|
@ -63,19 +60,19 @@ struct snd_seq_device {
|
|||
* Typically, call snd_device_free(dev->card, dev->driver_data)
|
||||
*/
|
||||
struct snd_seq_dev_ops {
|
||||
int (*init_device)(snd_seq_device_t *dev);
|
||||
int (*free_device)(snd_seq_device_t *dev);
|
||||
int (*init_device)(struct snd_seq_device *dev);
|
||||
int (*free_device)(struct snd_seq_device *dev);
|
||||
};
|
||||
|
||||
/*
|
||||
* prototypes
|
||||
*/
|
||||
void snd_seq_device_load_drivers(void);
|
||||
int snd_seq_device_new(snd_card_t *card, int device, char *id, int argsize, snd_seq_device_t **result);
|
||||
int snd_seq_device_register_driver(char *id, snd_seq_dev_ops_t *entry, int argsize);
|
||||
int snd_seq_device_new(struct snd_card *card, int device, char *id, int argsize, struct snd_seq_device **result);
|
||||
int snd_seq_device_register_driver(char *id, struct snd_seq_dev_ops *entry, int argsize);
|
||||
int snd_seq_device_unregister_driver(char *id);
|
||||
|
||||
#define SNDRV_SEQ_DEVICE_ARGPTR(dev) (void *)((char *)(dev) + sizeof(snd_seq_device_t))
|
||||
#define SNDRV_SEQ_DEVICE_ARGPTR(dev) (void *)((char *)(dev) + sizeof(struct snd_seq_device))
|
||||
|
||||
|
||||
/*
|
||||
|
|
@ -84,5 +81,4 @@ int snd_seq_device_unregister_driver(char *id);
|
|||
#define SNDRV_SEQ_DEV_ID_MIDISYNTH "seq-midi"
|
||||
#define SNDRV_SEQ_DEV_ID_OPL3 "opl3-synth"
|
||||
|
||||
|
||||
#endif /* __SOUND_SEQ_DEVICE_H */
|
||||
|
|
|
|||
|
|
@ -24,29 +24,27 @@
|
|||
#include "seq_kernel.h"
|
||||
|
||||
/* Instrument cluster */
|
||||
typedef struct _snd_seq_kcluster {
|
||||
struct snd_seq_kcluster {
|
||||
snd_seq_instr_cluster_t cluster;
|
||||
char name[32];
|
||||
int priority;
|
||||
struct _snd_seq_kcluster *next;
|
||||
} snd_seq_kcluster_t;
|
||||
struct snd_seq_kcluster *next;
|
||||
};
|
||||
|
||||
/* return pointer to private data */
|
||||
#define KINSTR_DATA(kinstr) (void *)(((char *)kinstr) + sizeof(snd_seq_kinstr_t))
|
||||
|
||||
typedef struct snd_seq_kinstr_ops snd_seq_kinstr_ops_t;
|
||||
#define KINSTR_DATA(kinstr) (void *)(((char *)kinstr) + sizeof(struct snd_seq_kinstr))
|
||||
|
||||
/* Instrument structure */
|
||||
typedef struct _snd_seq_kinstr {
|
||||
snd_seq_instr_t instr;
|
||||
struct snd_seq_kinstr {
|
||||
struct snd_seq_instr instr;
|
||||
char name[32];
|
||||
int type; /* instrument type */
|
||||
int use; /* use count */
|
||||
int busy; /* not useable */
|
||||
int add_len; /* additional length */
|
||||
snd_seq_kinstr_ops_t *ops; /* operations */
|
||||
struct _snd_seq_kinstr *next;
|
||||
} snd_seq_kinstr_t;
|
||||
struct snd_seq_kinstr_ops *ops; /* operations */
|
||||
struct snd_seq_kinstr *next;
|
||||
};
|
||||
|
||||
#define SNDRV_SEQ_INSTR_HASH_SIZE 32
|
||||
|
||||
|
|
@ -54,11 +52,11 @@ typedef struct _snd_seq_kinstr {
|
|||
#define SNDRV_SEQ_INSTR_FLG_DIRECT (1<<0) /* accept only direct events */
|
||||
|
||||
/* List of all instruments */
|
||||
typedef struct {
|
||||
snd_seq_kinstr_t *hash[SNDRV_SEQ_INSTR_HASH_SIZE];
|
||||
struct snd_seq_kinstr_list {
|
||||
struct snd_seq_kinstr *hash[SNDRV_SEQ_INSTR_HASH_SIZE];
|
||||
int count; /* count of all instruments */
|
||||
|
||||
snd_seq_kcluster_t *chash[SNDRV_SEQ_INSTR_HASH_SIZE];
|
||||
struct snd_seq_kcluster *chash[SNDRV_SEQ_INSTR_HASH_SIZE];
|
||||
int ccount; /* count of all clusters */
|
||||
|
||||
int owner; /* current owner of the instrument list */
|
||||
|
|
@ -68,7 +66,7 @@ typedef struct {
|
|||
spinlock_t ops_lock;
|
||||
struct semaphore ops_mutex;
|
||||
unsigned long ops_flags;
|
||||
} snd_seq_kinstr_list_t;
|
||||
};
|
||||
|
||||
#define SNDRV_SEQ_INSTR_NOTIFY_REMOVE 0
|
||||
#define SNDRV_SEQ_INSTR_NOTIFY_CHANGE 1
|
||||
|
|
@ -78,33 +76,33 @@ struct snd_seq_kinstr_ops {
|
|||
long add_len; /* additional length */
|
||||
char *instr_type;
|
||||
int (*info)(void *private_data, char *info_data, long len);
|
||||
int (*put)(void *private_data, snd_seq_kinstr_t *kinstr,
|
||||
int (*put)(void *private_data, struct snd_seq_kinstr *kinstr,
|
||||
char __user *instr_data, long len, int atomic, int cmd);
|
||||
int (*get)(void *private_data, snd_seq_kinstr_t *kinstr,
|
||||
int (*get)(void *private_data, struct snd_seq_kinstr *kinstr,
|
||||
char __user *instr_data, long len, int atomic, int cmd);
|
||||
int (*get_size)(void *private_data, snd_seq_kinstr_t *kinstr, long *size);
|
||||
int (*remove)(void *private_data, snd_seq_kinstr_t *kinstr, int atomic);
|
||||
void (*notify)(void *private_data, snd_seq_kinstr_t *kinstr, int what);
|
||||
int (*get_size)(void *private_data, struct snd_seq_kinstr *kinstr, long *size);
|
||||
int (*remove)(void *private_data, struct snd_seq_kinstr *kinstr, int atomic);
|
||||
void (*notify)(void *private_data, struct snd_seq_kinstr *kinstr, int what);
|
||||
struct snd_seq_kinstr_ops *next;
|
||||
};
|
||||
|
||||
|
||||
/* instrument operations */
|
||||
snd_seq_kinstr_list_t *snd_seq_instr_list_new(void);
|
||||
void snd_seq_instr_list_free(snd_seq_kinstr_list_t **list);
|
||||
int snd_seq_instr_list_free_cond(snd_seq_kinstr_list_t *list,
|
||||
snd_seq_instr_header_t *ifree,
|
||||
struct snd_seq_kinstr_list *snd_seq_instr_list_new(void);
|
||||
void snd_seq_instr_list_free(struct snd_seq_kinstr_list **list);
|
||||
int snd_seq_instr_list_free_cond(struct snd_seq_kinstr_list *list,
|
||||
struct snd_seq_instr_header *ifree,
|
||||
int client,
|
||||
int atomic);
|
||||
snd_seq_kinstr_t *snd_seq_instr_find(snd_seq_kinstr_list_t *list,
|
||||
snd_seq_instr_t *instr,
|
||||
int exact,
|
||||
int follow_alias);
|
||||
void snd_seq_instr_free_use(snd_seq_kinstr_list_t *list,
|
||||
snd_seq_kinstr_t *instr);
|
||||
int snd_seq_instr_event(snd_seq_kinstr_ops_t *ops,
|
||||
snd_seq_kinstr_list_t *list,
|
||||
snd_seq_event_t *ev,
|
||||
struct snd_seq_kinstr *snd_seq_instr_find(struct snd_seq_kinstr_list *list,
|
||||
struct snd_seq_instr *instr,
|
||||
int exact,
|
||||
int follow_alias);
|
||||
void snd_seq_instr_free_use(struct snd_seq_kinstr_list *list,
|
||||
struct snd_seq_kinstr *instr);
|
||||
int snd_seq_instr_event(struct snd_seq_kinstr_ops *ops,
|
||||
struct snd_seq_kinstr_list *list,
|
||||
struct snd_seq_event *ev,
|
||||
int client,
|
||||
int atomic,
|
||||
int hop);
|
||||
|
|
|
|||
|
|
@ -24,62 +24,8 @@
|
|||
#include <linux/time.h>
|
||||
#include "asequencer.h"
|
||||
|
||||
typedef sndrv_seq_tick_time_t snd_seq_tick_time_t;
|
||||
typedef sndrv_seq_position_t snd_seq_position_t;
|
||||
typedef sndrv_seq_frequency_t snd_seq_frequency_t;
|
||||
typedef sndrv_seq_instr_cluster_t snd_seq_instr_cluster_t;
|
||||
typedef enum sndrv_seq_client_type snd_seq_client_type_t;
|
||||
typedef enum sndrv_seq_stop_mode snd_seq_stop_mode_t;
|
||||
typedef struct sndrv_seq_port_info snd_seq_port_info_t;
|
||||
typedef struct sndrv_seq_port_subscribe snd_seq_port_subscribe_t;
|
||||
typedef struct sndrv_seq_event snd_seq_event_t;
|
||||
typedef struct sndrv_seq_addr snd_seq_addr_t;
|
||||
typedef struct sndrv_seq_ev_volume snd_seq_ev_volume_t;
|
||||
typedef struct sndrv_seq_ev_loop snd_seq_ev_loop_t;
|
||||
typedef struct sndrv_seq_remove_events snd_seq_remove_events_t;
|
||||
typedef struct sndrv_seq_query_subs snd_seq_query_subs_t;
|
||||
typedef struct sndrv_seq_real_time snd_seq_real_time_t;
|
||||
typedef struct sndrv_seq_system_info snd_seq_system_info_t;
|
||||
typedef struct sndrv_seq_client_info snd_seq_client_info_t;
|
||||
typedef struct sndrv_seq_queue_info snd_seq_queue_info_t;
|
||||
typedef struct sndrv_seq_queue_status snd_seq_queue_status_t;
|
||||
typedef struct sndrv_seq_queue_tempo snd_seq_queue_tempo_t;
|
||||
typedef struct sndrv_seq_queue_owner snd_seq_queue_owner_t;
|
||||
typedef struct sndrv_seq_queue_timer snd_seq_queue_timer_t;
|
||||
typedef struct sndrv_seq_queue_client snd_seq_queue_client_t;
|
||||
typedef struct sndrv_seq_client_pool snd_seq_client_pool_t;
|
||||
typedef struct sndrv_seq_instr snd_seq_instr_t;
|
||||
typedef struct sndrv_seq_instr_data snd_seq_instr_data_t;
|
||||
typedef struct sndrv_seq_instr_header snd_seq_instr_header_t;
|
||||
typedef union sndrv_seq_timestamp snd_seq_timestamp_t;
|
||||
|
||||
#define snd_seq_event_bounce_ext_data sndrv_seq_event_bounce_ext_data
|
||||
#define snd_seq_ev_is_result_type sndrv_seq_ev_is_result_type
|
||||
#define snd_seq_ev_is_channel_type sndrv_seq_ev_is_channel_type
|
||||
#define snd_seq_ev_is_note_type sndrv_seq_ev_is_note_type
|
||||
#define snd_seq_ev_is_control_type sndrv_seq_ev_is_control_type
|
||||
#define snd_seq_ev_is_queue_type sndrv_seq_ev_is_queue_type
|
||||
#define snd_seq_ev_is_message_type sndrv_seq_ev_is_message_type
|
||||
#define snd_seq_ev_is_sample_type sndrv_seq_ev_is_sample_type
|
||||
#define snd_seq_ev_is_user_type sndrv_seq_ev_is_user_type
|
||||
#define snd_seq_ev_is_fixed_type sndrv_seq_ev_is_fixed_type
|
||||
#define snd_seq_ev_is_instr_type sndrv_seq_ev_is_instr_type
|
||||
#define snd_seq_ev_is_variable_type sndrv_seq_ev_is_variable_type
|
||||
#define snd_seq_ev_is_reserved sndrv_seq_ev_is_reserved
|
||||
#define snd_seq_ev_is_direct sndrv_seq_ev_is_direct
|
||||
#define snd_seq_ev_is_prior sndrv_seq_ev_is_prior
|
||||
#define snd_seq_ev_length_type sndrv_seq_ev_length_type
|
||||
#define snd_seq_ev_is_fixed sndrv_seq_ev_is_fixed
|
||||
#define snd_seq_ev_is_variable sndrv_seq_ev_is_variable
|
||||
#define snd_seq_ev_is_varusr sndrv_seq_ev_is_varusr
|
||||
#define snd_seq_ev_timestamp_type sndrv_seq_ev_timestamp_type
|
||||
#define snd_seq_ev_is_tick sndrv_seq_ev_is_tick
|
||||
#define snd_seq_ev_is_real sndrv_seq_ev_is_real
|
||||
#define snd_seq_ev_timemode_type sndrv_seq_ev_timemode_type
|
||||
#define snd_seq_ev_is_abstime sndrv_seq_ev_is_abstime
|
||||
#define snd_seq_ev_is_reltime sndrv_seq_ev_is_reltime
|
||||
#define snd_seq_queue_sync_port sndrv_seq_queue_sync_port
|
||||
#define snd_seq_queue_owner sndrv_seq_queue_owner
|
||||
typedef struct snd_seq_real_time snd_seq_real_time_t;
|
||||
typedef union snd_seq_timestamp snd_seq_timestamp_t;
|
||||
|
||||
/* maximum number of events dequeued per schedule interval */
|
||||
#define SNDRV_SEQ_MAX_DEQUEUE 50
|
||||
|
|
@ -114,69 +60,56 @@ typedef union sndrv_seq_timestamp snd_seq_timestamp_t;
|
|||
/* max size of event size */
|
||||
#define SNDRV_SEQ_MAX_EVENT_LEN 0x3fffffff
|
||||
|
||||
/* typedefs */
|
||||
struct _snd_seq_user_client;
|
||||
struct _snd_seq_kernel_client;
|
||||
struct _snd_seq_client;
|
||||
struct _snd_seq_queue;
|
||||
|
||||
typedef struct _snd_seq_user_client user_client_t;
|
||||
typedef struct _snd_seq_kernel_client kernel_client_t;
|
||||
typedef struct _snd_seq_client client_t;
|
||||
typedef struct _snd_seq_queue queue_t;
|
||||
|
||||
/* call-backs for kernel client */
|
||||
|
||||
typedef struct {
|
||||
struct snd_seq_client_callback {
|
||||
void *private_data;
|
||||
unsigned allow_input: 1,
|
||||
allow_output: 1;
|
||||
/*...*/
|
||||
} snd_seq_client_callback_t;
|
||||
};
|
||||
|
||||
/* call-backs for kernel port */
|
||||
typedef int (snd_seq_kernel_port_open_t)(void *private_data, snd_seq_port_subscribe_t *info);
|
||||
typedef int (snd_seq_kernel_port_close_t)(void *private_data, snd_seq_port_subscribe_t *info);
|
||||
typedef int (snd_seq_kernel_port_input_t)(snd_seq_event_t *ev, int direct, void *private_data, int atomic, int hop);
|
||||
typedef void (snd_seq_kernel_port_private_free_t)(void *private_data);
|
||||
|
||||
typedef struct {
|
||||
struct snd_seq_port_callback {
|
||||
struct module *owner;
|
||||
void *private_data;
|
||||
snd_seq_kernel_port_open_t *subscribe;
|
||||
snd_seq_kernel_port_close_t *unsubscribe;
|
||||
snd_seq_kernel_port_open_t *use;
|
||||
snd_seq_kernel_port_close_t *unuse;
|
||||
snd_seq_kernel_port_input_t *event_input;
|
||||
snd_seq_kernel_port_private_free_t *private_free;
|
||||
int (*subscribe)(void *private_data, struct snd_seq_port_subscribe *info);
|
||||
int (*unsubscribe)(void *private_data, struct snd_seq_port_subscribe *info);
|
||||
int (*use)(void *private_data, struct snd_seq_port_subscribe *info);
|
||||
int (*unuse)(void *private_data, struct snd_seq_port_subscribe *info);
|
||||
int (*event_input)(struct snd_seq_event *ev, int direct, void *private_data, int atomic, int hop);
|
||||
void (*private_free)(void *private_data);
|
||||
unsigned int callback_all; /* call subscribe callbacks at each connection/disconnection */
|
||||
/*...*/
|
||||
} snd_seq_port_callback_t;
|
||||
};
|
||||
|
||||
/* interface for kernel client */
|
||||
extern int snd_seq_create_kernel_client(snd_card_t *card, int client_index, snd_seq_client_callback_t *callback);
|
||||
extern int snd_seq_delete_kernel_client(int client);
|
||||
extern int snd_seq_kernel_client_enqueue(int client, snd_seq_event_t *ev, int atomic, int hop);
|
||||
extern int snd_seq_kernel_client_dispatch(int client, snd_seq_event_t *ev, int atomic, int hop);
|
||||
extern int snd_seq_kernel_client_ctl(int client, unsigned int cmd, void *arg);
|
||||
int snd_seq_create_kernel_client(struct snd_card *card, int client_index,
|
||||
struct snd_seq_client_callback *callback);
|
||||
int snd_seq_delete_kernel_client(int client);
|
||||
int snd_seq_kernel_client_enqueue(int client, struct snd_seq_event *ev, int atomic, int hop);
|
||||
int snd_seq_kernel_client_dispatch(int client, struct snd_seq_event *ev, int atomic, int hop);
|
||||
int snd_seq_kernel_client_ctl(int client, unsigned int cmd, void *arg);
|
||||
|
||||
#define SNDRV_SEQ_EXT_MASK 0xc0000000
|
||||
#define SNDRV_SEQ_EXT_USRPTR 0x80000000
|
||||
#define SNDRV_SEQ_EXT_CHAINED 0x40000000
|
||||
|
||||
typedef int (*snd_seq_dump_func_t)(void *ptr, void *buf, int count);
|
||||
int snd_seq_expand_var_event(const snd_seq_event_t *event, int count, char *buf, int in_kernel, int size_aligned);
|
||||
int snd_seq_dump_var_event(const snd_seq_event_t *event, snd_seq_dump_func_t func, void *private_data);
|
||||
int snd_seq_expand_var_event(const struct snd_seq_event *event, int count, char *buf,
|
||||
int in_kernel, int size_aligned);
|
||||
int snd_seq_dump_var_event(const struct snd_seq_event *event,
|
||||
snd_seq_dump_func_t func, void *private_data);
|
||||
|
||||
/* interface for OSS emulation */
|
||||
int snd_seq_set_queue_tempo(int client, snd_seq_queue_tempo_t *tempo);
|
||||
int snd_seq_set_queue_tempo(int client, struct snd_seq_queue_tempo *tempo);
|
||||
|
||||
/* port callback routines */
|
||||
void snd_port_init_callback(snd_seq_port_callback_t *p);
|
||||
snd_seq_port_callback_t *snd_port_alloc_callback(void);
|
||||
void snd_port_init_callback(struct snd_seq_port_callback *p);
|
||||
struct snd_seq_port_callback *snd_port_alloc_callback(void);
|
||||
|
||||
/* port attach/detach */
|
||||
int snd_seq_event_port_attach(int client, snd_seq_port_callback_t *pcbp,
|
||||
int snd_seq_event_port_attach(int client, struct snd_seq_port_callback *pcbp,
|
||||
int cap, int type, int midi_channels, int midi_voices, char *portname);
|
||||
int snd_seq_event_port_detach(int client, int port);
|
||||
|
||||
|
|
|
|||
|
|
@ -29,7 +29,7 @@
|
|||
* channel. All drivers for hardware that does not understand midi
|
||||
* directly will probably need to use this structure.
|
||||
*/
|
||||
typedef struct snd_midi_channel {
|
||||
struct snd_midi_channel {
|
||||
void *private; /* A back pointer to driver data */
|
||||
int number; /* The channel number */
|
||||
int client; /* The client associated with this channel */
|
||||
|
|
@ -53,41 +53,43 @@ typedef struct snd_midi_channel {
|
|||
short gm_rpn_fine_tuning; /* Master fine tuning */
|
||||
short gm_rpn_coarse_tuning; /* Master coarse tuning */
|
||||
|
||||
} snd_midi_channel_t;
|
||||
};
|
||||
|
||||
/*
|
||||
* A structure that represets a set of channels bound to a port. There
|
||||
* would usually be 16 channels per port. But fewer could be used for
|
||||
* particular cases.
|
||||
* The channel set consists of information describing the client and
|
||||
* port for this midi synth and an array of snd_midi_channel_t structures.
|
||||
* A driver that had no need for snd_midi_channel_t could still use the
|
||||
* port for this midi synth and an array of snd_midi_channel structures.
|
||||
* A driver that had no need for snd_midi_channel could still use the
|
||||
* channel set type if it wished with the channel array null.
|
||||
*/
|
||||
typedef struct snd_midi_channel_set {
|
||||
struct snd_midi_channel_set {
|
||||
void *private_data; /* Driver data */
|
||||
int client; /* Client for this port */
|
||||
int port; /* The port number */
|
||||
|
||||
int max_channels; /* Size of the channels array */
|
||||
snd_midi_channel_t *channels;
|
||||
struct snd_midi_channel *channels;
|
||||
|
||||
unsigned char midi_mode; /* MIDI operating mode */
|
||||
unsigned char gs_master_volume; /* SYSEX master volume: 0-127 */
|
||||
unsigned char gs_chorus_mode;
|
||||
unsigned char gs_reverb_mode;
|
||||
|
||||
} snd_midi_channel_set_t;
|
||||
};
|
||||
|
||||
typedef struct snd_seq_midi_op {
|
||||
void (*note_on)(void *private_data, int note, int vel, snd_midi_channel_t *chan);
|
||||
void (*note_off)(void *private_data,int note, int vel, snd_midi_channel_t *chan); /* release note */
|
||||
void (*key_press)(void *private_data, int note, int vel, snd_midi_channel_t *chan);
|
||||
void (*note_terminate)(void *private_data, int note, snd_midi_channel_t *chan); /* terminate note immediately */
|
||||
void (*control)(void *private_data, int type, snd_midi_channel_t *chan);
|
||||
void (*nrpn)(void *private_data, snd_midi_channel_t *chan, snd_midi_channel_set_t *chset);
|
||||
void (*sysex)(void *private_data, unsigned char *buf, int len, int parsed, snd_midi_channel_set_t *chset);
|
||||
} snd_midi_op_t;
|
||||
struct snd_midi_op {
|
||||
void (*note_on)(void *private_data, int note, int vel, struct snd_midi_channel *chan);
|
||||
void (*note_off)(void *private_data,int note, int vel, struct snd_midi_channel *chan); /* release note */
|
||||
void (*key_press)(void *private_data, int note, int vel, struct snd_midi_channel *chan);
|
||||
void (*note_terminate)(void *private_data, int note, struct snd_midi_channel *chan); /* terminate note immediately */
|
||||
void (*control)(void *private_data, int type, struct snd_midi_channel *chan);
|
||||
void (*nrpn)(void *private_data, struct snd_midi_channel *chan,
|
||||
struct snd_midi_channel_set *chset);
|
||||
void (*sysex)(void *private_data, unsigned char *buf, int len, int parsed,
|
||||
struct snd_midi_channel_set *chset);
|
||||
};
|
||||
|
||||
/*
|
||||
* These defines are used so that pitchbend, aftertouch etc, can be
|
||||
|
|
@ -186,10 +188,10 @@ enum {
|
|||
};
|
||||
|
||||
/* Prototypes for midi_process.c */
|
||||
void snd_midi_process_event(snd_midi_op_t *ops, snd_seq_event_t *ev,
|
||||
snd_midi_channel_set_t *chanset);
|
||||
void snd_midi_channel_set_clear(snd_midi_channel_set_t *chset);
|
||||
snd_midi_channel_set_t *snd_midi_channel_alloc_set(int n);
|
||||
void snd_midi_channel_free_set(snd_midi_channel_set_t *chset);
|
||||
void snd_midi_process_event(struct snd_midi_op *ops, struct snd_seq_event *ev,
|
||||
struct snd_midi_channel_set *chanset);
|
||||
void snd_midi_channel_set_clear(struct snd_midi_channel_set *chset);
|
||||
struct snd_midi_channel_set *snd_midi_channel_alloc_set(int n);
|
||||
void snd_midi_channel_free_set(struct snd_midi_channel_set *chset);
|
||||
|
||||
#endif /* __SOUND_SEQ_MIDI_EMUL_H */
|
||||
|
|
|
|||
|
|
@ -26,10 +26,8 @@
|
|||
|
||||
#define MAX_MIDI_EVENT_BUF 256
|
||||
|
||||
typedef struct snd_midi_event_t snd_midi_event_t;
|
||||
|
||||
/* midi status */
|
||||
struct snd_midi_event_t {
|
||||
struct snd_midi_event {
|
||||
int qlen; /* queue length */
|
||||
int read; /* chars read */
|
||||
int type; /* current event type */
|
||||
|
|
@ -40,15 +38,17 @@ struct snd_midi_event_t {
|
|||
spinlock_t lock;
|
||||
};
|
||||
|
||||
int snd_midi_event_new(int bufsize, snd_midi_event_t **rdev);
|
||||
void snd_midi_event_free(snd_midi_event_t *dev);
|
||||
void snd_midi_event_reset_encode(snd_midi_event_t *dev);
|
||||
void snd_midi_event_reset_decode(snd_midi_event_t *dev);
|
||||
void snd_midi_event_no_status(snd_midi_event_t *dev, int on);
|
||||
int snd_midi_event_new(int bufsize, struct snd_midi_event **rdev);
|
||||
void snd_midi_event_free(struct snd_midi_event *dev);
|
||||
void snd_midi_event_reset_encode(struct snd_midi_event *dev);
|
||||
void snd_midi_event_reset_decode(struct snd_midi_event *dev);
|
||||
void snd_midi_event_no_status(struct snd_midi_event *dev, int on);
|
||||
/* encode from byte stream - return number of written bytes if success */
|
||||
long snd_midi_event_encode(snd_midi_event_t *dev, unsigned char *buf, long count, snd_seq_event_t *ev);
|
||||
int snd_midi_event_encode_byte(snd_midi_event_t *dev, int c, snd_seq_event_t *ev);
|
||||
long snd_midi_event_encode(struct snd_midi_event *dev, unsigned char *buf, long count,
|
||||
struct snd_seq_event *ev);
|
||||
int snd_midi_event_encode_byte(struct snd_midi_event *dev, int c, struct snd_seq_event *ev);
|
||||
/* decode from event to bytes - return number of written bytes if success */
|
||||
long snd_midi_event_decode(snd_midi_event_t *dev, unsigned char *buf, long count, snd_seq_event_t *ev);
|
||||
long snd_midi_event_decode(struct snd_midi_event *dev, unsigned char *buf, long count,
|
||||
struct snd_seq_event *ev);
|
||||
|
||||
#endif /* __SOUND_SEQ_MIDI_EVENT_H */
|
||||
|
|
|
|||
|
|
@ -25,25 +25,23 @@
|
|||
#include "rawmidi.h"
|
||||
#include "seq_midi_event.h"
|
||||
|
||||
typedef struct _snd_virmidi_dev snd_virmidi_dev_t;
|
||||
|
||||
/*
|
||||
* device file instance:
|
||||
* This instance is created at each time the midi device file is
|
||||
* opened. Each instance has its own input buffer and MIDI parser
|
||||
* (buffer), and is associated with the device instance.
|
||||
*/
|
||||
typedef struct _snd_virmidi {
|
||||
struct snd_virmidi {
|
||||
struct list_head list;
|
||||
int seq_mode;
|
||||
int client;
|
||||
int port;
|
||||
unsigned int trigger: 1;
|
||||
snd_midi_event_t *parser;
|
||||
snd_seq_event_t event;
|
||||
snd_virmidi_dev_t *rdev;
|
||||
snd_rawmidi_substream_t *substream;
|
||||
} snd_virmidi_t;
|
||||
struct snd_midi_event *parser;
|
||||
struct snd_seq_event event;
|
||||
struct snd_virmidi_dev *rdev;
|
||||
struct snd_rawmidi_substream *substream;
|
||||
};
|
||||
|
||||
#define SNDRV_VIRMIDI_SUBSCRIBE (1<<0)
|
||||
#define SNDRV_VIRMIDI_USE (1<<1)
|
||||
|
|
@ -53,9 +51,9 @@ typedef struct _snd_virmidi {
|
|||
* Each virtual midi device has one device instance. It contains
|
||||
* common information and the linked-list of opened files,
|
||||
*/
|
||||
struct _snd_virmidi_dev {
|
||||
snd_card_t *card; /* associated card */
|
||||
snd_rawmidi_t *rmidi; /* rawmidi device */
|
||||
struct snd_virmidi_dev {
|
||||
struct snd_card *card; /* associated card */
|
||||
struct snd_rawmidi *rmidi; /* rawmidi device */
|
||||
int seq_mode; /* SNDRV_VIRMIDI_XXX */
|
||||
int device; /* sequencer device */
|
||||
int client; /* created/attached client */
|
||||
|
|
@ -78,6 +76,6 @@ struct _snd_virmidi_dev {
|
|||
#define SNDRV_VIRMIDI_SEQ_ATTACH 1
|
||||
#define SNDRV_VIRMIDI_SEQ_DISPATCH 2
|
||||
|
||||
int snd_virmidi_new(snd_card_t *card, int device, snd_rawmidi_t **rrmidi);
|
||||
int snd_virmidi_new(struct snd_card *card, int device, struct snd_rawmidi **rrmidi);
|
||||
|
||||
#endif /* __SOUND_SEQ_VIRMIDI */
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue