mirror of
https://gitee.com/openharmony/third_party_alsa-lib
synced 2024-11-27 09:40:32 +00:00
244d345fda
Wed, 22 Dec 1999 15:51:37 +0100
Changes in alsa-driver:
1. SND_SEQ_DEST_DIRECT was removed. For direct dispatching, specify
the scheduling queue as SND_SEQ_QUEUE_DIRECT.
Source compatibility is kept if alsa-lib functions are used to set
or check direct mode.
Tested: pmidi, playmidi1, aconnect, aseqview, OSS emulation
2. The error event can be bounced to the sender as an encapsulated
event with SND_SEQ_EVENT_BOUNCE type. If the orignal event is
variable length (like SYSEX), the data body is added after the
copied event data. (To access to it, use
snd_seq_event_bounce_ext_data() macro.)
This feature is enabled only when the sender is opened with read
flag and has a client-filter flag SND_SEQ_FILTER_BOUNCE, so that
as default it is disabled.
3. Maximum size of VARIABLE length event is defined as 2048 bytes.
Larger events will be refused.
Note that this is not the size of VARUSR nor VARIPC event.
4. Return error code was revised.
Possible errors for read():
-ENXIO invalid client or file open mode
-ENOSPC FIFO overflow (the flag is cleared after this error report)
-EINVAL no enough user-space buffer to write the whole event
-EFAULT seg. fault during copy to user space
Possible errors for write():
-ENXIO invalid client or file open mode
-ENOMEM malloc failed
-EFAULT seg. fault during copy from user space
-EINVAL invalid event
-EAGAIN no space in output pool
-EINTR interrupts while sleep
-EMLINK too many hops
others depends on return value from driver event_input callback
Changes in alsa-lib:
5. Behavior of snd_seq_flush_output() was changed.
It flushes data in output buffer as much as possible. This has
two advantages. One is that most data can be sent at one call,
and another is that the error in write() can be detected directly
from this function.
The demerit of this implementation is that in non-blocking mode, it
tries twice write() even if write pool of sequencer is full, which
is not actually error. In this case, flush_output() always returns
-EAGAIN error code.
After an error is detected (except for -EAGAIN in non-blocking
mode), you should remove the error event via
snd_seq_extract_output() as below. Otherwise, it'll remain in
output buffer and cause the same error again.
6. Some functions were added:
snd_seq_exract_output(seq, &event)
This extracts the first event on *output* buffer. This will
be useful to know (and remove) the event which causes error in
write().
snd_seq_event_input_pending(seq, fetch)
Retunrs the number of events on input buffer.
If no events exist in input buffer, it fetches from sequencer
(only when flag is true).
snd_seq_event_input_selective(seq, &ev, type, blocking)
Retrieve the event from input with the given event type.
If blocking is true, it waits until the target event is
received. It'll be useful for checking bounced error or
waiting for hand-shake results (eg. loading insruments).
80 lines
4.4 KiB
C
80 lines
4.4 KiB
C
/****************************************************************************
|
|
* *
|
|
* seq.h *
|
|
* Sequencer *
|
|
* *
|
|
****************************************************************************/
|
|
|
|
#define SND_SEQ_OPEN_OUT (O_WRONLY)
|
|
#define SND_SEQ_OPEN_IN (O_RDONLY)
|
|
#define SND_SEQ_OPEN (O_RDWR)
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
typedef struct snd_seq snd_seq_t;
|
|
|
|
int snd_seq_open(snd_seq_t **handle, int mode);
|
|
int snd_seq_close(snd_seq_t *handle);
|
|
int snd_seq_file_descriptor(snd_seq_t *handle);
|
|
int snd_seq_block_mode(snd_seq_t *handle, int enable);
|
|
int snd_seq_client_id(snd_seq_t *handle);
|
|
int snd_seq_system_info(snd_seq_t *handle, snd_seq_system_info_t *info);
|
|
int snd_seq_get_client_info(snd_seq_t *handle, snd_seq_client_info_t *info);
|
|
int snd_seq_get_any_client_info(snd_seq_t *handle, int client, snd_seq_client_info_t *info);
|
|
int snd_seq_set_client_info(snd_seq_t *handle, snd_seq_client_info_t *info);
|
|
int snd_seq_create_port(snd_seq_t *handle, snd_seq_port_info_t *info);
|
|
int snd_seq_delete_port(snd_seq_t *handle, snd_seq_port_info_t *info);
|
|
int snd_seq_get_port_info(snd_seq_t *handle, int port, snd_seq_port_info_t *info);
|
|
int snd_seq_get_any_port_info(snd_seq_t *handle, int client, int port, snd_seq_port_info_t *info);
|
|
int snd_seq_set_port_info(snd_seq_t *handle, int port, snd_seq_port_info_t *info);
|
|
int snd_seq_get_port_subscription(snd_seq_t *handle, snd_seq_port_subscribe_t *sub);
|
|
int snd_seq_subscribe_port(snd_seq_t *handle, snd_seq_port_subscribe_t *sub);
|
|
int snd_seq_unsubscribe_port(snd_seq_t *handle, snd_seq_port_subscribe_t *sub);
|
|
int snd_seq_query_port_subscribers(snd_seq_t *seq, snd_seq_query_subs_t * subs);
|
|
int snd_seq_get_queue_status(snd_seq_t *handle, int q, snd_seq_queue_status_t *status);
|
|
int snd_seq_get_queue_tempo(snd_seq_t *handle, int q, snd_seq_queue_tempo_t *tempo);
|
|
int snd_seq_set_queue_tempo(snd_seq_t *handle, int q, snd_seq_queue_tempo_t *tempo);
|
|
int snd_seq_get_queue_owner(snd_seq_t *handle, int q, snd_seq_queue_owner_t *owner);
|
|
int snd_seq_set_queue_owner(snd_seq_t *handle, int q, snd_seq_queue_owner_t *owner);
|
|
int snd_seq_get_queue_timer(snd_seq_t *handle, int q, snd_seq_queue_timer_t *timer);
|
|
int snd_seq_set_queue_timer(snd_seq_t *handle, int q, snd_seq_queue_timer_t *timer);
|
|
int snd_seq_get_queue_sync(snd_seq_t *handle, int q, snd_seq_queue_sync_t *sync);
|
|
int snd_seq_set_queue_sync(snd_seq_t *handle, int q, snd_seq_queue_sync_t *sync);
|
|
int snd_seq_get_queue_client(snd_seq_t *handle, int q, snd_seq_queue_client_t *queue);
|
|
int snd_seq_set_queue_client(snd_seq_t *handle, int q, snd_seq_queue_client_t *queue);
|
|
int snd_seq_alloc_named_queue(snd_seq_t *seq, char *name);
|
|
int snd_seq_alloc_queue(snd_seq_t *handle);
|
|
int snd_seq_free_queue(snd_seq_t *handle, int q);
|
|
int snd_seq_get_queue_info(snd_seq_t *seq, int q, snd_seq_queue_info_t *info);
|
|
int snd_seq_set_queue_info(snd_seq_t *seq, int q, snd_seq_queue_info_t *info);
|
|
int snd_seq_get_named_queue(snd_seq_t *seq, char *name);
|
|
int snd_seq_get_client_pool(snd_seq_t *handle, snd_seq_client_pool_t * info);
|
|
int snd_seq_set_client_pool(snd_seq_t *handle, snd_seq_client_pool_t * info);
|
|
int snd_seq_query_next_client(snd_seq_t *handle, snd_seq_client_info_t * info);
|
|
int snd_seq_query_next_port(snd_seq_t *handle, snd_seq_port_info_t * info);
|
|
|
|
/* event routines */
|
|
snd_seq_event_t *snd_seq_create_event(void);
|
|
int snd_seq_free_event(snd_seq_event_t *ev);
|
|
int snd_seq_event_length(snd_seq_event_t *ev);
|
|
int snd_seq_event_output(snd_seq_t *handle, snd_seq_event_t *ev);
|
|
int snd_seq_event_input(snd_seq_t *handle, snd_seq_event_t **ev);
|
|
int snd_seq_event_input_pending(snd_seq_t *seq, int fetch_sequencer);
|
|
int snd_seq_event_input_selective(snd_seq_t *seq, snd_seq_event_t **ev, int type, int blocking);
|
|
int snd_seq_flush_output(snd_seq_t *handle);
|
|
int snd_seq_extract_output(snd_seq_t *handle, snd_seq_event_t **ev);
|
|
int snd_seq_drain_output(snd_seq_t *handle);
|
|
int snd_seq_drain_input(snd_seq_t *handle);
|
|
int snd_seq_remove_events(snd_seq_t *handle, snd_seq_remove_events_t *info);
|
|
/* misc */
|
|
void snd_seq_set_bit(int nr, void *array);
|
|
int snd_seq_change_bit(int nr, void *array);
|
|
int snd_seq_get_bit(int nr, void *array);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|