#include <sys/un.h>
#include <sys/uio.h>
#include <stdio.h>
-#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
-#include <assert.h>
#include <stddef.h>
#include <getopt.h>
#include <netinet/in.h>
#include <netdb.h>
#include <limits.h>
-#include "asoundlib.h"
#include "aserver.h"
#include "list.h"
snd_pcm_t *pcm;
int err;
int result;
- err = snd_pcm_open(&pcm, client->name, client->stream, SND_PCM_NONBLOCK);
+ err = snd_pcm_open(&pcm, client->name, snd_int_to_enum(client->stream), SND_PCM_NONBLOCK);
if (err < 0)
return err;
client->device.pcm.handle = pcm;
- client->device.pcm.fd = snd_pcm_poll_descriptor(pcm);
+ client->device.pcm.fd = _snd_pcm_poll_descriptor(pcm);
shmid = shmget(IPC_PRIVATE, PCM_SHM_SIZE, 0666);
if (shmid < 0) {
ctrl->cmd = 0;
pcm = client->device.pcm.handle;
switch (cmd) {
- case SND_PCM_IOCTL_CARD:
- ctrl->result = snd_pcm_card(pcm);
- break;
case SND_PCM_IOCTL_ASYNC:
ctrl->result = snd_pcm_async(pcm, ctrl->u.async.sig, ctrl->u.async.pid);
break;
- case SND_PCM_IOCTL_INFO:
+ case SNDRV_PCM_IOCTL_INFO:
ctrl->result = snd_pcm_info(pcm, (snd_pcm_info_t *) &ctrl->u.info);
break;
- case SND_PCM_IOCTL_HW_REFINE:
+ case SNDRV_PCM_IOCTL_HW_REFINE:
ctrl->result = snd_pcm_hw_refine(pcm, (snd_pcm_hw_params_t *) &ctrl->u.hw_refine);
break;
- case SND_PCM_IOCTL_HW_PARAMS:
+ case SNDRV_PCM_IOCTL_HW_PARAMS:
ctrl->result = snd_pcm_hw_params(pcm, (snd_pcm_hw_params_t *) &ctrl->u.hw_params);
break;
- case SND_PCM_IOCTL_SW_PARAMS:
+ case SNDRV_PCM_IOCTL_HW_FREE:
+ ctrl->result = snd_pcm_hw_free(pcm);
+ break;
+ case SNDRV_PCM_IOCTL_SW_PARAMS:
ctrl->result = snd_pcm_sw_params(pcm, (snd_pcm_sw_params_t *) &ctrl->u.sw_params);
break;
- case SND_PCM_IOCTL_STATUS:
+ case SNDRV_PCM_IOCTL_STATUS:
ctrl->result = snd_pcm_status(pcm, (snd_pcm_status_t *) &ctrl->u.status);
break;
case SND_PCM_IOCTL_STATE:
- ctrl->result = snd_pcm_state(pcm);
+ ctrl->result = snd_enum_to_int(snd_pcm_state(pcm));
break;
- case SND_PCM_IOCTL_DELAY:
- ctrl->result = snd_pcm_delay(pcm, (ssize_t *) &ctrl->u.delay.frames);
+ case SNDRV_PCM_IOCTL_DELAY:
+ ctrl->result = snd_pcm_delay(pcm, (snd_pcm_sframes_t *) &ctrl->u.delay.frames);
break;
case SND_PCM_IOCTL_AVAIL_UPDATE:
ctrl->result = snd_pcm_avail_update(pcm);
ctrl->hw_ptr = *pcm->hw_ptr;
break;
- case SND_PCM_IOCTL_PREPARE:
+ case SNDRV_PCM_IOCTL_PREPARE:
ctrl->result = snd_pcm_prepare(pcm);
ctrl->appl_ptr = *pcm->appl_ptr;
ctrl->hw_ptr = *pcm->hw_ptr;
break;
- case SND_PCM_IOCTL_RESET:
+ case SNDRV_PCM_IOCTL_RESET:
ctrl->result = snd_pcm_reset(pcm);
ctrl->appl_ptr = *pcm->appl_ptr;
ctrl->hw_ptr = *pcm->hw_ptr;
break;
- case SND_PCM_IOCTL_START:
+ case SNDRV_PCM_IOCTL_START:
ctrl->result = snd_pcm_start(pcm);
ctrl->appl_ptr = *pcm->appl_ptr;
ctrl->hw_ptr = *pcm->hw_ptr;
break;
- case SND_PCM_IOCTL_DRAIN:
+ case SNDRV_PCM_IOCTL_DRAIN:
ctrl->result = snd_pcm_drain(pcm);
break;
- case SND_PCM_IOCTL_DROP:
+ case SNDRV_PCM_IOCTL_DROP:
ctrl->result = snd_pcm_drop(pcm);
break;
- case SND_PCM_IOCTL_PAUSE:
+ case SNDRV_PCM_IOCTL_PAUSE:
ctrl->result = snd_pcm_pause(pcm, ctrl->u.pause.enable);
break;
- case SND_PCM_IOCTL_CHANNEL_INFO:
+ case SNDRV_PCM_IOCTL_CHANNEL_INFO:
ctrl->result = snd_pcm_channel_info(pcm, (snd_pcm_channel_info_t *) &ctrl->u.channel_info);
if (ctrl->result >= 0 &&
ctrl->u.channel_info.type == SND_PCM_AREA_MMAP)
return shm_ack_fd(client, ctrl->u.channel_info.u.mmap.fd);
break;
- case SND_PCM_IOCTL_REWIND:
+ case SNDRV_PCM_IOCTL_REWIND:
ctrl->result = snd_pcm_rewind(pcm, ctrl->u.rewind.frames);
ctrl->appl_ptr = *pcm->appl_ptr;
break;
- case SND_PCM_IOCTL_LINK:
+ case SNDRV_PCM_IOCTL_LINK:
{
/* FIXME */
ctrl->result = -ENOSYS;
break;
}
- case SND_PCM_IOCTL_UNLINK:
+ case SNDRV_PCM_IOCTL_UNLINK:
ctrl->result = snd_pcm_unlink(pcm);
break;
case SND_PCM_IOCTL_MMAP:
break;
case SND_PCM_IOCTL_POLL_DESCRIPTOR:
ctrl->result = 0;
- return shm_ack_fd(client, snd_pcm_poll_descriptor(pcm));
+ return shm_ack_fd(client, _snd_pcm_poll_descriptor(pcm));
case SND_PCM_IOCTL_CLOSE:
client->ops->close(client);
break;
snd_ctl_t *ctl;
int err;
int result;
- err = snd_ctl_open(&ctl, client->name);
+ err = snd_ctl_open(&ctl, client->name, SND_CTL_NONBLOCK);
if (err < 0)
return err;
client->device.control.handle = ctl;
- client->device.control.fd = snd_ctl_poll_descriptor(ctl);
+ client->device.control.fd = _snd_ctl_poll_descriptor(ctl);
shmid = shmget(IPC_PRIVATE, CTL_SHM_SIZE, 0666);
if (shmid < 0) {
return 0;
}
-extern int snd_ctl_read1(snd_ctl_t *ctl, snd_ctl_event_t *event);
-
int ctl_shm_cmd(client_t *client)
{
snd_ctl_shm_ctrl_t *ctrl = client->transport.shm.ctrl;
ctrl->cmd = 0;
ctl = client->device.control.handle;
switch (cmd) {
- case SND_CTL_IOCTL_HW_INFO:
- ctrl->result = snd_ctl_hw_info(ctl, &ctrl->u.hw_info);
+ case SND_CTL_IOCTL_ASYNC:
+ ctrl->result = snd_ctl_async(ctl, ctrl->u.async.sig, ctrl->u.async.pid);
+ break;
+ case SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS:
+ ctrl->result = snd_ctl_subscribe_events(ctl, ctrl->u.subscribe_events);
break;
- case SND_CTL_IOCTL_CONTROL_LIST:
+ case SNDRV_CTL_IOCTL_CARD_INFO:
+ ctrl->result = snd_ctl_card_info(ctl, &ctrl->u.card_info);
+ break;
+ case SNDRV_CTL_IOCTL_ELEM_LIST:
{
size_t maxsize = CTL_SHM_DATA_MAXLEN;
- if (ctrl->u.clist.controls_request * sizeof(*ctrl->u.clist.pids) > maxsize) {
+ if (ctrl->u.element_list.space * sizeof(*ctrl->u.element_list.pids) > maxsize) {
ctrl->result = -EFAULT;
break;
}
- ctrl->u.clist.pids = (snd_control_id_t*) ctrl->data;
- ctrl->result = snd_ctl_clist(ctl, &ctrl->u.clist);
+ ctrl->u.element_list.pids = (snd_ctl_elem_id_t*) ctrl->data;
+ ctrl->result = snd_ctl_elem_list(ctl, &ctrl->u.element_list);
break;
}
- case SND_CTL_IOCTL_CONTROL_INFO:
- ctrl->result = snd_ctl_cinfo(ctl, &ctrl->u.cinfo);
+ case SNDRV_CTL_IOCTL_ELEM_INFO:
+ ctrl->result = snd_ctl_elem_info(ctl, &ctrl->u.element_info);
break;
- case SND_CTL_IOCTL_CONTROL_READ:
- ctrl->result = snd_ctl_cread(ctl, &ctrl->u.cread);
+ case SNDRV_CTL_IOCTL_ELEM_READ:
+ ctrl->result = snd_ctl_elem_read(ctl, &ctrl->u.element_read);
break;
- case SND_CTL_IOCTL_CONTROL_WRITE:
- ctrl->result = snd_ctl_cwrite(ctl, &ctrl->u.cwrite);
+ case SNDRV_CTL_IOCTL_ELEM_WRITE:
+ ctrl->result = snd_ctl_elem_write(ctl, &ctrl->u.element_write);
break;
- case SND_CTL_IOCTL_HWDEP_NEXT_DEVICE:
+ case SNDRV_CTL_IOCTL_HWDEP_NEXT_DEVICE:
ctrl->result = snd_ctl_hwdep_next_device(ctl, &ctrl->u.device);
break;
- case SND_CTL_IOCTL_HWDEP_INFO:
+ case SNDRV_CTL_IOCTL_HWDEP_INFO:
ctrl->result = snd_ctl_hwdep_info(ctl, &ctrl->u.hwdep_info);
break;
- case SND_CTL_IOCTL_PCM_NEXT_DEVICE:
+ case SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE:
ctrl->result = snd_ctl_pcm_next_device(ctl, &ctrl->u.device);
break;
- case SND_CTL_IOCTL_PCM_INFO:
+ case SNDRV_CTL_IOCTL_PCM_INFO:
ctrl->result = snd_ctl_pcm_info(ctl, &ctrl->u.pcm_info);
break;
- case SND_CTL_IOCTL_PCM_PREFER_SUBDEVICE:
+ case SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE:
ctrl->result = snd_ctl_pcm_prefer_subdevice(ctl, ctrl->u.pcm_prefer_subdevice);
break;
- case SND_CTL_IOCTL_RAWMIDI_NEXT_DEVICE:
+ case SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE:
ctrl->result = snd_ctl_rawmidi_next_device(ctl, &ctrl->u.device);
break;
- case SND_CTL_IOCTL_RAWMIDI_INFO:
+ case SNDRV_CTL_IOCTL_RAWMIDI_INFO:
ctrl->result = snd_ctl_rawmidi_info(ctl, &ctrl->u.rawmidi_info);
break;
- case SND_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE:
+ case SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE:
ctrl->result = snd_ctl_rawmidi_prefer_subdevice(ctl, ctrl->u.rawmidi_prefer_subdevice);
break;
case SND_CTL_IOCTL_READ:
- ctrl->result = snd_ctl_read1(ctl, &ctrl->u.read);
+ ctrl->result = snd_ctl_read(ctl, &ctrl->u.read);
break;
case SND_CTL_IOCTL_CLOSE:
client->ops->close(client);
break;
- case SND_CTL_IOCTL_CARD:
- ctrl->result = snd_ctl_card(ctl);
- break;
case SND_CTL_IOCTL_POLL_DESCRIPTOR:
ctrl->result = 0;
- return shm_ack_fd(client, snd_ctl_poll_descriptor(ctl));
+ return shm_ack_fd(client, _snd_ctl_poll_descriptor(ctl));
default:
ERROR("Bogus cmd: %x", ctrl->cmd);
ctrl->result = -ENOSYS;
return 0;
}
-int server(char *sockname, int port)
+int server(const char *sockname, int port)
{
int err;
unsigned int k;
};
int c;
snd_config_t *conf;
- snd_config_iterator_t i;
- char *socket = NULL;
- char *host = NULL;
+ snd_config_iterator_t i, next;
+ const char *socket = NULL;
+ const char *host = NULL;
long port = -1;
int err;
char *srvname;
return 1;
}
srvname = argv[optind];
- err = snd_config_searchv(snd_config, &conf, "server", srvname, 0);
+ err = snd_config_search_alias(snd_config, "server", srvname, &conf);
if (err < 0) {
ERROR("Missing definition for server %s", srvname);
return 1;
}
- snd_config_foreach(i, conf) {
- snd_config_t *n = snd_config_entry(i);
- if (strcmp(n->id, "comment") == 0)
+ if (snd_config_get_type(conf) != SND_CONFIG_TYPE_COMPOUND) {
+ SNDERR("Invalid type for server %s definition", srvname);
+ return -EINVAL;
+ }
+ snd_config_for_each(i, next, conf) {
+ snd_config_t *n = snd_config_iterator_entry(i);
+ const char *id = snd_config_get_id(n);
+ if (strcmp(id, "comment") == 0)
continue;
- if (strcmp(n->id, "host") == 0) {
- err = snd_config_string_get(n, &host);
+ if (strcmp(id, "host") == 0) {
+ err = snd_config_get_string(n, &host);
if (err < 0) {
- ERROR("Invalid type for %s", n->id);
+ ERROR("Invalid type for %s", id);
return 1;
}
continue;
}
- if (strcmp(n->id, "socket") == 0) {
- err = snd_config_string_get(n, &socket);
+ if (strcmp(id, "socket") == 0) {
+ err = snd_config_get_string(n, &socket);
if (err < 0) {
- ERROR("Invalid type for %s", n->id);
+ ERROR("Invalid type for %s", id);
return 1;
}
continue;
}
- if (strcmp(n->id, "port") == 0) {
- err = snd_config_integer_get(n, &port);
+ if (strcmp(id, "port") == 0) {
+ err = snd_config_get_integer(n, &port);
if (err < 0) {
- ERROR("Invalid type for %s", n->id);
+ ERROR("Invalid type for %s", id);
return 1;
}
continue;
}
- ERROR("Unknown field %s", n->id);
+ ERROR("Unknown field %s", id);
return 1;
}
if (!host) {
OSDN Git Service
