mirrors/alsa-lib
1
0
Fork 0
mirror of https://github.com/alsa-project/alsa-lib.git synced 2025-11-03 09:01:52 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

First part of PCM documentation

Browse source
This commit is contained in:
Abramo Bagnara 2001-03-23 11:05:41 +00:00
parent 82fcfe1ab5
commit 445e2b0c07
7 changed files with 870 additions and 377 deletions
Download patch file Download diff file Expand all files Collapse all files

578
src/pcm/pcm.c
View file

@ -1,3 +1,16 @@
/**
* \file pcm.c
* \author Jaroslav Kysela <perex@suse.cz>
* \author Abramo Bagnara <abramo@alsa-project.org>
* \date 2000-2001
*
* PCM Interface is designed to write or read digital audio frames. A
* frame is the data unit converted into/from sound in one time unit
* (1/rate seconds), by example if you set your playback PCM rate to
* 44100 you'll hear 44100 frames per second. The size in bytes of a
* frame may be obtained from bits needed to store a sample and
* channels count.
*/
/*
* PCM Interface - main file
* Copyright (c) 1998 by Jaroslav Kysela <perex@suse.cz>
@ -33,24 +46,54 @@
#include "pcm_local.h"
#include "list.h"
/**
* \brief get identifier of PCM handle
* \param pcm a PCM handle
* \return ascii identifier of PCM handle
*
* Returns the ASCII identifier of given PCM handle. It's the same
* identifier as for snd_pcm_open().
*/
const char *snd_pcm_name(snd_pcm_t *pcm)
{
assert(pcm);
return pcm->name;
}
/**
* \brief get type of PCM handle
* \param pcm a PCM handle
* \return type of PCM handle
*
* Returns the type #snd_pcm_type_t of given PCM handle.
*/
snd_pcm_type_t snd_pcm_type(snd_pcm_t *pcm)
{
assert(pcm);
return pcm->type;
}
/**
* \brief get stream for a PCM handle
* \param pcm a PCM handle
* \return stream of PCM handle
*
* Returns the type #snd_pcm_stream_t of given PCM handle.
*/
snd_pcm_stream_t snd_pcm_stream(snd_pcm_t *pcm)
{
assert(pcm);
return pcm->stream;
}
/**
* \brief close PCM handle
* \param pcm PCM handle
* \return zero on success otherwise a negative error code
*
* Closes the specified PCM handle and frees all associated
* resources.
*/
int snd_pcm_close(snd_pcm_t *pcm)
{
int ret = 0;
@ -75,6 +118,12 @@ int snd_pcm_close(snd_pcm_t *pcm)
return 0;
}
/**
* \brief set nonblock mode
* \param pcm PCM handle
* \param nonblock 0 = block, 1 = nonblock mode
* \return zero on success otherwise a negative error code
*/
int snd_pcm_nonblock(snd_pcm_t *pcm, int nonblock)
{
int err;
@ -88,6 +137,15 @@ int snd_pcm_nonblock(snd_pcm_t *pcm, int nonblock)
return 0;
}
/**
* \brief set async mode
* \param pcm PCM handle
* \param sig Signal to raise: < 0 disable, 0 default (SIGIO)
* \param pid Process ID to signal: 0 current
* \return zero on success otherwise a negative error code
*
* A signal is raised every period.
*/
int snd_pcm_async(snd_pcm_t *pcm, int sig, pid_t pid)
{
int err;
@ -106,24 +164,115 @@ int snd_pcm_async(snd_pcm_t *pcm, int sig, pid_t pid)
return 0;
}
/**
* \brief Obtain general (static) information for PCM handle
* \param pcm PCM handle
* \param info Information container
* \return zero on success otherwise a negative error code
*/
int snd_pcm_info(snd_pcm_t *pcm, snd_pcm_info_t *info)
{
assert(pcm && info);
return pcm->ops->info(pcm->op_arg, info);
}
/** \brief Install one PCM hardware configuration choosen from a configuration space and #snd_pcm_prepare it
* \param pcm PCM handle
* \param params Configuration space definition container
* \return zero on success otherwise a negative error code
*
* The configuration is choosen fixing single parameters in this order:
* first access, first format, first subformat, min channels, min rate,
* min period time, max buffer size, min tick time
*/
int snd_pcm_hw_params(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
{
int err;
assert(pcm && params);
err = _snd_pcm_hw_params(pcm, params);
if (err >= 0)
err = snd_pcm_prepare(pcm);
return err;
}
/** \brief Remove PCM hardware configuration and free associated resources
* \param pcm PCM handle
* \return zero on success otherwise a negative error code
*/
int snd_pcm_hw_free(snd_pcm_t *pcm)
{
int err;
assert(pcm->setup);
assert(snd_pcm_state(pcm) <= SND_PCM_STATE_PREPARED);
if (pcm->mmap_channels) {
err = snd_pcm_munmap(pcm);
if (err < 0)
return err;
}
err = pcm->ops->hw_free(pcm->op_arg);
pcm->setup = 0;
return err;
}
/** \brief Install PCM software configuration defined by params
* \param pcm PCM handle
* \param params Configuration container
* \return zero on success otherwise a negative error code
*/
int snd_pcm_sw_params(snd_pcm_t *pcm, snd_pcm_sw_params_t *params)
{
int err;
err = pcm->ops->sw_params(pcm->op_arg, params);
if (err < 0)
return err;
pcm->start_mode = snd_pcm_sw_params_get_start_mode(params);
pcm->xrun_mode = snd_pcm_sw_params_get_xrun_mode(params);
pcm->tstamp_mode = snd_pcm_sw_params_get_tstamp_mode(params);
pcm->period_step = params->period_step;
pcm->sleep_min = params->sleep_min;
pcm->avail_min = params->avail_min;
pcm->xfer_align = params->xfer_align;
pcm->silence_threshold = params->silence_threshold;
pcm->silence_size = params->silence_size;
pcm->boundary = params->boundary;
return 0;
}
/**
* \brief Obtain status (runtime) information for PCM handle
* \param pcm PCM handle
* \param status Status container
* \return zero on success otherwise a negative error code
*/
int snd_pcm_status(snd_pcm_t *pcm, snd_pcm_status_t *status)
{
assert(pcm && status);
return pcm->fast_ops->status(pcm->fast_op_arg, status);
}
/**
* \brief Return PCM state
* \param pcm PCM handle
* \return PCM state #snd_pcm_state_t of given PCM handle
*/
snd_pcm_state_t snd_pcm_state(snd_pcm_t *pcm)
{
assert(pcm);
return pcm->fast_ops->state(pcm->fast_op_arg);
}
/**
* \brief Obtain delay in frames for a running PCM handle
* \param pcm PCM handle
* \param delayp Returned delay
* \return zero on success otherwise a negative error code
*
* Delay is distance between current application frame position and
* sound frame position.
* It's positive and less than buffer size in normal situation,
* negative on playback underrun and greater than buffer size on
* capture overrun.
*/
int snd_pcm_delay(snd_pcm_t *pcm, snd_pcm_sframes_t *delayp)
{
assert(pcm);
@ -131,6 +280,11 @@ int snd_pcm_delay(snd_pcm_t *pcm, snd_pcm_sframes_t *delayp)
return pcm->fast_ops->delay(pcm->fast_op_arg, delayp);
}
/**
* \brief Prepare PCM for use
* \param pcm PCM handle
* \return zero on success otherwise a negative error code
*/
int snd_pcm_prepare(snd_pcm_t *pcm)
{
assert(pcm);
@ -138,6 +292,13 @@ int snd_pcm_prepare(snd_pcm_t *pcm)
return pcm->fast_ops->prepare(pcm->fast_op_arg);
}
/**
* \brief Reset PCM position
* \param pcm PCM handle
* \return zero on success otherwise a negative error code
*
* Reduce PCM delay to 0.
*/
int snd_pcm_reset(snd_pcm_t *pcm)
{
assert(pcm);
@ -145,6 +306,11 @@ int snd_pcm_reset(snd_pcm_t *pcm)
return pcm->fast_ops->reset(pcm->fast_op_arg);
}
/**
* \brief Start a PCM
* \param pcm PCM handle
* \return zero on success otherwise a negative error code
*/
int snd_pcm_start(snd_pcm_t *pcm)
{
assert(pcm);
@ -152,6 +318,11 @@ int snd_pcm_start(snd_pcm_t *pcm)
return pcm->fast_ops->start(pcm->fast_op_arg);
}
/**
* \brief Stop a PCM dropping pending frames
* \param pcm PCM handle
* \return zero on success otherwise a negative error code
*/
int snd_pcm_drop(snd_pcm_t *pcm)
{
assert(pcm);
@ -159,6 +330,15 @@ int snd_pcm_drop(snd_pcm_t *pcm)
return pcm->fast_ops->drop(pcm->fast_op_arg);
}
/**
* \brief Stop a PCM preserving pending frames
* \param pcm PCM handle
* \return zero on success otherwise a negative error code
*
* For playback wait for all pending frames to be played and then stop
* the PCM.
* For capture stop PCM permitting to retrieve residual frames.
*/
int snd_pcm_drain(snd_pcm_t *pcm)
{
assert(pcm);
@ -166,6 +346,12 @@ int snd_pcm_drain(snd_pcm_t *pcm)
return pcm->fast_ops->drain(pcm->fast_op_arg);
}
/**
* \brief Pause/resume PCM
* \param pcm PCM handle
* \param pause 0 = resume, 1 = pause
* \return zero on success otherwise a negative error code
*/
int snd_pcm_pause(snd_pcm_t *pcm, int enable)
{
assert(pcm);
@ -173,7 +359,13 @@ int snd_pcm_pause(snd_pcm_t *pcm, int enable)
return pcm->fast_ops->pause(pcm->fast_op_arg, enable);
}
/**
* \brief Move application frame position backward
* \param pcm PCM handle
* \param frames wanted displacement in frames
* \return a positive number for actual displacement otherwise a
* negative error code
*/
snd_pcm_sframes_t snd_pcm_rewind(snd_pcm_t *pcm, snd_pcm_uframes_t frames)
{
assert(pcm);
@ -182,6 +374,14 @@ snd_pcm_sframes_t snd_pcm_rewind(snd_pcm_t *pcm, snd_pcm_uframes_t frames)
return pcm->fast_ops->rewind(pcm->fast_op_arg, frames);
}
/**
* \brief Write interleaved frames to a PCM
* \param pcm PCM handle
* \param buffer frames containing buffer
* \param size frames to be written
* \return a positive number of frames actually written otherwise a
* negative error code
*/
snd_pcm_sframes_t snd_pcm_writei(snd_pcm_t *pcm, const void *buffer, snd_pcm_uframes_t size)
{
assert(pcm);
@ -191,6 +391,14 @@ snd_pcm_sframes_t snd_pcm_writei(snd_pcm_t *pcm, const void *buffer, snd_pcm_ufr
return _snd_pcm_writei(pcm, buffer, size);
}
/**
* \brief Write non interleaved frames to a PCM
* \param pcm PCM handle
* \param bufs frames containing buffers (one for each channel)
* \param size frames to be written
* \return a positive number of frames actually written otherwise a
* negative error code
*/
snd_pcm_sframes_t snd_pcm_writen(snd_pcm_t *pcm, void **bufs, snd_pcm_uframes_t size)
{
assert(pcm);
@ -200,6 +408,14 @@ snd_pcm_sframes_t snd_pcm_writen(snd_pcm_t *pcm, void **bufs, snd_pcm_uframes_t
return _snd_pcm_writen(pcm, bufs, size);
}
/**
* \brief Read interleaved frames from a PCM
* \param pcm PCM handle
* \param buffer frames containing buffer
* \param size frames to be written
* \return a positive number of frames actually read otherwise a
* negative error code
*/
snd_pcm_sframes_t snd_pcm_readi(snd_pcm_t *pcm, void *buffer, snd_pcm_uframes_t size)
{
assert(pcm);
@ -209,6 +425,14 @@ snd_pcm_sframes_t snd_pcm_readi(snd_pcm_t *pcm, void *buffer, snd_pcm_uframes_t
return _snd_pcm_readi(pcm, buffer, size);
}
/**
* \brief Read non interleaved frames to a PCM
* \param pcm PCM handle
* \param bufs frames containing buffers (one for each channel)
* \param size frames to be written
* \return a positive number of frames actually read otherwise a
* negative error code
*/
snd_pcm_sframes_t snd_pcm_readn(snd_pcm_t *pcm, void **bufs, snd_pcm_uframes_t size)
{
assert(pcm);
@ -218,9 +442,14 @@ snd_pcm_sframes_t snd_pcm_readn(snd_pcm_t *pcm, void **bufs, snd_pcm_uframes_t s
return _snd_pcm_readn(pcm, bufs, size);
}
/* FIXME */
#define _snd_pcm_link_descriptor _snd_pcm_poll_descriptor
/**
* \brief Link two PCMs
* \param pcm1 first PCM handle
* \param pcm2 first PCM handle
* \return zero on success otherwise a negative error code
*
* The two PCMs will start/stop/prepare in sync.
*/
int snd_pcm_link(snd_pcm_t *pcm1, snd_pcm_t *pcm2)
{
int fd1 = _snd_pcm_link_descriptor(pcm1);
@ -234,6 +463,11 @@ int snd_pcm_link(snd_pcm_t *pcm1, snd_pcm_t *pcm2)
return 0;
}
/**
* \brief Remove a PCM from a linked group
* \param pcm PCM handle
* \return zero on success otherwise a negative error code
*/
int snd_pcm_unlink(snd_pcm_t *pcm)
{
int fd;
@ -245,12 +479,25 @@ int snd_pcm_unlink(snd_pcm_t *pcm)
return 0;
}
int _snd_pcm_poll_descriptor(snd_pcm_t *pcm)
/**
* \brief get count of poll descriptors for PCM handle
* \param pcm PCM handle
* \return count of poll descriptors
*/
int snd_pcm_poll_descriptors_count(snd_pcm_t *pcm)
{
assert(pcm);
return pcm->poll_fd;
return 1;
}
/**
* \brief get poll descriptors
* \param pcm PCM handle
* \param pfds array of poll descriptors
* \param space space in the poll descriptor array
* \return count of filled descriptors
*/
int snd_pcm_poll_descriptors(snd_pcm_t *pcm, struct pollfd *pfds, unsigned int space)
{
assert(pcm);
@ -261,6 +508,7 @@ int snd_pcm_poll_descriptors(snd_pcm_t *pcm, struct pollfd *pfds, unsigned int s
return 1;
}
#ifndef DOC_HIDDEN
#define STATE(v) [SND_PCM_STATE_##v] = #v
#define STREAM(v) [SND_PCM_STREAM_##v] = #v
#define READY(v) [SND_PCM_READY_##v] = #v
@ -277,12 +525,12 @@ int snd_pcm_poll_descriptors(snd_pcm_t *pcm, struct pollfd *pfds, unsigned int s
#define FORMATD(v, d) [SND_PCM_FORMAT_##v] = d
#define SUBFORMATD(v, d) [SND_PCM_SUBFORMAT_##v] = d
const char *snd_pcm_stream_names[] = {
static const char *snd_pcm_stream_names[] = {
STREAM(PLAYBACK),
STREAM(CAPTURE),
};
const char *snd_pcm_state_names[] = {
static const char *snd_pcm_state_names[] = {
STATE(OPEN),
STATE(SETUP),
STATE(PREPARED),
@ -291,25 +539,7 @@ const char *snd_pcm_state_names[] = {
STATE(PAUSED),
};
const char *snd_pcm_hw_param_names[] = {
HW_PARAM(ACCESS),
HW_PARAM(FORMAT),
HW_PARAM(SUBFORMAT),
HW_PARAM(SAMPLE_BITS),
HW_PARAM(FRAME_BITS),
HW_PARAM(CHANNELS),
HW_PARAM(RATE),
HW_PARAM(PERIOD_TIME),
HW_PARAM(PERIOD_SIZE),
HW_PARAM(PERIOD_BYTES),
HW_PARAM(PERIODS),
HW_PARAM(BUFFER_TIME),
HW_PARAM(BUFFER_SIZE),
HW_PARAM(BUFFER_BYTES),
HW_PARAM(TICK_TIME),
};
const char *snd_pcm_access_names[] = {
static const char *snd_pcm_access_names[] = {
ACCESS(MMAP_INTERLEAVED),
ACCESS(MMAP_NONINTERLEAVED),
ACCESS(MMAP_COMPLEX),
@ -317,7 +547,7 @@ const char *snd_pcm_access_names[] = {
ACCESS(RW_NONINTERLEAVED),
};
const char *snd_pcm_format_names[] = {
static const char *snd_pcm_format_names[] = {
FORMAT(S8),
FORMAT(U8),
FORMAT(S16_LE),
@ -346,25 +576,25 @@ const char *snd_pcm_format_names[] = {
FORMAT(SPECIAL),
};
const char *snd_pcm_format_descriptions[] = {
FORMATD(S8, "Signed 8-bit"),
FORMATD(U8, "Unsigned 8-bit"),
FORMATD(S16_LE, "Signed 16-bit Little Endian"),
FORMATD(S16_BE, "Signed 16-bit Big Endian"),
FORMATD(U16_LE, "Unsigned 16-bit Little Endian"),
FORMATD(U16_BE, "Unsigned 16-bit Big Endian"),
FORMATD(S24_LE, "Signed 24-bit Little Endian"),
FORMATD(S24_BE, "Signed 24-bit Big Endian"),
FORMATD(U24_LE, "Unsigned 24-bit Little Endian"),
FORMATD(U24_BE, "Unsigned 24-bit Big Endian"),
FORMATD(S32_LE, "Signed 32-bit Little Endian"),
FORMATD(S32_BE, "Signed 32-bit Big Endian"),
FORMATD(U32_LE, "Unsigned 32-bit Little Endian"),
FORMATD(U32_BE, "Unsigned 32-bit Big Endian"),
FORMATD(FLOAT_LE, "Float Little Endian"),
FORMATD(FLOAT_BE, "Float Big Endian"),
FORMATD(FLOAT64_LE, "Float64 Little Endian"),
FORMATD(FLOAT64_BE, "Float64 Big Endian"),
static const char *snd_pcm_format_descriptions[] = {
FORMATD(S8, "Signed 8 bit"),
FORMATD(U8, "Unsigned 8 bit"),
FORMATD(S16_LE, "Signed 16 bit Little Endian"),
FORMATD(S16_BE, "Signed 16 bit Big Endian"),
FORMATD(U16_LE, "Unsigned 16 bit Little Endian"),
FORMATD(U16_BE, "Unsigned 16 bit Big Endian"),
FORMATD(S24_LE, "Signed 24 bit Little Endian"),
FORMATD(S24_BE, "Signed 24 bit Big Endian"),
FORMATD(U24_LE, "Unsigned 24 bit Little Endian"),
FORMATD(U24_BE, "Unsigned 24 bit Big Endian"),
FORMATD(S32_LE, "Signed 32 bit Little Endian"),
FORMATD(S32_BE, "Signed 32 bit Big Endian"),
FORMATD(U32_LE, "Unsigned 32 bit Little Endian"),
FORMATD(U32_BE, "Unsigned 32 bit Big Endian"),
FORMATD(FLOAT_LE, "Float 32 bit Little Endian"),
FORMATD(FLOAT_BE, "Float 32 bit Big Endian"),
FORMATD(FLOAT64_LE, "Float 64 bit Little Endian"),
FORMATD(FLOAT64_BE, "Float 64 bit Big Endian"),
FORMATD(IEC958_SUBFRAME_LE, "IEC-958 Little Endian"),
FORMATD(IEC958_SUBFRAME_BE, "IEC-958 Big Endian"),
FORMATD(MU_LAW, "Mu-Law"),
@ -375,53 +605,79 @@ const char *snd_pcm_format_descriptions[] = {
FORMATD(SPECIAL, "Special"),
};
const char *snd_pcm_subformat_names[] = {
static const char *snd_pcm_subformat_names[] = {
SUBFORMAT(STD),
};
const char *snd_pcm_subformat_descriptions[] = {
static const char *snd_pcm_subformat_descriptions[] = {
SUBFORMATD(STD, "Standard"),
};
const char *snd_pcm_start_mode_names[] = {
static const char *snd_pcm_start_mode_names[] = {
START(EXPLICIT),
START(DATA),
};
const char *snd_pcm_xrun_mode_names[] = {
static const char *snd_pcm_xrun_mode_names[] = {
XRUN(NONE),
XRUN(STOP),
};
const char *snd_pcm_tstamp_mode_names[] = {
static const char *snd_pcm_tstamp_mode_names[] = {
TSTAMP(NONE),
TSTAMP(MMAP),
};
#endif
/**
* \brief get name of PCM stream
* \param stream PCM stream
* \return ascii name of PCM stream
*/
const char *snd_pcm_stream_name(snd_pcm_stream_t stream)
{
assert(stream <= SND_PCM_STREAM_LAST);
return snd_pcm_stream_names[snd_enum_to_int(stream)];
}
/**
* \brief get name of PCM access type
* \param access PCM access type
* \return ascii name of PCM access type
*/
const char *snd_pcm_access_name(snd_pcm_access_t access)
{
assert(access <= SND_PCM_ACCESS_LAST);
return snd_pcm_access_names[snd_enum_to_int(access)];
}
/**
* \brief get name of PCM sample format
* \param format PCM sample format
* \return ascii name of PCM sample format
*/
const char *snd_pcm_format_name(snd_pcm_format_t format)
{
assert(format <= SND_PCM_FORMAT_LAST);
return snd_pcm_format_names[snd_enum_to_int(format)];
}
/**
* \brief get description of PCM sample format
* \param format PCM sample format
* \return ascii description of PCM sample format
*/
const char *snd_pcm_format_description(snd_pcm_format_t format)
{
assert(format <= SND_PCM_FORMAT_LAST);
return snd_pcm_format_descriptions[snd_enum_to_int(format)];
}
/**
* \brief get PCM sample format from name
* \param name PCM sample format name (case insensitive)
* \return PCM sample format
*/
snd_pcm_format_t snd_pcm_format_value(const char* name)
{
snd_pcm_format_t format;
@ -434,42 +690,78 @@ snd_pcm_format_t snd_pcm_format_value(const char* name)
return SND_PCM_FORMAT_UNKNOWN;
}
/**
* \brief get name of PCM sample subformat
* \param format PCM sample subformat
* \return ascii name of PCM sample subformat
*/
const char *snd_pcm_subformat_name(snd_pcm_subformat_t subformat)
{
assert(subformat <= SND_PCM_SUBFORMAT_LAST);
return snd_pcm_subformat_names[snd_enum_to_int(subformat)];
}
const char *snd_pcm_hw_param_name(snd_pcm_hw_param_t param)
/**
* \brief get description of PCM sample subformat
* \param subformat PCM sample subformat
* \return ascii description of PCM sample subformat
*/
const char *snd_pcm_subformat_description(snd_pcm_subformat_t subformat)
{
assert(param <= SND_PCM_HW_PARAM_LAST);
return snd_pcm_hw_param_names[snd_enum_to_int(param)];
assert(subformat <= SND_PCM_SUBFORMAT_LAST);
return snd_pcm_subformat_descriptions[snd_enum_to_int(subformat)];
}
/**
* \brief get name of PCM start mode setting
* \param mode PCM start mode
* \return ascii name of PCM start mode setting
*/
const char *snd_pcm_start_mode_name(snd_pcm_start_t mode)
{
assert(mode <= SND_PCM_START_LAST);
return snd_pcm_start_mode_names[snd_enum_to_int(mode)];
}
/**
* \brief get name of PCM xrun mode setting
* \param mode PCM xrun mode
* \return ascii name of PCM xrun mode setting
*/
const char *snd_pcm_xrun_mode_name(snd_pcm_xrun_t mode)
{
assert(mode <= SND_PCM_XRUN_LAST);
return snd_pcm_xrun_mode_names[snd_enum_to_int(mode)];
}
/**
* \brief get name of PCM tstamp mode setting
* \param mode PCM tstamp mode
* \return ascii name of PCM tstamp mode setting
*/
const char *snd_pcm_tstamp_mode_name(snd_pcm_tstamp_t mode)
{
assert(mode <= SND_PCM_TSTAMP_LAST);
return snd_pcm_tstamp_mode_names[snd_enum_to_int(mode)];
}
/**
* \brief get name of PCM state
* \param state PCM state
* \return ascii name of PCM state
*/
const char *snd_pcm_state_name(snd_pcm_state_t state)
{
assert(state <= SND_PCM_STATE_LAST);
return snd_pcm_state_names[snd_enum_to_int(state)];
}
/**
* \brief Dump current hardware setup for PCM
* \param pcm PCM handle
* \param out Output handle
* \return zero on success otherwise a negative error code
*/
int snd_pcm_dump_hw_setup(snd_pcm_t *pcm, snd_output_t *out)
{
assert(pcm);
@ -490,6 +782,12 @@ int snd_pcm_dump_hw_setup(snd_pcm_t *pcm, snd_output_t *out)
return 0;
}
/**
* \brief Dump current software setup for PCM
* \param pcm PCM handle
* \param out Output handle
* \return zero on success otherwise a negative error code
*/
int snd_pcm_dump_sw_setup(snd_pcm_t *pcm, snd_output_t *out)
{
assert(pcm);
@ -508,6 +806,12 @@ int snd_pcm_dump_sw_setup(snd_pcm_t *pcm, snd_output_t *out)
return 0;
}
/**
* \brief Dump current setup (hardware and software) for PCM
* \param pcm PCM handle
* \param out Output handle
* \return zero on success otherwise a negative error code
*/
int snd_pcm_dump_setup(snd_pcm_t *pcm, snd_output_t *out)
{
snd_pcm_dump_hw_setup(pcm, out);
@ -515,6 +819,12 @@ int snd_pcm_dump_setup(snd_pcm_t *pcm, snd_output_t *out)
return 0;
}
/**
* \brief Dump status
* \param status Status container
* \param out Output handle
* \return zero on success otherwise a negative error code
*/
int snd_pcm_status_dump(snd_pcm_status_t *status, snd_output_t *out)
{
assert(status);
@ -529,6 +839,12 @@ int snd_pcm_status_dump(snd_pcm_status_t *status, snd_output_t *out)
return 0;
}
/**
* \brief Dump PCM info
* \param pcm PCM handle
* \param out Output handle
* \return zero on success otherwise a negative error code
*/
int snd_pcm_dump(snd_pcm_t *pcm, snd_output_t *out)
{
assert(pcm);
@ -537,6 +853,12 @@ int snd_pcm_dump(snd_pcm_t *pcm, snd_output_t *out)
return 0;
}
/**
* \brief Convert bytes in frames for a PCM
* \param pcm PCM handle
* \param bytes quantity in bytes
* \return quantity expressed in frames
*/
snd_pcm_sframes_t snd_pcm_bytes_to_frames(snd_pcm_t *pcm, ssize_t bytes)
{
assert(pcm);
@ -544,6 +866,12 @@ snd_pcm_sframes_t snd_pcm_bytes_to_frames(snd_pcm_t *pcm, ssize_t bytes)
return bytes * 8 / pcm->frame_bits;
}
/**
* \brief Convert frames in bytes for a PCM
* \param pcm PCM handle
* \param frames quantity in frames
* \return quantity expressed in bytes
*/
ssize_t snd_pcm_frames_to_bytes(snd_pcm_t *pcm, snd_pcm_sframes_t frames)
{
assert(pcm);
@ -551,6 +879,12 @@ ssize_t snd_pcm_frames_to_bytes(snd_pcm_t *pcm, snd_pcm_sframes_t frames)
return frames * pcm->frame_bits / 8;
}
/**
* \brief Convert bytes in samples for a PCM
* \param pcm PCM handle
* \param bytes quantity in bytes
* \return quantity expressed in samples
*/
int snd_pcm_bytes_to_samples(snd_pcm_t *pcm, ssize_t bytes)
{
assert(pcm);
@ -558,6 +892,12 @@ int snd_pcm_bytes_to_samples(snd_pcm_t *pcm, ssize_t bytes)
return bytes * 8 / pcm->sample_bits;
}
/**
* \brief Convert samples in bytes for a PCM
* \param pcm PCM handle
* \param samples quantity in samples
* \return quantity expressed in bytes
*/
ssize_t snd_pcm_samples_to_bytes(snd_pcm_t *pcm, int samples)
{
assert(pcm);
@ -565,6 +905,14 @@ ssize_t snd_pcm_samples_to_bytes(snd_pcm_t *pcm, int samples)
return samples * pcm->sample_bits / 8;
}
/**
* \brief Opens a PCM
* \param pcmp Returned PCM handle
* \param name ASCII identifier of the PCM handle
* \param stream Wanted stream
* \param mode Open mode (see #SND_PCM_NONBLOCK, #SND_PCM_ASYNC)
* \return a negative error code on failure or zero on success
*/
int snd_pcm_open(snd_pcm_t **pcmp, const char *name,
snd_pcm_stream_t stream, int mode)
{
@ -706,30 +1054,12 @@ int snd_pcm_open(snd_pcm_t **pcmp, const char *name,
return open_func(pcmp, name, pcm_conf, stream, mode);
}
void snd_pcm_areas_from_buf(snd_pcm_t *pcm, snd_pcm_channel_area_t *areas,
void *buf)
{
unsigned int channel;
unsigned int channels = pcm->channels;
for (channel = 0; channel < channels; ++channel, ++areas) {
areas->addr = buf;
areas->first = channel * pcm->sample_bits;
areas->step = pcm->frame_bits;
}
}
void snd_pcm_areas_from_bufs(snd_pcm_t *pcm, snd_pcm_channel_area_t *areas,
void **bufs)
{
unsigned int channel;
unsigned int channels = pcm->channels;
for (channel = 0; channel < channels; ++channel, ++areas, ++bufs) {
areas->addr = *bufs;
areas->first = 0;
areas->step = pcm->sample_bits;
}
}
/**
* \brief Wait for a PCM to become ready
* \param pcm a PCM handle
* \param timeout maximum time in milliseconds to wait
* \return a negative error code on failure or zero on success
*/
int snd_pcm_wait(snd_pcm_t *pcm, int timeout)
{
struct pollfd pfd;
@ -742,11 +1072,30 @@ int snd_pcm_wait(snd_pcm_t *pcm, int timeout)
return 0;
}
/**
* \brief Return number of frames ready to be read/written
* \param pcm a PCM handle
* \return a positive number of frames ready otherwise a negative
* error code
*
* On capture does all the actions needed to transport to application
* level all the ready frames across underlying layers.
*/
snd_pcm_sframes_t snd_pcm_avail_update(snd_pcm_t *pcm)
{
return pcm->fast_ops->avail_update(pcm->fast_op_arg);
}
/**
* \brief Advance PCM frame position in mmap buffer
* \param pcm a PCM handle
* \param size movement size
* \return a positive number of actual movement size otherwise a negative
* error code
*
* On playback does all the actions needed to transport the frames across
* underlying layers.
*/
snd_pcm_sframes_t snd_pcm_mmap_forward(snd_pcm_t *pcm, snd_pcm_uframes_t size)
{
assert(size > 0);
@ -754,6 +1103,14 @@ snd_pcm_sframes_t snd_pcm_mmap_forward(snd_pcm_t *pcm, snd_pcm_uframes_t size)
return pcm->fast_ops->mmap_forward(pcm->fast_op_arg, size);
}
/**
* \brief Silence an area
* \param dst_area area specification
* \param dst_offset offset in frames inside area
* \param samples samples to silence
* \param format PCM sample format
* \return zero on success otherwise a negative error code
*/
int snd_pcm_area_silence(const snd_pcm_channel_area_t *dst_area, snd_pcm_uframes_t dst_offset,
unsigned int samples, snd_pcm_format_t format)
{
@ -836,6 +1193,15 @@ int snd_pcm_area_silence(const snd_pcm_channel_area_t *dst_area, snd_pcm_uframes
return 0;
}
/**
* \brief Silence one or more areas
* \param dst_areas areas specification (one for each channel)
* \param dst_offset offset in frames inside area
* \param channels channels count
* \param frames frames to silence
* \param format PCM sample format
* \return zero on success otherwise a negative error code
*/
int snd_pcm_areas_silence(const snd_pcm_channel_area_t *dst_areas, snd_pcm_uframes_t dst_offset,
unsigned int channels, snd_pcm_uframes_t frames, snd_pcm_format_t format)
{
@ -877,6 +1243,16 @@ int snd_pcm_areas_silence(const snd_pcm_channel_area_t *dst_areas, snd_pcm_ufram
}
/**
* \brief Copy an area
* \param dst_area destination area specification
* \param dst_offset offset in frames inside destination area
* \param src_area source area specification
* \param src_offset offset in frames inside source area
* \param samples samples to copy
* \param format PCM sample format
* \return zero on success otherwise a negative error code
*/
int snd_pcm_area_copy(const snd_pcm_channel_area_t *dst_area, snd_pcm_uframes_t dst_offset,
const snd_pcm_channel_area_t *src_area, snd_pcm_uframes_t src_offset,
unsigned int samples, snd_pcm_format_t format)
@ -973,6 +1349,17 @@ int snd_pcm_area_copy(const snd_pcm_channel_area_t *dst_area, snd_pcm_uframes_t
return 0;
}
/**
* \brief Copy one or more areas
* \param dst_areas destination areas specification (one for each channel)
* \param dst_offset offset in frames inside destination area
* \param src_areas source areas specification (one for each channel)
* \param src_offset offset in frames inside source area
* \param channels channels count
* \param frames frames to copy
* \param format PCM sample format
* \return zero on success otherwise a negative error code
*/
int snd_pcm_areas_copy(const snd_pcm_channel_area_t *dst_areas, snd_pcm_uframes_t dst_offset,
const snd_pcm_channel_area_t *src_areas, snd_pcm_uframes_t src_offset,
unsigned int channels, snd_pcm_uframes_t frames, snd_pcm_format_t format)
@ -1024,6 +1411,38 @@ int snd_pcm_areas_copy(const snd_pcm_channel_area_t *dst_areas, snd_pcm_uframes_
return 0;
}
#ifndef DOC_HIDDEN
int _snd_pcm_poll_descriptor(snd_pcm_t *pcm)
{
assert(pcm);
return pcm->poll_fd;
}
void snd_pcm_areas_from_buf(snd_pcm_t *pcm, snd_pcm_channel_area_t *areas,
void *buf)
{
unsigned int channel;
unsigned int channels = pcm->channels;
for (channel = 0; channel < channels; ++channel, ++areas) {
areas->addr = buf;
areas->first = channel * pcm->sample_bits;
areas->step = pcm->frame_bits;
}
}
void snd_pcm_areas_from_bufs(snd_pcm_t *pcm, snd_pcm_channel_area_t *areas,
void **bufs)
{
unsigned int channel;
unsigned int channels = pcm->channels;
for (channel = 0; channel < channels; ++channel, ++areas, ++bufs) {
areas->addr = *bufs;
areas->first = 0;
areas->step = pcm->sample_bits;
}
}
snd_pcm_sframes_t snd_pcm_read_areas(snd_pcm_t *pcm, const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset, snd_pcm_uframes_t size,
snd_pcm_xfer_areas_func_t func)
@ -1307,3 +1726,4 @@ int snd_pcm_slave_conf(snd_config_t *conf, const char **namep,
return 0;
}
#endif

4
src/pcm/pcm_hw.c
View file

@ -362,7 +362,7 @@ static int snd_pcm_hw_mmap_status(snd_pcm_t *pcm)
snd_pcm_hw_t *hw = pcm->private_data;
void *ptr;
ptr = mmap(NULL, page_align(sizeof(struct sndrv_pcm_mmap_status)), PROT_READ, MAP_FILE|MAP_SHARED,
hw->fd, SND_PCM_MMAP_OFFSET_STATUS);
hw->fd, SNDRV_PCM_MMAP_OFFSET_STATUS);
if (ptr == MAP_FAILED || ptr == NULL) {
SYSERR("status mmap failed");
return -errno;
@ -377,7 +377,7 @@ static int snd_pcm_hw_mmap_control(snd_pcm_t *pcm)
snd_pcm_hw_t *hw = pcm->private_data;
void *ptr;
ptr = mmap(NULL, page_align(sizeof(struct sndrv_pcm_mmap_control)), PROT_READ|PROT_WRITE, MAP_FILE|MAP_SHARED,
hw->fd, SND_PCM_MMAP_OFFSET_CONTROL);
hw->fd, SNDRV_PCM_MMAP_OFFSET_CONTROL);
if (ptr == MAP_FAILED || ptr == NULL) {
SYSERR("control mmap failed");
return -errno;

4
src/pcm/pcm_local.h
View file

@ -181,6 +181,9 @@ typedef int snd_pcm_route_ttable_entry_t;
#define FULL ROUTE_PLUGIN_RESOLUTION
#endif
/* FIXME */
#define _snd_pcm_link_descriptor _snd_pcm_poll_descriptor
int snd_pcm_hw_open(snd_pcm_t **pcm, const char *name, int card, int device, int subdevice, snd_pcm_stream_t stream, int mode);
int snd_pcm_plug_open(snd_pcm_t **pcmp,
const char *name,
@ -478,7 +481,6 @@ unsigned int snd_pcm_hw_param_get_min(const snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var, int *dir);
unsigned int snd_pcm_hw_param_get_max(const snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var, int *dir);
const char *snd_pcm_hw_param_name(snd_pcm_hw_param_t var);
int snd_pcm_hw_strategy_simple_near(snd_pcm_hw_strategy_t *strategy, int order,
snd_pcm_hw_param_t var,
unsigned int best,

4
src/pcm/pcm_misc.c
View file

@ -236,6 +236,7 @@ ssize_t snd_pcm_format_size(snd_pcm_format_t format, size_t samples)
return -EINVAL;
return samples / 2;
default:
assert(0);
return -EINVAL;
}
}
@ -344,6 +345,9 @@ u_int64_t snd_pcm_format_silence_64(snd_pcm_format_t format)
case SNDRV_PCM_FORMAT_GSM:
case SNDRV_PCM_FORMAT_SPECIAL:
return 0;
default:
assert(0);
return -EINVAL;
}
return 0;
}

70
src/pcm/pcm_params.c
View file

@ -1151,6 +1151,32 @@ void snd_pcm_hw_param_dump(const snd_pcm_hw_params_t *params,
assert(0);
}
#define HW_PARAM(v) [SND_PCM_HW_PARAM_##v] = #v
const char *snd_pcm_hw_param_names[] = {
HW_PARAM(ACCESS),
HW_PARAM(FORMAT),
HW_PARAM(SUBFORMAT),
HW_PARAM(SAMPLE_BITS),
HW_PARAM(FRAME_BITS),
HW_PARAM(CHANNELS),
HW_PARAM(RATE),
HW_PARAM(PERIOD_TIME),
HW_PARAM(PERIOD_SIZE),
HW_PARAM(PERIOD_BYTES),
HW_PARAM(PERIODS),
HW_PARAM(BUFFER_TIME),
HW_PARAM(BUFFER_SIZE),
HW_PARAM(BUFFER_BYTES),
HW_PARAM(TICK_TIME),
};
static const char *snd_pcm_hw_param_name(snd_pcm_hw_param_t param)
{
assert(param <= SND_PCM_HW_PARAM_LAST);
return snd_pcm_hw_param_names[snd_enum_to_int(param)];
}
int snd_pcm_hw_params_dump(snd_pcm_hw_params_t *params, snd_output_t *out)
{
unsigned int k;
@ -2152,47 +2178,3 @@ int _snd_pcm_hw_params(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
return err;
}
int snd_pcm_hw_params(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
{
int err;
assert(pcm && params);
err = _snd_pcm_hw_params(pcm, params);
if (err >= 0)
err = snd_pcm_prepare(pcm);
return err;
}
int snd_pcm_hw_free(snd_pcm_t *pcm)
{
int err;
assert(pcm->setup);
assert(snd_pcm_state(pcm) <= SND_PCM_STATE_PREPARED);
if (pcm->mmap_channels) {
err = snd_pcm_munmap(pcm);
if (err < 0)
return err;
}
err = pcm->ops->hw_free(pcm->op_arg);
pcm->setup = 0;
return err;
}
int snd_pcm_sw_params(snd_pcm_t *pcm, snd_pcm_sw_params_t *params)
{
int err;
err = pcm->ops->sw_params(pcm->op_arg, params);
if (err < 0)
return err;
pcm->start_mode = snd_pcm_sw_params_get_start_mode(params);
pcm->xrun_mode = snd_pcm_sw_params_get_xrun_mode(params);
pcm->tstamp_mode = snd_pcm_sw_params_get_tstamp_mode(params);
pcm->period_step = params->period_step;
pcm->sleep_min = params->sleep_min;
pcm->avail_min = params->avail_min;
pcm->xfer_align = params->xfer_align;
pcm->silence_threshold = params->silence_threshold;
pcm->silence_size = params->silence_size;
pcm->boundary = params->boundary;
return 0;
}

243
src/rawmidi/rawmidi.c
View file

@ -11,7 +11,7 @@
*
* RawMidi devices are opened exclusively for a selected direction.
* While more than one process may not open a given MIDI device in the same
* direction simultaneously, seperate processes may open a single MIDI device
* direction simultaneously, separate processes may open a single MIDI device
* in different directions (i.e. process one opens a MIDI device in write
* direction and process two opens the same device in read direction). MIDI
* devices return EBUSY error to applications when other applications have
@ -44,11 +44,27 @@
#include <dlfcn.h>
#include "rawmidi_local.h"
/**
* \brief setup the default parameters
* \param rawmidi RawMidi handle
* \param params pointer to a snd_rawmidi_params_t structure
* \return zero on success otherwise a negative error code
*/
static int snd_rawmidi_params_default(snd_rawmidi_t *rawmidi, snd_rawmidi_params_t *params)
{
assert(rawmidi);
assert(params);
params->buffer_size = page_size();
params->avail_min = 1;
params->no_active_sensing = 0;
return 0;
}
/**
* \brief Opens a new connection to the RawMidi interface.
* \param inputp Returned input handle
* \param outputp Returned output handle
* \param name ASCII identifier of the RawMidi stream
* \param inputp Returned input handle (NULL if not wanted)
* \param outputp Returned output handle (NULL if not wanted)
* \param name ASCII identifier of the RawMidi handle
* \param mode Open mode
* \return a negative error code on failure or zero on success
*
@ -161,31 +177,31 @@ int snd_rawmidi_open(snd_rawmidi_t **inputp, snd_rawmidi_t **outputp,
}
/**
* \brief close rawmidi handle
* \param rmidi rawmidi handle
* \return zero if success otherwise a negative error code
* \brief close RawMidi handle
* \param rawmidi RawMidi handle
* \return zero on success otherwise a negative error code
*
* Closes the specified rawmidi handle and frees all associated
* Closes the specified RawMidi handle and frees all associated
* resources.
*/
int snd_rawmidi_close(snd_rawmidi_t *rmidi)
int snd_rawmidi_close(snd_rawmidi_t *rawmidi)
{
int err;
assert(rmidi);
if ((err = rmidi->ops->close(rmidi)) < 0)
assert(rawmidi);
if ((err = rawmidi->ops->close(rawmidi)) < 0)
return err;
if (rmidi->name)
free(rmidi->name);
free(rmidi);
if (rawmidi->name)
free(rawmidi->name);
free(rawmidi);
return 0;
}
/**
* \brief get identifier of rawmidi handle
* \param rawmidi a rawmidi handle
* \return ascii identifier of rawmidi handle
* \brief get identifier of RawMidi handle
* \param rawmidi a RawMidi handle
* \return ascii identifier of RawMidi handle
*
* Returns the ASCII identifier of given rawmidi handle. It's the same
* Returns the ASCII identifier of given RawMidi handle. It's the same
* identifier as for snd_rawmidi_open().
*/
const char *snd_rawmidi_name(snd_rawmidi_t *rawmidi)
@ -195,11 +211,11 @@ const char *snd_rawmidi_name(snd_rawmidi_t *rawmidi)
}
/**
* \brief get type of rawmidi handle
* \param rawmidi a rawmidi handle
* \return type of rawmidi handle
* \brief get type of RawMidi handle
* \param rawmidi a RawMidi handle
* \return type of RawMidi handle
*
* Returns the type #snd_rawmidi_type_t of given rawmidi handle.
* Returns the type #snd_rawmidi_type_t of given RawMidi handle.
*/
snd_rawmidi_type_t snd_rawmidi_type(snd_rawmidi_t *rawmidi)
{
@ -208,29 +224,42 @@ snd_rawmidi_type_t snd_rawmidi_type(snd_rawmidi_t *rawmidi)
}
/**
* \brief get count of poll descriptors for rawmidi handle
* \param rmidi rawmidi handle
* \brief get stream (direction) of RawMidi handle
* \param rawmidi a RawMidi handle
* \return stream of RawMidi handle
*
* Returns the stream #snd_rawmidi_stream_t of given RawMidi handle.
*/
snd_rawmidi_stream_t snd_rawmidi_stream(snd_rawmidi_t *rawmidi)
{
assert(rawmidi);
return rawmidi->stream;
}
/**
* \brief get count of poll descriptors for RawMidi handle
* \param rawmidi RawMidi handle
* \return count of poll descriptors
*/
int snd_rawmidi_poll_descriptors_count(snd_rawmidi_t *rmidi)
int snd_rawmidi_poll_descriptors_count(snd_rawmidi_t *rawmidi)
{
assert(rmidi);
assert(rawmidi);
return 1;
}
/**
* \brief get poll descriptors
* \param rmidi rawmidi handle
* \param rawmidi RawMidi handle
* \param pfds array of poll descriptors
* \param space space in the poll descriptor array
* \return count of filled descriptors
*/
int snd_rawmidi_poll_descriptors(snd_rawmidi_t *rmidi, struct pollfd *pfds, unsigned int space)
int snd_rawmidi_poll_descriptors(snd_rawmidi_t *rawmidi, struct pollfd *pfds, unsigned int space)
{
assert(rmidi);
assert(rawmidi);
if (space >= 1) {
pfds->fd = rmidi->poll_fd;
pfds->events = rmidi->stream == SND_RAWMIDI_STREAM_OUTPUT ? POLLOUT : POLLIN;
pfds->fd = rawmidi->poll_fd;
pfds->events = rawmidi->stream == SND_RAWMIDI_STREAM_OUTPUT ? POLLOUT : POLLIN;
return 1;
}
return 0;
@ -238,21 +267,21 @@ int snd_rawmidi_poll_descriptors(snd_rawmidi_t *rmidi, struct pollfd *pfds, unsi
/**
* \brief set nonblock mode
* \param rmidi rawmidi handle
* \param rawmidi RawMidi handle
* \param nonblock 0 = block, 1 = nonblock mode
* \return zero if success otherwise a negative error code
* \return zero on success otherwise a negative error code
*/
int snd_rawmidi_nonblock(snd_rawmidi_t *rmidi, int nonblock)
int snd_rawmidi_nonblock(snd_rawmidi_t *rawmidi, int nonblock)
{
int err;
assert(rmidi);
assert(!(rmidi->mode & SND_RAWMIDI_APPEND));
if ((err = rmidi->ops->nonblock(rmidi, nonblock)) < 0)
assert(rawmidi);
assert(!(rawmidi->mode & SND_RAWMIDI_APPEND));
if ((err = rawmidi->ops->nonblock(rawmidi, nonblock)) < 0)
return err;
if (nonblock)
rmidi->mode |= SND_RAWMIDI_NONBLOCK;
rawmidi->mode |= SND_RAWMIDI_NONBLOCK;
else
rmidi->mode &= ~SND_RAWMIDI_NONBLOCK;
rawmidi->mode &= ~SND_RAWMIDI_NONBLOCK;
return 0;
}
@ -268,7 +297,7 @@ size_t snd_rawmidi_info_sizeof()
/**
* \brief allocate a new snd_rawmidi_info_t structure
* \param ptr returned pointer
* \return zero if success or a negative error code if fails
* \return zero on success or a negative error code if fails
*
* Allocates a new snd_rawmidi_params_t structure using the standard
* malloc C library function.
@ -450,16 +479,16 @@ void snd_rawmidi_info_set_stream(snd_rawmidi_info_t *info, snd_rawmidi_stream_t
}
/**
* \brief get information about rawmidi handle
* \param rmidi rawmidi handle
* \brief get information about RawMidi handle
* \param rawmidi RawMidi handle
* \param info pointer to a snd_rawmidi_info_t structure to be filled
* \return zero if success otherwise a negative error code
* \return zero on success otherwise a negative error code
*/
int snd_rawmidi_info(snd_rawmidi_t *rmidi, snd_rawmidi_info_t * info)
int snd_rawmidi_info(snd_rawmidi_t *rawmidi, snd_rawmidi_info_t * info)
{
assert(rmidi);
assert(rawmidi);
assert(info);
return rmidi->ops->info(rmidi, info);
return rawmidi->ops->info(rawmidi, info);
}
/**
@ -474,7 +503,7 @@ size_t snd_rawmidi_params_sizeof()
/**
* \brief allocate the snd_rawmidi_params_t structure
* \param ptr returned pointer
* \return zero if success or a negative error code if fails
* \return zero on success or a negative error code if fails
*
* Allocates a new snd_rawmidi_params_t structure using the standard
* malloc C library function.
@ -512,32 +541,16 @@ void snd_rawmidi_params_copy(snd_rawmidi_params_t *dst, const snd_rawmidi_params
*dst = *src;
}
/**
* \brief setup the default parameters
* \param rmidi rawmidi handle
* \param params pointer to a snd_rawmidi_params_t structure
* \return zero if success otherwise a negative error code
*/
int snd_rawmidi_params_default(snd_rawmidi_t *rmidi, snd_rawmidi_params_t *params)
{
assert(rmidi);
assert(params);
params->buffer_size = page_size();
params->avail_min = 1;
params->no_active_sensing = 0;
return 0;
}
/**
* \brief set rawmidi I/O ring buffer size
* \param rmidi rawmidi handle
* \param rawmidi RawMidi handle
* \param params pointer to a snd_rawmidi_params_t structure
* \param val size in bytes
* \return zero if success otherwise a negative error code
* \return zero on success otherwise a negative error code
*/
int snd_rawmidi_params_set_buffer_size(snd_rawmidi_t *rmidi ATTRIBUTE_UNUSED, snd_rawmidi_params_t *params, size_t val)
int snd_rawmidi_params_set_buffer_size(snd_rawmidi_t *rawmidi ATTRIBUTE_UNUSED, snd_rawmidi_params_t *params, size_t val)
{
assert(rmidi && params);
assert(rawmidi && params);
assert(val > params->avail_min);
params->buffer_size = val;
return 0;
@ -556,13 +569,13 @@ size_t snd_rawmidi_params_get_buffer_size(const snd_rawmidi_params_t *params)
/**
* \brief set minimum available bytes in rawmidi I/O ring buffer for wakeup
* \param rmidi rawmidi handle
* \param rawmidi RawMidi handle
* \param params pointer to a snd_rawmidi_params_t structure
* \param val desired value
*/
int snd_rawmidi_params_set_avail_min(snd_rawmidi_t *rmidi ATTRIBUTE_UNUSED, snd_rawmidi_params_t *params, size_t val)
int snd_rawmidi_params_set_avail_min(snd_rawmidi_t *rawmidi ATTRIBUTE_UNUSED, snd_rawmidi_params_t *params, size_t val)
{
assert(rmidi && params);
assert(rawmidi && params);
assert(val < params->buffer_size);
params->avail_min = val;
return 0;
@ -581,14 +594,14 @@ size_t snd_rawmidi_params_get_avail_min(const snd_rawmidi_params_t *params)
/**
* \brief set no-active-sensing action on snd_rawmidi_close()
* \param rmidi rawmidi handle
* \param rawmidi RawMidi handle
* \param params pointer to snd_rawmidi_params_t structure
* \param val value: 0 = enable to send the active sensing message, 1 = disable
* \return zero if success otherwise a negative error code
* \return zero on success otherwise a negative error code
*/
int snd_rawmidi_params_set_no_active_sensing(snd_rawmidi_t *rmidi ATTRIBUTE_UNUSED, snd_rawmidi_params_t *params, int val)
int snd_rawmidi_params_set_no_active_sensing(snd_rawmidi_t *rawmidi ATTRIBUTE_UNUSED, snd_rawmidi_params_t *params, int val)
{
assert(rmidi && params);
assert(rawmidi && params);
params->no_active_sensing = val;
return 0;
}
@ -606,37 +619,37 @@ int snd_rawmidi_params_get_no_active_sensing(const snd_rawmidi_params_t *params)
/**
* \brief get parameters about rawmidi stream
* \param rmidi rawmidi handle
* \param rawmidi RawMidi handle
* \param params pointer to a snd_rawmidi_params_t structure to be filled
* \return zero if success otherwise a negative error code
* \return zero on success otherwise a negative error code
*/
int snd_rawmidi_params(snd_rawmidi_t *rmidi, snd_rawmidi_params_t * params)
int snd_rawmidi_params(snd_rawmidi_t *rawmidi, snd_rawmidi_params_t * params)
{
int err;
assert(rmidi);
assert(rawmidi);
assert(params);
err = rmidi->ops->params(rmidi, params);
err = rawmidi->ops->params(rawmidi, params);
if (err < 0)
return err;
rmidi->buffer_size = params->buffer_size;
rmidi->avail_min = params->avail_min;
rmidi->no_active_sensing = params->no_active_sensing;
rawmidi->buffer_size = params->buffer_size;
rawmidi->avail_min = params->avail_min;
rawmidi->no_active_sensing = params->no_active_sensing;
return 0;
}
/**
* \brief get current parameters about rawmidi stream
* \param rmidi rawmidi handle
* \param rawmidi RawMidi handle
* \param params pointer to a snd_rawmidi_params_t structure to be filled
* \return zero if success otherwise a negative error code
* \return zero on success otherwise a negative error code
*/
int snd_rawmidi_params_current(snd_rawmidi_t *rmidi, snd_rawmidi_params_t *params)
int snd_rawmidi_params_current(snd_rawmidi_t *rawmidi, snd_rawmidi_params_t *params)
{
assert(rmidi);
assert(rawmidi);
assert(params);
params->buffer_size = rmidi->buffer_size;
params->avail_min = rmidi->avail_min;
params->no_active_sensing = rmidi->no_active_sensing;
params->buffer_size = rawmidi->buffer_size;
params->avail_min = rawmidi->avail_min;
params->no_active_sensing = rawmidi->no_active_sensing;
return 0;
}
@ -652,7 +665,7 @@ size_t snd_rawmidi_status_sizeof()
/**
* \brief allocate the snd_rawmidi_status_t structure
* \param ptr returned pointer
* \return zero if success or a negative error code if fails
* \return zero on success or a negative error code if fails
*
* Allocates a new snd_rawmidi_status_t structure using the standard
* malloc C library function.
@ -725,66 +738,66 @@ size_t snd_rawmidi_status_get_xruns(const snd_rawmidi_status_t *status)
/**
* \brief get status of rawmidi stream
* \param rmidi rawmidi handle
* \param rawmidi RawMidi handle
* \param status pointer to a snd_rawmidi_status_t structure to be filled
* \return zero if success otherwise a negative error code
* \return zero on success otherwise a negative error code
*/
int snd_rawmidi_status(snd_rawmidi_t *rmidi, snd_rawmidi_status_t * status)
int snd_rawmidi_status(snd_rawmidi_t *rawmidi, snd_rawmidi_status_t * status)
{
assert(rmidi);
assert(rawmidi);
assert(status);
return rmidi->ops->status(rmidi, status);
return rawmidi->ops->status(rawmidi, status);
}
/**
* \brief drop all bytes in the rawmidi I/O ring buffer immediately
* \param rmidi rawmidi handle
* \return zero if success otherwise a negative error code
* \param rawmidi RawMidi handle
* \return zero on success otherwise a negative error code
*/
int snd_rawmidi_drop(snd_rawmidi_t *rmidi)
int snd_rawmidi_drop(snd_rawmidi_t *rawmidi)
{
assert(rmidi);
return rmidi->ops->drop(rmidi);
assert(rawmidi);
return rawmidi->ops->drop(rawmidi);
}
/**
* \brief drain all bytes in the rawmidi I/O ring buffer
* \param rmidi rawmidi handle
* \return zero if success otherwise a negative error code
* \param rawmidi RawMidi handle
* \return zero on success otherwise a negative error code
*
* Waits until all MIDI bytes are not drained (sent) to the
* hardware device.
*/
int snd_rawmidi_drain(snd_rawmidi_t *rmidi)
int snd_rawmidi_drain(snd_rawmidi_t *rawmidi)
{
assert(rmidi);
return rmidi->ops->drain(rmidi);
assert(rawmidi);
return rawmidi->ops->drain(rawmidi);
}
/**
* \brief write MIDI bytes to MIDI stream
* \param rmidi rawmidi handle
* \param rawmidi RawMidi handle
* \param buffer buffer containing MIDI bytes
* \param size output buffer size in bytes
*/
ssize_t snd_rawmidi_write(snd_rawmidi_t *rmidi, const void *buffer, size_t size)
ssize_t snd_rawmidi_write(snd_rawmidi_t *rawmidi, const void *buffer, size_t size)
{
assert(rmidi);
assert(rmidi->stream == SND_RAWMIDI_STREAM_OUTPUT);
assert(rawmidi);
assert(rawmidi->stream == SND_RAWMIDI_STREAM_OUTPUT);
assert(buffer || size == 0);
return rmidi->ops->write(rmidi, buffer, size);
return rawmidi->ops->write(rawmidi, buffer, size);
}
/**
* \brief read MIDI bytes from MIDI stream
* \param rmidi rawmidi handle
* \param rawmidi RawMidi handle
* \param buffer buffer to store the input MIDI bytes
* \param size input buffer size in bytes
*/
ssize_t snd_rawmidi_read(snd_rawmidi_t *rmidi, void *buffer, size_t size)
ssize_t snd_rawmidi_read(snd_rawmidi_t *rawmidi, void *buffer, size_t size)
{
assert(rmidi);
assert(rmidi->stream == SND_RAWMIDI_STREAM_INPUT);
assert(rawmidi);
assert(rawmidi->stream == SND_RAWMIDI_STREAM_INPUT);
assert(buffer || size == 0);
return rmidi->ops->read(rmidi, buffer, size);
return rawmidi->ops->read(rawmidi, buffer, size);
}