|
Packit |
4a16fb |
/*
|
|
Packit |
4a16fb |
* PCM - Direct Stream Mixing
|
|
Packit |
4a16fb |
* Copyright (c) 2003 by Jaroslav Kysela <perex@perex.cz>
|
|
Packit |
4a16fb |
*
|
|
Packit |
4a16fb |
*
|
|
Packit |
4a16fb |
* This library is free software; you can redistribute it and/or modify
|
|
Packit |
4a16fb |
* it under the terms of the GNU Lesser General Public License as
|
|
Packit |
4a16fb |
* published by the Free Software Foundation; either version 2.1 of
|
|
Packit |
4a16fb |
* the License, or (at your option) any later version.
|
|
Packit |
4a16fb |
*
|
|
Packit |
4a16fb |
* This program is distributed in the hope that it will be useful,
|
|
Packit |
4a16fb |
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
Packit |
4a16fb |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
Packit |
4a16fb |
* GNU Lesser General Public License for more details.
|
|
Packit |
4a16fb |
*
|
|
Packit |
4a16fb |
* You should have received a copy of the GNU Lesser General Public
|
|
Packit |
4a16fb |
* License along with this library; if not, write to the Free Software
|
|
Packit |
4a16fb |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
Packit |
4a16fb |
*
|
|
Packit |
4a16fb |
*/
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
#include <stdio.h>
|
|
Packit |
4a16fb |
#include <stdlib.h>
|
|
Packit |
4a16fb |
#include <stddef.h>
|
|
Packit |
4a16fb |
#include <unistd.h>
|
|
Packit |
4a16fb |
#include <signal.h>
|
|
Packit |
4a16fb |
#include <string.h>
|
|
Packit |
4a16fb |
#include <fcntl.h>
|
|
Packit |
4a16fb |
#include <ctype.h>
|
|
Packit |
4a16fb |
#include <grp.h>
|
|
Packit |
4a16fb |
#include <sys/ioctl.h>
|
|
Packit |
4a16fb |
#include <sys/mman.h>
|
|
Packit |
4a16fb |
#include <poll.h>
|
|
Packit |
4a16fb |
#include <sys/shm.h>
|
|
Packit |
4a16fb |
#include <sys/sem.h>
|
|
Packit |
4a16fb |
#include <sys/wait.h>
|
|
Packit |
4a16fb |
#include <sys/socket.h>
|
|
Packit |
4a16fb |
#include <sys/stat.h>
|
|
Packit |
4a16fb |
#include <sys/un.h>
|
|
Packit |
4a16fb |
#include <sys/mman.h>
|
|
Packit |
4a16fb |
#include "pcm_direct.h"
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
/*
|
|
Packit |
4a16fb |
*
|
|
Packit |
4a16fb |
*/
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
union semun {
|
|
Packit |
4a16fb |
int val; /* Value for SETVAL */
|
|
Packit |
4a16fb |
struct semid_ds *buf; /* Buffer for IPC_STAT, IPC_SET */
|
|
Packit |
4a16fb |
unsigned short *array; /* Array for GETALL, SETALL */
|
|
Packit |
4a16fb |
struct seminfo *__buf; /* Buffer for IPC_INFO (Linux specific) */
|
|
Packit |
4a16fb |
};
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
/*
|
|
Packit |
4a16fb |
* FIXME:
|
|
Packit |
4a16fb |
* add possibility to use futexes here
|
|
Packit |
4a16fb |
*/
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
int snd_pcm_direct_semaphore_create_or_connect(snd_pcm_direct_t *dmix)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
union semun s;
|
|
Packit |
4a16fb |
struct semid_ds buf;
|
|
Packit |
4a16fb |
int i;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
dmix->semid = semget(dmix->ipc_key, DIRECT_IPC_SEMS,
|
|
Packit |
4a16fb |
IPC_CREAT | dmix->ipc_perm);
|
|
Packit |
4a16fb |
if (dmix->semid < 0)
|
|
Packit |
4a16fb |
return -errno;
|
|
Packit |
4a16fb |
if (dmix->ipc_gid < 0)
|
|
Packit |
4a16fb |
return 0;
|
|
Packit |
4a16fb |
for (i = 0; i < DIRECT_IPC_SEMS; i++) {
|
|
Packit |
4a16fb |
s.buf = &buf;
|
|
Packit |
4a16fb |
if (semctl(dmix->semid, i, IPC_STAT, s) < 0) {
|
|
Packit |
4a16fb |
int err = -errno;
|
|
Packit |
4a16fb |
snd_pcm_direct_semaphore_discard(dmix);
|
|
Packit |
4a16fb |
return err;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
buf.sem_perm.gid = dmix->ipc_gid;
|
|
Packit |
4a16fb |
s.buf = &buf;
|
|
Packit |
4a16fb |
semctl(dmix->semid, i, IPC_SET, s);
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
return 0;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
#define SND_PCM_DIRECT_MAGIC (0xa15ad300 + sizeof(snd_pcm_direct_share_t))
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
/*
|
|
Packit |
4a16fb |
* global shared memory area
|
|
Packit |
4a16fb |
*/
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
int snd_pcm_direct_shm_create_or_connect(snd_pcm_direct_t *dmix)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
struct shmid_ds buf;
|
|
Packit |
4a16fb |
int tmpid, err, first_instance = 0;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
retryget:
|
|
Packit |
4a16fb |
dmix->shmid = shmget(dmix->ipc_key, sizeof(snd_pcm_direct_share_t),
|
|
Packit |
4a16fb |
dmix->ipc_perm);
|
|
Packit |
4a16fb |
if (dmix->shmid < 0 && errno == ENOENT) {
|
|
Packit |
4a16fb |
if ((dmix->shmid = shmget(dmix->ipc_key, sizeof(snd_pcm_direct_share_t),
|
|
Packit |
4a16fb |
IPC_CREAT | IPC_EXCL | dmix->ipc_perm)) != -1)
|
|
Packit |
4a16fb |
first_instance = 1;
|
|
Packit |
4a16fb |
else if (errno == EEXIST)
|
|
Packit |
4a16fb |
goto retryget;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
err = -errno;
|
|
Packit |
4a16fb |
if (dmix->shmid < 0) {
|
|
Packit |
4a16fb |
if (errno == EINVAL)
|
|
Packit |
4a16fb |
if ((tmpid = shmget(dmix->ipc_key, 0, dmix->ipc_perm)) != -1)
|
|
Packit |
4a16fb |
if (!shmctl(tmpid, IPC_STAT, &buf))
|
|
Packit |
4a16fb |
if (!buf.shm_nattch)
|
|
Packit |
4a16fb |
/* no users so destroy the segment */
|
|
Packit |
4a16fb |
if (!shmctl(tmpid, IPC_RMID, NULL))
|
|
Packit |
4a16fb |
goto retryget;
|
|
Packit |
4a16fb |
return err;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
dmix->shmptr = shmat(dmix->shmid, 0, 0);
|
|
Packit |
4a16fb |
if (dmix->shmptr == (void *) -1) {
|
|
Packit |
4a16fb |
err = -errno;
|
|
Packit |
4a16fb |
snd_pcm_direct_shm_discard(dmix);
|
|
Packit |
4a16fb |
return err;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
mlock(dmix->shmptr, sizeof(snd_pcm_direct_share_t));
|
|
Packit |
4a16fb |
if (shmctl(dmix->shmid, IPC_STAT, &buf) < 0) {
|
|
Packit |
4a16fb |
err = -errno;
|
|
Packit |
4a16fb |
snd_pcm_direct_shm_discard(dmix);
|
|
Packit |
4a16fb |
return err;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (first_instance) { /* we're the first user, clear the segment */
|
|
Packit |
4a16fb |
memset(dmix->shmptr, 0, sizeof(snd_pcm_direct_share_t));
|
|
Packit |
4a16fb |
if (dmix->ipc_gid >= 0) {
|
|
Packit |
4a16fb |
buf.shm_perm.gid = dmix->ipc_gid;
|
|
Packit |
4a16fb |
shmctl(dmix->shmid, IPC_SET, &buf;;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
dmix->shmptr->magic = SND_PCM_DIRECT_MAGIC;
|
|
Packit |
4a16fb |
return 1;
|
|
Packit |
4a16fb |
} else {
|
|
Packit |
4a16fb |
if (dmix->shmptr->magic != SND_PCM_DIRECT_MAGIC) {
|
|
Packit |
4a16fb |
snd_pcm_direct_shm_discard(dmix);
|
|
Packit |
4a16fb |
return -EINVAL;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
return 0;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
/* discard shared memory */
|
|
Packit |
4a16fb |
/*
|
|
Packit |
4a16fb |
* Define snd_* functions to be used in server.
|
|
Packit |
4a16fb |
* Since objects referred in a plugin can be released dynamically, a forked
|
|
Packit |
4a16fb |
* server should have statically linked functions.
|
|
Packit |
4a16fb |
* (e.g. Novell bugzilla #105772)
|
|
Packit |
4a16fb |
*/
|
|
Packit |
4a16fb |
static int _snd_pcm_direct_shm_discard(snd_pcm_direct_t *dmix)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
struct shmid_ds buf;
|
|
Packit |
4a16fb |
int ret = 0;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
if (dmix->shmid < 0)
|
|
Packit |
4a16fb |
return -EINVAL;
|
|
Packit |
4a16fb |
if (dmix->shmptr != (void *) -1 && shmdt(dmix->shmptr) < 0)
|
|
Packit |
4a16fb |
return -errno;
|
|
Packit |
4a16fb |
dmix->shmptr = (void *) -1;
|
|
Packit |
4a16fb |
if (shmctl(dmix->shmid, IPC_STAT, &buf) < 0)
|
|
Packit |
4a16fb |
return -errno;
|
|
Packit |
4a16fb |
if (buf.shm_nattch == 0) { /* we're the last user, destroy the segment */
|
|
Packit |
4a16fb |
if (shmctl(dmix->shmid, IPC_RMID, NULL) < 0)
|
|
Packit |
4a16fb |
return -errno;
|
|
Packit |
4a16fb |
ret = 1;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
dmix->shmid = -1;
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
/* ... and an exported version */
|
|
Packit |
4a16fb |
int snd_pcm_direct_shm_discard(snd_pcm_direct_t *dmix)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
return _snd_pcm_direct_shm_discard(dmix);
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
/*
|
|
Packit |
4a16fb |
* server side
|
|
Packit |
4a16fb |
*/
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
static int get_tmp_name(char *filename, size_t size)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
struct timeval tv;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
gettimeofday(&tv, NULL);
|
|
Packit |
4a16fb |
snprintf(filename, size, TMPDIR "/alsa-dmix-%i-%li-%li", (int)getpid(), (long)tv.tv_sec, (long)tv.tv_usec);
|
|
Packit |
4a16fb |
filename[size-1] = '\0';
|
|
Packit |
4a16fb |
return 0;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
static int make_local_socket(const char *filename, int server, mode_t ipc_perm, int ipc_gid)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
size_t l = strlen(filename);
|
|
Packit |
4a16fb |
size_t size = offsetof(struct sockaddr_un, sun_path) + l;
|
|
Packit |
4a16fb |
struct sockaddr_un *addr = alloca(size);
|
|
Packit |
4a16fb |
int sock;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
sock = socket(PF_LOCAL, SOCK_STREAM, 0);
|
|
Packit |
4a16fb |
if (sock < 0) {
|
|
Packit |
4a16fb |
int result = -errno;
|
|
Packit |
4a16fb |
SYSERR("socket failed");
|
|
Packit |
4a16fb |
return result;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
if (server)
|
|
Packit |
4a16fb |
unlink(filename);
|
|
Packit |
4a16fb |
memset(addr, 0, size); /* make valgrind happy */
|
|
Packit |
4a16fb |
addr->sun_family = AF_LOCAL;
|
|
Packit |
4a16fb |
memcpy(addr->sun_path, filename, l);
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
if (server) {
|
|
Packit |
4a16fb |
if (bind(sock, (struct sockaddr *) addr, size) < 0) {
|
|
Packit |
4a16fb |
int result = -errno;
|
|
Packit |
4a16fb |
SYSERR("bind failed: %s", filename);
|
|
Packit |
4a16fb |
close(sock);
|
|
Packit |
4a16fb |
return result;
|
|
Packit |
4a16fb |
} else {
|
|
Packit |
4a16fb |
if (chmod(filename, ipc_perm) < 0) {
|
|
Packit |
4a16fb |
int result = -errno;
|
|
Packit |
4a16fb |
SYSERR("chmod failed: %s", filename);
|
|
Packit |
4a16fb |
close(sock);
|
|
Packit |
4a16fb |
unlink(filename);
|
|
Packit |
4a16fb |
return result;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (chown(filename, -1, ipc_gid) < 0) {
|
|
Packit |
4a16fb |
#if 0 /* it's not fatal */
|
|
Packit |
4a16fb |
int result = -errno;
|
|
Packit |
4a16fb |
SYSERR("chown failed: %s", filename);
|
|
Packit |
4a16fb |
close(sock);
|
|
Packit |
4a16fb |
unlink(filename);
|
|
Packit |
4a16fb |
return result;
|
|
Packit |
4a16fb |
#endif
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
} else {
|
|
Packit |
4a16fb |
if (connect(sock, (struct sockaddr *) addr, size) < 0) {
|
|
Packit |
4a16fb |
int result = -errno;
|
|
Packit |
4a16fb |
SYSERR("connect failed: %s", filename);
|
|
Packit |
4a16fb |
close(sock);
|
|
Packit |
4a16fb |
return result;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
return sock;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
#if 0
|
|
Packit |
4a16fb |
#define SERVER_JOB_DEBUG
|
|
Packit |
4a16fb |
#define server_printf(fmt, args...) printf(fmt, ##args)
|
|
Packit |
4a16fb |
#else
|
|
Packit |
4a16fb |
#undef SERVER_JOB_DEBUG
|
|
Packit |
4a16fb |
#define server_printf(fmt, args...) /* nothing */
|
|
Packit |
4a16fb |
#endif
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
static snd_pcm_direct_t *server_job_dmix;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
static void server_cleanup(snd_pcm_direct_t *dmix)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
close(dmix->server_fd);
|
|
Packit |
4a16fb |
close(dmix->hw_fd);
|
|
Packit |
4a16fb |
if (dmix->server_free)
|
|
Packit |
4a16fb |
dmix->server_free(dmix);
|
|
Packit |
4a16fb |
unlink(dmix->shmptr->socket_name);
|
|
Packit |
4a16fb |
_snd_pcm_direct_shm_discard(dmix);
|
|
Packit |
4a16fb |
snd_pcm_direct_semaphore_discard(dmix);
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
static void server_job_signal(int sig ATTRIBUTE_UNUSED)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
snd_pcm_direct_semaphore_down(server_job_dmix, DIRECT_IPC_SEM_CLIENT);
|
|
Packit |
4a16fb |
server_cleanup(server_job_dmix);
|
|
Packit |
4a16fb |
server_printf("DIRECT SERVER EXIT - SIGNAL\n");
|
|
Packit |
4a16fb |
_exit(EXIT_SUCCESS);
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
/* This is a copy from ../socket.c, provided here only for a server job
|
|
Packit |
4a16fb |
* (see the comment above)
|
|
Packit |
4a16fb |
*/
|
|
Packit |
4a16fb |
static int _snd_send_fd(int sock, void *data, size_t len, int fd)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
int ret;
|
|
Packit |
4a16fb |
size_t cmsg_len = CMSG_LEN(sizeof(int));
|
|
Packit |
4a16fb |
struct cmsghdr *cmsg = alloca(cmsg_len);
|
|
Packit |
4a16fb |
int *fds = (int *) CMSG_DATA(cmsg);
|
|
Packit |
4a16fb |
struct msghdr msghdr;
|
|
Packit |
4a16fb |
struct iovec vec;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
vec.iov_base = (void *)&dat;;
|
|
Packit |
4a16fb |
vec.iov_len = len;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
cmsg->cmsg_len = cmsg_len;
|
|
Packit |
4a16fb |
cmsg->cmsg_level = SOL_SOCKET;
|
|
Packit |
4a16fb |
cmsg->cmsg_type = SCM_RIGHTS;
|
|
Packit |
4a16fb |
*fds = fd;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
msghdr.msg_name = NULL;
|
|
Packit |
4a16fb |
msghdr.msg_namelen = 0;
|
|
Packit |
4a16fb |
msghdr.msg_iov = &vec;
|
|
Packit |
4a16fb |
msghdr.msg_iovlen = 1;
|
|
Packit |
4a16fb |
msghdr.msg_control = cmsg;
|
|
Packit |
4a16fb |
msghdr.msg_controllen = cmsg_len;
|
|
Packit |
4a16fb |
msghdr.msg_flags = 0;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
ret = sendmsg(sock, &msghdr, 0 );
|
|
Packit |
4a16fb |
if (ret < 0)
|
|
Packit |
4a16fb |
return -errno;
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
static void server_job(snd_pcm_direct_t *dmix)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
int ret, sck, i;
|
|
Packit |
4a16fb |
int max = 128, current = 0;
|
|
Packit |
4a16fb |
struct pollfd pfds[max + 1];
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
server_job_dmix = dmix;
|
|
Packit |
4a16fb |
/* don't allow to be killed */
|
|
Packit |
4a16fb |
signal(SIGHUP, server_job_signal);
|
|
Packit |
4a16fb |
signal(SIGQUIT, server_job_signal);
|
|
Packit |
4a16fb |
signal(SIGTERM, server_job_signal);
|
|
Packit |
4a16fb |
signal(SIGKILL, server_job_signal);
|
|
Packit |
4a16fb |
/* close all files to free resources */
|
|
Packit |
4a16fb |
i = sysconf(_SC_OPEN_MAX);
|
|
Packit |
4a16fb |
#ifdef SERVER_JOB_DEBUG
|
|
Packit |
4a16fb |
while (--i >= 3) {
|
|
Packit |
4a16fb |
#else
|
|
Packit |
4a16fb |
while (--i >= 0) {
|
|
Packit |
4a16fb |
#endif
|
|
Packit |
4a16fb |
if (i != dmix->server_fd && i != dmix->hw_fd)
|
|
Packit |
4a16fb |
close(i);
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
/* detach from parent */
|
|
Packit |
4a16fb |
setsid();
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
pfds[0].fd = dmix->server_fd;
|
|
Packit |
4a16fb |
pfds[0].events = POLLIN | POLLERR | POLLHUP;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
server_printf("DIRECT SERVER STARTED\n");
|
|
Packit |
4a16fb |
while (1) {
|
|
Packit |
4a16fb |
ret = poll(pfds, current + 1, 500);
|
|
Packit |
4a16fb |
server_printf("DIRECT SERVER: poll ret = %i, revents[0] = 0x%x, errno = %i\n", ret, pfds[0].revents, errno);
|
|
Packit |
4a16fb |
if (ret < 0) {
|
|
Packit |
4a16fb |
if (errno == EINTR)
|
|
Packit |
4a16fb |
continue;
|
|
Packit |
4a16fb |
/* some error */
|
|
Packit |
4a16fb |
break;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (ret == 0 || (pfds[0].revents & (POLLERR | POLLHUP))) { /* timeout or error? */
|
|
Packit |
4a16fb |
struct shmid_ds buf;
|
|
Packit |
4a16fb |
snd_pcm_direct_semaphore_down(dmix, DIRECT_IPC_SEM_CLIENT);
|
|
Packit |
4a16fb |
if (shmctl(dmix->shmid, IPC_STAT, &buf) < 0) {
|
|
Packit |
4a16fb |
_snd_pcm_direct_shm_discard(dmix);
|
|
Packit |
4a16fb |
snd_pcm_direct_semaphore_up(dmix, DIRECT_IPC_SEM_CLIENT);
|
|
Packit |
4a16fb |
continue;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
server_printf("DIRECT SERVER: nattch = %i\n", (int)buf.shm_nattch);
|
|
Packit |
4a16fb |
if (buf.shm_nattch == 1) /* server is the last user, exit */
|
|
Packit |
4a16fb |
break;
|
|
Packit |
4a16fb |
snd_pcm_direct_semaphore_up(dmix, DIRECT_IPC_SEM_CLIENT);
|
|
Packit |
4a16fb |
continue;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (pfds[0].revents & POLLIN) {
|
|
Packit |
4a16fb |
ret--;
|
|
Packit |
4a16fb |
sck = accept(dmix->server_fd, 0, 0);
|
|
Packit |
4a16fb |
if (sck >= 0) {
|
|
Packit |
4a16fb |
server_printf("DIRECT SERVER: new connection %i\n", sck);
|
|
Packit |
4a16fb |
if (current == max) {
|
|
Packit |
4a16fb |
close(sck);
|
|
Packit |
4a16fb |
} else {
|
|
Packit |
4a16fb |
unsigned char buf = 'A';
|
|
Packit |
4a16fb |
pfds[current+1].fd = sck;
|
|
Packit |
4a16fb |
pfds[current+1].events = POLLIN | POLLERR | POLLHUP;
|
|
Packit |
4a16fb |
_snd_send_fd(sck, &buf, 1, dmix->hw_fd);
|
|
Packit |
4a16fb |
server_printf("DIRECT SERVER: fd sent ok\n");
|
|
Packit |
4a16fb |
current++;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
for (i = 0; i < current && ret > 0; i++) {
|
|
Packit |
4a16fb |
struct pollfd *pfd = &pfds[i+1];
|
|
Packit |
4a16fb |
unsigned char cmd;
|
|
Packit |
4a16fb |
server_printf("client %i revents = 0x%x\n", pfd->fd, pfd->revents);
|
|
Packit |
4a16fb |
if (pfd->revents & (POLLERR | POLLHUP)) {
|
|
Packit |
4a16fb |
ret--;
|
|
Packit |
4a16fb |
close(pfd->fd);
|
|
Packit |
4a16fb |
pfd->fd = -1;
|
|
Packit |
4a16fb |
continue;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (!(pfd->revents & POLLIN))
|
|
Packit |
4a16fb |
continue;
|
|
Packit |
4a16fb |
ret--;
|
|
Packit |
4a16fb |
if (read(pfd->fd, &cmd, 1) == 1)
|
|
Packit |
4a16fb |
cmd = 0 /*process command */;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
for (i = 0; i < current; i++) {
|
|
Packit |
4a16fb |
if (pfds[i+1].fd < 0) {
|
|
Packit |
4a16fb |
if (i + 1 != max)
|
|
Packit |
4a16fb |
memcpy(&pfds[i+1], &pfds[i+2], sizeof(struct pollfd) * (max - i - 1));
|
|
Packit |
4a16fb |
current--;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
server_cleanup(dmix);
|
|
Packit |
4a16fb |
server_printf("DIRECT SERVER EXIT\n");
|
|
Packit |
4a16fb |
#ifdef SERVER_JOB_DEBUG
|
|
Packit |
4a16fb |
close(0); close(1); close(2);
|
|
Packit |
4a16fb |
#endif
|
|
Packit |
4a16fb |
_exit(EXIT_SUCCESS);
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
int snd_pcm_direct_server_create(snd_pcm_direct_t *dmix)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
int ret;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
dmix->server_fd = -1;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
ret = get_tmp_name(dmix->shmptr->socket_name, sizeof(dmix->shmptr->socket_name));
|
|
Packit |
4a16fb |
if (ret < 0)
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
ret = make_local_socket(dmix->shmptr->socket_name, 1, dmix->ipc_perm, dmix->ipc_gid);
|
|
Packit |
4a16fb |
if (ret < 0)
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
dmix->server_fd = ret;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
ret = listen(dmix->server_fd, 4);
|
|
Packit |
4a16fb |
if (ret < 0) {
|
|
Packit |
4a16fb |
close(dmix->server_fd);
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
ret = fork();
|
|
Packit |
4a16fb |
if (ret < 0) {
|
|
Packit |
4a16fb |
close(dmix->server_fd);
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
} else if (ret == 0) {
|
|
Packit |
4a16fb |
ret = fork();
|
|
Packit |
4a16fb |
if (ret == 0)
|
|
Packit |
4a16fb |
server_job(dmix);
|
|
Packit |
4a16fb |
_exit(EXIT_SUCCESS);
|
|
Packit |
4a16fb |
} else {
|
|
Packit |
4a16fb |
waitpid(ret, NULL, 0);
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
dmix->server_pid = ret;
|
|
Packit |
4a16fb |
dmix->server = 1;
|
|
Packit |
4a16fb |
return 0;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
int snd_pcm_direct_server_discard(snd_pcm_direct_t *dmix)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
if (dmix->server) {
|
|
Packit |
4a16fb |
//kill(dmix->server_pid, SIGTERM);
|
|
Packit |
4a16fb |
//waitpid(dmix->server_pid, NULL, 0);
|
|
Packit |
4a16fb |
dmix->server_pid = (pid_t)-1;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (dmix->server_fd > 0) {
|
|
Packit |
4a16fb |
close(dmix->server_fd);
|
|
Packit |
4a16fb |
dmix->server_fd = -1;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
dmix->server = 0;
|
|
Packit |
4a16fb |
return 0;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
/*
|
|
Packit |
4a16fb |
* client side
|
|
Packit |
4a16fb |
*/
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
int snd_pcm_direct_client_connect(snd_pcm_direct_t *dmix)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
int ret;
|
|
Packit |
4a16fb |
unsigned char buf;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
ret = make_local_socket(dmix->shmptr->socket_name, 0, -1, -1);
|
|
Packit |
4a16fb |
if (ret < 0)
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
dmix->comm_fd = ret;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
ret = snd_receive_fd(dmix->comm_fd, &buf, 1, &dmix->hw_fd);
|
|
Packit |
4a16fb |
if (ret < 1 || buf != 'A') {
|
|
Packit |
4a16fb |
close(dmix->comm_fd);
|
|
Packit |
4a16fb |
dmix->comm_fd = -1;
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
dmix->client = 1;
|
|
Packit |
4a16fb |
return 0;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
int snd_pcm_direct_client_discard(snd_pcm_direct_t *dmix)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
if (dmix->client) {
|
|
Packit |
4a16fb |
close(dmix->comm_fd);
|
|
Packit |
4a16fb |
dmix->comm_fd = -1;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
return 0;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
/*
|
|
Packit |
4a16fb |
* plugin helpers
|
|
Packit |
4a16fb |
*/
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
int snd_pcm_direct_nonblock(snd_pcm_t *pcm ATTRIBUTE_UNUSED, int nonblock ATTRIBUTE_UNUSED)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
/* value is cached for us in pcm->mode (SND_PCM_NONBLOCK flag) */
|
|
Packit |
4a16fb |
return 0;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
int snd_pcm_direct_async(snd_pcm_t *pcm, int sig, pid_t pid)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
snd_pcm_direct_t *dmix = pcm->private_data;
|
|
Packit |
4a16fb |
return snd_timer_async(dmix->timer, sig, pid);
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
/* empty the timer read queue */
|
|
Packit |
4a16fb |
int snd_pcm_direct_clear_timer_queue(snd_pcm_direct_t *dmix)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
int changed = 0;
|
|
Packit |
4a16fb |
if (dmix->timer_need_poll) {
|
|
Packit |
4a16fb |
while (poll(&dmix->timer_fd, 1, 0) > 0) {
|
|
Packit |
4a16fb |
changed++;
|
|
Packit |
4a16fb |
/* we don't need the value */
|
|
Packit |
4a16fb |
if (dmix->tread) {
|
|
Packit |
4a16fb |
snd_timer_tread_t rbuf[4];
|
|
Packit |
4a16fb |
snd_timer_read(dmix->timer, rbuf, sizeof(rbuf));
|
|
Packit |
4a16fb |
} else {
|
|
Packit |
4a16fb |
snd_timer_read_t rbuf;
|
|
Packit |
4a16fb |
snd_timer_read(dmix->timer, &rbuf, sizeof(rbuf));
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
} else {
|
|
Packit |
4a16fb |
if (dmix->tread) {
|
|
Packit |
4a16fb |
snd_timer_tread_t rbuf[4];
|
|
Packit |
4a16fb |
int len;
|
|
Packit |
4a16fb |
while ((len = snd_timer_read(dmix->timer, rbuf,
|
|
Packit |
4a16fb |
sizeof(rbuf))) > 0
|
|
Packit |
4a16fb |
&& (++changed) &&
|
|
Packit |
4a16fb |
len != sizeof(rbuf[0]))
|
|
Packit |
4a16fb |
;
|
|
Packit |
4a16fb |
} else {
|
|
Packit |
4a16fb |
snd_timer_read_t rbuf;
|
|
Packit |
4a16fb |
while (snd_timer_read(dmix->timer, &rbuf, sizeof(rbuf)) > 0)
|
|
Packit |
4a16fb |
changed++;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
return changed;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
int snd_pcm_direct_timer_stop(snd_pcm_direct_t *dmix)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
snd_timer_stop(dmix->timer);
|
|
Packit |
4a16fb |
return 0;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
/*
|
|
Packit |
4a16fb |
* Recover slave on XRUN.
|
|
Packit |
4a16fb |
* Even if direct plugins disable xrun detection, there might be an xrun
|
|
Packit |
4a16fb |
* raised directly by some drivers.
|
|
Packit |
4a16fb |
* The first client recovers slave pcm.
|
|
Packit |
4a16fb |
* Each client needs to execute sw xrun handling afterwards
|
|
Packit |
4a16fb |
*/
|
|
Packit |
4a16fb |
int snd_pcm_direct_slave_recover(snd_pcm_direct_t *direct)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
int ret;
|
|
Packit |
4a16fb |
int semerr;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
semerr = snd_pcm_direct_semaphore_down(direct,
|
|
Packit |
4a16fb |
DIRECT_IPC_SEM_CLIENT);
|
|
Packit |
4a16fb |
if (semerr < 0) {
|
|
Packit |
4a16fb |
SNDERR("SEMDOWN FAILED with err %d", semerr);
|
|
Packit |
4a16fb |
return semerr;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
if (snd_pcm_state(direct->spcm) != SND_PCM_STATE_XRUN) {
|
|
Packit |
4a16fb |
/* ignore... someone else already did recovery */
|
|
Packit |
4a16fb |
semerr = snd_pcm_direct_semaphore_up(direct,
|
|
Packit |
4a16fb |
DIRECT_IPC_SEM_CLIENT);
|
|
Packit |
4a16fb |
if (semerr < 0) {
|
|
Packit |
4a16fb |
SNDERR("SEMUP FAILED with err %d", semerr);
|
|
Packit |
4a16fb |
return semerr;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
return 0;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
ret = snd_pcm_prepare(direct->spcm);
|
|
Packit |
4a16fb |
if (ret < 0) {
|
|
Packit |
4a16fb |
SNDERR("recover: unable to prepare slave");
|
|
Packit |
4a16fb |
semerr = snd_pcm_direct_semaphore_up(direct,
|
|
Packit |
4a16fb |
DIRECT_IPC_SEM_CLIENT);
|
|
Packit |
4a16fb |
if (semerr < 0) {
|
|
Packit |
4a16fb |
SNDERR("SEMUP FAILED with err %d", semerr);
|
|
Packit |
4a16fb |
return semerr;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
if (direct->type == SND_PCM_TYPE_DSHARE) {
|
|
Packit |
4a16fb |
const snd_pcm_channel_area_t *dst_areas;
|
|
Packit |
4a16fb |
dst_areas = snd_pcm_mmap_areas(direct->spcm);
|
|
Packit |
4a16fb |
snd_pcm_areas_silence(dst_areas, 0, direct->spcm->channels,
|
|
Packit |
4a16fb |
direct->spcm->buffer_size,
|
|
Packit |
4a16fb |
direct->spcm->format);
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
ret = snd_pcm_start(direct->spcm);
|
|
Packit |
4a16fb |
if (ret < 0) {
|
|
Packit |
4a16fb |
SNDERR("recover: unable to start slave");
|
|
Packit |
4a16fb |
semerr = snd_pcm_direct_semaphore_up(direct,
|
|
Packit |
4a16fb |
DIRECT_IPC_SEM_CLIENT);
|
|
Packit |
4a16fb |
if (semerr < 0) {
|
|
Packit |
4a16fb |
SNDERR("SEMUP FAILED with err %d", semerr);
|
|
Packit |
4a16fb |
return semerr;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
direct->shmptr->s.recoveries++;
|
|
Packit |
4a16fb |
semerr = snd_pcm_direct_semaphore_up(direct,
|
|
Packit |
4a16fb |
DIRECT_IPC_SEM_CLIENT);
|
|
Packit |
4a16fb |
if (semerr < 0) {
|
|
Packit |
4a16fb |
SNDERR("SEMUP FAILED with err %d", semerr);
|
|
Packit |
4a16fb |
return semerr;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
return 0;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
/*
|
|
Packit |
4a16fb |
* enter xrun state, if slave xrun occurred
|
|
Packit |
4a16fb |
* @return: 0 - no xrun >0: xrun happened
|
|
Packit |
4a16fb |
*/
|
|
Packit |
4a16fb |
int snd_pcm_direct_client_chk_xrun(snd_pcm_direct_t *direct, snd_pcm_t *pcm)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
if (direct->shmptr->s.recoveries != direct->recoveries) {
|
|
Packit |
4a16fb |
/* no matter how many xruns we missed -
|
|
Packit |
4a16fb |
* so don't increment but just update to actual counter
|
|
Packit |
4a16fb |
*/
|
|
Packit |
4a16fb |
direct->recoveries = direct->shmptr->s.recoveries;
|
|
Packit |
4a16fb |
pcm->fast_ops->drop(pcm);
|
|
Packit |
4a16fb |
/* trigger_tstamp update is missing in drop callbacks */
|
|
Packit |
4a16fb |
gettimestamp(&direct->trigger_tstamp, pcm->tstamp_type);
|
|
Packit |
4a16fb |
/* no timer clear:
|
|
Packit |
4a16fb |
* if slave already entered xrun again the event is lost.
|
|
Packit |
4a16fb |
* snd_pcm_direct_clear_timer_queue(direct);
|
|
Packit |
4a16fb |
*/
|
|
Packit |
4a16fb |
direct->state = SND_PCM_STATE_XRUN;
|
|
Packit |
4a16fb |
return 1;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
return 0;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
/*
|
|
Packit |
4a16fb |
* This is the only operation guaranteed to be called before entering poll().
|
|
Packit |
4a16fb |
* Direct plugins use fd of snd_timer to poll on, these timers do NOT check
|
|
Packit |
4a16fb |
* state of substream in kernel by intention.
|
|
Packit |
4a16fb |
* Only the enter to xrun might be notified once (SND_TIMER_EVENT_MSTOP).
|
|
Packit |
4a16fb |
* If xrun event was not correctly handled or was ignored it will never be
|
|
Packit |
4a16fb |
* evaluated again afterwards.
|
|
Packit |
4a16fb |
* This will result in snd_pcm_wait() always returning timeout.
|
|
Packit |
4a16fb |
* In contrast poll() on pcm hardware checks ALSA state and will immediately
|
|
Packit |
4a16fb |
* return POLLERR on XRUN.
|
|
Packit |
4a16fb |
*
|
|
Packit |
4a16fb |
* To prevent timeout and applications endlessly spinning without xrun
|
|
Packit |
4a16fb |
* detected we add a state check here which may trigger the xrun sequence.
|
|
Packit |
4a16fb |
*
|
|
Packit |
4a16fb |
* return count of filled descriptors or negative error code
|
|
Packit |
4a16fb |
*/
|
|
Packit |
4a16fb |
int snd_pcm_direct_poll_descriptors(snd_pcm_t *pcm, struct pollfd *pfds,
|
|
Packit |
4a16fb |
unsigned int space)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
if (pcm->poll_fd < 0) {
|
|
Packit |
4a16fb |
SNDMSG("poll_fd < 0");
|
|
Packit |
4a16fb |
return -EIO;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (space >= 1 && pfds) {
|
|
Packit |
4a16fb |
pfds->fd = pcm->poll_fd;
|
|
Packit |
4a16fb |
pfds->events = pcm->poll_events | POLLERR | POLLNVAL;
|
|
Packit |
4a16fb |
} else {
|
|
Packit |
4a16fb |
return 0;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
/* this will also evaluate slave state and enter xrun if necessary */
|
|
Packit |
4a16fb |
/* using __snd_pcm_state() since this function is called inside lock */
|
|
Packit |
4a16fb |
switch (__snd_pcm_state(pcm)) {
|
|
Packit |
4a16fb |
case SND_PCM_STATE_XRUN:
|
|
Packit |
4a16fb |
return -EPIPE;
|
|
Packit |
4a16fb |
default:
|
|
Packit |
4a16fb |
break;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
return 1;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
int snd_pcm_direct_poll_revents(snd_pcm_t *pcm, struct pollfd *pfds, unsigned int nfds, unsigned short *revents)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
snd_pcm_direct_t *dmix = pcm->private_data;
|
|
Packit |
4a16fb |
unsigned short events;
|
|
Packit |
4a16fb |
int empty = 0;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
assert(pfds && nfds == 1 && revents);
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
timer_changed:
|
|
Packit |
4a16fb |
events = pfds[0].revents;
|
|
Packit |
4a16fb |
if (events & POLLIN) {
|
|
Packit |
4a16fb |
snd_pcm_uframes_t avail;
|
|
Packit |
4a16fb |
__snd_pcm_avail_update(pcm);
|
|
Packit |
4a16fb |
if (pcm->stream == SND_PCM_STREAM_PLAYBACK) {
|
|
Packit |
4a16fb |
events |= POLLOUT;
|
|
Packit |
4a16fb |
events &= ~POLLIN;
|
|
Packit |
4a16fb |
avail = snd_pcm_mmap_playback_avail(pcm);
|
|
Packit |
4a16fb |
} else {
|
|
Packit |
4a16fb |
avail = snd_pcm_mmap_capture_avail(pcm);
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
empty = avail < pcm->avail_min;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
switch (snd_pcm_state(dmix->spcm)) {
|
|
Packit |
4a16fb |
case SND_PCM_STATE_XRUN:
|
|
Packit |
4a16fb |
/* recover slave and update client state to xrun
|
|
Packit |
4a16fb |
* before returning POLLERR
|
|
Packit |
4a16fb |
*/
|
|
Packit |
4a16fb |
snd_pcm_direct_slave_recover(dmix);
|
|
Packit |
4a16fb |
snd_pcm_direct_client_chk_xrun(dmix, pcm);
|
|
Packit |
4a16fb |
/* fallthrough */
|
|
Packit |
4a16fb |
case SND_PCM_STATE_SUSPENDED:
|
|
Packit |
4a16fb |
case SND_PCM_STATE_SETUP:
|
|
Packit |
4a16fb |
events |= POLLERR;
|
|
Packit |
4a16fb |
break;
|
|
Packit |
4a16fb |
default:
|
|
Packit |
4a16fb |
if (empty) {
|
|
Packit |
4a16fb |
/* here we have a race condition:
|
|
Packit |
4a16fb |
* if period event arrived after the avail_update call
|
|
Packit |
4a16fb |
* above we might clear this event with the following
|
|
Packit |
4a16fb |
* clear_timer_queue.
|
|
Packit |
4a16fb |
* There is no way to do this in atomic manner, so we
|
|
Packit |
4a16fb |
* need to recheck avail_update if we successfully
|
|
Packit |
4a16fb |
* cleared a poll event.
|
|
Packit |
4a16fb |
*/
|
|
Packit |
4a16fb |
if (snd_pcm_direct_clear_timer_queue(dmix))
|
|
Packit |
4a16fb |
goto timer_changed;
|
|
Packit |
4a16fb |
events &= ~(POLLOUT|POLLIN);
|
|
Packit |
4a16fb |
/* additional check */
|
|
Packit |
4a16fb |
switch (__snd_pcm_state(pcm)) {
|
|
Packit |
4a16fb |
case SND_PCM_STATE_XRUN:
|
|
Packit |
4a16fb |
case SND_PCM_STATE_SUSPENDED:
|
|
Packit |
4a16fb |
case SND_PCM_STATE_SETUP:
|
|
Packit |
4a16fb |
events |= POLLERR;
|
|
Packit |
4a16fb |
break;
|
|
Packit |
4a16fb |
default:
|
|
Packit |
4a16fb |
break;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
break;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
*revents = events;
|
|
Packit |
4a16fb |
return 0;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
int snd_pcm_direct_info(snd_pcm_t *pcm, snd_pcm_info_t * info)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
snd_pcm_direct_t *dmix = pcm->private_data;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
if (dmix->spcm && !dmix->shmptr->use_server)
|
|
Packit |
4a16fb |
return snd_pcm_info(dmix->spcm, info);
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
memset(info, 0, sizeof(*info));
|
|
Packit |
4a16fb |
info->stream = pcm->stream;
|
|
Packit |
4a16fb |
info->card = -1;
|
|
Packit |
4a16fb |
/* FIXME: fill this with something more useful: we know the hardware name */
|
|
Packit |
4a16fb |
if (pcm->name) {
|
|
Packit |
4a16fb |
snd_strlcpy((char *)info->id, pcm->name, sizeof(info->id));
|
|
Packit |
4a16fb |
snd_strlcpy((char *)info->name, pcm->name, sizeof(info->name));
|
|
Packit |
4a16fb |
snd_strlcpy((char *)info->subname, pcm->name, sizeof(info->subname));
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
info->subdevices_count = 1;
|
|
Packit |
4a16fb |
return 0;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
static inline snd_mask_t *hw_param_mask(snd_pcm_hw_params_t *params,
|
|
Packit |
4a16fb |
snd_pcm_hw_param_t var)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
return ¶ms->masks[var - SND_PCM_HW_PARAM_FIRST_MASK];
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
static inline snd_interval_t *hw_param_interval(snd_pcm_hw_params_t *params,
|
|
Packit |
4a16fb |
snd_pcm_hw_param_t var)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
return ¶ms->intervals[var - SND_PCM_HW_PARAM_FIRST_INTERVAL];
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
static int hw_param_interval_refine_one(snd_pcm_hw_params_t *params,
|
|
Packit |
4a16fb |
snd_pcm_hw_param_t var,
|
|
Packit |
4a16fb |
snd_interval_t *src)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
snd_interval_t *i;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
if (!(params->rmask & (1<
|
|
Packit |
4a16fb |
return 0;
|
|
Packit |
4a16fb |
i = hw_param_interval(params, var);
|
|
Packit |
4a16fb |
if (snd_interval_empty(i)) {
|
|
Packit |
4a16fb |
SNDERR("dshare interval %i empty?", (int)var);
|
|
Packit |
4a16fb |
return -EINVAL;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (snd_interval_refine(i, src))
|
|
Packit |
4a16fb |
params->cmask |= 1<
|
|
Packit |
4a16fb |
return 0;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
static int hw_param_interval_refine_minmax(snd_pcm_hw_params_t *params,
|
|
Packit |
4a16fb |
snd_pcm_hw_param_t var,
|
|
Packit |
4a16fb |
unsigned int imin,
|
|
Packit |
4a16fb |
unsigned int imax)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
snd_interval_t t;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
memset(&t, 0, sizeof(t));
|
|
Packit |
4a16fb |
snd_interval_set_minmax(&t, imin, imax);
|
|
Packit |
4a16fb |
t.integer = 1;
|
|
Packit |
4a16fb |
return hw_param_interval_refine_one(params, var, &t);
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
/* this code is used 'as-is' from the alsa kernel code */
|
|
Packit |
4a16fb |
static int snd_interval_step(struct snd_interval *i, unsigned int min,
|
|
Packit |
4a16fb |
unsigned int step)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
unsigned int n;
|
|
Packit |
4a16fb |
int changed = 0;
|
|
Packit |
4a16fb |
n = (i->min - min) % step;
|
|
Packit |
4a16fb |
if (n != 0 || i->openmin) {
|
|
Packit |
4a16fb |
i->min += step - n;
|
|
Packit |
4a16fb |
changed = 1;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
n = (i->max - min) % step;
|
|
Packit |
4a16fb |
if (n != 0 || i->openmax) {
|
|
Packit |
4a16fb |
i->max -= n;
|
|
Packit |
4a16fb |
changed = 1;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (snd_interval_checkempty(i)) {
|
|
Packit |
4a16fb |
i->empty = 1;
|
|
Packit |
4a16fb |
return -EINVAL;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
return changed;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
#undef REFINE_DEBUG
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
int snd_pcm_direct_hw_refine(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
snd_pcm_direct_t *dshare = pcm->private_data;
|
|
Packit |
4a16fb |
static const snd_mask_t access = { .bits = {
|
|
Packit |
4a16fb |
(1<
|
|
Packit |
4a16fb |
(1<
|
|
Packit |
4a16fb |
(1<
|
|
Packit |
4a16fb |
(1<
|
|
Packit |
4a16fb |
0, 0, 0 } };
|
|
Packit |
4a16fb |
int err;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
#ifdef REFINE_DEBUG
|
|
Packit |
4a16fb |
snd_output_t *log;
|
|
Packit |
4a16fb |
snd_output_stdio_attach(&log, stderr, 0);
|
|
Packit |
4a16fb |
snd_output_puts(log, "DMIX REFINE (begin):\n");
|
|
Packit |
4a16fb |
snd_pcm_hw_params_dump(params, log);
|
|
Packit |
4a16fb |
#endif
|
|
Packit |
4a16fb |
if (params->rmask & (1<
|
|
Packit |
4a16fb |
if (snd_mask_empty(hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS))) {
|
|
Packit |
4a16fb |
SNDERR("dshare access mask empty?");
|
|
Packit |
4a16fb |
return -EINVAL;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (snd_mask_refine(hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS), &access))
|
|
Packit |
4a16fb |
params->cmask |= 1<
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (params->rmask & (1<
|
|
Packit |
4a16fb |
if (snd_mask_empty(hw_param_mask(params, SND_PCM_HW_PARAM_FORMAT))) {
|
|
Packit |
4a16fb |
SNDERR("dshare format mask empty?");
|
|
Packit |
4a16fb |
return -EINVAL;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (snd_mask_refine_set(hw_param_mask(params, SND_PCM_HW_PARAM_FORMAT),
|
|
Packit |
4a16fb |
dshare->shmptr->hw.format))
|
|
Packit |
4a16fb |
params->cmask |= 1<
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
//snd_mask_none(hw_param_mask(params, SND_PCM_HW_PARAM_SUBFORMAT));
|
|
Packit |
4a16fb |
if (params->rmask & (1<
|
|
Packit |
4a16fb |
if (snd_interval_empty(hw_param_interval(params, SND_PCM_HW_PARAM_CHANNELS))) {
|
|
Packit |
4a16fb |
SNDERR("dshare channels mask empty?");
|
|
Packit |
4a16fb |
return -EINVAL;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
err = snd_interval_refine_set(hw_param_interval(params, SND_PCM_HW_PARAM_CHANNELS), dshare->channels);
|
|
Packit |
4a16fb |
if (err < 0)
|
|
Packit |
4a16fb |
return err;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
err = hw_param_interval_refine_one(params, SND_PCM_HW_PARAM_RATE,
|
|
Packit |
4a16fb |
&dshare->shmptr->hw.rate);
|
|
Packit |
4a16fb |
if (err < 0)
|
|
Packit |
4a16fb |
return err;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
if (dshare->max_periods < 0) {
|
|
Packit |
4a16fb |
err = hw_param_interval_refine_one(params, SND_PCM_HW_PARAM_PERIOD_SIZE,
|
|
Packit |
4a16fb |
&dshare->shmptr->hw.period_size);
|
|
Packit |
4a16fb |
if (err < 0)
|
|
Packit |
4a16fb |
return err;
|
|
Packit |
4a16fb |
err = hw_param_interval_refine_one(params, SND_PCM_HW_PARAM_PERIOD_TIME,
|
|
Packit |
4a16fb |
&dshare->shmptr->hw.period_time);
|
|
Packit |
4a16fb |
if (err < 0)
|
|
Packit |
4a16fb |
return err;
|
|
Packit |
4a16fb |
err = hw_param_interval_refine_one(params, SND_PCM_HW_PARAM_BUFFER_SIZE,
|
|
Packit |
4a16fb |
&dshare->shmptr->hw.buffer_size);
|
|
Packit |
4a16fb |
if (err < 0)
|
|
Packit |
4a16fb |
return err;
|
|
Packit |
4a16fb |
err = hw_param_interval_refine_one(params, SND_PCM_HW_PARAM_BUFFER_TIME,
|
|
Packit |
4a16fb |
&dshare->shmptr->hw.buffer_time);
|
|
Packit |
4a16fb |
if (err < 0)
|
|
Packit |
4a16fb |
return err;
|
|
Packit |
4a16fb |
} else if (params->rmask & ((1<
|
|
Packit |
4a16fb |
(1<
|
|
Packit |
4a16fb |
(1<
|
|
Packit |
4a16fb |
(1<
|
|
Packit |
4a16fb |
(1<
|
|
Packit |
4a16fb |
(1<
|
|
Packit |
4a16fb |
(1<
|
|
Packit |
4a16fb |
snd_interval_t period_size = dshare->shmptr->hw.period_size;
|
|
Packit |
4a16fb |
snd_interval_t period_time = dshare->shmptr->hw.period_time;
|
|
Packit |
4a16fb |
int changed;
|
|
Packit |
4a16fb |
unsigned int max_periods = dshare->max_periods;
|
|
Packit |
4a16fb |
if (max_periods < 2)
|
|
Packit |
4a16fb |
max_periods = dshare->slave_buffer_size / dshare->slave_period_size;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
/* make sure buffer size does not exceed slave buffer size */
|
|
Packit |
4a16fb |
err = hw_param_interval_refine_minmax(params, SND_PCM_HW_PARAM_BUFFER_SIZE,
|
|
Packit |
4a16fb |
2 * dshare->slave_period_size, dshare->slave_buffer_size);
|
|
Packit |
4a16fb |
if (err < 0)
|
|
Packit |
4a16fb |
return err;
|
|
Packit |
4a16fb |
if (dshare->var_periodsize) {
|
|
Packit |
4a16fb |
/* more tolerant settings... */
|
|
Packit |
4a16fb |
if (dshare->shmptr->hw.buffer_size.max / 2 > period_size.max)
|
|
Packit |
4a16fb |
period_size.max = dshare->shmptr->hw.buffer_size.max / 2;
|
|
Packit |
4a16fb |
if (dshare->shmptr->hw.buffer_time.max / 2 > period_time.max)
|
|
Packit |
4a16fb |
period_time.max = dshare->shmptr->hw.buffer_time.max / 2;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
err = hw_param_interval_refine_one(params, SND_PCM_HW_PARAM_PERIOD_SIZE,
|
|
Packit |
4a16fb |
&period_size);
|
|
Packit |
4a16fb |
if (err < 0)
|
|
Packit |
4a16fb |
return err;
|
|
Packit |
4a16fb |
err = hw_param_interval_refine_one(params, SND_PCM_HW_PARAM_PERIOD_TIME,
|
|
Packit |
4a16fb |
&period_time);
|
|
Packit |
4a16fb |
if (err < 0)
|
|
Packit |
4a16fb |
return err;
|
|
Packit |
4a16fb |
do {
|
|
Packit |
4a16fb |
changed = 0;
|
|
Packit |
4a16fb |
err = hw_param_interval_refine_minmax(params, SND_PCM_HW_PARAM_PERIODS,
|
|
Packit |
4a16fb |
2, max_periods);
|
|
Packit |
4a16fb |
if (err < 0)
|
|
Packit |
4a16fb |
return err;
|
|
Packit |
4a16fb |
changed |= err;
|
|
Packit |
4a16fb |
err = snd_pcm_hw_refine_soft(pcm, params);
|
|
Packit |
4a16fb |
if (err < 0)
|
|
Packit |
4a16fb |
return err;
|
|
Packit |
4a16fb |
changed |= err;
|
|
Packit |
4a16fb |
err = snd_interval_step(hw_param_interval(params, SND_PCM_HW_PARAM_PERIOD_SIZE),
|
|
Packit |
4a16fb |
0, dshare->slave_period_size);
|
|
Packit |
4a16fb |
if (err < 0)
|
|
Packit |
4a16fb |
return err;
|
|
Packit |
4a16fb |
changed |= err;
|
|
Packit |
4a16fb |
if (err)
|
|
Packit |
4a16fb |
params->rmask |= (1 << SND_PCM_HW_PARAM_PERIOD_SIZE);
|
|
Packit |
4a16fb |
} while (changed);
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
dshare->timer_ticks = hw_param_interval(params, SND_PCM_HW_PARAM_PERIOD_SIZE)->max / dshare->slave_period_size;
|
|
Packit |
4a16fb |
params->info = dshare->shmptr->s.info;
|
|
Packit |
4a16fb |
#ifdef REFINE_DEBUG
|
|
Packit |
4a16fb |
snd_output_puts(log, "DMIX REFINE (end):\n");
|
|
Packit |
4a16fb |
snd_pcm_hw_params_dump(params, log);
|
|
Packit |
4a16fb |
snd_output_close(log);
|
|
Packit |
4a16fb |
#endif
|
|
Packit |
4a16fb |
return 0;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
int snd_pcm_direct_hw_params(snd_pcm_t *pcm, snd_pcm_hw_params_t * params)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
snd_pcm_direct_t *dmix = pcm->private_data;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
params->info = dmix->shmptr->s.info;
|
|
Packit |
4a16fb |
params->rate_num = dmix->shmptr->s.rate;
|
|
Packit |
4a16fb |
params->rate_den = 1;
|
|
Packit |
4a16fb |
params->fifo_size = 0;
|
|
Packit |
4a16fb |
params->msbits = dmix->shmptr->s.msbits;
|
|
Packit |
4a16fb |
return 0;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
int snd_pcm_direct_hw_free(snd_pcm_t *pcm ATTRIBUTE_UNUSED)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
/* values are cached in the pcm structure */
|
|
Packit |
4a16fb |
return 0;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
int snd_pcm_direct_sw_params(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_sw_params_t * params ATTRIBUTE_UNUSED)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
/* values are cached in the pcm structure */
|
|
Packit |
4a16fb |
return 0;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
int snd_pcm_direct_channel_info(snd_pcm_t *pcm, snd_pcm_channel_info_t * info)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
return snd_pcm_channel_info_shm(pcm, info, -1);
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
int snd_pcm_direct_mmap(snd_pcm_t *pcm ATTRIBUTE_UNUSED)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
return 0;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
int snd_pcm_direct_munmap(snd_pcm_t *pcm ATTRIBUTE_UNUSED)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
return 0;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
snd_pcm_chmap_query_t **snd_pcm_direct_query_chmaps(snd_pcm_t *pcm)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
snd_pcm_direct_t *dmix = pcm->private_data;
|
|
Packit |
4a16fb |
return snd_pcm_query_chmaps(dmix->spcm);
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
snd_pcm_chmap_t *snd_pcm_direct_get_chmap(snd_pcm_t *pcm)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
snd_pcm_direct_t *dmix = pcm->private_data;
|
|
Packit |
4a16fb |
return snd_pcm_get_chmap(dmix->spcm);
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
int snd_pcm_direct_set_chmap(snd_pcm_t *pcm, const snd_pcm_chmap_t *map)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
snd_pcm_direct_t *dmix = pcm->private_data;
|
|
Packit |
4a16fb |
return snd_pcm_set_chmap(dmix->spcm, map);
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
int snd_pcm_direct_prepare(snd_pcm_t *pcm)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
snd_pcm_direct_t *dmix = pcm->private_data;
|
|
Packit |
4a16fb |
int err;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
switch (snd_pcm_state(dmix->spcm)) {
|
|
Packit |
4a16fb |
case SND_PCM_STATE_SETUP:
|
|
Packit |
4a16fb |
case SND_PCM_STATE_XRUN:
|
|
Packit |
4a16fb |
case SND_PCM_STATE_SUSPENDED:
|
|
Packit |
4a16fb |
err = snd_pcm_prepare(dmix->spcm);
|
|
Packit |
4a16fb |
if (err < 0)
|
|
Packit |
4a16fb |
return err;
|
|
Packit |
4a16fb |
snd_pcm_start(dmix->spcm);
|
|
Packit |
4a16fb |
break;
|
|
Packit |
4a16fb |
case SND_PCM_STATE_OPEN:
|
|
Packit |
4a16fb |
case SND_PCM_STATE_DISCONNECTED:
|
|
Packit |
4a16fb |
return -EBADFD;
|
|
Packit |
4a16fb |
default:
|
|
Packit |
4a16fb |
break;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
snd_pcm_direct_check_interleave(dmix, pcm);
|
|
Packit |
4a16fb |
dmix->state = SND_PCM_STATE_PREPARED;
|
|
Packit |
4a16fb |
dmix->appl_ptr = dmix->last_appl_ptr = 0;
|
|
Packit |
4a16fb |
dmix->hw_ptr = 0;
|
|
Packit |
4a16fb |
return snd_pcm_direct_set_timer_params(dmix);
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
int snd_pcm_direct_resume(snd_pcm_t *pcm)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
snd_pcm_direct_t *dmix = pcm->private_data;
|
|
Packit |
4a16fb |
snd_pcm_t *spcm = dmix->spcm;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
snd_pcm_direct_semaphore_down(dmix, DIRECT_IPC_SEM_CLIENT);
|
|
Packit |
4a16fb |
/* some buggy drivers require the device resumed before prepared;
|
|
Packit |
4a16fb |
* when a device has RESUME flag and is in SUSPENDED state, resume
|
|
Packit |
4a16fb |
* here but immediately drop to bring it to a sane active state.
|
|
Packit |
4a16fb |
*/
|
|
Packit |
4a16fb |
if ((spcm->info & SND_PCM_INFO_RESUME) &&
|
|
Packit |
4a16fb |
snd_pcm_state(spcm) == SND_PCM_STATE_SUSPENDED) {
|
|
Packit |
4a16fb |
snd_pcm_resume(spcm);
|
|
Packit |
4a16fb |
snd_pcm_drop(spcm);
|
|
Packit |
4a16fb |
snd_pcm_direct_timer_stop(dmix);
|
|
Packit |
4a16fb |
snd_pcm_direct_clear_timer_queue(dmix);
|
|
Packit |
4a16fb |
snd_pcm_areas_silence(snd_pcm_mmap_areas(spcm), 0,
|
|
Packit |
4a16fb |
spcm->channels, spcm->buffer_size,
|
|
Packit |
4a16fb |
spcm->format);
|
|
Packit |
4a16fb |
snd_pcm_prepare(spcm);
|
|
Packit |
4a16fb |
snd_pcm_start(spcm);
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
snd_pcm_direct_semaphore_up(dmix, DIRECT_IPC_SEM_CLIENT);
|
|
Packit |
4a16fb |
return -ENOSYS;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
#define COPY_SLAVE(field) (dmix->shmptr->s.field = spcm->field)
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
/* copy the slave setting */
|
|
Packit |
4a16fb |
static void save_slave_setting(snd_pcm_direct_t *dmix, snd_pcm_t *spcm)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
spcm->info &= ~SND_PCM_INFO_PAUSE;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
COPY_SLAVE(access);
|
|
Packit |
4a16fb |
COPY_SLAVE(format);
|
|
Packit |
4a16fb |
COPY_SLAVE(subformat);
|
|
Packit |
4a16fb |
COPY_SLAVE(channels);
|
|
Packit |
4a16fb |
COPY_SLAVE(rate);
|
|
Packit |
4a16fb |
COPY_SLAVE(period_size);
|
|
Packit |
4a16fb |
COPY_SLAVE(period_time);
|
|
Packit |
4a16fb |
COPY_SLAVE(periods);
|
|
Packit |
4a16fb |
COPY_SLAVE(tstamp_mode);
|
|
Packit |
4a16fb |
COPY_SLAVE(tstamp_type);
|
|
Packit |
4a16fb |
COPY_SLAVE(period_step);
|
|
Packit |
4a16fb |
COPY_SLAVE(avail_min);
|
|
Packit |
4a16fb |
COPY_SLAVE(start_threshold);
|
|
Packit |
4a16fb |
COPY_SLAVE(stop_threshold);
|
|
Packit |
4a16fb |
COPY_SLAVE(silence_threshold);
|
|
Packit |
4a16fb |
COPY_SLAVE(silence_size);
|
|
Packit |
4a16fb |
COPY_SLAVE(boundary);
|
|
Packit |
4a16fb |
COPY_SLAVE(info);
|
|
Packit |
4a16fb |
COPY_SLAVE(msbits);
|
|
Packit |
4a16fb |
COPY_SLAVE(rate_num);
|
|
Packit |
4a16fb |
COPY_SLAVE(rate_den);
|
|
Packit |
4a16fb |
COPY_SLAVE(hw_flags);
|
|
Packit |
4a16fb |
COPY_SLAVE(fifo_size);
|
|
Packit |
4a16fb |
COPY_SLAVE(buffer_size);
|
|
Packit |
4a16fb |
COPY_SLAVE(buffer_time);
|
|
Packit |
4a16fb |
COPY_SLAVE(sample_bits);
|
|
Packit |
4a16fb |
COPY_SLAVE(frame_bits);
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
dmix->shmptr->s.info &= ~SND_PCM_INFO_RESUME;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
#undef COPY_SLAVE
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
/*
|
|
Packit |
4a16fb |
* this function initializes hardware and starts playback operation with
|
|
Packit |
4a16fb |
* no stop threshold (it operates all time without xrun checking)
|
|
Packit |
4a16fb |
* also, the driver silences the unused ring buffer areas for us
|
|
Packit |
4a16fb |
*/
|
|
Packit |
4a16fb |
int snd_pcm_direct_initialize_slave(snd_pcm_direct_t *dmix, snd_pcm_t *spcm, struct slave_params *params)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
snd_pcm_hw_params_t hw_params = {0};
|
|
Packit |
4a16fb |
snd_pcm_sw_params_t sw_params = {0};
|
|
Packit |
4a16fb |
int ret, buffer_is_not_initialized;
|
|
Packit |
4a16fb |
snd_pcm_uframes_t boundary;
|
|
Packit |
4a16fb |
struct pollfd fd;
|
|
Packit |
4a16fb |
int loops = 10;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
__again:
|
|
Packit |
4a16fb |
if (loops-- <= 0) {
|
|
Packit |
4a16fb |
SNDERR("unable to find a valid configuration for slave");
|
|
Packit |
4a16fb |
return -EINVAL;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
ret = snd_pcm_hw_params_any(spcm, &hw_params);
|
|
Packit |
4a16fb |
if (ret < 0) {
|
|
Packit |
4a16fb |
SNDERR("snd_pcm_hw_params_any failed");
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
ret = snd_pcm_hw_params_set_access(spcm, &hw_params,
|
|
Packit |
4a16fb |
SND_PCM_ACCESS_MMAP_INTERLEAVED);
|
|
Packit |
4a16fb |
if (ret < 0) {
|
|
Packit |
4a16fb |
ret = snd_pcm_hw_params_set_access(spcm, &hw_params,
|
|
Packit |
4a16fb |
SND_PCM_ACCESS_MMAP_NONINTERLEAVED);
|
|
Packit |
4a16fb |
if (ret < 0) {
|
|
Packit |
4a16fb |
SNDERR("slave plugin does not support mmap interleaved or mmap noninterleaved access");
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (params->format == SND_PCM_FORMAT_UNKNOWN)
|
|
Packit |
4a16fb |
ret = -EINVAL;
|
|
Packit |
4a16fb |
else
|
|
Packit |
4a16fb |
ret = snd_pcm_hw_params_set_format(spcm, &hw_params,
|
|
Packit |
4a16fb |
params->format);
|
|
Packit |
4a16fb |
if (ret < 0) {
|
|
Packit |
4a16fb |
static const snd_pcm_format_t dmix_formats[] = {
|
|
Packit |
4a16fb |
SND_PCM_FORMAT_S32,
|
|
Packit |
4a16fb |
SND_PCM_FORMAT_S32 ^ SND_PCM_FORMAT_S32_LE ^
|
|
Packit |
4a16fb |
SND_PCM_FORMAT_S32_BE,
|
|
Packit |
4a16fb |
SND_PCM_FORMAT_S16,
|
|
Packit |
4a16fb |
SND_PCM_FORMAT_S16 ^ SND_PCM_FORMAT_S16_LE ^
|
|
Packit |
4a16fb |
SND_PCM_FORMAT_S16_BE,
|
|
Packit |
4a16fb |
SND_PCM_FORMAT_S24_LE,
|
|
Packit |
4a16fb |
SND_PCM_FORMAT_S24_3LE,
|
|
Packit |
4a16fb |
SND_PCM_FORMAT_U8,
|
|
Packit |
4a16fb |
};
|
|
Packit |
4a16fb |
snd_pcm_format_t format;
|
|
Packit |
4a16fb |
unsigned int i;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
for (i = 0; i < ARRAY_SIZE(dmix_formats); ++i) {
|
|
Packit |
4a16fb |
format = dmix_formats[i];
|
|
Packit |
4a16fb |
ret = snd_pcm_hw_params_set_format(spcm, &hw_params,
|
|
Packit |
4a16fb |
format);
|
|
Packit |
4a16fb |
if (ret >= 0)
|
|
Packit |
4a16fb |
break;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (ret < 0 && dmix->type != SND_PCM_TYPE_DMIX) {
|
|
Packit |
4a16fb |
/* TODO: try to choose a good format */
|
|
Packit |
4a16fb |
ret = INTERNAL(snd_pcm_hw_params_set_format_first)(spcm,
|
|
Packit |
4a16fb |
&hw_params, &format);
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (ret < 0) {
|
|
Packit |
4a16fb |
SNDERR("requested or auto-format is not available");
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
params->format = format;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
ret = INTERNAL(snd_pcm_hw_params_set_channels_near)(spcm, &hw_params,
|
|
Packit |
4a16fb |
(unsigned int *)¶ms->channels);
|
|
Packit |
4a16fb |
if (ret < 0) {
|
|
Packit |
4a16fb |
SNDERR("requested count of channels is not available");
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
ret = INTERNAL(snd_pcm_hw_params_set_rate_near)(spcm, &hw_params,
|
|
Packit |
4a16fb |
(unsigned int *)¶ms->rate, 0);
|
|
Packit |
4a16fb |
if (ret < 0) {
|
|
Packit |
4a16fb |
SNDERR("requested rate is not available");
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
buffer_is_not_initialized = 0;
|
|
Packit |
4a16fb |
if (params->buffer_time > 0) {
|
|
Packit |
4a16fb |
ret = INTERNAL(snd_pcm_hw_params_set_buffer_time_near)(spcm,
|
|
Packit |
4a16fb |
&hw_params, (unsigned int *)¶ms->buffer_time, 0);
|
|
Packit |
4a16fb |
if (ret < 0) {
|
|
Packit |
4a16fb |
SNDERR("unable to set buffer time");
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
} else if (params->buffer_size > 0) {
|
|
Packit |
4a16fb |
ret = INTERNAL(snd_pcm_hw_params_set_buffer_size_near)(spcm,
|
|
Packit |
4a16fb |
&hw_params, (snd_pcm_uframes_t *)¶ms->buffer_size);
|
|
Packit |
4a16fb |
if (ret < 0) {
|
|
Packit |
4a16fb |
SNDERR("unable to set buffer size");
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
} else {
|
|
Packit |
4a16fb |
buffer_is_not_initialized = 1;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
if (params->period_time > 0) {
|
|
Packit |
4a16fb |
ret = INTERNAL(snd_pcm_hw_params_set_period_time_near)(spcm,
|
|
Packit |
4a16fb |
&hw_params, (unsigned int *)¶ms->period_time, 0);
|
|
Packit |
4a16fb |
if (ret < 0) {
|
|
Packit |
4a16fb |
SNDERR("unable to set period_time");
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
} else if (params->period_size > 0) {
|
|
Packit |
4a16fb |
ret = INTERNAL(snd_pcm_hw_params_set_period_size_near)(spcm,
|
|
Packit |
4a16fb |
&hw_params, (snd_pcm_uframes_t *)¶ms->period_size,
|
|
Packit |
4a16fb |
0);
|
|
Packit |
4a16fb |
if (ret < 0) {
|
|
Packit |
4a16fb |
SNDERR("unable to set period_size");
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
if (buffer_is_not_initialized && params->periods > 0) {
|
|
Packit |
4a16fb |
unsigned int periods = params->periods;
|
|
Packit |
4a16fb |
ret = INTERNAL(snd_pcm_hw_params_set_periods_near)(spcm,
|
|
Packit |
4a16fb |
&hw_params, ¶ms->periods, 0);
|
|
Packit |
4a16fb |
if (ret < 0) {
|
|
Packit |
4a16fb |
SNDERR("unable to set requested periods");
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (params->periods == 1) {
|
|
Packit |
4a16fb |
params->periods = periods;
|
|
Packit |
4a16fb |
if (params->period_time > 0) {
|
|
Packit |
4a16fb |
params->period_time /= 2;
|
|
Packit |
4a16fb |
goto __again;
|
|
Packit |
4a16fb |
} else if (params->period_size > 0) {
|
|
Packit |
4a16fb |
params->period_size /= 2;
|
|
Packit |
4a16fb |
goto __again;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
SNDERR("unable to use stream with periods == 1");
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
ret = snd_pcm_hw_params(spcm, &hw_params);
|
|
Packit |
4a16fb |
if (ret < 0) {
|
|
Packit |
4a16fb |
SNDERR("unable to install hw params");
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
/* store some hw_params values to shared info */
|
|
Packit |
4a16fb |
dmix->shmptr->hw.format =
|
|
Packit |
4a16fb |
snd_mask_value(hw_param_mask(&hw_params,
|
|
Packit |
4a16fb |
SND_PCM_HW_PARAM_FORMAT));
|
|
Packit |
4a16fb |
dmix->shmptr->hw.rate =
|
|
Packit |
4a16fb |
*hw_param_interval(&hw_params, SND_PCM_HW_PARAM_RATE);
|
|
Packit |
4a16fb |
dmix->shmptr->hw.buffer_size =
|
|
Packit |
4a16fb |
*hw_param_interval(&hw_params, SND_PCM_HW_PARAM_BUFFER_SIZE);
|
|
Packit |
4a16fb |
dmix->shmptr->hw.buffer_time =
|
|
Packit |
4a16fb |
*hw_param_interval(&hw_params, SND_PCM_HW_PARAM_BUFFER_TIME);
|
|
Packit |
4a16fb |
dmix->shmptr->hw.period_size =
|
|
Packit |
4a16fb |
*hw_param_interval(&hw_params, SND_PCM_HW_PARAM_PERIOD_SIZE);
|
|
Packit |
4a16fb |
dmix->shmptr->hw.period_time =
|
|
Packit |
4a16fb |
*hw_param_interval(&hw_params, SND_PCM_HW_PARAM_PERIOD_TIME);
|
|
Packit |
4a16fb |
dmix->shmptr->hw.periods =
|
|
Packit |
4a16fb |
*hw_param_interval(&hw_params, SND_PCM_HW_PARAM_PERIODS);
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
ret = snd_pcm_sw_params_current(spcm, &sw_params);
|
|
Packit |
4a16fb |
if (ret < 0) {
|
|
Packit |
4a16fb |
SNDERR("unable to get current sw_params");
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
ret = snd_pcm_sw_params_get_boundary(&sw_params, &boundary);
|
|
Packit |
4a16fb |
if (ret < 0) {
|
|
Packit |
4a16fb |
SNDERR("unable to get boundary");
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
ret = snd_pcm_sw_params_set_stop_threshold(spcm, &sw_params, boundary);
|
|
Packit |
4a16fb |
if (ret < 0) {
|
|
Packit |
4a16fb |
SNDERR("unable to set stop threshold");
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
/* set timestamp mode to MMAP
|
|
Packit |
4a16fb |
* the slave timestamp is copied appropriately in dsnoop/dmix/dshare
|
|
Packit |
4a16fb |
* based on the tstamp_mode of each client
|
|
Packit |
4a16fb |
*/
|
|
Packit |
4a16fb |
ret = snd_pcm_sw_params_set_tstamp_mode(spcm, &sw_params,
|
|
Packit |
4a16fb |
SND_PCM_TSTAMP_ENABLE);
|
|
Packit |
4a16fb |
if (ret < 0) {
|
|
Packit |
4a16fb |
SNDERR("unable to tstamp mode MMAP");
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
if (dmix->type != SND_PCM_TYPE_DMIX &&
|
|
Packit |
4a16fb |
dmix->type != SND_PCM_TYPE_DSHARE)
|
|
Packit |
4a16fb |
goto __skip_silencing;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
ret = snd_pcm_sw_params_set_silence_threshold(spcm, &sw_params, 0);
|
|
Packit |
4a16fb |
if (ret < 0) {
|
|
Packit |
4a16fb |
SNDERR("unable to set silence threshold");
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
ret = snd_pcm_sw_params_set_silence_size(spcm, &sw_params, boundary);
|
|
Packit |
4a16fb |
if (ret < 0) {
|
|
Packit |
4a16fb |
SNDERR("unable to set silence threshold (please upgrade to 0.9.0rc8+ driver)");
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
__skip_silencing:
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
ret = snd_pcm_sw_params(spcm, &sw_params);
|
|
Packit |
4a16fb |
if (ret < 0) {
|
|
Packit |
4a16fb |
SNDERR("unable to install sw params (please upgrade to 0.9.0rc8+ driver)");
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
if (dmix->type == SND_PCM_TYPE_DSHARE) {
|
|
Packit |
4a16fb |
const snd_pcm_channel_area_t *dst_areas;
|
|
Packit |
4a16fb |
dst_areas = snd_pcm_mmap_areas(spcm);
|
|
Packit |
4a16fb |
snd_pcm_areas_silence(dst_areas, 0, spcm->channels,
|
|
Packit |
4a16fb |
spcm->buffer_size, spcm->format);
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
ret = snd_pcm_start(spcm);
|
|
Packit |
4a16fb |
if (ret < 0) {
|
|
Packit |
4a16fb |
SNDERR("unable to start PCM stream");
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
if (snd_pcm_poll_descriptors_count(spcm) != 1) {
|
|
Packit |
4a16fb |
SNDERR("unable to use hardware pcm with fd more than one!!!");
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
snd_pcm_poll_descriptors(spcm, &fd, 1);
|
|
Packit |
4a16fb |
dmix->hw_fd = fd.fd;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
save_slave_setting(dmix, spcm);
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
/* Currently, we assume that each dmix client has the same
|
|
Packit |
4a16fb |
* hw_params setting.
|
|
Packit |
4a16fb |
* If the arbitrary hw_parmas is supported in future,
|
|
Packit |
4a16fb |
* boundary has to be taken from the slave config but
|
|
Packit |
4a16fb |
* recalculated for the native boundary size (for 32bit
|
|
Packit |
4a16fb |
* emulation on 64bit arch).
|
|
Packit |
4a16fb |
*/
|
|
Packit |
4a16fb |
dmix->slave_buffer_size = spcm->buffer_size;
|
|
Packit |
4a16fb |
dmix->slave_period_size = spcm->period_size;
|
|
Packit |
4a16fb |
dmix->slave_boundary = spcm->boundary;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
spcm->donot_close = 1;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
int ver = 0;
|
|
Packit |
4a16fb |
ioctl(spcm->poll_fd, SNDRV_PCM_IOCTL_PVERSION, &ver);
|
|
Packit |
4a16fb |
if (ver < SNDRV_PROTOCOL_VERSION(2, 0, 8))
|
|
Packit |
4a16fb |
dmix->shmptr->use_server = 1;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
return 0;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
/*
|
|
Packit |
4a16fb |
* the trick is used here; we cannot use effectively the hardware handle because
|
|
Packit |
4a16fb |
* we cannot drive multiple accesses to appl_ptr; so we use slave timer of given
|
|
Packit |
4a16fb |
* PCM hardware handle; it's not this easy and cheap?
|
|
Packit |
4a16fb |
*/
|
|
Packit |
4a16fb |
int snd_pcm_direct_initialize_poll_fd(snd_pcm_direct_t *dmix)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
int ret;
|
|
Packit |
4a16fb |
snd_pcm_info_t info = {0};
|
|
Packit |
4a16fb |
char name[128];
|
|
Packit |
4a16fb |
int capture = dmix->type == SND_PCM_TYPE_DSNOOP ? 1 : 0;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
dmix->tread = 1;
|
|
Packit |
4a16fb |
dmix->timer_need_poll = 0;
|
|
Packit |
4a16fb |
dmix->timer_ticks = 1;
|
|
Packit |
4a16fb |
ret = snd_pcm_info(dmix->spcm, &info;;
|
|
Packit |
4a16fb |
if (ret < 0) {
|
|
Packit |
4a16fb |
SNDERR("unable to info for slave pcm");
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
sprintf(name, "hw:CLASS=%i,SCLASS=0,CARD=%i,DEV=%i,SUBDEV=%i",
|
|
Packit |
4a16fb |
(int)SND_TIMER_CLASS_PCM,
|
|
Packit |
4a16fb |
snd_pcm_info_get_card(&info),
|
|
Packit |
4a16fb |
snd_pcm_info_get_device(&info),
|
|
Packit |
4a16fb |
snd_pcm_info_get_subdevice(&info) * 2 + capture);
|
|
Packit |
4a16fb |
ret = snd_timer_open(&dmix->timer, name,
|
|
Packit |
4a16fb |
SND_TIMER_OPEN_NONBLOCK | SND_TIMER_OPEN_TREAD);
|
|
Packit |
4a16fb |
if (ret < 0) {
|
|
Packit |
4a16fb |
dmix->tread = 0;
|
|
Packit |
4a16fb |
ret = snd_timer_open(&dmix->timer, name,
|
|
Packit |
4a16fb |
SND_TIMER_OPEN_NONBLOCK);
|
|
Packit |
4a16fb |
if (ret < 0) {
|
|
Packit |
4a16fb |
SNDERR("unable to open timer '%s'", name);
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
if (snd_timer_poll_descriptors_count(dmix->timer) != 1) {
|
|
Packit |
4a16fb |
SNDERR("unable to use timer '%s' with more than one fd!", name);
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
snd_timer_poll_descriptors(dmix->timer, &dmix->timer_fd, 1);
|
|
Packit |
4a16fb |
dmix->poll_fd = dmix->timer_fd.fd;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
dmix->timer_events = (1<
|
|
Packit |
4a16fb |
(1<
|
|
Packit |
4a16fb |
(1<
|
|
Packit |
4a16fb |
(1<
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
/*
|
|
Packit |
4a16fb |
* Some hacks for older kernel drivers
|
|
Packit |
4a16fb |
*/
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
int ver = 0;
|
|
Packit |
4a16fb |
ioctl(dmix->poll_fd, SNDRV_TIMER_IOCTL_PVERSION, &ver);
|
|
Packit |
4a16fb |
/* In older versions, check via poll before read() is needed
|
|
Packit |
4a16fb |
* because of the confliction between TIMER_START and
|
|
Packit |
4a16fb |
* FIONBIO ioctls.
|
|
Packit |
4a16fb |
*/
|
|
Packit |
4a16fb |
if (ver < SNDRV_PROTOCOL_VERSION(2, 0, 4))
|
|
Packit |
4a16fb |
dmix->timer_need_poll = 1;
|
|
Packit |
4a16fb |
/*
|
|
Packit |
4a16fb |
* In older versions, timer uses pause events instead
|
|
Packit |
4a16fb |
* suspend/resume events.
|
|
Packit |
4a16fb |
*/
|
|
Packit |
4a16fb |
if (ver < SNDRV_PROTOCOL_VERSION(2, 0, 5)) {
|
|
Packit |
4a16fb |
dmix->timer_events &= ~((1<
|
|
Packit |
4a16fb |
(1<
|
|
Packit |
4a16fb |
dmix->timer_events |= (1<
|
|
Packit |
4a16fb |
(1<
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
/* In older versions, use SND_TIMER_EVENT_START too.
|
|
Packit |
4a16fb |
*/
|
|
Packit |
4a16fb |
if (ver < SNDRV_PROTOCOL_VERSION(2, 0, 6))
|
|
Packit |
4a16fb |
dmix->timer_events |= 1<
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
return 0;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
static snd_pcm_uframes_t recalc_boundary_size(unsigned long long bsize, snd_pcm_uframes_t buffer_size)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
if (bsize > LONG_MAX) {
|
|
Packit |
4a16fb |
bsize = buffer_size;
|
|
Packit |
4a16fb |
while (bsize * 2 <= LONG_MAX - buffer_size)
|
|
Packit |
4a16fb |
bsize *= 2;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
return (snd_pcm_uframes_t)bsize;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
#define COPY_SLAVE(field) (spcm->field = dmix->shmptr->s.field)
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
/* copy the slave setting */
|
|
Packit |
4a16fb |
static void copy_slave_setting(snd_pcm_direct_t *dmix, snd_pcm_t *spcm)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
COPY_SLAVE(access);
|
|
Packit |
4a16fb |
COPY_SLAVE(format);
|
|
Packit |
4a16fb |
COPY_SLAVE(subformat);
|
|
Packit |
4a16fb |
COPY_SLAVE(channels);
|
|
Packit |
4a16fb |
COPY_SLAVE(rate);
|
|
Packit |
4a16fb |
COPY_SLAVE(period_size);
|
|
Packit |
4a16fb |
COPY_SLAVE(period_time);
|
|
Packit |
4a16fb |
COPY_SLAVE(periods);
|
|
Packit |
4a16fb |
COPY_SLAVE(tstamp_mode);
|
|
Packit |
4a16fb |
COPY_SLAVE(tstamp_type);
|
|
Packit |
4a16fb |
COPY_SLAVE(period_step);
|
|
Packit |
4a16fb |
COPY_SLAVE(avail_min);
|
|
Packit |
4a16fb |
COPY_SLAVE(start_threshold);
|
|
Packit |
4a16fb |
COPY_SLAVE(stop_threshold);
|
|
Packit |
4a16fb |
COPY_SLAVE(silence_threshold);
|
|
Packit |
4a16fb |
COPY_SLAVE(silence_size);
|
|
Packit |
4a16fb |
COPY_SLAVE(boundary);
|
|
Packit |
4a16fb |
COPY_SLAVE(info);
|
|
Packit |
4a16fb |
COPY_SLAVE(msbits);
|
|
Packit |
4a16fb |
COPY_SLAVE(rate_num);
|
|
Packit |
4a16fb |
COPY_SLAVE(rate_den);
|
|
Packit |
4a16fb |
COPY_SLAVE(hw_flags);
|
|
Packit |
4a16fb |
COPY_SLAVE(fifo_size);
|
|
Packit |
4a16fb |
COPY_SLAVE(buffer_size);
|
|
Packit |
4a16fb |
COPY_SLAVE(buffer_time);
|
|
Packit |
4a16fb |
COPY_SLAVE(sample_bits);
|
|
Packit |
4a16fb |
COPY_SLAVE(frame_bits);
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
spcm->info &= ~SND_PCM_INFO_PAUSE;
|
|
Packit |
4a16fb |
spcm->boundary = recalc_boundary_size(dmix->shmptr->s.boundary, spcm->buffer_size);
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
#undef COPY_SLAVE
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
/*
|
|
Packit |
4a16fb |
* open a slave PCM as secondary client (dup'ed fd)
|
|
Packit |
4a16fb |
*/
|
|
Packit |
4a16fb |
int snd_pcm_direct_open_secondary_client(snd_pcm_t **spcmp, snd_pcm_direct_t *dmix, const char *client_name)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
int ret;
|
|
Packit |
4a16fb |
snd_pcm_t *spcm;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
ret = snd_pcm_hw_open_fd(spcmp, client_name, dmix->hw_fd, 0);
|
|
Packit |
4a16fb |
if (ret < 0) {
|
|
Packit |
4a16fb |
SNDERR("unable to open hardware");
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
spcm = *spcmp;
|
|
Packit |
4a16fb |
spcm->donot_close = 1;
|
|
Packit |
4a16fb |
spcm->setup = 1;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
copy_slave_setting(dmix, spcm);
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
/* Use the slave setting as SPCM, so far */
|
|
Packit |
4a16fb |
dmix->slave_buffer_size = spcm->buffer_size;
|
|
Packit |
4a16fb |
dmix->slave_period_size = dmix->shmptr->s.period_size;
|
|
Packit |
4a16fb |
dmix->slave_boundary = spcm->boundary;
|
|
Packit |
4a16fb |
dmix->recoveries = dmix->shmptr->s.recoveries;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
ret = snd_pcm_mmap(spcm);
|
|
Packit |
4a16fb |
if (ret < 0) {
|
|
Packit |
4a16fb |
SNDERR("unable to mmap channels");
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
return 0;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
/*
|
|
Packit |
4a16fb |
* open a slave PCM as secondary client (dup'ed fd)
|
|
Packit |
4a16fb |
*/
|
|
Packit |
4a16fb |
int snd_pcm_direct_initialize_secondary_slave(snd_pcm_direct_t *dmix,
|
|
Packit |
4a16fb |
snd_pcm_t *spcm,
|
|
Packit |
4a16fb |
struct slave_params *params ATTRIBUTE_UNUSED)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
int ret;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
spcm->donot_close = 1;
|
|
Packit |
4a16fb |
spcm->setup = 1;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
copy_slave_setting(dmix, spcm);
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
/* Use the slave setting as SPCM, so far */
|
|
Packit |
4a16fb |
dmix->slave_buffer_size = spcm->buffer_size;
|
|
Packit |
4a16fb |
dmix->slave_period_size = dmix->shmptr->s.period_size;
|
|
Packit |
4a16fb |
dmix->slave_boundary = spcm->boundary;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
ret = snd_pcm_mmap(spcm);
|
|
Packit |
4a16fb |
if (ret < 0) {
|
|
Packit |
4a16fb |
SNDERR("unable to mmap channels");
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
return 0;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
int snd_pcm_direct_set_timer_params(snd_pcm_direct_t *dmix)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
snd_timer_params_t params = {0};
|
|
Packit |
4a16fb |
unsigned int filter;
|
|
Packit |
4a16fb |
int ret;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
snd_timer_params_set_auto_start(¶ms, 1);
|
|
Packit |
4a16fb |
if (dmix->type != SND_PCM_TYPE_DSNOOP)
|
|
Packit |
4a16fb |
snd_timer_params_set_early_event(¶ms, 1);
|
|
Packit |
4a16fb |
snd_timer_params_set_ticks(¶ms, dmix->timer_ticks);
|
|
Packit |
4a16fb |
if (dmix->tread) {
|
|
Packit |
4a16fb |
filter = (1<
|
|
Packit |
4a16fb |
dmix->timer_events;
|
|
Packit |
4a16fb |
INTERNAL(snd_timer_params_set_filter)(¶ms, filter);
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
ret = snd_timer_params(dmix->timer, ¶ms);
|
|
Packit |
4a16fb |
if (ret < 0) {
|
|
Packit |
4a16fb |
SNDERR("unable to set timer parameters");
|
|
Packit |
4a16fb |
return ret;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
return 0;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
/*
|
|
Packit |
4a16fb |
* ring buffer operation
|
|
Packit |
4a16fb |
*/
|
|
Packit |
4a16fb |
int snd_pcm_direct_check_interleave(snd_pcm_direct_t *dmix, snd_pcm_t *pcm)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
unsigned int chn, channels;
|
|
Packit |
4a16fb |
int bits, interleaved = 1;
|
|
Packit |
4a16fb |
const snd_pcm_channel_area_t *dst_areas;
|
|
Packit |
4a16fb |
const snd_pcm_channel_area_t *src_areas;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
bits = snd_pcm_format_physical_width(pcm->format);
|
|
Packit |
4a16fb |
if ((bits % 8) != 0)
|
|
Packit |
4a16fb |
interleaved = 0;
|
|
Packit |
4a16fb |
channels = dmix->channels;
|
|
Packit |
4a16fb |
dst_areas = snd_pcm_mmap_areas(dmix->spcm);
|
|
Packit |
4a16fb |
src_areas = snd_pcm_mmap_areas(pcm);
|
|
Packit |
4a16fb |
for (chn = 1; chn < channels; chn++) {
|
|
Packit |
4a16fb |
if (dst_areas[chn-1].addr != dst_areas[chn].addr) {
|
|
Packit |
4a16fb |
interleaved = 0;
|
|
Packit |
4a16fb |
break;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (src_areas[chn-1].addr != src_areas[chn].addr) {
|
|
Packit |
4a16fb |
interleaved = 0;
|
|
Packit |
4a16fb |
break;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
for (chn = 0; chn < channels; chn++) {
|
|
Packit |
4a16fb |
if (dmix->bindings && dmix->bindings[chn] != chn) {
|
|
Packit |
4a16fb |
interleaved = 0;
|
|
Packit |
4a16fb |
break;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (dst_areas[chn].first != chn * bits ||
|
|
Packit |
4a16fb |
dst_areas[chn].step != channels * bits) {
|
|
Packit |
4a16fb |
interleaved = 0;
|
|
Packit |
4a16fb |
break;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (src_areas[chn].first != chn * bits ||
|
|
Packit |
4a16fb |
src_areas[chn].step != channels * bits) {
|
|
Packit |
4a16fb |
interleaved = 0;
|
|
Packit |
4a16fb |
break;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
return dmix->interleaved = interleaved;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
/*
|
|
Packit |
4a16fb |
* parse the channel map
|
|
Packit |
4a16fb |
* id == client channel
|
|
Packit |
4a16fb |
* value == slave's channel
|
|
Packit |
4a16fb |
*/
|
|
Packit |
4a16fb |
int snd_pcm_direct_parse_bindings(snd_pcm_direct_t *dmix,
|
|
Packit |
4a16fb |
struct slave_params *params,
|
|
Packit |
4a16fb |
snd_config_t *cfg)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
snd_config_iterator_t i, next;
|
|
Packit |
4a16fb |
unsigned int chn, chn1, count = 0;
|
|
Packit |
4a16fb |
unsigned int *bindings;
|
|
Packit |
4a16fb |
int err;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
dmix->channels = UINT_MAX;
|
|
Packit |
4a16fb |
if (cfg == NULL)
|
|
Packit |
4a16fb |
return 0;
|
|
Packit |
4a16fb |
if (snd_config_get_type(cfg) != SND_CONFIG_TYPE_COMPOUND) {
|
|
Packit |
4a16fb |
SNDERR("invalid type for bindings");
|
|
Packit |
4a16fb |
return -EINVAL;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
snd_config_for_each(i, next, cfg) {
|
|
Packit |
4a16fb |
snd_config_t *n = snd_config_iterator_entry(i);
|
|
Packit |
4a16fb |
const char *id;
|
|
Packit |
4a16fb |
long cchannel;
|
|
Packit |
4a16fb |
if (snd_config_get_id(n, &id) < 0)
|
|
Packit |
4a16fb |
continue;
|
|
Packit |
4a16fb |
err = safe_strtol(id, &cchannel);
|
|
Packit |
4a16fb |
if (err < 0 || cchannel < 0) {
|
|
Packit |
4a16fb |
SNDERR("invalid client channel in binding: %s\n", id);
|
|
Packit |
4a16fb |
return -EINVAL;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if ((unsigned)cchannel >= count)
|
|
Packit |
4a16fb |
count = cchannel + 1;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (count == 0)
|
|
Packit |
4a16fb |
return 0;
|
|
Packit |
4a16fb |
if (count > 1024) {
|
|
Packit |
4a16fb |
SNDERR("client channel out of range");
|
|
Packit |
4a16fb |
return -EINVAL;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
bindings = malloc(count * sizeof(unsigned int));
|
|
Packit |
4a16fb |
if (bindings == NULL)
|
|
Packit |
4a16fb |
return -ENOMEM;
|
|
Packit |
4a16fb |
for (chn = 0; chn < count; chn++)
|
|
Packit |
4a16fb |
bindings[chn] = UINT_MAX; /* don't route */
|
|
Packit |
4a16fb |
snd_config_for_each(i, next, cfg) {
|
|
Packit |
4a16fb |
snd_config_t *n = snd_config_iterator_entry(i);
|
|
Packit |
4a16fb |
const char *id;
|
|
Packit |
4a16fb |
long cchannel, schannel;
|
|
Packit |
4a16fb |
if (snd_config_get_id(n, &id) < 0)
|
|
Packit |
4a16fb |
continue;
|
|
Packit |
4a16fb |
safe_strtol(id, &cchannel);
|
|
Packit |
4a16fb |
if (snd_config_get_integer(n, &schannel) < 0) {
|
|
Packit |
4a16fb |
SNDERR("unable to get slave channel (should be integer type) in binding: %s\n", id);
|
|
Packit |
4a16fb |
free(bindings);
|
|
Packit |
4a16fb |
return -EINVAL;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (schannel < 0 || schannel >= params->channels) {
|
|
Packit |
4a16fb |
SNDERR("invalid slave channel number %ld in binding to %ld",
|
|
Packit |
4a16fb |
schannel, cchannel);
|
|
Packit |
4a16fb |
free(bindings);
|
|
Packit |
4a16fb |
return -EINVAL;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
bindings[cchannel] = schannel;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (dmix->type == SND_PCM_TYPE_DSNOOP ||
|
|
Packit |
4a16fb |
! dmix->bindings)
|
|
Packit |
4a16fb |
goto __skip_same_dst;
|
|
Packit |
4a16fb |
for (chn = 0; chn < count; chn++) {
|
|
Packit |
4a16fb |
for (chn1 = 0; chn1 < count; chn1++) {
|
|
Packit |
4a16fb |
if (chn == chn1)
|
|
Packit |
4a16fb |
continue;
|
|
Packit |
4a16fb |
if (bindings[chn] == dmix->bindings[chn1]) {
|
|
Packit |
4a16fb |
SNDERR("unable to route channels %d,%d to same destination %d", chn, chn1, bindings[chn]);
|
|
Packit |
4a16fb |
free(bindings);
|
|
Packit |
4a16fb |
return -EINVAL;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
__skip_same_dst:
|
|
Packit |
4a16fb |
dmix->bindings = bindings;
|
|
Packit |
4a16fb |
dmix->channels = count;
|
|
Packit |
4a16fb |
return 0;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
/*
|
|
Packit |
4a16fb |
* parse slave config and calculate the ipc_key offset
|
|
Packit |
4a16fb |
*/
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
static int _snd_pcm_direct_get_slave_ipc_offset(snd_config_t *root,
|
|
Packit |
4a16fb |
snd_config_t *sconf,
|
|
Packit |
4a16fb |
int direction,
|
|
Packit |
4a16fb |
int hop)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
snd_config_iterator_t i, next;
|
|
Packit |
4a16fb |
snd_config_t *pcm_conf, *pcm_conf2;
|
|
Packit |
4a16fb |
int err;
|
|
Packit |
4a16fb |
long card = 0, device = 0, subdevice = 0;
|
|
Packit |
4a16fb |
const char *str;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
if (snd_config_get_string(sconf, &str) >= 0) {
|
|
Packit |
4a16fb |
if (hop > SND_CONF_MAX_HOPS) {
|
|
Packit |
4a16fb |
SNDERR("Too many definition levels (looped?)");
|
|
Packit |
4a16fb |
return -EINVAL;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
err = snd_config_search_definition(root, "pcm", str, &pcm_conf);
|
|
Packit |
4a16fb |
if (err < 0) {
|
|
Packit |
4a16fb |
SNDERR("Unknown slave PCM %s", str);
|
|
Packit |
4a16fb |
return err;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
err = _snd_pcm_direct_get_slave_ipc_offset(root, pcm_conf,
|
|
Packit |
4a16fb |
direction,
|
|
Packit |
4a16fb |
hop + 1);
|
|
Packit |
4a16fb |
snd_config_delete(pcm_conf);
|
|
Packit |
4a16fb |
return err;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
#if 0 /* for debug purposes */
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
snd_output_t *out;
|
|
Packit |
4a16fb |
snd_output_stdio_attach(&out, stderr, 0);
|
|
Packit |
4a16fb |
snd_config_save(sconf, out);
|
|
Packit |
4a16fb |
snd_output_close(out);
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
#endif
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
if (snd_config_search(sconf, "slave", &pcm_conf) >= 0) {
|
|
Packit |
4a16fb |
if (snd_config_search(pcm_conf, "pcm", &pcm_conf) >= 0) {
|
|
Packit |
4a16fb |
return _snd_pcm_direct_get_slave_ipc_offset(root,
|
|
Packit |
4a16fb |
pcm_conf,
|
|
Packit |
4a16fb |
direction,
|
|
Packit |
4a16fb |
hop + 1);
|
|
Packit |
4a16fb |
} else {
|
|
Packit |
4a16fb |
if (snd_config_get_string(pcm_conf, &str) >= 0 &&
|
|
Packit |
4a16fb |
snd_config_search_definition(root, "pcm_slave",
|
|
Packit |
4a16fb |
str, &pcm_conf) >= 0) {
|
|
Packit |
4a16fb |
if (snd_config_search(pcm_conf, "pcm",
|
|
Packit |
4a16fb |
&pcm_conf2) >= 0) {
|
|
Packit |
4a16fb |
err =
|
|
Packit |
4a16fb |
_snd_pcm_direct_get_slave_ipc_offset(
|
|
Packit |
4a16fb |
root, pcm_conf2, direction, hop + 1);
|
|
Packit |
4a16fb |
snd_config_delete(pcm_conf);
|
|
Packit |
4a16fb |
return err;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
snd_config_delete(pcm_conf);
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
snd_config_for_each(i, next, sconf) {
|
|
Packit |
4a16fb |
snd_config_t *n = snd_config_iterator_entry(i);
|
|
Packit |
4a16fb |
const char *id, *str;
|
|
Packit |
4a16fb |
if (snd_config_get_id(n, &id) < 0)
|
|
Packit |
4a16fb |
continue;
|
|
Packit |
4a16fb |
if (strcmp(id, "type") == 0) {
|
|
Packit |
4a16fb |
err = snd_config_get_string(n, &str);
|
|
Packit |
4a16fb |
if (err < 0) {
|
|
Packit |
4a16fb |
SNDERR("Invalid value for PCM type definition\n");
|
|
Packit |
4a16fb |
return -EINVAL;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (strcmp(str, "hw")) {
|
|
Packit |
4a16fb |
SNDERR("Invalid type '%s' for slave PCM\n", str);
|
|
Packit |
4a16fb |
return -EINVAL;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
continue;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (strcmp(id, "card") == 0) {
|
|
Packit |
4a16fb |
err = snd_config_get_integer(n, &card;;
|
|
Packit |
4a16fb |
if (err < 0) {
|
|
Packit |
4a16fb |
err = snd_config_get_string(n, &str);
|
|
Packit |
4a16fb |
if (err < 0) {
|
|
Packit |
4a16fb |
SNDERR("Invalid type for %s", id);
|
|
Packit |
4a16fb |
return -EINVAL;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
card = snd_card_get_index(str);
|
|
Packit |
4a16fb |
if (card < 0) {
|
|
Packit |
4a16fb |
SNDERR("Invalid value for %s", id);
|
|
Packit |
4a16fb |
return card;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
continue;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (strcmp(id, "device") == 0) {
|
|
Packit |
4a16fb |
err = snd_config_get_integer(n, &device);
|
|
Packit |
4a16fb |
if (err < 0) {
|
|
Packit |
4a16fb |
SNDERR("Invalid type for %s", id);
|
|
Packit |
4a16fb |
return err;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
continue;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (strcmp(id, "subdevice") == 0) {
|
|
Packit |
4a16fb |
err = snd_config_get_integer(n, &subdevice);
|
|
Packit |
4a16fb |
if (err < 0) {
|
|
Packit |
4a16fb |
SNDERR("Invalid type for %s", id);
|
|
Packit |
4a16fb |
return err;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
continue;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (card < 0)
|
|
Packit |
4a16fb |
card = 0;
|
|
Packit |
4a16fb |
if (device < 0)
|
|
Packit |
4a16fb |
device = 0;
|
|
Packit |
4a16fb |
if (subdevice < 0)
|
|
Packit |
4a16fb |
subdevice = 0;
|
|
Packit |
4a16fb |
return (direction << 1) + (device << 2) + (subdevice << 8) + (card << 12);
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
static int snd_pcm_direct_get_slave_ipc_offset(snd_config_t *root,
|
|
Packit |
4a16fb |
snd_config_t *sconf,
|
|
Packit |
4a16fb |
int direction)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
return _snd_pcm_direct_get_slave_ipc_offset(root, sconf, direction, 0);
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
int snd_pcm_direct_parse_open_conf(snd_config_t *root, snd_config_t *conf,
|
|
Packit |
4a16fb |
int stream, struct snd_pcm_direct_open_conf *rec)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
snd_config_iterator_t i, next;
|
|
Packit |
4a16fb |
int ipc_key_add_uid = 0;
|
|
Packit |
4a16fb |
snd_config_t *n;
|
|
Packit |
4a16fb |
int err;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
rec->slave = NULL;
|
|
Packit |
4a16fb |
rec->bindings = NULL;
|
|
Packit |
4a16fb |
rec->ipc_key = 0;
|
|
Packit |
4a16fb |
rec->ipc_perm = 0600;
|
|
Packit |
4a16fb |
rec->ipc_gid = -1;
|
|
Packit |
4a16fb |
rec->slowptr = 1;
|
|
Packit |
4a16fb |
rec->max_periods = 0;
|
|
Packit |
4a16fb |
rec->var_periodsize = 0;
|
|
Packit |
4a16fb |
rec->direct_memory_access = 1;
|
|
Packit |
4a16fb |
rec->hw_ptr_alignment = SND_PCM_HW_PTR_ALIGNMENT_AUTO;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
/* read defaults */
|
|
Packit |
4a16fb |
if (snd_config_search(root, "defaults.pcm.dmix_max_periods", &n) >= 0) {
|
|
Packit |
4a16fb |
long val;
|
|
Packit |
4a16fb |
err = snd_config_get_integer(n, &val;;
|
|
Packit |
4a16fb |
if (err >= 0)
|
|
Packit |
4a16fb |
rec->max_periods = val;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
snd_config_for_each(i, next, conf) {
|
|
Packit |
4a16fb |
const char *id;
|
|
Packit |
4a16fb |
n = snd_config_iterator_entry(i);
|
|
Packit |
4a16fb |
if (snd_config_get_id(n, &id) < 0)
|
|
Packit |
4a16fb |
continue;
|
|
Packit |
4a16fb |
if (snd_pcm_conf_generic_id(id))
|
|
Packit |
4a16fb |
continue;
|
|
Packit |
4a16fb |
if (strcmp(id, "ipc_key") == 0) {
|
|
Packit |
4a16fb |
long key;
|
|
Packit |
4a16fb |
err = snd_config_get_integer(n, &key);
|
|
Packit |
4a16fb |
if (err < 0) {
|
|
Packit |
4a16fb |
SNDERR("The field ipc_key must be an integer type");
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
return err;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
rec->ipc_key = key;
|
|
Packit |
4a16fb |
continue;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (strcmp(id, "ipc_perm") == 0) {
|
|
Packit |
4a16fb |
long perm;
|
|
Packit |
4a16fb |
err = snd_config_get_integer(n, &perm);
|
|
Packit |
4a16fb |
if (err < 0) {
|
|
Packit |
4a16fb |
SNDERR("Invalid type for %s", id);
|
|
Packit |
4a16fb |
return err;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if ((perm & ~0777) != 0) {
|
|
Packit |
4a16fb |
SNDERR("The field ipc_perm must be a valid file permission");
|
|
Packit |
4a16fb |
return -EINVAL;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
rec->ipc_perm = perm;
|
|
Packit |
4a16fb |
continue;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (strcmp(id, "hw_ptr_alignment") == 0) {
|
|
Packit |
4a16fb |
const char *str;
|
|
Packit |
4a16fb |
err = snd_config_get_string(n, &str);
|
|
Packit |
4a16fb |
if (err < 0) {
|
|
Packit |
4a16fb |
SNDERR("Invalid type for %s", id);
|
|
Packit |
4a16fb |
return -EINVAL;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (strcmp(str, "no") == 0)
|
|
Packit |
4a16fb |
rec->hw_ptr_alignment = SND_PCM_HW_PTR_ALIGNMENT_NO;
|
|
Packit |
4a16fb |
else if (strcmp(str, "roundup") == 0)
|
|
Packit |
4a16fb |
rec->hw_ptr_alignment = SND_PCM_HW_PTR_ALIGNMENT_ROUNDUP;
|
|
Packit |
4a16fb |
else if (strcmp(str, "rounddown") == 0)
|
|
Packit |
4a16fb |
rec->hw_ptr_alignment = SND_PCM_HW_PTR_ALIGNMENT_ROUNDDOWN;
|
|
Packit |
4a16fb |
else if (strcmp(str, "auto") == 0)
|
|
Packit |
4a16fb |
rec->hw_ptr_alignment = SND_PCM_HW_PTR_ALIGNMENT_AUTO;
|
|
Packit |
4a16fb |
else {
|
|
Packit |
4a16fb |
SNDERR("The field hw_ptr_alignment is invalid : %s", str);
|
|
Packit |
4a16fb |
return -EINVAL;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
continue;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (strcmp(id, "ipc_gid") == 0) {
|
|
Packit |
4a16fb |
char *group;
|
|
Packit |
4a16fb |
char *endp;
|
|
Packit |
4a16fb |
err = snd_config_get_ascii(n, &group);
|
|
Packit |
4a16fb |
if (err < 0) {
|
|
Packit |
4a16fb |
SNDERR("The field ipc_gid must be a valid group");
|
|
Packit |
4a16fb |
return err;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (! *group) {
|
|
Packit |
4a16fb |
rec->ipc_gid = -1;
|
|
Packit |
4a16fb |
free(group);
|
|
Packit |
4a16fb |
continue;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (isdigit(*group) == 0) {
|
|
Packit |
4a16fb |
long clen = sysconf(_SC_GETGR_R_SIZE_MAX);
|
|
Packit |
4a16fb |
size_t len = (clen == -1) ? 1024 : (size_t)clen;
|
|
Packit |
4a16fb |
struct group grp, *pgrp;
|
|
Packit |
4a16fb |
char *buffer = (char *)malloc(len);
|
|
Packit |
4a16fb |
if (buffer == NULL)
|
|
Packit |
4a16fb |
return -ENOMEM;
|
|
Packit |
4a16fb |
int st = getgrnam_r(group, &grp, buffer, len, &pgrp);
|
|
Packit |
4a16fb |
if (st != 0 || !pgrp) {
|
|
Packit |
4a16fb |
SNDERR("The field ipc_gid must be a valid group (create group %s)", group);
|
|
Packit |
4a16fb |
free(buffer);
|
|
Packit |
4a16fb |
return -EINVAL;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
rec->ipc_gid = pgrp->gr_gid;
|
|
Packit |
4a16fb |
free(buffer);
|
|
Packit |
4a16fb |
} else {
|
|
Packit |
4a16fb |
rec->ipc_gid = strtol(group, &endp, 10);
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
free(group);
|
|
Packit |
4a16fb |
continue;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (strcmp(id, "ipc_key_add_uid") == 0) {
|
|
Packit |
4a16fb |
if ((err = snd_config_get_bool(n)) < 0) {
|
|
Packit |
4a16fb |
SNDERR("The field ipc_key_add_uid must be a boolean type");
|
|
Packit |
4a16fb |
return err;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
ipc_key_add_uid = err;
|
|
Packit |
4a16fb |
continue;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (strcmp(id, "slave") == 0) {
|
|
Packit |
4a16fb |
rec->slave = n;
|
|
Packit |
4a16fb |
continue;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (strcmp(id, "bindings") == 0) {
|
|
Packit |
4a16fb |
rec->bindings = n;
|
|
Packit |
4a16fb |
continue;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (strcmp(id, "slowptr") == 0) {
|
|
Packit |
4a16fb |
err = snd_config_get_bool(n);
|
|
Packit |
4a16fb |
if (err < 0)
|
|
Packit |
4a16fb |
return err;
|
|
Packit |
4a16fb |
rec->slowptr = err;
|
|
Packit |
4a16fb |
continue;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (strcmp(id, "max_periods") == 0) {
|
|
Packit |
4a16fb |
long val;
|
|
Packit |
4a16fb |
err = snd_config_get_integer(n, &val;;
|
|
Packit |
4a16fb |
if (err < 0)
|
|
Packit |
4a16fb |
return err;
|
|
Packit |
4a16fb |
rec->max_periods = val;
|
|
Packit |
4a16fb |
continue;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (strcmp(id, "var_periodsize") == 0) {
|
|
Packit |
4a16fb |
err = snd_config_get_bool(n);
|
|
Packit |
4a16fb |
if (err < 0)
|
|
Packit |
4a16fb |
return err;
|
|
Packit |
4a16fb |
rec->var_periodsize = err;
|
|
Packit |
4a16fb |
continue;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (strcmp(id, "direct_memory_access") == 0) {
|
|
Packit |
4a16fb |
err = snd_config_get_bool(n);
|
|
Packit |
4a16fb |
if (err < 0)
|
|
Packit |
4a16fb |
return err;
|
|
Packit |
4a16fb |
rec->direct_memory_access = err;
|
|
Packit |
4a16fb |
continue;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
SNDERR("Unknown field %s", id);
|
|
Packit |
4a16fb |
return -EINVAL;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (!rec->slave) {
|
|
Packit |
4a16fb |
SNDERR("slave is not defined");
|
|
Packit |
4a16fb |
return -EINVAL;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (!rec->ipc_key) {
|
|
Packit |
4a16fb |
SNDERR("Unique IPC key is not defined");
|
|
Packit |
4a16fb |
return -EINVAL;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
if (ipc_key_add_uid)
|
|
Packit |
4a16fb |
rec->ipc_key += getuid();
|
|
Packit |
4a16fb |
err = snd_pcm_direct_get_slave_ipc_offset(root, conf, stream);
|
|
Packit |
4a16fb |
if (err < 0)
|
|
Packit |
4a16fb |
return err;
|
|
Packit |
4a16fb |
rec->ipc_key += err;
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
return 0;
|
|
Packit |
4a16fb |
}
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
void snd_pcm_direct_reset_slave_ptr(snd_pcm_t *pcm, snd_pcm_direct_t *dmix)
|
|
Packit |
4a16fb |
{
|
|
Packit |
4a16fb |
|
|
Packit |
4a16fb |
if (dmix->hw_ptr_alignment == SND_PCM_HW_PTR_ALIGNMENT_ROUNDUP ||
|
|
Packit |
4a16fb |
(dmix->hw_ptr_alignment == SND_PCM_HW_PTR_ALIGNMENT_AUTO &&
|
|
Packit |
4a16fb |
pcm->buffer_size <= pcm->period_size * 2))
|
|
Packit |
4a16fb |
dmix->slave_appl_ptr =
|
|
Packit |
4a16fb |
((dmix->slave_appl_ptr + dmix->slave_period_size - 1) /
|
|
Packit |
4a16fb |
dmix->slave_period_size) * dmix->slave_period_size;
|
|
Packit |
4a16fb |
else if (dmix->hw_ptr_alignment == SND_PCM_HW_PTR_ALIGNMENT_ROUNDDOWN ||
|
|
Packit |
4a16fb |
(dmix->hw_ptr_alignment == SND_PCM_HW_PTR_ALIGNMENT_AUTO &&
|
|
Packit |
4a16fb |
(dmix->slave_period_size * SEC_TO_MS) /
|
|
Packit |
4a16fb |
pcm->rate < LOW_LATENCY_PERIOD_TIME))
|
|
Packit |
4a16fb |
dmix->slave_appl_ptr = dmix->slave_hw_ptr =
|
|
Packit |
4a16fb |
((dmix->slave_hw_ptr / dmix->slave_period_size) *
|
|
Packit |
4a16fb |
dmix->slave_period_size);
|
|
Packit |
4a16fb |
}
|