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

First step toward encapsulation

Browse source
This commit is contained in:
Abramo Bagnara 2001-01-29 14:27:53 +00:00
parent d44c657826
commit 70809b1835
13 changed files with 997 additions and 391 deletions
Download patch file Download diff file Expand all files Collapse all files

36
src/control/control_hw.c
View file

@ -31,8 +31,8 @@
#include "asoundlib.h"
#include "control_local.h"
#define SND_FILE_CONTROL "/dev/snd/controlC%i"
#define SND_CTL_VERSION_MAX SND_PROTOCOL_VERSION(2, 0, 0)
#define SNDRV_FILE_CONTROL "/dev/snd/controlC%i"
#define SNDRV_CTL_VERSION_MAX SNDRV_PROTOCOL_VERSION(2, 0, 0)
typedef struct {
int card;
@ -63,7 +63,7 @@ static int snd_ctl_hw_poll_descriptor(snd_ctl_t *handle)
static int snd_ctl_hw_hw_info(snd_ctl_t *handle, snd_ctl_hw_info_t *info)
{
snd_ctl_hw_t *hw = handle->private;
if (ioctl(hw->fd, SND_CTL_IOCTL_HW_INFO, info) < 0)
if (ioctl(hw->fd, SNDRV_CTL_IOCTL_HW_INFO, info) < 0)
return -errno;
return 0;
}
@ -71,7 +71,7 @@ static int snd_ctl_hw_hw_info(snd_ctl_t *handle, snd_ctl_hw_info_t *info)
static int snd_ctl_hw_clist(snd_ctl_t *handle, snd_control_list_t *list)
{
snd_ctl_hw_t *hw = handle->private;
if (ioctl(hw->fd, SND_CTL_IOCTL_CONTROL_LIST, list) < 0)
if (ioctl(hw->fd, SNDRV_CTL_IOCTL_CONTROL_LIST, list) < 0)
return -errno;
return 0;
}
@ -79,7 +79,7 @@ static int snd_ctl_hw_clist(snd_ctl_t *handle, snd_control_list_t *list)
static int snd_ctl_hw_cinfo(snd_ctl_t *handle, snd_control_info_t *info)
{
snd_ctl_hw_t *hw = handle->private;
if (ioctl(hw->fd, SND_CTL_IOCTL_CONTROL_INFO, info) < 0)
if (ioctl(hw->fd, SNDRV_CTL_IOCTL_CONTROL_INFO, info) < 0)
return -errno;
return 0;
}
@ -87,7 +87,7 @@ static int snd_ctl_hw_cinfo(snd_ctl_t *handle, snd_control_info_t *info)
static int snd_ctl_hw_cread(snd_ctl_t *handle, snd_control_t *control)
{
snd_ctl_hw_t *hw = handle->private;
if (ioctl(hw->fd, SND_CTL_IOCTL_CONTROL_READ, control) < 0)
if (ioctl(hw->fd, SNDRV_CTL_IOCTL_CONTROL_READ, control) < 0)
return -errno;
return 0;
}
@ -95,7 +95,7 @@ static int snd_ctl_hw_cread(snd_ctl_t *handle, snd_control_t *control)
static int snd_ctl_hw_cwrite(snd_ctl_t *handle, snd_control_t *control)
{
snd_ctl_hw_t *hw = handle->private;
if (ioctl(hw->fd, SND_CTL_IOCTL_CONTROL_WRITE, control) < 0)
if (ioctl(hw->fd, SNDRV_CTL_IOCTL_CONTROL_WRITE, control) < 0)
return -errno;
return 0;
}
@ -103,7 +103,7 @@ static int snd_ctl_hw_cwrite(snd_ctl_t *handle, snd_control_t *control)
static int snd_ctl_hw_hwdep_next_device(snd_ctl_t *handle, int * device)
{
snd_ctl_hw_t *hw = handle->private;
if (ioctl(hw->fd, SND_CTL_IOCTL_HWDEP_NEXT_DEVICE, device) < 0)
if (ioctl(hw->fd, SNDRV_CTL_IOCTL_HWDEP_NEXT_DEVICE, device) < 0)
return -errno;
return 0;
}
@ -111,7 +111,7 @@ static int snd_ctl_hw_hwdep_next_device(snd_ctl_t *handle, int * device)
static int snd_ctl_hw_hwdep_info(snd_ctl_t *handle, snd_hwdep_info_t * info)
{
snd_ctl_hw_t *hw = handle->private;
if (ioctl(hw->fd, SND_CTL_IOCTL_HWDEP_INFO, info) < 0)
if (ioctl(hw->fd, SNDRV_CTL_IOCTL_HWDEP_INFO, info) < 0)
return -errno;
return 0;
}
@ -119,7 +119,7 @@ static int snd_ctl_hw_hwdep_info(snd_ctl_t *handle, snd_hwdep_info_t * info)
static int snd_ctl_hw_pcm_next_device(snd_ctl_t *handle, int * device)
{
snd_ctl_hw_t *hw = handle->private;
if (ioctl(hw->fd, SND_CTL_IOCTL_PCM_NEXT_DEVICE, device) < 0)
if (ioctl(hw->fd, SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE, device) < 0)
return -errno;
return 0;
}
@ -127,7 +127,7 @@ static int snd_ctl_hw_pcm_next_device(snd_ctl_t *handle, int * device)
static int snd_ctl_hw_pcm_info(snd_ctl_t *handle, snd_pcm_info_t * info)
{
snd_ctl_hw_t *hw = handle->private;
if (ioctl(hw->fd, SND_CTL_IOCTL_PCM_INFO, info) < 0)
if (ioctl(hw->fd, SNDRV_CTL_IOCTL_PCM_INFO, info) < 0)
return -errno;
return 0;
}
@ -135,7 +135,7 @@ static int snd_ctl_hw_pcm_info(snd_ctl_t *handle, snd_pcm_info_t * info)
static int snd_ctl_hw_pcm_prefer_subdevice(snd_ctl_t *handle, int subdev)
{
snd_ctl_hw_t *hw = handle->private;
if (ioctl(hw->fd, SND_CTL_IOCTL_PCM_PREFER_SUBDEVICE, &subdev) < 0)
if (ioctl(hw->fd, SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE, &subdev) < 0)
return -errno;
return 0;
}
@ -143,7 +143,7 @@ static int snd_ctl_hw_pcm_prefer_subdevice(snd_ctl_t *handle, int subdev)
static int snd_ctl_hw_rawmidi_next_device(snd_ctl_t *handle, int * device)
{
snd_ctl_hw_t *hw = handle->private;
if (ioctl(hw->fd, SND_CTL_IOCTL_RAWMIDI_NEXT_DEVICE, device) < 0)
if (ioctl(hw->fd, SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE, device) < 0)
return -errno;
return 0;
}
@ -151,7 +151,7 @@ static int snd_ctl_hw_rawmidi_next_device(snd_ctl_t *handle, int * device)
static int snd_ctl_hw_rawmidi_info(snd_ctl_t *handle, snd_rawmidi_info_t * info)
{
snd_ctl_hw_t *hw = handle->private;
if (ioctl(hw->fd, SND_CTL_IOCTL_RAWMIDI_INFO, info) < 0)
if (ioctl(hw->fd, SNDRV_CTL_IOCTL_RAWMIDI_INFO, info) < 0)
return -errno;
return 0;
}
@ -159,7 +159,7 @@ static int snd_ctl_hw_rawmidi_info(snd_ctl_t *handle, snd_rawmidi_info_t * info)
static int snd_ctl_hw_rawmidi_prefer_subdevice(snd_ctl_t *handle, int subdev)
{
snd_ctl_hw_t *hw = handle->private;
if (ioctl(hw->fd, SND_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE, &subdev) < 0)
if (ioctl(hw->fd, SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE, &subdev) < 0)
return -errno;
return 0;
}
@ -200,18 +200,18 @@ int snd_ctl_hw_open(snd_ctl_t **handle, char *name, int card)
*handle = NULL;
assert(card >= 0 && card < 32);
sprintf(filename, SND_FILE_CONTROL, card);
sprintf(filename, SNDRV_FILE_CONTROL, card);
if ((fd = open(filename, O_RDWR)) < 0) {
snd_card_load(card);
if ((fd = open(filename, O_RDWR)) < 0)
return -errno;
}
if (ioctl(fd, SND_CTL_IOCTL_PVERSION, &ver) < 0) {
if (ioctl(fd, SNDRV_CTL_IOCTL_PVERSION, &ver) < 0) {
close(fd);
return -errno;
}
if (SND_PROTOCOL_INCOMPATIBLE(ver, SND_CTL_VERSION_MAX)) {
if (SNDRV_PROTOCOL_INCOMPATIBLE(ver, SNDRV_CTL_VERSION_MAX)) {
close(fd);
return -SND_ERROR_INCOMPATIBLE_VERSION;
}

26
src/control/control_shm.c
View file

@ -121,7 +121,7 @@ static int snd_ctl_shm_hw_info(snd_ctl_t *ctl, snd_ctl_hw_info_t *info)
volatile snd_ctl_shm_ctrl_t *ctrl = shm->ctrl;
int err;
// ctrl->u.hw_info = *info;
ctrl->cmd = SND_CTL_IOCTL_HW_INFO;
ctrl->cmd = SNDRV_CTL_IOCTL_HW_INFO;
err = snd_ctl_shm_action(ctl);
if (err < 0)
return err;
@ -140,7 +140,7 @@ static int snd_ctl_shm_clist(snd_ctl_t *ctl, snd_control_list_t *list)
if (bytes > maxsize)
return -EINVAL;
ctrl->u.clist = *list;
ctrl->cmd = SND_CTL_IOCTL_CONTROL_LIST;
ctrl->cmd = SNDRV_CTL_IOCTL_CONTROL_LIST;
err = snd_ctl_shm_action(ctl);
if (err < 0)
return err;
@ -156,7 +156,7 @@ static int snd_ctl_shm_cinfo(snd_ctl_t *ctl, snd_control_info_t *info)
volatile snd_ctl_shm_ctrl_t *ctrl = shm->ctrl;
int err;
ctrl->u.cinfo = *info;
ctrl->cmd = SND_CTL_IOCTL_CONTROL_INFO;
ctrl->cmd = SNDRV_CTL_IOCTL_CONTROL_INFO;
err = snd_ctl_shm_action(ctl);
if (err < 0)
return err;
@ -170,7 +170,7 @@ static int snd_ctl_shm_cread(snd_ctl_t *ctl, snd_control_t *control)
volatile snd_ctl_shm_ctrl_t *ctrl = shm->ctrl;
int err;
ctrl->u.cread = *control;
ctrl->cmd = SND_CTL_IOCTL_CONTROL_READ;
ctrl->cmd = SNDRV_CTL_IOCTL_CONTROL_READ;
err = snd_ctl_shm_action(ctl);
if (err < 0)
return err;
@ -184,7 +184,7 @@ static int snd_ctl_shm_cwrite(snd_ctl_t *ctl, snd_control_t *control)
volatile snd_ctl_shm_ctrl_t *ctrl = shm->ctrl;
int err;
ctrl->u.cwrite = *control;
ctrl->cmd = SND_CTL_IOCTL_CONTROL_WRITE;
ctrl->cmd = SNDRV_CTL_IOCTL_CONTROL_WRITE;
err = snd_ctl_shm_action(ctl);
if (err < 0)
return err;
@ -198,7 +198,7 @@ static int snd_ctl_shm_hwdep_next_device(snd_ctl_t *ctl, int * device)
volatile snd_ctl_shm_ctrl_t *ctrl = shm->ctrl;
int err;
ctrl->u.device = *device;
ctrl->cmd = SND_CTL_IOCTL_HWDEP_NEXT_DEVICE;
ctrl->cmd = SNDRV_CTL_IOCTL_HWDEP_NEXT_DEVICE;
err = snd_ctl_shm_action(ctl);
if (err < 0)
return err;
@ -212,7 +212,7 @@ static int snd_ctl_shm_hwdep_info(snd_ctl_t *ctl, snd_hwdep_info_t * info)
volatile snd_ctl_shm_ctrl_t *ctrl = shm->ctrl;
int err;
ctrl->u.hwdep_info = *info;
ctrl->cmd = SND_CTL_IOCTL_HWDEP_INFO;
ctrl->cmd = SNDRV_CTL_IOCTL_HWDEP_INFO;
err = snd_ctl_shm_action(ctl);
if (err < 0)
return err;
@ -226,7 +226,7 @@ static int snd_ctl_shm_pcm_next_device(snd_ctl_t *ctl, int * device)
volatile snd_ctl_shm_ctrl_t *ctrl = shm->ctrl;
int err;
ctrl->u.device = *device;
ctrl->cmd = SND_CTL_IOCTL_PCM_NEXT_DEVICE;
ctrl->cmd = SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE;
err = snd_ctl_shm_action(ctl);
if (err < 0)
return err;
@ -240,7 +240,7 @@ static int snd_ctl_shm_pcm_info(snd_ctl_t *ctl, snd_pcm_info_t * info)
volatile snd_ctl_shm_ctrl_t *ctrl = shm->ctrl;
int err;
ctrl->u.pcm_info = *info;
ctrl->cmd = SND_CTL_IOCTL_PCM_INFO;
ctrl->cmd = SNDRV_CTL_IOCTL_PCM_INFO;
err = snd_ctl_shm_action(ctl);
if (err < 0)
return err;
@ -254,7 +254,7 @@ static int snd_ctl_shm_pcm_prefer_subdevice(snd_ctl_t *ctl, int subdev)
volatile snd_ctl_shm_ctrl_t *ctrl = shm->ctrl;
int err;
ctrl->u.pcm_prefer_subdevice = subdev;
ctrl->cmd = SND_CTL_IOCTL_PCM_PREFER_SUBDEVICE;
ctrl->cmd = SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE;
err = snd_ctl_shm_action(ctl);
if (err < 0)
return err;
@ -267,7 +267,7 @@ static int snd_ctl_shm_rawmidi_next_device(snd_ctl_t *ctl, int * device)
volatile snd_ctl_shm_ctrl_t *ctrl = shm->ctrl;
int err;
ctrl->u.device = *device;
ctrl->cmd = SND_CTL_IOCTL_RAWMIDI_NEXT_DEVICE;
ctrl->cmd = SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE;
err = snd_ctl_shm_action(ctl);
if (err < 0)
return err;
@ -281,7 +281,7 @@ static int snd_ctl_shm_rawmidi_info(snd_ctl_t *ctl, snd_rawmidi_info_t * info)
volatile snd_ctl_shm_ctrl_t *ctrl = shm->ctrl;
int err;
ctrl->u.rawmidi_info = *info;
ctrl->cmd = SND_CTL_IOCTL_RAWMIDI_INFO;
ctrl->cmd = SNDRV_CTL_IOCTL_RAWMIDI_INFO;
err = snd_ctl_shm_action(ctl);
if (err < 0)
return err;
@ -295,7 +295,7 @@ static int snd_ctl_shm_rawmidi_prefer_subdevice(snd_ctl_t *ctl, int subdev)
volatile snd_ctl_shm_ctrl_t *ctrl = shm->ctrl;
int err;
ctrl->u.rawmidi_prefer_subdevice = subdev;
ctrl->cmd = SND_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE;
ctrl->cmd = SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE;
err = snd_ctl_shm_action(ctl);
if (err < 0)
return err;

12
src/hwdep/hwdep.c
View file

@ -28,8 +28,8 @@
#include <sys/ioctl.h>
#include "asoundlib.h"
#define SND_FILE_HWDEP "/dev/snd/hwC%iD%i"
#define SND_HWDEP_VERSION_MAX SND_PROTOCOL_VERSION(1, 0, 0)
#define SNDRV_FILE_HWDEP "/dev/snd/hwC%iD%i"
#define SNDRV_HWDEP_VERSION_MAX SNDRV_PROTOCOL_VERSION(1, 0, 0)
struct _snd_hwdep {
int card;
@ -48,17 +48,17 @@ int snd_hwdep_open(snd_hwdep_t **handle, int card, int device, int mode)
if (card < 0 || card >= 32)
return -EINVAL;
sprintf(filename, SND_FILE_HWDEP, card, device);
sprintf(filename, SNDRV_FILE_HWDEP, card, device);
if ((fd = open(filename, mode)) < 0) {
snd_card_load(card);
if ((fd = open(filename, mode)) < 0)
return -errno;
}
if (ioctl(fd, SND_HWDEP_IOCTL_PVERSION, &ver) < 0) {
if (ioctl(fd, SNDRV_HWDEP_IOCTL_PVERSION, &ver) < 0) {
close(fd);
return -errno;
}
if (SND_PROTOCOL_INCOMPATIBLE(ver, SND_HWDEP_VERSION_MAX)) {
if (SNDRV_PROTOCOL_INCOMPATIBLE(ver, SNDRV_HWDEP_VERSION_MAX)) {
close(fd);
return -SND_ERROR_INCOMPATIBLE_VERSION;
}
@ -114,7 +114,7 @@ int snd_hwdep_info(snd_hwdep_t *hwdep, snd_hwdep_info_t * info)
{
if (!hwdep || !info)
return -EINVAL;
if (ioctl(hwdep->fd, SND_HWDEP_IOCTL_INFO, info) < 0)
if (ioctl(hwdep->fd, SNDRV_HWDEP_IOCTL_INFO, info) < 0)
return -errno;
return 0;
}

8
src/pcm/pcm.c
View file

@ -244,8 +244,8 @@ int snd_pcm_link(snd_pcm_t *pcm1, snd_pcm_t *pcm2)
int fd2 = snd_pcm_link_descriptor(pcm2);
if (fd1 < 0 || fd2 < 0)
return -ENOSYS;
if (ioctl(fd1, SND_PCM_IOCTL_LINK, fd2) < 0) {
SYSERR("SND_PCM_IOCTL_LINK failed");
if (ioctl(fd1, SNDRV_PCM_IOCTL_LINK, fd2) < 0) {
SYSERR("SNDRV_PCM_IOCTL_LINK failed");
return -errno;
}
return 0;
@ -262,8 +262,8 @@ int snd_pcm_unlink(snd_pcm_t *pcm)
default:
return -ENOSYS;
}
if (ioctl(fd, SND_PCM_IOCTL_UNLINK) < 0) {
SYSERR("SND_PCM_IOCTL_UNLINK failed");
if (ioctl(fd, SNDRV_PCM_IOCTL_UNLINK) < 0) {
SYSERR("SNDRV_PCM_IOCTL_UNLINK failed");
return -errno;
}
return 0;

88
src/pcm/pcm_hw.c
View file

@ -49,9 +49,9 @@ typedef struct {
int shmid;
} snd_pcm_hw_t;
#define SND_FILE_PCM_STREAM_PLAYBACK "/dev/snd/pcmC%iD%ip"
#define SND_FILE_PCM_STREAM_CAPTURE "/dev/snd/pcmC%iD%ic"
#define SND_PCM_VERSION_MAX SND_PROTOCOL_VERSION(2, 0, 0)
#define SNDRV_FILE_PCM_STREAM_PLAYBACK "/dev/snd/pcmC%iD%ip"
#define SNDRV_FILE_PCM_STREAM_CAPTURE "/dev/snd/pcmC%iD%ic"
#define SNDRV_PCM_VERSION_MAX SNDRV_PROTOCOL_VERSION(2, 0, 0)
static int snd_pcm_hw_nonblock(snd_pcm_t *pcm, int nonblock)
{
@ -119,8 +119,8 @@ static int snd_pcm_hw_info(snd_pcm_t *pcm, snd_pcm_info_t * info)
{
snd_pcm_hw_t *hw = pcm->private;
int fd = hw->fd;
if (ioctl(fd, SND_PCM_IOCTL_INFO, info) < 0) {
SYSERR("SND_PCM_IOCTL_INFO failed");
if (ioctl(fd, SNDRV_PCM_IOCTL_INFO, info) < 0) {
SYSERR("SNDRV_PCM_IOCTL_INFO failed");
return -errno;
}
return 0;
@ -130,8 +130,8 @@ static int snd_pcm_hw_hw_refine(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
{
snd_pcm_hw_t *hw = pcm->private;
int fd = hw->fd;
if (ioctl(fd, SND_PCM_IOCTL_HW_REFINE, params) < 0) {
// SYSERR("SND_PCM_IOCTL_HW_REFINE failed");
if (ioctl(fd, SNDRV_PCM_IOCTL_HW_REFINE, params) < 0) {
// SYSERR("SNDRV_PCM_IOCTL_HW_REFINE failed");
return -errno;
}
return 0;
@ -141,8 +141,8 @@ static int snd_pcm_hw_hw_params(snd_pcm_t *pcm, snd_pcm_hw_params_t * params)
{
snd_pcm_hw_t *hw = pcm->private;
int fd = hw->fd;
if (ioctl(fd, SND_PCM_IOCTL_HW_PARAMS, params) < 0) {
SYSERR("SND_PCM_IOCTL_HW_PARAMS failed");
if (ioctl(fd, SNDRV_PCM_IOCTL_HW_PARAMS, params) < 0) {
SYSERR("SNDRV_PCM_IOCTL_HW_PARAMS failed");
return -errno;
}
return 0;
@ -152,8 +152,8 @@ static int snd_pcm_hw_hw_free(snd_pcm_t *pcm)
{
snd_pcm_hw_t *hw = pcm->private;
int fd = hw->fd;
if (ioctl(fd, SND_PCM_IOCTL_HW_FREE) < 0) {
SYSERR("SND_PCM_IOCTL_HW_FREE failed");
if (ioctl(fd, SNDRV_PCM_IOCTL_HW_FREE) < 0) {
SYSERR("SNDRV_PCM_IOCTL_HW_FREE failed");
return -errno;
}
return 0;
@ -174,8 +174,8 @@ static int snd_pcm_hw_sw_params(snd_pcm_t *pcm, snd_pcm_sw_params_t * params)
hw->mmap_control->avail_min = params->avail_min;
return 0;
}
if (ioctl(fd, SND_PCM_IOCTL_SW_PARAMS, params) < 0) {
SYSERR("SND_PCM_IOCTL_SW_PARAMS failed");
if (ioctl(fd, SNDRV_PCM_IOCTL_SW_PARAMS, params) < 0) {
SYSERR("SNDRV_PCM_IOCTL_SW_PARAMS failed");
return -errno;
}
return 0;
@ -187,8 +187,8 @@ static int snd_pcm_hw_channel_info(snd_pcm_t *pcm, snd_pcm_channel_info_t * info
snd_pcm_hw_channel_info_t hw_info;
int fd = hw->fd;
hw_info.channel = info->channel;
if (ioctl(fd, SND_PCM_IOCTL_CHANNEL_INFO, &hw_info) < 0) {
SYSERR("SND_PCM_IOCTL_CHANNEL_INFO failed");
if (ioctl(fd, SNDRV_PCM_IOCTL_CHANNEL_INFO, &hw_info) < 0) {
SYSERR("SNDRV_PCM_IOCTL_CHANNEL_INFO failed");
return -errno;
}
info->channel = hw_info.channel;
@ -208,8 +208,8 @@ static int snd_pcm_hw_status(snd_pcm_t *pcm, snd_pcm_status_t * status)
{
snd_pcm_hw_t *hw = pcm->private;
int fd = hw->fd;
if (ioctl(fd, SND_PCM_IOCTL_STATUS, status) < 0) {
SYSERR("SND_PCM_IOCTL_STATUS failed");
if (ioctl(fd, SNDRV_PCM_IOCTL_STATUS, status) < 0) {
SYSERR("SNDRV_PCM_IOCTL_STATUS failed");
return -errno;
}
return 0;
@ -225,8 +225,8 @@ static int snd_pcm_hw_delay(snd_pcm_t *pcm, snd_pcm_sframes_t *delayp)
{
snd_pcm_hw_t *hw = pcm->private;
int fd = hw->fd;
if (ioctl(fd, SND_PCM_IOCTL_DELAY, delayp) < 0) {
SYSERR("SND_PCM_IOCTL_DELAY failed");
if (ioctl(fd, SNDRV_PCM_IOCTL_DELAY, delayp) < 0) {
SYSERR("SNDRV_PCM_IOCTL_DELAY failed");
return -errno;
}
return 0;
@ -236,8 +236,8 @@ static int snd_pcm_hw_prepare(snd_pcm_t *pcm)
{
snd_pcm_hw_t *hw = pcm->private;
int fd = hw->fd;
if (ioctl(fd, SND_PCM_IOCTL_PREPARE) < 0) {
SYSERR("SND_PCM_IOCTL_PREPARE failed");
if (ioctl(fd, SNDRV_PCM_IOCTL_PREPARE) < 0) {
SYSERR("SNDRV_PCM_IOCTL_PREPARE failed");
return -errno;
}
return 0;
@ -247,8 +247,8 @@ static int snd_pcm_hw_reset(snd_pcm_t *pcm)
{
snd_pcm_hw_t *hw = pcm->private;
int fd = hw->fd;
if (ioctl(fd, SND_PCM_IOCTL_RESET) < 0) {
SYSERR("SND_PCM_IOCTL_RESET failed");
if (ioctl(fd, SNDRV_PCM_IOCTL_RESET) < 0) {
SYSERR("SNDRV_PCM_IOCTL_RESET failed");
return -errno;
}
return 0;
@ -262,8 +262,8 @@ static int snd_pcm_hw_start(snd_pcm_t *pcm)
assert(pcm->stream != SND_PCM_STREAM_PLAYBACK ||
snd_pcm_mmap_playback_hw_avail(pcm) > 0);
#endif
if (ioctl(fd, SND_PCM_IOCTL_START) < 0) {
SYSERR("SND_PCM_IOCTL_START failed");
if (ioctl(fd, SNDRV_PCM_IOCTL_START) < 0) {
SYSERR("SNDRV_PCM_IOCTL_START failed");
return -errno;
}
return 0;
@ -273,8 +273,8 @@ static int snd_pcm_hw_drop(snd_pcm_t *pcm)
{
snd_pcm_hw_t *hw = pcm->private;
int fd = hw->fd;
if (ioctl(fd, SND_PCM_IOCTL_DROP) < 0) {
SYSERR("SND_PCM_IOCTL_DROP failed");
if (ioctl(fd, SNDRV_PCM_IOCTL_DROP) < 0) {
SYSERR("SNDRV_PCM_IOCTL_DROP failed");
return -errno;
}
return 0;
@ -284,8 +284,8 @@ static int snd_pcm_hw_drain(snd_pcm_t *pcm)
{
snd_pcm_hw_t *hw = pcm->private;
int fd = hw->fd;
if (ioctl(fd, SND_PCM_IOCTL_DRAIN) < 0) {
SYSERR("SND_PCM_IOCTL_DRAIN failed");
if (ioctl(fd, SNDRV_PCM_IOCTL_DRAIN) < 0) {
SYSERR("SNDRV_PCM_IOCTL_DRAIN failed");
return -errno;
}
return 0;
@ -295,8 +295,8 @@ static int snd_pcm_hw_pause(snd_pcm_t *pcm, int enable)
{
snd_pcm_hw_t *hw = pcm->private;
int fd = hw->fd;
if (ioctl(fd, SND_PCM_IOCTL_PAUSE, enable) < 0) {
SYSERR("SND_PCM_IOCTL_PAUSE failed");
if (ioctl(fd, SNDRV_PCM_IOCTL_PAUSE, enable) < 0) {
SYSERR("SNDRV_PCM_IOCTL_PAUSE failed");
return -errno;
}
return 0;
@ -306,8 +306,8 @@ static snd_pcm_sframes_t snd_pcm_hw_rewind(snd_pcm_t *pcm, snd_pcm_uframes_t fra
{
snd_pcm_hw_t *hw = pcm->private;
int fd = hw->fd;
if (ioctl(fd, SND_PCM_IOCTL_REWIND, &frames) < 0) {
SYSERR("SND_PCM_IOCTL_REWIND failed");
if (ioctl(fd, SNDRV_PCM_IOCTL_REWIND, &frames) < 0) {
SYSERR("SNDRV_PCM_IOCTL_REWIND failed");
return -errno;
}
return 0;
@ -321,7 +321,7 @@ static snd_pcm_sframes_t snd_pcm_hw_writei(snd_pcm_t *pcm, const void *buffer, s
snd_xferi_t xferi;
xferi.buf = (char*) buffer;
xferi.frames = size;
result = ioctl(fd, SND_PCM_IOCTL_WRITEI_FRAMES, &xferi);
result = ioctl(fd, SNDRV_PCM_IOCTL_WRITEI_FRAMES, &xferi);
if (result < 0)
return -errno;
return xferi.result;
@ -335,7 +335,7 @@ static snd_pcm_sframes_t snd_pcm_hw_writen(snd_pcm_t *pcm, void **bufs, snd_pcm_
snd_xfern_t xfern;
xfern.bufs = bufs;
xfern.frames = size;
result = ioctl(fd, SND_PCM_IOCTL_WRITEN_FRAMES, &xfern);
result = ioctl(fd, SNDRV_PCM_IOCTL_WRITEN_FRAMES, &xfern);
if (result < 0)
return -errno;
return xfern.result;
@ -349,7 +349,7 @@ static snd_pcm_sframes_t snd_pcm_hw_readi(snd_pcm_t *pcm, void *buffer, snd_pcm_
snd_xferi_t xferi;
xferi.buf = buffer;
xferi.frames = size;
result = ioctl(fd, SND_PCM_IOCTL_READI_FRAMES, &xferi);
result = ioctl(fd, SNDRV_PCM_IOCTL_READI_FRAMES, &xferi);
if (result < 0)
return -errno;
return xferi.result;
@ -363,7 +363,7 @@ snd_pcm_sframes_t snd_pcm_hw_readn(snd_pcm_t *pcm, void **bufs, snd_pcm_uframes_
snd_xfern_t xfern;
xfern.bufs = bufs;
xfern.frames = size;
result = ioctl(fd, SND_PCM_IOCTL_READN_FRAMES, &xfern);
result = ioctl(fd, SNDRV_PCM_IOCTL_READN_FRAMES, &xfern);
if (result < 0)
return -errno;
return xfern.result;
@ -568,10 +568,10 @@ int snd_pcm_hw_open_subdevice(snd_pcm_t **pcmp, int card, int device, int subdev
switch (stream) {
case SND_PCM_STREAM_PLAYBACK:
filefmt = SND_FILE_PCM_STREAM_PLAYBACK;
filefmt = SNDRV_FILE_PCM_STREAM_PLAYBACK;
break;
case SND_PCM_STREAM_CAPTURE:
filefmt = SND_FILE_PCM_STREAM_CAPTURE;
filefmt = SNDRV_FILE_PCM_STREAM_CAPTURE;
break;
default:
assert(0);
@ -596,19 +596,19 @@ int snd_pcm_hw_open_subdevice(snd_pcm_t **pcmp, int card, int device, int subdev
ret = -errno;
goto _err;
}
if (ioctl(fd, SND_PCM_IOCTL_PVERSION, &ver) < 0) {
SYSERR("SND_PCM_IOCTL_PVERSION failed");
if (ioctl(fd, SNDRV_PCM_IOCTL_PVERSION, &ver) < 0) {
SYSERR("SNDRV_PCM_IOCTL_PVERSION failed");
ret = -errno;
goto _err;
}
if (SND_PROTOCOL_INCOMPATIBLE(ver, SND_PCM_VERSION_MAX)) {
if (SNDRV_PROTOCOL_INCOMPATIBLE(ver, SNDRV_PCM_VERSION_MAX)) {
ret = -SND_ERROR_INCOMPATIBLE_VERSION;
goto _err;
}
if (subdevice >= 0) {
memset(&info, 0, sizeof(info));
if (ioctl(fd, SND_PCM_IOCTL_INFO, &info) < 0) {
SYSERR("SND_PCM_IOCTL_INFO failed");
if (ioctl(fd, SNDRV_PCM_IOCTL_INFO, &info) < 0) {
SYSERR("SNDRV_PCM_IOCTL_INFO failed");
ret = -errno;
goto _err;
}

308
src/pcm/pcm_misc.c
View file

@ -39,21 +39,21 @@
int snd_pcm_format_signed(int format)
{
switch (format) {
case SND_PCM_FORMAT_S8:
case SND_PCM_FORMAT_S16_LE:
case SND_PCM_FORMAT_S16_BE:
case SND_PCM_FORMAT_S24_LE:
case SND_PCM_FORMAT_S24_BE:
case SND_PCM_FORMAT_S32_LE:
case SND_PCM_FORMAT_S32_BE:
case SNDRV_PCM_FORMAT_S8:
case SNDRV_PCM_FORMAT_S16_LE:
case SNDRV_PCM_FORMAT_S16_BE:
case SNDRV_PCM_FORMAT_S24_LE:
case SNDRV_PCM_FORMAT_S24_BE:
case SNDRV_PCM_FORMAT_S32_LE:
case SNDRV_PCM_FORMAT_S32_BE:
return 1;
case SND_PCM_FORMAT_U8:
case SND_PCM_FORMAT_U16_LE:
case SND_PCM_FORMAT_U16_BE:
case SND_PCM_FORMAT_U24_LE:
case SND_PCM_FORMAT_U24_BE:
case SND_PCM_FORMAT_U32_LE:
case SND_PCM_FORMAT_U32_BE:
case SNDRV_PCM_FORMAT_U8:
case SNDRV_PCM_FORMAT_U16_LE:
case SNDRV_PCM_FORMAT_U16_BE:
case SNDRV_PCM_FORMAT_U24_LE:
case SNDRV_PCM_FORMAT_U24_BE:
case SNDRV_PCM_FORMAT_U32_LE:
case SNDRV_PCM_FORMAT_U32_BE:
return 0;
default:
return -EINVAL;
@ -78,25 +78,25 @@ int snd_pcm_format_linear(int format)
int snd_pcm_format_little_endian(int format)
{
switch (format) {
case SND_PCM_FORMAT_S16_LE:
case SND_PCM_FORMAT_U16_LE:
case SND_PCM_FORMAT_S24_LE:
case SND_PCM_FORMAT_U24_LE:
case SND_PCM_FORMAT_S32_LE:
case SND_PCM_FORMAT_U32_LE:
case SND_PCM_FORMAT_FLOAT_LE:
case SND_PCM_FORMAT_FLOAT64_LE:
case SND_PCM_FORMAT_IEC958_SUBFRAME_LE:
case SNDRV_PCM_FORMAT_S16_LE:
case SNDRV_PCM_FORMAT_U16_LE:
case SNDRV_PCM_FORMAT_S24_LE:
case SNDRV_PCM_FORMAT_U24_LE:
case SNDRV_PCM_FORMAT_S32_LE:
case SNDRV_PCM_FORMAT_U32_LE:
case SNDRV_PCM_FORMAT_FLOAT_LE:
case SNDRV_PCM_FORMAT_FLOAT64_LE:
case SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE:
return 1;
case SND_PCM_FORMAT_S16_BE:
case SND_PCM_FORMAT_U16_BE:
case SND_PCM_FORMAT_S24_BE:
case SND_PCM_FORMAT_U24_BE:
case SND_PCM_FORMAT_S32_BE:
case SND_PCM_FORMAT_U32_BE:
case SND_PCM_FORMAT_FLOAT_BE:
case SND_PCM_FORMAT_FLOAT64_BE:
case SND_PCM_FORMAT_IEC958_SUBFRAME_BE:
case SNDRV_PCM_FORMAT_S16_BE:
case SNDRV_PCM_FORMAT_U16_BE:
case SNDRV_PCM_FORMAT_S24_BE:
case SNDRV_PCM_FORMAT_U24_BE:
case SNDRV_PCM_FORMAT_S32_BE:
case SNDRV_PCM_FORMAT_U32_BE:
case SNDRV_PCM_FORMAT_FLOAT_BE:
case SNDRV_PCM_FORMAT_FLOAT64_BE:
case SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE:
return 0;
default:
return -EINVAL;
@ -115,7 +115,7 @@ int snd_pcm_format_big_endian(int format)
int snd_pcm_format_cpu_endian(int format)
{
#ifdef SND_LITTLE_ENDIAN
#ifdef SNDRV_LITTLE_ENDIAN
return snd_pcm_format_little_endian(format);
#else
return snd_pcm_format_big_endian(format);
@ -125,36 +125,36 @@ int snd_pcm_format_cpu_endian(int format)
int snd_pcm_format_width(int format)
{
switch (format) {
case SND_PCM_FORMAT_S8:
case SND_PCM_FORMAT_U8:
case SNDRV_PCM_FORMAT_S8:
case SNDRV_PCM_FORMAT_U8:
return 8;
case SND_PCM_FORMAT_S16_LE:
case SND_PCM_FORMAT_S16_BE:
case SND_PCM_FORMAT_U16_LE:
case SND_PCM_FORMAT_U16_BE:
case SNDRV_PCM_FORMAT_S16_LE:
case SNDRV_PCM_FORMAT_S16_BE:
case SNDRV_PCM_FORMAT_U16_LE:
case SNDRV_PCM_FORMAT_U16_BE:
return 16;
case SND_PCM_FORMAT_S24_LE:
case SND_PCM_FORMAT_S24_BE:
case SND_PCM_FORMAT_U24_LE:
case SND_PCM_FORMAT_U24_BE:
case SNDRV_PCM_FORMAT_S24_LE:
case SNDRV_PCM_FORMAT_S24_BE:
case SNDRV_PCM_FORMAT_U24_LE:
case SNDRV_PCM_FORMAT_U24_BE:
return 24;
case SND_PCM_FORMAT_S32_LE:
case SND_PCM_FORMAT_S32_BE:
case SND_PCM_FORMAT_U32_LE:
case SND_PCM_FORMAT_U32_BE:
case SND_PCM_FORMAT_FLOAT_LE:
case SND_PCM_FORMAT_FLOAT_BE:
case SNDRV_PCM_FORMAT_S32_LE:
case SNDRV_PCM_FORMAT_S32_BE:
case SNDRV_PCM_FORMAT_U32_LE:
case SNDRV_PCM_FORMAT_U32_BE:
case SNDRV_PCM_FORMAT_FLOAT_LE:
case SNDRV_PCM_FORMAT_FLOAT_BE:
return 32;
case SND_PCM_FORMAT_FLOAT64_LE:
case SND_PCM_FORMAT_FLOAT64_BE:
case SNDRV_PCM_FORMAT_FLOAT64_LE:
case SNDRV_PCM_FORMAT_FLOAT64_BE:
return 64;
case SND_PCM_FORMAT_IEC958_SUBFRAME_LE:
case SND_PCM_FORMAT_IEC958_SUBFRAME_BE:
case SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE:
case SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE:
return 24;
case SND_PCM_FORMAT_MU_LAW:
case SND_PCM_FORMAT_A_LAW:
case SNDRV_PCM_FORMAT_MU_LAW:
case SNDRV_PCM_FORMAT_A_LAW:
return 8;
case SND_PCM_FORMAT_IMA_ADPCM:
case SNDRV_PCM_FORMAT_IMA_ADPCM:
return 4;
default:
return -EINVAL;
@ -164,34 +164,34 @@ int snd_pcm_format_width(int format)
int snd_pcm_format_physical_width(int format)
{
switch (format) {
case SND_PCM_FORMAT_S8:
case SND_PCM_FORMAT_U8:
case SNDRV_PCM_FORMAT_S8:
case SNDRV_PCM_FORMAT_U8:
return 8;
case SND_PCM_FORMAT_S16_LE:
case SND_PCM_FORMAT_S16_BE:
case SND_PCM_FORMAT_U16_LE:
case SND_PCM_FORMAT_U16_BE:
case SNDRV_PCM_FORMAT_S16_LE:
case SNDRV_PCM_FORMAT_S16_BE:
case SNDRV_PCM_FORMAT_U16_LE:
case SNDRV_PCM_FORMAT_U16_BE:
return 16;
case SND_PCM_FORMAT_S24_LE:
case SND_PCM_FORMAT_S24_BE:
case SND_PCM_FORMAT_U24_LE:
case SND_PCM_FORMAT_U24_BE:
case SND_PCM_FORMAT_S32_LE:
case SND_PCM_FORMAT_S32_BE:
case SND_PCM_FORMAT_U32_LE:
case SND_PCM_FORMAT_U32_BE:
case SND_PCM_FORMAT_FLOAT_LE:
case SND_PCM_FORMAT_FLOAT_BE:
case SND_PCM_FORMAT_IEC958_SUBFRAME_LE:
case SND_PCM_FORMAT_IEC958_SUBFRAME_BE:
case SNDRV_PCM_FORMAT_S24_LE:
case SNDRV_PCM_FORMAT_S24_BE:
case SNDRV_PCM_FORMAT_U24_LE:
case SNDRV_PCM_FORMAT_U24_BE:
case SNDRV_PCM_FORMAT_S32_LE:
case SNDRV_PCM_FORMAT_S32_BE:
case SNDRV_PCM_FORMAT_U32_LE:
case SNDRV_PCM_FORMAT_U32_BE:
case SNDRV_PCM_FORMAT_FLOAT_LE:
case SNDRV_PCM_FORMAT_FLOAT_BE:
case SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE:
case SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE:
return 32;
case SND_PCM_FORMAT_FLOAT64_LE:
case SND_PCM_FORMAT_FLOAT64_BE:
case SNDRV_PCM_FORMAT_FLOAT64_LE:
case SNDRV_PCM_FORMAT_FLOAT64_BE:
return 64;
case SND_PCM_FORMAT_MU_LAW:
case SND_PCM_FORMAT_A_LAW:
case SNDRV_PCM_FORMAT_MU_LAW:
case SNDRV_PCM_FORMAT_A_LAW:
return 8;
case SND_PCM_FORMAT_IMA_ADPCM:
case SNDRV_PCM_FORMAT_IMA_ADPCM:
return 4;
default:
return -EINVAL;
@ -201,35 +201,35 @@ int snd_pcm_format_physical_width(int format)
ssize_t snd_pcm_format_size(int format, size_t samples)
{
switch (format) {
case SND_PCM_FORMAT_S8:
case SND_PCM_FORMAT_U8:
case SNDRV_PCM_FORMAT_S8:
case SNDRV_PCM_FORMAT_U8:
return samples;
case SND_PCM_FORMAT_S16_LE:
case SND_PCM_FORMAT_S16_BE:
case SND_PCM_FORMAT_U16_LE:
case SND_PCM_FORMAT_U16_BE:
case SNDRV_PCM_FORMAT_S16_LE:
case SNDRV_PCM_FORMAT_S16_BE:
case SNDRV_PCM_FORMAT_U16_LE:
case SNDRV_PCM_FORMAT_U16_BE:
return samples * 2;
case SND_PCM_FORMAT_S24_LE:
case SND_PCM_FORMAT_S24_BE:
case SND_PCM_FORMAT_U24_LE:
case SND_PCM_FORMAT_U24_BE:
case SND_PCM_FORMAT_S32_LE:
case SND_PCM_FORMAT_S32_BE:
case SND_PCM_FORMAT_U32_LE:
case SND_PCM_FORMAT_U32_BE:
case SND_PCM_FORMAT_FLOAT_LE:
case SND_PCM_FORMAT_FLOAT_BE:
case SNDRV_PCM_FORMAT_S24_LE:
case SNDRV_PCM_FORMAT_S24_BE:
case SNDRV_PCM_FORMAT_U24_LE:
case SNDRV_PCM_FORMAT_U24_BE:
case SNDRV_PCM_FORMAT_S32_LE:
case SNDRV_PCM_FORMAT_S32_BE:
case SNDRV_PCM_FORMAT_U32_LE:
case SNDRV_PCM_FORMAT_U32_BE:
case SNDRV_PCM_FORMAT_FLOAT_LE:
case SNDRV_PCM_FORMAT_FLOAT_BE:
return samples * 4;
case SND_PCM_FORMAT_FLOAT64_LE:
case SND_PCM_FORMAT_FLOAT64_BE:
case SNDRV_PCM_FORMAT_FLOAT64_LE:
case SNDRV_PCM_FORMAT_FLOAT64_BE:
return samples * 8;
case SND_PCM_FORMAT_IEC958_SUBFRAME_LE:
case SND_PCM_FORMAT_IEC958_SUBFRAME_BE:
case SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE:
case SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE:
return samples * 4;
case SND_PCM_FORMAT_MU_LAW:
case SND_PCM_FORMAT_A_LAW:
case SNDRV_PCM_FORMAT_MU_LAW:
case SNDRV_PCM_FORMAT_A_LAW:
return samples;
case SND_PCM_FORMAT_IMA_ADPCM:
case SNDRV_PCM_FORMAT_IMA_ADPCM:
if (samples & 1)
return -EINVAL;
return samples / 2;
@ -241,105 +241,105 @@ ssize_t snd_pcm_format_size(int format, size_t samples)
u_int64_t snd_pcm_format_silence_64(int format)
{
switch (format) {
case SND_PCM_FORMAT_S8:
case SND_PCM_FORMAT_S16_LE:
case SND_PCM_FORMAT_S16_BE:
case SND_PCM_FORMAT_S24_LE:
case SND_PCM_FORMAT_S24_BE:
case SND_PCM_FORMAT_S32_LE:
case SND_PCM_FORMAT_S32_BE:
case SNDRV_PCM_FORMAT_S8:
case SNDRV_PCM_FORMAT_S16_LE:
case SNDRV_PCM_FORMAT_S16_BE:
case SNDRV_PCM_FORMAT_S24_LE:
case SNDRV_PCM_FORMAT_S24_BE:
case SNDRV_PCM_FORMAT_S32_LE:
case SNDRV_PCM_FORMAT_S32_BE:
return 0;
case SND_PCM_FORMAT_U8:
case SNDRV_PCM_FORMAT_U8:
return 0x8080808080808080ULL;
#ifdef SND_LITTLE_ENDIAN
case SND_PCM_FORMAT_U16_LE:
#ifdef SNDRV_LITTLE_ENDIAN
case SNDRV_PCM_FORMAT_U16_LE:
return 0x8000800080008000ULL;
case SND_PCM_FORMAT_U24_LE:
case SNDRV_PCM_FORMAT_U24_LE:
return 0x0080000000800000ULL;
case SND_PCM_FORMAT_U32_LE:
case SNDRV_PCM_FORMAT_U32_LE:
return 0x8000000080000000ULL;
case SND_PCM_FORMAT_U16_BE:
case SNDRV_PCM_FORMAT_U16_BE:
return 0x0080008000800080ULL;
case SND_PCM_FORMAT_U24_BE:
case SNDRV_PCM_FORMAT_U24_BE:
return 0x0000800000008000ULL;
case SND_PCM_FORMAT_U32_BE:
case SNDRV_PCM_FORMAT_U32_BE:
return 0x0000008000000080ULL;
#else
case SND_PCM_FORMAT_U16_LE:
case SNDRV_PCM_FORMAT_U16_LE:
return 0x0080008000800080ULL;
case SND_PCM_FORMAT_U24_LE:
case SNDRV_PCM_FORMAT_U24_LE:
return 0x0000800000008000ULL;
case SND_PCM_FORMAT_U32_LE:
case SNDRV_PCM_FORMAT_U32_LE:
return 0x0000008000000080ULL;
case SND_PCM_FORMAT_U16_BE:
case SNDRV_PCM_FORMAT_U16_BE:
return 0x8000800080008000ULL;
case SND_PCM_FORMAT_U24_BE:
case SNDRV_PCM_FORMAT_U24_BE:
return 0x0080000000800000ULL;
case SND_PCM_FORMAT_U32_BE:
case SNDRV_PCM_FORMAT_U32_BE:
return 0x8000000080000000ULL;
#endif
case SND_PCM_FORMAT_FLOAT_LE:
case SNDRV_PCM_FORMAT_FLOAT_LE:
{
union {
float f;
u_int32_t i;
} u;
u.f = 0.0;
#ifdef SND_LITTLE_ENDIAN
#ifdef SNDRV_LITTLE_ENDIAN
return u.i;
#else
return bswap_32(u.i);
#endif
}
case SND_PCM_FORMAT_FLOAT64_LE:
case SNDRV_PCM_FORMAT_FLOAT64_LE:
{
union {
double f;
u_int64_t i;
} u;
u.f = 0.0;
#ifdef SND_LITTLE_ENDIAN
#ifdef SNDRV_LITTLE_ENDIAN
return u.i;
#else
return bswap_64(u.i);
#endif
}
case SND_PCM_FORMAT_FLOAT_BE:
case SNDRV_PCM_FORMAT_FLOAT_BE:
{
union {
float f;
u_int32_t i;
} u;
u.f = 0.0;
#ifdef SND_LITTLE_ENDIAN
#ifdef SNDRV_LITTLE_ENDIAN
return bswap_32(u.i);
#else
return u.i;
#endif
}
case SND_PCM_FORMAT_FLOAT64_BE:
case SNDRV_PCM_FORMAT_FLOAT64_BE:
{
union {
double f;
u_int64_t i;
} u;
u.f = 0.0;
#ifdef SND_LITTLE_ENDIAN
#ifdef SNDRV_LITTLE_ENDIAN
return bswap_64(u.i);
#else
return u.i;
#endif
}
case SND_PCM_FORMAT_IEC958_SUBFRAME_LE:
case SND_PCM_FORMAT_IEC958_SUBFRAME_BE:
case SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE:
case SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE:
return 0;
case SND_PCM_FORMAT_MU_LAW:
case SNDRV_PCM_FORMAT_MU_LAW:
return 0x7f7f7f7f7f7f7f7fULL;
case SND_PCM_FORMAT_A_LAW:
case SNDRV_PCM_FORMAT_A_LAW:
return 0x5555555555555555ULL;
case SND_PCM_FORMAT_IMA_ADPCM: /* special case */
case SND_PCM_FORMAT_MPEG:
case SND_PCM_FORMAT_GSM:
case SNDRV_PCM_FORMAT_IMA_ADPCM: /* special case */
case SNDRV_PCM_FORMAT_MPEG:
case SNDRV_PCM_FORMAT_GSM:
return 0;
}
return 0;
@ -404,22 +404,22 @@ int snd_pcm_format_set_silence(int format, void *data, unsigned int samples)
}
static int linear_formats[4*2*2] = {
SND_PCM_FORMAT_S8,
SND_PCM_FORMAT_S8,
SND_PCM_FORMAT_U8,
SND_PCM_FORMAT_U8,
SND_PCM_FORMAT_S16_LE,
SND_PCM_FORMAT_S16_BE,
SND_PCM_FORMAT_U16_LE,
SND_PCM_FORMAT_U16_BE,
SND_PCM_FORMAT_S24_LE,
SND_PCM_FORMAT_S24_BE,
SND_PCM_FORMAT_U24_LE,
SND_PCM_FORMAT_U24_BE,
SND_PCM_FORMAT_S32_LE,
SND_PCM_FORMAT_S32_BE,
SND_PCM_FORMAT_U32_LE,
SND_PCM_FORMAT_U32_BE
SNDRV_PCM_FORMAT_S8,
SNDRV_PCM_FORMAT_S8,
SNDRV_PCM_FORMAT_U8,
SNDRV_PCM_FORMAT_U8,
SNDRV_PCM_FORMAT_S16_LE,
SNDRV_PCM_FORMAT_S16_BE,
SNDRV_PCM_FORMAT_U16_LE,
SNDRV_PCM_FORMAT_U16_BE,
SNDRV_PCM_FORMAT_S24_LE,
SNDRV_PCM_FORMAT_S24_BE,
SNDRV_PCM_FORMAT_U24_LE,
SNDRV_PCM_FORMAT_U24_BE,
SNDRV_PCM_FORMAT_S32_LE,
SNDRV_PCM_FORMAT_S32_BE,
SNDRV_PCM_FORMAT_U32_LE,
SNDRV_PCM_FORMAT_U32_BE
};
int snd_pcm_build_linear_format(int width, int unsignd, int big_endian)

30
src/pcm/pcm_shm.c
View file

@ -147,7 +147,7 @@ static int snd_pcm_shm_info(snd_pcm_t *pcm, snd_pcm_info_t * info)
volatile snd_pcm_shm_ctrl_t *ctrl = shm->ctrl;
int err;
// ctrl->u.info = *info;
ctrl->cmd = SND_PCM_IOCTL_INFO;
ctrl->cmd = SNDRV_PCM_IOCTL_INFO;
err = snd_pcm_shm_action(pcm);
if (err < 0)
return err;
@ -215,7 +215,7 @@ static int snd_pcm_shm_hw_refine_slave(snd_pcm_t *pcm,
volatile snd_pcm_shm_ctrl_t *ctrl = shm->ctrl;
int err;
ctrl->u.hw_refine = *params;
ctrl->cmd = SND_PCM_IOCTL_HW_REFINE;
ctrl->cmd = SNDRV_PCM_IOCTL_HW_REFINE;
err = snd_pcm_shm_action(pcm);
*params = ctrl->u.hw_refine;
return err;
@ -237,7 +237,7 @@ static int snd_pcm_shm_hw_params_slave(snd_pcm_t *pcm,
snd_pcm_shm_t *shm = pcm->private;
volatile snd_pcm_shm_ctrl_t *ctrl = shm->ctrl;
int err;
ctrl->cmd = SND_PCM_IOCTL_HW_PARAMS;
ctrl->cmd = SNDRV_PCM_IOCTL_HW_PARAMS;
ctrl->u.hw_params = *params;
err = snd_pcm_shm_action(pcm);
*params = ctrl->u.hw_params;
@ -257,7 +257,7 @@ static int snd_pcm_shm_hw_free(snd_pcm_t *pcm)
{
snd_pcm_shm_t *shm = pcm->private;
volatile snd_pcm_shm_ctrl_t *ctrl = shm->ctrl;
ctrl->cmd = SND_PCM_IOCTL_HW_FREE;
ctrl->cmd = SNDRV_PCM_IOCTL_HW_FREE;
return snd_pcm_shm_action(pcm);
}
@ -266,7 +266,7 @@ static int snd_pcm_shm_sw_params(snd_pcm_t *pcm, snd_pcm_sw_params_t * params)
snd_pcm_shm_t *shm = pcm->private;
volatile snd_pcm_shm_ctrl_t *ctrl = shm->ctrl;
int err;
ctrl->cmd = SND_PCM_IOCTL_SW_PARAMS;
ctrl->cmd = SNDRV_PCM_IOCTL_SW_PARAMS;
ctrl->u.sw_params = *params;
err = snd_pcm_shm_action(pcm);
*params = ctrl->u.sw_params;
@ -314,7 +314,7 @@ static int snd_pcm_shm_channel_info(snd_pcm_t *pcm, snd_pcm_channel_info_t * inf
volatile snd_pcm_shm_ctrl_t *ctrl = shm->ctrl;
int err;
int fd;
ctrl->cmd = SND_PCM_IOCTL_CHANNEL_INFO;
ctrl->cmd = SNDRV_PCM_IOCTL_CHANNEL_INFO;
ctrl->u.channel_info = *info;
err = snd_pcm_shm_action_fd(pcm, &fd);
if (err < 0)
@ -339,7 +339,7 @@ static int snd_pcm_shm_status(snd_pcm_t *pcm, snd_pcm_status_t * status)
snd_pcm_shm_t *shm = pcm->private;
volatile snd_pcm_shm_ctrl_t *ctrl = shm->ctrl;
int err;
ctrl->cmd = SND_PCM_IOCTL_STATUS;
ctrl->cmd = SNDRV_PCM_IOCTL_STATUS;
// ctrl->u.status = *status;
err = snd_pcm_shm_action(pcm);
if (err < 0)
@ -361,7 +361,7 @@ static int snd_pcm_shm_delay(snd_pcm_t *pcm, snd_pcm_sframes_t *delayp)
snd_pcm_shm_t *shm = pcm->private;
volatile snd_pcm_shm_ctrl_t *ctrl = shm->ctrl;
int err;
ctrl->cmd = SND_PCM_IOCTL_DELAY;
ctrl->cmd = SNDRV_PCM_IOCTL_DELAY;
err = snd_pcm_shm_action(pcm);
if (err < 0)
return err;
@ -385,7 +385,7 @@ static int snd_pcm_shm_prepare(snd_pcm_t *pcm)
{
snd_pcm_shm_t *shm = pcm->private;
volatile snd_pcm_shm_ctrl_t *ctrl = shm->ctrl;
ctrl->cmd = SND_PCM_IOCTL_PREPARE;
ctrl->cmd = SNDRV_PCM_IOCTL_PREPARE;
return snd_pcm_shm_action(pcm);
}
@ -393,7 +393,7 @@ static int snd_pcm_shm_reset(snd_pcm_t *pcm)
{
snd_pcm_shm_t *shm = pcm->private;
volatile snd_pcm_shm_ctrl_t *ctrl = shm->ctrl;
ctrl->cmd = SND_PCM_IOCTL_RESET;
ctrl->cmd = SNDRV_PCM_IOCTL_RESET;
return snd_pcm_shm_action(pcm);
}
@ -401,7 +401,7 @@ static int snd_pcm_shm_start(snd_pcm_t *pcm)
{
snd_pcm_shm_t *shm = pcm->private;
volatile snd_pcm_shm_ctrl_t *ctrl = shm->ctrl;
ctrl->cmd = SND_PCM_IOCTL_START;
ctrl->cmd = SNDRV_PCM_IOCTL_START;
return snd_pcm_shm_action(pcm);
}
@ -409,7 +409,7 @@ static int snd_pcm_shm_drop(snd_pcm_t *pcm)
{
snd_pcm_shm_t *shm = pcm->private;
volatile snd_pcm_shm_ctrl_t *ctrl = shm->ctrl;
ctrl->cmd = SND_PCM_IOCTL_DROP;
ctrl->cmd = SNDRV_PCM_IOCTL_DROP;
return snd_pcm_shm_action(pcm);
}
@ -418,7 +418,7 @@ static int snd_pcm_shm_drain(snd_pcm_t *pcm)
snd_pcm_shm_t *shm = pcm->private;
volatile snd_pcm_shm_ctrl_t *ctrl = shm->ctrl;
int err;
ctrl->cmd = SND_PCM_IOCTL_DRAIN;
ctrl->cmd = SNDRV_PCM_IOCTL_DRAIN;
err = snd_pcm_shm_action(pcm);
if (err < 0)
return err;
@ -431,7 +431,7 @@ static int snd_pcm_shm_pause(snd_pcm_t *pcm, int enable)
{
snd_pcm_shm_t *shm = pcm->private;
volatile snd_pcm_shm_ctrl_t *ctrl = shm->ctrl;
ctrl->cmd = SND_PCM_IOCTL_PAUSE;
ctrl->cmd = SNDRV_PCM_IOCTL_PAUSE;
ctrl->u.pause.enable = enable;
return snd_pcm_shm_action(pcm);
}
@ -440,7 +440,7 @@ static snd_pcm_sframes_t snd_pcm_shm_rewind(snd_pcm_t *pcm, snd_pcm_uframes_t fr
{
snd_pcm_shm_t *shm = pcm->private;
volatile snd_pcm_shm_ctrl_t *ctrl = shm->ctrl;
ctrl->cmd = SND_PCM_IOCTL_REWIND;
ctrl->cmd = SNDRV_PCM_IOCTL_REWIND;
ctrl->u.rewind.frames = frames;
return snd_pcm_shm_action(pcm);
}

36
src/rawmidi/rawmidi_hw.c
View file

@ -31,8 +31,8 @@
#include "rawmidi_local.h"
#include "asoundlib.h"
#define SND_FILE_RAWMIDI "/dev/snd/midiC%iD%i"
#define SND_RAWMIDI_VERSION_MAX SND_PROTOCOL_VERSION(2, 0, 0)
#define SNDRV_FILE_RAWMIDI "/dev/snd/midiC%iD%i"
#define SNDRV_RAWMIDI_VERSION_MAX SNDRV_PROTOCOL_VERSION(2, 0, 0)
typedef struct {
int fd;
@ -79,8 +79,8 @@ static int snd_rawmidi_hw_nonblock(snd_rawmidi_t *rmidi, int nonblock)
static int snd_rawmidi_hw_info(snd_rawmidi_t *rmidi, snd_rawmidi_info_t * info)
{
snd_rawmidi_hw_t *hw = rmidi->private;
if (ioctl(hw->fd, SND_RAWMIDI_IOCTL_INFO, info) < 0) {
SYSERR("SND_RAWMIDI_IOCTL_INFO failed");
if (ioctl(hw->fd, SNDRV_RAWMIDI_IOCTL_INFO, info) < 0) {
SYSERR("SNDRV_RAWMIDI_IOCTL_INFO failed");
return -errno;
}
return 0;
@ -89,8 +89,8 @@ static int snd_rawmidi_hw_info(snd_rawmidi_t *rmidi, snd_rawmidi_info_t * info)
static int snd_rawmidi_hw_params(snd_rawmidi_t *rmidi, snd_rawmidi_params_t * params)
{
snd_rawmidi_hw_t *hw = rmidi->private;
if (ioctl(hw->fd, SND_RAWMIDI_IOCTL_PARAMS, params) < 0) {
SYSERR("SND_RAWMIDI_IOCTL_PARAMS failed");
if (ioctl(hw->fd, SNDRV_RAWMIDI_IOCTL_PARAMS, params) < 0) {
SYSERR("SNDRV_RAWMIDI_IOCTL_PARAMS failed");
return -errno;
}
return 0;
@ -99,8 +99,8 @@ static int snd_rawmidi_hw_params(snd_rawmidi_t *rmidi, snd_rawmidi_params_t * pa
static int snd_rawmidi_hw_status(snd_rawmidi_t *rmidi, snd_rawmidi_status_t * status)
{
snd_rawmidi_hw_t *hw = rmidi->private;
if (ioctl(hw->fd, SND_RAWMIDI_IOCTL_STATUS, status) < 0) {
SYSERR("SND_RAWMIDI_IOCTL_STATUS failed");
if (ioctl(hw->fd, SNDRV_RAWMIDI_IOCTL_STATUS, status) < 0) {
SYSERR("SNDRV_RAWMIDI_IOCTL_STATUS failed");
return -errno;
}
return 0;
@ -109,8 +109,8 @@ static int snd_rawmidi_hw_status(snd_rawmidi_t *rmidi, snd_rawmidi_status_t * st
static int snd_rawmidi_hw_drop(snd_rawmidi_t *rmidi, int stream)
{
snd_rawmidi_hw_t *hw = rmidi->private;
if (ioctl(hw->fd, SND_RAWMIDI_IOCTL_DROP, &stream) < 0) {
SYSERR("SND_RAWMIDI_IOCTL_DROP failed");
if (ioctl(hw->fd, SNDRV_RAWMIDI_IOCTL_DROP, &stream) < 0) {
SYSERR("SNDRV_RAWMIDI_IOCTL_DROP failed");
return -errno;
}
return 0;
@ -119,8 +119,8 @@ static int snd_rawmidi_hw_drop(snd_rawmidi_t *rmidi, int stream)
static int snd_rawmidi_hw_drain(snd_rawmidi_t *rmidi, int stream)
{
snd_rawmidi_hw_t *hw = rmidi->private;
if (ioctl(hw->fd, SND_RAWMIDI_IOCTL_DRAIN, &stream) < 0) {
SYSERR("SND_RAWMIDI_IOCTL_DRAIN failed");
if (ioctl(hw->fd, SNDRV_RAWMIDI_IOCTL_DRAIN, &stream) < 0) {
SYSERR("SNDRV_RAWMIDI_IOCTL_DRAIN failed");
return -errno;
}
return 0;
@ -177,7 +177,7 @@ int snd_rawmidi_hw_open(snd_rawmidi_t **handlep, char *name, int card, int devic
if ((ret = snd_ctl_hw_open(&ctl, NULL, card)) < 0)
return ret;
sprintf(filename, SND_FILE_RAWMIDI, card, device);
sprintf(filename, SNDRV_FILE_RAWMIDI, card, device);
__again:
if (attempt++ > 3) {
@ -224,22 +224,22 @@ int snd_rawmidi_hw_open(snd_rawmidi_t **handlep, char *name, int card, int devic
return -errno;
}
}
if (ioctl(fd, SND_RAWMIDI_IOCTL_PVERSION, &ver) < 0) {
if (ioctl(fd, SNDRV_RAWMIDI_IOCTL_PVERSION, &ver) < 0) {
ret = -errno;
SYSERR("SND_RAWMIDI_IOCTL_PVERSION failed");
SYSERR("SNDRV_RAWMIDI_IOCTL_PVERSION failed");
close(fd);
snd_ctl_close(ctl);
return ret;
}
if (SND_PROTOCOL_INCOMPATIBLE(ver, SND_RAWMIDI_VERSION_MAX)) {
if (SNDRV_PROTOCOL_INCOMPATIBLE(ver, SNDRV_RAWMIDI_VERSION_MAX)) {
close(fd);
snd_ctl_close(ctl);
return -SND_ERROR_INCOMPATIBLE_VERSION;
}
if (subdevice >= 0) {
memset(&info, 0, sizeof(info));
if (ioctl(fd, SND_RAWMIDI_IOCTL_INFO, &info) < 0) {
SYSERR("SND_RAWMIDI_IOCTL_INFO failed");
if (ioctl(fd, SNDRV_RAWMIDI_IOCTL_INFO, &info) < 0) {
SYSERR("SNDRV_RAWMIDI_IOCTL_INFO failed");
ret = -errno;
close(fd);
snd_ctl_close(ctl);

140
src/seq/seq_hw.c
View file

@ -25,9 +25,9 @@
#include "seq_local.h"
#include "asoundlib.h"
#define SND_FILE_SEQ "/dev/snd/seq"
#define SND_FILE_ALOADSEQ "/dev/aloadSEQ"
#define SND_SEQ_VERSION_MAX SND_PROTOCOL_VERSION(1, 0, 0)
#define SNDRV_FILE_SEQ "/dev/snd/seq"
#define SNDRV_FILE_ALOADSEQ "/dev/aloadSEQ"
#define SNDRV_SEQ_VERSION_MAX SNDRV_PROTOCOL_VERSION(1, 0, 0)
typedef struct {
int fd;
@ -68,8 +68,8 @@ static int snd_seq_hw_client_id(snd_seq_t *seq)
{
snd_seq_hw_t *hw = seq->private;
int client;
if (ioctl(hw->fd, SND_SEQ_IOCTL_CLIENT_ID, &client) < 0) {
SYSERR("SND_SEQ_IOCTL_CLIENT_ID failed");
if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_CLIENT_ID, &client) < 0) {
SYSERR("SNDRV_SEQ_IOCTL_CLIENT_ID failed");
return -errno;
}
return client;
@ -78,8 +78,8 @@ static int snd_seq_hw_client_id(snd_seq_t *seq)
static int snd_seq_hw_system_info(snd_seq_t *seq, snd_seq_system_info_t * info)
{
snd_seq_hw_t *hw = seq->private;
if (ioctl(hw->fd, SND_SEQ_IOCTL_SYSTEM_INFO, info) < 0) {
SYSERR("SND_SEQ_IOCTL_SYSTEM_INFO failed");
if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_SYSTEM_INFO, info) < 0) {
SYSERR("SNDRV_SEQ_IOCTL_SYSTEM_INFO failed");
return -errno;
}
return 0;
@ -88,8 +88,8 @@ static int snd_seq_hw_system_info(snd_seq_t *seq, snd_seq_system_info_t * info)
static int snd_seq_hw_get_client_info(snd_seq_t *seq, snd_seq_client_info_t * info)
{
snd_seq_hw_t *hw = seq->private;
if (ioctl(hw->fd, SND_SEQ_IOCTL_GET_CLIENT_INFO, info) < 0) {
SYSERR("SND_SEQ_IOCTL_GET_CLIENT_INFO failed");
if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_GET_CLIENT_INFO, info) < 0) {
SYSERR("SNDRV_SEQ_IOCTL_GET_CLIENT_INFO failed");
return -errno;
}
return 0;
@ -98,8 +98,8 @@ static int snd_seq_hw_get_client_info(snd_seq_t *seq, snd_seq_client_info_t * in
static int snd_seq_hw_set_client_info(snd_seq_t *seq, snd_seq_client_info_t * info)
{
snd_seq_hw_t *hw = seq->private;
if (ioctl(hw->fd, SND_SEQ_IOCTL_SET_CLIENT_INFO, info) < 0) {
SYSERR("SND_SEQ_IOCTL_SET_CLIENT_INFO failed");
if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_SET_CLIENT_INFO, info) < 0) {
SYSERR("SNDRV_SEQ_IOCTL_SET_CLIENT_INFO failed");
return -errno;
}
return 0;
@ -108,8 +108,8 @@ static int snd_seq_hw_set_client_info(snd_seq_t *seq, snd_seq_client_info_t * in
static int snd_seq_hw_create_port(snd_seq_t *seq, snd_seq_port_info_t * port)
{
snd_seq_hw_t *hw = seq->private;
if (ioctl(hw->fd, SND_SEQ_IOCTL_CREATE_PORT, port) < 0) {
SYSERR("SND_SEQ_IOCTL_CREATE_PORT failed");
if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_CREATE_PORT, port) < 0) {
SYSERR("SNDRV_SEQ_IOCTL_CREATE_PORT failed");
return -errno;
}
return 0;
@ -118,8 +118,8 @@ static int snd_seq_hw_create_port(snd_seq_t *seq, snd_seq_port_info_t * port)
static int snd_seq_hw_delete_port(snd_seq_t *seq, snd_seq_port_info_t * port)
{
snd_seq_hw_t *hw = seq->private;
if (ioctl(hw->fd, SND_SEQ_IOCTL_DELETE_PORT, port) < 0) {
SYSERR("SND_SEQ_IOCTL_DELETE_PORT failed");
if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_DELETE_PORT, port) < 0) {
SYSERR("SNDRV_SEQ_IOCTL_DELETE_PORT failed");
return -errno;
}
return 0;
@ -128,8 +128,8 @@ static int snd_seq_hw_delete_port(snd_seq_t *seq, snd_seq_port_info_t * port)
static int snd_seq_hw_get_port_info(snd_seq_t *seq, snd_seq_port_info_t * info)
{
snd_seq_hw_t *hw = seq->private;
if (ioctl(hw->fd, SND_SEQ_IOCTL_GET_PORT_INFO, info) < 0) {
SYSERR("SND_SEQ_IOCTL_GET_PORT_INFO failed");
if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_GET_PORT_INFO, info) < 0) {
SYSERR("SNDRV_SEQ_IOCTL_GET_PORT_INFO failed");
return -errno;
}
return 0;
@ -138,8 +138,8 @@ static int snd_seq_hw_get_port_info(snd_seq_t *seq, snd_seq_port_info_t * info)
static int snd_seq_hw_set_port_info(snd_seq_t *seq, snd_seq_port_info_t * info)
{
snd_seq_hw_t *hw = seq->private;
if (ioctl(hw->fd, SND_SEQ_IOCTL_SET_PORT_INFO, info) < 0) {
SYSERR("SND_SEQ_IOCTL_SET_PORT_INFO failed");
if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_SET_PORT_INFO, info) < 0) {
SYSERR("SNDRV_SEQ_IOCTL_SET_PORT_INFO failed");
return -errno;
}
return 0;
@ -148,8 +148,8 @@ static int snd_seq_hw_set_port_info(snd_seq_t *seq, snd_seq_port_info_t * info)
static int snd_seq_hw_get_port_subscription(snd_seq_t *seq, snd_seq_port_subscribe_t * sub)
{
snd_seq_hw_t *hw = seq->private;
if (ioctl(hw->fd, SND_SEQ_IOCTL_GET_SUBSCRIPTION, sub) < 0) {
SYSERR("SND_SEQ_IOCTL_GET_SUBSCRIPTION failed");
if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_GET_SUBSCRIPTION, sub) < 0) {
SYSERR("SNDRV_SEQ_IOCTL_GET_SUBSCRIPTION failed");
return -errno;
}
return 0;
@ -158,8 +158,8 @@ static int snd_seq_hw_get_port_subscription(snd_seq_t *seq, snd_seq_port_subscri
static int snd_seq_hw_subscribe_port(snd_seq_t *seq, snd_seq_port_subscribe_t * sub)
{
snd_seq_hw_t *hw = seq->private;
if (ioctl(hw->fd, SND_SEQ_IOCTL_SUBSCRIBE_PORT, sub) < 0) {
SYSERR("SND_SEQ_IOCTL_SUBSCRIBE_PORT failed");
if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT, sub) < 0) {
SYSERR("SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT failed");
return -errno;
}
return 0;
@ -168,8 +168,8 @@ static int snd_seq_hw_subscribe_port(snd_seq_t *seq, snd_seq_port_subscribe_t *
static int snd_seq_hw_unsubscribe_port(snd_seq_t *seq, snd_seq_port_subscribe_t * sub)
{
snd_seq_hw_t *hw = seq->private;
if (ioctl(hw->fd, SND_SEQ_IOCTL_UNSUBSCRIBE_PORT, sub) < 0) {
SYSERR("SND_SEQ_IOCTL_UNSUBSCRIBE_PORT failed");
if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_UNSUBSCRIBE_PORT, sub) < 0) {
SYSERR("SNDRV_SEQ_IOCTL_UNSUBSCRIBE_PORT failed");
return -errno;
}
return 0;
@ -178,8 +178,8 @@ static int snd_seq_hw_unsubscribe_port(snd_seq_t *seq, snd_seq_port_subscribe_t
static int snd_seq_hw_query_port_subscribers(snd_seq_t *seq, snd_seq_query_subs_t * subs)
{
snd_seq_hw_t *hw = seq->private;
if (ioctl(hw->fd, SND_SEQ_IOCTL_QUERY_SUBS, subs) < 0) {
SYSERR("SND_SEQ_IOCTL_QUERY_SUBS failed");
if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_QUERY_SUBS, subs) < 0) {
SYSERR("SNDRV_SEQ_IOCTL_QUERY_SUBS failed");
return -errno;
}
return 0;
@ -188,8 +188,8 @@ static int snd_seq_hw_query_port_subscribers(snd_seq_t *seq, snd_seq_query_subs_
static int snd_seq_hw_get_queue_status(snd_seq_t *seq, snd_seq_queue_status_t * status)
{
snd_seq_hw_t *hw = seq->private;
if (ioctl(hw->fd, SND_SEQ_IOCTL_GET_QUEUE_STATUS, status) < 0) {
SYSERR("SND_SEQ_IOCTL_GET_QUEUE_STATUS failed");
if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_GET_QUEUE_STATUS, status) < 0) {
SYSERR("SNDRV_SEQ_IOCTL_GET_QUEUE_STATUS failed");
return -errno;
}
return 0;
@ -198,8 +198,8 @@ static int snd_seq_hw_get_queue_status(snd_seq_t *seq, snd_seq_queue_status_t *
static int snd_seq_hw_get_queue_tempo(snd_seq_t *seq, snd_seq_queue_tempo_t * tempo)
{
snd_seq_hw_t *hw = seq->private;
if (ioctl(hw->fd, SND_SEQ_IOCTL_GET_QUEUE_TEMPO, tempo) < 0) {
SYSERR("SND_SEQ_IOCTL_GET_QUEUE_TEMPO failed");
if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_GET_QUEUE_TEMPO, tempo) < 0) {
SYSERR("SNDRV_SEQ_IOCTL_GET_QUEUE_TEMPO failed");
return -errno;
}
return 0;
@ -208,8 +208,8 @@ static int snd_seq_hw_get_queue_tempo(snd_seq_t *seq, snd_seq_queue_tempo_t * te
static int snd_seq_hw_set_queue_tempo(snd_seq_t *seq, snd_seq_queue_tempo_t * tempo)
{
snd_seq_hw_t *hw = seq->private;
if (ioctl(hw->fd, SND_SEQ_IOCTL_SET_QUEUE_TEMPO, tempo) < 0) {
SYSERR("SND_SEQ_IOCTL_SET_QUEUE_TEMPO failed");
if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_SET_QUEUE_TEMPO, tempo) < 0) {
SYSERR("SNDRV_SEQ_IOCTL_SET_QUEUE_TEMPO failed");
return -errno;
}
return 0;
@ -218,8 +218,8 @@ static int snd_seq_hw_set_queue_tempo(snd_seq_t *seq, snd_seq_queue_tempo_t * te
static int snd_seq_hw_get_queue_owner(snd_seq_t *seq, snd_seq_queue_owner_t * owner)
{
snd_seq_hw_t *hw = seq->private;
if (ioctl(hw->fd, SND_SEQ_IOCTL_GET_QUEUE_OWNER, owner) < 0) {
SYSERR("SND_SEQ_IOCTL_GET_QUEUE_OWNER failed");
if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_GET_QUEUE_OWNER, owner) < 0) {
SYSERR("SNDRV_SEQ_IOCTL_GET_QUEUE_OWNER failed");
return -errno;
}
return 0;
@ -228,8 +228,8 @@ static int snd_seq_hw_get_queue_owner(snd_seq_t *seq, snd_seq_queue_owner_t * ow
static int snd_seq_hw_set_queue_owner(snd_seq_t *seq, snd_seq_queue_owner_t * owner)
{
snd_seq_hw_t *hw = seq->private;
if (ioctl(hw->fd, SND_SEQ_IOCTL_SET_QUEUE_OWNER, owner) < 0) {
SYSERR("SND_SEQ_IOCTL_SET_QUEUE_OWNER failed");
if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_SET_QUEUE_OWNER, owner) < 0) {
SYSERR("SNDRV_SEQ_IOCTL_SET_QUEUE_OWNER failed");
return -errno;
}
return 0;
@ -238,8 +238,8 @@ static int snd_seq_hw_set_queue_owner(snd_seq_t *seq, snd_seq_queue_owner_t * ow
static int snd_seq_hw_get_queue_timer(snd_seq_t *seq, snd_seq_queue_timer_t * timer)
{
snd_seq_hw_t *hw = seq->private;
if (ioctl(hw->fd, SND_SEQ_IOCTL_GET_QUEUE_TIMER, timer) < 0) {
SYSERR("SND_SEQ_IOCTL_GET_QUEUE_TIMER failed");
if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_GET_QUEUE_TIMER, timer) < 0) {
SYSERR("SNDRV_SEQ_IOCTL_GET_QUEUE_TIMER failed");
return -errno;
}
return 0;
@ -248,8 +248,8 @@ static int snd_seq_hw_get_queue_timer(snd_seq_t *seq, snd_seq_queue_timer_t * ti
static int snd_seq_hw_set_queue_timer(snd_seq_t *seq, snd_seq_queue_timer_t * timer)
{
snd_seq_hw_t *hw = seq->private;
if (ioctl(hw->fd, SND_SEQ_IOCTL_SET_QUEUE_TIMER, timer) < 0) {
SYSERR("SND_SEQ_IOCTL_SET_QUEUE_TIMER failed");
if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_SET_QUEUE_TIMER, timer) < 0) {
SYSERR("SNDRV_SEQ_IOCTL_SET_QUEUE_TIMER failed");
return -errno;
}
return 0;
@ -258,8 +258,8 @@ static int snd_seq_hw_set_queue_timer(snd_seq_t *seq, snd_seq_queue_timer_t * ti
static int snd_seq_hw_get_queue_client(snd_seq_t *seq, snd_seq_queue_client_t * info)
{
snd_seq_hw_t *hw = seq->private;
if (ioctl(hw->fd, SND_SEQ_IOCTL_GET_QUEUE_CLIENT, info) < 0) {
SYSERR("SND_SEQ_IOCTL_GET_QUEUE_CLIENT failed");
if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_GET_QUEUE_CLIENT, info) < 0) {
SYSERR("SNDRV_SEQ_IOCTL_GET_QUEUE_CLIENT failed");
return -errno;
}
return 0;
@ -268,8 +268,8 @@ static int snd_seq_hw_get_queue_client(snd_seq_t *seq, snd_seq_queue_client_t *
static int snd_seq_hw_set_queue_client(snd_seq_t *seq, snd_seq_queue_client_t * info)
{
snd_seq_hw_t *hw = seq->private;
if (ioctl(hw->fd, SND_SEQ_IOCTL_SET_QUEUE_CLIENT, info) < 0) {
SYSERR("SND_SEQ_IOCTL_SET_QUEUE_CLIENT failed");
if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_SET_QUEUE_CLIENT, info) < 0) {
SYSERR("SNDRV_SEQ_IOCTL_SET_QUEUE_CLIENT failed");
return -errno;
}
return 0;
@ -278,8 +278,8 @@ static int snd_seq_hw_set_queue_client(snd_seq_t *seq, snd_seq_queue_client_t *
static int snd_seq_hw_create_queue(snd_seq_t *seq, snd_seq_queue_info_t *info)
{
snd_seq_hw_t *hw = seq->private;
if (ioctl(hw->fd, SND_SEQ_IOCTL_CREATE_QUEUE, info) < 0) {
SYSERR("SND_SEQ_IOCTL_CREATE_QUEUE failed");
if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_CREATE_QUEUE, info) < 0) {
SYSERR("SNDRV_SEQ_IOCTL_CREATE_QUEUE failed");
return -errno;
}
return 0;
@ -288,8 +288,8 @@ static int snd_seq_hw_create_queue(snd_seq_t *seq, snd_seq_queue_info_t *info)
static int snd_seq_hw_delete_queue(snd_seq_t *seq, snd_seq_queue_info_t *info)
{
snd_seq_hw_t *hw = seq->private;
if (ioctl(hw->fd, SND_SEQ_IOCTL_DELETE_QUEUE, info) < 0) {
SYSERR("SND_SEQ_IOCTL_DELETE_QUEUE failed");
if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_DELETE_QUEUE, info) < 0) {
SYSERR("SNDRV_SEQ_IOCTL_DELETE_QUEUE failed");
return -errno;
}
return 0;
@ -298,8 +298,8 @@ static int snd_seq_hw_delete_queue(snd_seq_t *seq, snd_seq_queue_info_t *info)
static int snd_seq_hw_get_queue_info(snd_seq_t *seq, snd_seq_queue_info_t *info)
{
snd_seq_hw_t *hw = seq->private;
if (ioctl(hw->fd, SND_SEQ_IOCTL_GET_QUEUE_INFO, info) < 0) {
SYSERR("SND_SEQ_IOCTL_GET_QUEUE_INFO failed");
if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_GET_QUEUE_INFO, info) < 0) {
SYSERR("SNDRV_SEQ_IOCTL_GET_QUEUE_INFO failed");
return -errno;
}
return 0;
@ -308,8 +308,8 @@ static int snd_seq_hw_get_queue_info(snd_seq_t *seq, snd_seq_queue_info_t *info)
static int snd_seq_hw_set_queue_info(snd_seq_t *seq, snd_seq_queue_info_t *info)
{
snd_seq_hw_t *hw = seq->private;
if (ioctl(hw->fd, SND_SEQ_IOCTL_SET_QUEUE_INFO, info) < 0) {
SYSERR("SND_SEQ_IOCTL_SET_QUEUE_INFO failed");
if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_SET_QUEUE_INFO, info) < 0) {
SYSERR("SNDRV_SEQ_IOCTL_SET_QUEUE_INFO failed");
return -errno;
}
return 0;
@ -318,8 +318,8 @@ static int snd_seq_hw_set_queue_info(snd_seq_t *seq, snd_seq_queue_info_t *info)
static int snd_seq_hw_get_named_queue(snd_seq_t *seq, snd_seq_queue_info_t *info)
{
snd_seq_hw_t *hw = seq->private;
if (ioctl(hw->fd, SND_SEQ_IOCTL_GET_NAMED_QUEUE, info) < 0) {
SYSERR("SND_SEQ_IOCTL_GET_NAMED_QUEUE failed");
if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_GET_NAMED_QUEUE, info) < 0) {
SYSERR("SNDRV_SEQ_IOCTL_GET_NAMED_QUEUE failed");
return -errno;
}
return 0;
@ -346,8 +346,8 @@ static ssize_t snd_seq_hw_read(snd_seq_t *seq, void *buf, size_t len)
static int snd_seq_hw_remove_events(snd_seq_t *seq, snd_seq_remove_events_t *rmp)
{
snd_seq_hw_t *hw = seq->private;
if (ioctl(hw->fd, SND_SEQ_IOCTL_REMOVE_EVENTS, rmp) < 0) {
SYSERR("SND_SEQ_IOCTL_REMOVE_EVENTS failed");
if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_REMOVE_EVENTS, rmp) < 0) {
SYSERR("SNDRV_SEQ_IOCTL_REMOVE_EVENTS failed");
return -errno;
}
return 0;
@ -356,8 +356,8 @@ static int snd_seq_hw_remove_events(snd_seq_t *seq, snd_seq_remove_events_t *rmp
static int snd_seq_hw_get_client_pool(snd_seq_t *seq, snd_seq_client_pool_t *info)
{
snd_seq_hw_t *hw = seq->private;
if (ioctl(hw->fd, SND_SEQ_IOCTL_GET_CLIENT_POOL, info) < 0) {
SYSERR("SND_SEQ_IOCTL_GET_CLIENT_POOL failed");
if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_GET_CLIENT_POOL, info) < 0) {
SYSERR("SNDRV_SEQ_IOCTL_GET_CLIENT_POOL failed");
return -errno;
}
return 0;
@ -366,8 +366,8 @@ static int snd_seq_hw_get_client_pool(snd_seq_t *seq, snd_seq_client_pool_t *inf
static int snd_seq_hw_set_client_pool(snd_seq_t *seq, snd_seq_client_pool_t *info)
{
snd_seq_hw_t *hw = seq->private;
if (ioctl(hw->fd, SND_SEQ_IOCTL_SET_CLIENT_POOL, info) < 0) {
SYSERR("SND_SEQ_IOCTL_SET_CLIENT_POOL failed");
if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_SET_CLIENT_POOL, info) < 0) {
SYSERR("SNDRV_SEQ_IOCTL_SET_CLIENT_POOL failed");
return -errno;
}
return 0;
@ -376,8 +376,8 @@ static int snd_seq_hw_set_client_pool(snd_seq_t *seq, snd_seq_client_pool_t *inf
static int snd_seq_hw_query_next_client(snd_seq_t *seq, snd_seq_client_info_t *info)
{
snd_seq_hw_t *hw = seq->private;
if (ioctl(hw->fd, SND_SEQ_IOCTL_QUERY_NEXT_CLIENT, info) < 0) {
SYSERR("SND_SEQ_IOCTL_QUERY_NEXT_CLIENT failed");
if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_QUERY_NEXT_CLIENT, info) < 0) {
SYSERR("SNDRV_SEQ_IOCTL_QUERY_NEXT_CLIENT failed");
return -errno;
}
return 0;
@ -386,8 +386,8 @@ static int snd_seq_hw_query_next_client(snd_seq_t *seq, snd_seq_client_info_t *i
static int snd_seq_hw_query_next_port(snd_seq_t *seq, snd_seq_port_info_t *info)
{
snd_seq_hw_t *hw = seq->private;
if (ioctl(hw->fd, SND_SEQ_IOCTL_QUERY_NEXT_PORT, info) < 0) {
SYSERR("SND_SEQ_IOCTL_QUERY_NEXT_PORT failed");
if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_QUERY_NEXT_PORT, info) < 0) {
SYSERR("SNDRV_SEQ_IOCTL_QUERY_NEXT_PORT failed");
return -errno;
}
return 0;
@ -457,20 +457,20 @@ int snd_seq_hw_open(snd_seq_t **handle, char *name, int streams, int mode)
if (mode & SND_SEQ_NONBLOCK)
fmode |= O_NONBLOCK;
sprintf(filename, SND_FILE_SEQ);
sprintf(filename, SNDRV_FILE_SEQ);
if ((fd = open(filename, fmode)) < 0) {
close(open(SND_FILE_ALOADSEQ, O_RDWR));
close(open(SNDRV_FILE_ALOADSEQ, O_RDWR));
if ((fd = open(filename, fmode)) < 0) {
SYSERR("open %s failed", filename);
return -errno;
}
}
if (ioctl(fd, SND_SEQ_IOCTL_PVERSION, &ver) < 0) {
SYSERR("SND_SEQ_IOCTL_PVERSION failed");
if (ioctl(fd, SNDRV_SEQ_IOCTL_PVERSION, &ver) < 0) {
SYSERR("SNDRV_SEQ_IOCTL_PVERSION failed");
close(fd);
return -errno;
}
if (SND_PROTOCOL_INCOMPATIBLE(ver, SND_SEQ_VERSION_MAX)) {
if (SNDRV_PROTOCOL_INCOMPATIBLE(ver, SNDRV_SEQ_VERSION_MAX)) {
close(fd);
return -SND_ERROR_INCOMPATIBLE_VERSION;
}

12
src/seq/seq_midi_event.c
View file

@ -228,7 +228,7 @@ int snd_midi_event_encode_byte(snd_midi_event_t *dev, int c, snd_seq_event_t *ev
c &= 0xff;
if (c >= SND_MCMD_COMMON_CLOCK) {
if (c >= MIDI_CMD_COMMON_CLOCK) {
/* real-time event */
ev->type = status_event[ST_SPECIAL + c - 0xf0].event;
ev->flags &= ~SND_SEQ_EVENT_LENGTH_MASK;
@ -265,13 +265,13 @@ int snd_midi_event_encode_byte(snd_midi_event_t *dev, int c, snd_seq_event_t *ev
status_event[dev->type].encode(dev, ev);
rc = 1;
} else if (dev->type == ST_SYSEX) {
if (c == SND_MCMD_COMMON_SYSEX_END ||
if (c == MIDI_CMD_COMMON_SYSEX_END ||
dev->read >= dev->bufsize) {
ev->flags &= ~SND_SEQ_EVENT_LENGTH_MASK;
ev->flags |= SND_SEQ_EVENT_LENGTH_VARIABLE;
ev->data.ext.len = dev->read;
ev->data.ext.ptr = dev->buf;
if (c != SND_MCMD_COMMON_SYSEX_END)
if (c != MIDI_CMD_COMMON_SYSEX_END)
dev->read = 0; /* continue to parse */
else
reset_encode(dev); /* all parsed */
@ -355,7 +355,7 @@ long snd_midi_event_decode(snd_midi_event_t *dev, unsigned char *buf, long count
cmd = 0x80 | (type << 4) | (ev->data.note.channel & 0x0f);
if (cmd == SND_MCMD_COMMON_SYSEX) {
if (cmd == MIDI_CMD_COMMON_SYSEX) {
qlen = ev->data.ext.len;
if (count < qlen)
return -ENOMEM;
@ -429,7 +429,7 @@ static int extra_decode_ctrl14(snd_midi_event_t *dev, unsigned char *buf, int co
if (ev->data.control.param < 32) {
if (count < 5)
return -ENOMEM;
buf[0] = SND_MCMD_CONTROL|(ev->data.control.channel & 0x0f);
buf[0] = MIDI_CMD_CONTROL|(ev->data.control.channel & 0x0f);
buf[1] = ev->data.control.param;
buf[2] = (ev->data.control.value >> 7) & 0x7f;
buf[3] = ev->data.control.param + 32;
@ -439,7 +439,7 @@ static int extra_decode_ctrl14(snd_midi_event_t *dev, unsigned char *buf, int co
} else {
if (count < 3)
return -ENOMEM;
buf[0] = SND_MCMD_CONTROL|(ev->data.control.channel & 0x0f);
buf[0] = MIDI_CMD_CONTROL|(ev->data.control.channel & 0x0f);
buf[1] = ev->data.control.param & 0x7f;
buf[4] = ev->data.control.value & 0x7f;
dev->lastcmd = buf[0];

26
src/timer/timer.c
View file

@ -28,8 +28,8 @@
#include <sys/ioctl.h>
#include "asoundlib.h"
#define SND_FILE_TIMER "/dev/snd/timer"
#define SND_TIMER_VERSION_MAX SND_PROTOCOL_VERSION(2, 0, 0)
#define SNDRV_FILE_TIMER "/dev/snd/timer"
#define SNDRV_TIMER_VERSION_MAX SNDRV_PROTOCOL_VERSION(2, 0, 0)
struct _snd_timer {
int fd;
@ -42,13 +42,13 @@ int snd_timer_open(snd_timer_t **handle)
*handle = NULL;
if ((fd = open(SND_FILE_TIMER, O_RDONLY)) < 0)
if ((fd = open(SNDRV_FILE_TIMER, O_RDONLY)) < 0)
return -errno;
if (ioctl(fd, SND_TIMER_IOCTL_PVERSION, &ver) < 0) {
if (ioctl(fd, SNDRV_TIMER_IOCTL_PVERSION, &ver) < 0) {
close(fd);
return -errno;
}
if (SND_PROTOCOL_INCOMPATIBLE(ver, SND_TIMER_VERSION_MAX)) {
if (SNDRV_PROTOCOL_INCOMPATIBLE(ver, SNDRV_TIMER_VERSION_MAX)) {
close(fd);
return -SND_ERROR_INCOMPATIBLE_VERSION;
}
@ -92,7 +92,7 @@ int snd_timer_next_device(snd_timer_t *handle, snd_timer_id_t * tid)
tmr = handle;
if (!tmr || !tid)
return -EINVAL;
if (ioctl(tmr->fd, SND_TIMER_IOCTL_NEXT_DEVICE, tid) < 0)
if (ioctl(tmr->fd, SNDRV_TIMER_IOCTL_NEXT_DEVICE, tid) < 0)
return -errno;
return 0;
}
@ -104,7 +104,7 @@ int snd_timer_select(snd_timer_t *handle, snd_timer_select_t * tselect)
tmr = handle;
if (!tmr || !tselect)
return -EINVAL;
if (ioctl(tmr->fd, SND_TIMER_IOCTL_SELECT, tselect) < 0)
if (ioctl(tmr->fd, SNDRV_TIMER_IOCTL_SELECT, tselect) < 0)
return -errno;
return 0;
}
@ -116,7 +116,7 @@ int snd_timer_info(snd_timer_t *handle, snd_timer_info_t * info)
tmr = handle;
if (!tmr || !info)
return -EINVAL;
if (ioctl(tmr->fd, SND_TIMER_IOCTL_INFO, info) < 0)
if (ioctl(tmr->fd, SNDRV_TIMER_IOCTL_INFO, info) < 0)
return -errno;
return 0;
}
@ -128,7 +128,7 @@ int snd_timer_params(snd_timer_t *handle, snd_timer_params_t * params)
tmr = handle;
if (!tmr || !params)
return -EINVAL;
if (ioctl(tmr->fd, SND_TIMER_IOCTL_PARAMS, params) < 0)
if (ioctl(tmr->fd, SNDRV_TIMER_IOCTL_PARAMS, params) < 0)
return -errno;
return 0;
}
@ -140,7 +140,7 @@ int snd_timer_status(snd_timer_t *handle, snd_timer_status_t * status)
tmr = handle;
if (!tmr || !status)
return -EINVAL;
if (ioctl(tmr->fd, SND_TIMER_IOCTL_STATUS, status) < 0)
if (ioctl(tmr->fd, SNDRV_TIMER_IOCTL_STATUS, status) < 0)
return -errno;
return 0;
}
@ -152,7 +152,7 @@ int snd_timer_start(snd_timer_t *handle)
tmr = handle;
if (!tmr)
return -EINVAL;
if (ioctl(tmr->fd, SND_TIMER_IOCTL_START) < 0)
if (ioctl(tmr->fd, SNDRV_TIMER_IOCTL_START) < 0)
return -errno;
return 0;
}
@ -164,7 +164,7 @@ int snd_timer_stop(snd_timer_t *handle)
tmr = handle;
if (!tmr)
return -EINVAL;
if (ioctl(tmr->fd, SND_TIMER_IOCTL_STOP) < 0)
if (ioctl(tmr->fd, SNDRV_TIMER_IOCTL_STOP) < 0)
return -errno;
return 0;
}
@ -176,7 +176,7 @@ int snd_timer_continue(snd_timer_t *handle)
tmr = handle;
if (!tmr)
return -EINVAL;
if (ioctl(tmr->fd, SND_TIMER_IOCTL_CONTINUE) < 0)
if (ioctl(tmr->fd, SNDRV_TIMER_IOCTL_CONTINUE) < 0)
return -errno;
return 0;
}