static int process_render(struct userdata *u) {
pa_assert(u);
if (u->memchunk.length <= 0)
pa_sink_render(u->sink, pa_frame_align(pa_pipe_buf(u->fd), &u->sink->sample_spec), &u->memchunk);
pa_assert(u->memchunk.length > 0);
for (;;) {
ssize_t l;
void *p;
p = pa_memblock_acquire(u->memchunk.memblock);
l = pa_write(u->fd, (uint8_t*) p + u->memchunk.index, u->memchunk.length, &u->write_type);
pa_memblock_release(u->memchunk.memblock);
pa_assert(l != 0);
if (l < 0) {
if (errno == EINTR)
continue;
else if (errno == EAGAIN)
return 0;
else {
pa_log("Failed to write data to FIFO: %s", pa_cstrerror(errno));
return -1;
}
} else {
u->memchunk.index += (size_t) l;
u->memchunk.length -= (size_t) l;
if (u->memchunk.length <= 0) {
pa_memblock_unref(u->memchunk.memblock);
pa_memchunk_reset(&u->memchunk);
}
}
return 0;
}
}
int pa__init(pa_module *m) {
struct userdata *u;
struct stat st;
pa_sample_spec ss;
pa_channel_map map;
pa_modargs *ma;
struct pollfd *pollfd;
pa_source_new_data data;
pa_assert(m);
if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
pa_log("Failed to parse module arguments.");
goto fail;
}
ss = m->core->default_sample_spec;
map = m->core->default_channel_map;
if (pa_modargs_get_sample_spec_and_channel_map(ma, &ss, &map, PA_CHANNEL_MAP_DEFAULT) < 0) {
pa_log("Invalid sample format specification or channel map");
goto fail;
}
m->userdata = u = pa_xnew0(struct userdata, 1);
u->core = m->core;
u->module = m;
pa_memchunk_reset(&u->memchunk);
u->rtpoll = pa_rtpoll_new();
if (pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll) < 0) {
pa_log("pa_thread_mq_init() failed.");
goto fail;
}
u->filename = pa_runtime_path(pa_modargs_get_value(ma, "file", DEFAULT_FILE_NAME));
if (mkfifo(u->filename, 0666) < 0) {
pa_log("mkfifo('%s'): %s", u->filename, pa_cstrerror(errno));
goto fail;
}
if ((u->fd = pa_open_cloexec(u->filename, O_RDWR, 0)) < 0) {
pa_log("open('%s'): %s", u->filename, pa_cstrerror(errno));
goto fail;
}
pa_make_fd_nonblock(u->fd);
if (fstat(u->fd, &st) < 0) {
pa_log("fstat('%s'): %s", u->filename, pa_cstrerror(errno));
goto fail;
}
if (!S_ISFIFO(st.st_mode)) {
pa_log("'%s' is not a FIFO.", u->filename);
goto fail;
}
pa_source_new_data_init(&data);
data.driver = __FILE__;
data.module = m;
pa_source_new_data_set_name(&data, pa_modargs_get_value(ma, "source_name", DEFAULT_SOURCE_NAME));
pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, u->filename);
pa_proplist_setf(data.proplist, PA_PROP_DEVICE_DESCRIPTION, "Unix FIFO source %s", u->filename);
pa_source_new_data_set_sample_spec(&data, &ss);
pa_source_new_data_set_channel_map(&data, &map);
if (pa_modargs_get_proplist(ma, "source_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
pa_log("Invalid properties");
pa_source_new_data_done(&data);
goto fail;
}
u->source = pa_source_new(m->core, &data, PA_SOURCE_LATENCY);
pa_source_new_data_done(&data);
if (!u->source) {
pa_log("Failed to create source.");
goto fail;
}
u->source->parent.process_msg = source_process_msg;
u->source->userdata = u;
pa_source_set_asyncmsgq(u->source, u->thread_mq.inq);
pa_source_set_rtpoll(u->source, u->rtpoll);
pa_source_set_fixed_latency(u->source, pa_bytes_to_usec(pa_pipe_buf(u->fd), &u->source->sample_spec));
u->rtpoll_item = pa_rtpoll_item_new(u->rtpoll, PA_RTPOLL_NEVER, 1);
pollfd = pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL);
pollfd->fd = u->fd;
pollfd->events = pollfd->revents = 0;
if (!(u->thread = pa_thread_new("pipe-source", thread_func, u))) {
pa_log("Failed to create thread.");
goto fail;
}
pa_source_put(u->source);
pa_modargs_free(ma);
return 0;
fail:
if (ma)
pa_modargs_free(ma);
pa__done(m);
return -1;
}
static void thread_func(void *userdata) {
struct userdata *u = userdata;
int read_type = 0;
pa_assert(u);
pa_log_debug("Thread starting up");
pa_thread_mq_install(&u->thread_mq);
for (;;) {
int ret;
struct pollfd *pollfd;
pollfd = pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL);
/* Try to read some data and pass it on to the source driver */
if (u->source->thread_info.state == PA_SOURCE_RUNNING && pollfd->revents) {
ssize_t l;
void *p;
if (!u->memchunk.memblock) {
u->memchunk.memblock = pa_memblock_new(u->core->mempool, pa_pipe_buf(u->fd));
u->memchunk.index = u->memchunk.length = 0;
}
pa_assert(pa_memblock_get_length(u->memchunk.memblock) > u->memchunk.index);
p = pa_memblock_acquire(u->memchunk.memblock);
l = pa_read(u->fd, (uint8_t*) p + u->memchunk.index, pa_memblock_get_length(u->memchunk.memblock) - u->memchunk.index, &read_type);
pa_memblock_release(u->memchunk.memblock);
pa_assert(l != 0); /* EOF cannot happen, since we opened the fifo for both reading and writing */
if (l < 0) {
if (errno == EINTR)
continue;
else if (errno != EAGAIN) {
pa_log("Failed to read data from FIFO: %s", pa_cstrerror(errno));
goto fail;
}
} else {
u->memchunk.length = (size_t) l;
pa_source_post(u->source, &u->memchunk);
u->memchunk.index += (size_t) l;
if (u->memchunk.index >= pa_memblock_get_length(u->memchunk.memblock)) {
pa_memblock_unref(u->memchunk.memblock);
pa_memchunk_reset(&u->memchunk);
}
pollfd->revents = 0;
}
}
/* Hmm, nothing to do. Let's sleep */
pollfd->events = (short) (u->source->thread_info.state == PA_SOURCE_RUNNING ? POLLIN : 0);
if ((ret = pa_rtpoll_run(u->rtpoll)) < 0)
goto fail;
if (ret == 0)
goto finish;
pollfd = pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL);
if (pollfd->revents & ~POLLIN) {
pa_log("FIFO shutdown.");
goto fail;
}
}
fail:
/* If this was no regular exit from the loop we have to continue
* processing messages until we received PA_MESSAGE_SHUTDOWN */
pa_asyncmsgq_post(u->thread_mq.outq, PA_MSGOBJECT(u->core), PA_CORE_MESSAGE_UNLOAD_MODULE, u->module, 0, NULL, NULL);
pa_asyncmsgq_wait_for(u->thread_mq.inq, PA_MESSAGE_SHUTDOWN);
finish:
pa_log_debug("Thread shutting down");
}
int main(int argc, char*argv[]) {
pid_t pid;
int fd = -1;
int ret = 1, i;
struct sockaddr_un sa;
char *ibuf = NULL;
char *obuf = NULL;
size_t buf_size, ibuf_size, ibuf_index, ibuf_length, obuf_size, obuf_index, obuf_length;
char *cli;
bool ibuf_eof, obuf_eof, ibuf_closed, obuf_closed;
struct pollfd pollfd[3];
struct pollfd *watch_socket, *watch_stdin, *watch_stdout;
int stdin_type = 0, stdout_type = 0, fd_type = 0;
char *bn = NULL;
int c;
static const struct option long_options[] = {
{"version", 0, NULL, ARG_VERSION},
{"help", 0, NULL, 'h'},
{NULL, 0, NULL, 0}
};
setlocale(LC_ALL, "");
#ifdef ENABLE_NLS
bindtextdomain(GETTEXT_PACKAGE, PULSE_LOCALEDIR);
#endif
bn = pa_path_get_filename(argv[0]);
while ((c = getopt_long(argc, argv, "h", long_options, NULL)) != -1) {
switch (c) {
case 'h' :
help(bn);
ret = 0;
goto quit;
case ARG_VERSION:
printf(_("pacmd %s\n"
"Compiled with libpulse %s\n"
"Linked with libpulse %s\n"),
PACKAGE_VERSION,
pa_get_headers_version(),
pa_get_library_version());
ret = 0;
goto quit;
default:
goto quit;
}
}
if (pa_pid_file_check_running(&pid, "pulseaudio") < 0) {
pa_log(_("No PulseAudio daemon running, or not running as session daemon."));
goto quit;
}
if ((fd = pa_socket_cloexec(PF_UNIX, SOCK_STREAM, 0)) < 0) {
pa_log(_("socket(PF_UNIX, SOCK_STREAM, 0): %s"), strerror(errno));
goto quit;
}
pa_zero(sa);
sa.sun_family = AF_UNIX;
if (!(cli = pa_runtime_path("cli")))
goto quit;
pa_strlcpy(sa.sun_path, cli, sizeof(sa.sun_path));
pa_xfree(cli);
for (i = 0; i < 5; i++) {
int r;
if ((r = connect(fd, (struct sockaddr*) &sa, sizeof(sa))) < 0 && (errno != ECONNREFUSED && errno != ENOENT)) {
pa_log(_("connect(): %s"), strerror(errno));
goto quit;
}
if (r >= 0)
break;
if (pa_pid_file_kill(SIGUSR2, NULL, "pulseaudio") < 0) {
pa_log(_("Failed to kill PulseAudio daemon."));
goto quit;
}
pa_msleep(300);
}
if (i >= 5) {
pa_log(_("Daemon not responding."));
goto quit;
}
buf_size = pa_pipe_buf(fd);
ibuf_size = PA_MIN(buf_size, pa_pipe_buf(STDIN_FILENO));
ibuf = pa_xmalloc(ibuf_size);
obuf_size = PA_MIN(buf_size, pa_pipe_buf(STDOUT_FILENO));
obuf = pa_xmalloc(obuf_size);
ibuf_index = ibuf_length = obuf_index = obuf_length = 0;
ibuf_eof = obuf_eof = ibuf_closed = obuf_closed = false;
if (argc > 1) {
for (i = 1; i < argc; i++) {
size_t k;
k = PA_MIN(ibuf_size - ibuf_length, strlen(argv[i]));
memcpy(ibuf + ibuf_length, argv[i], k);
ibuf_length += k;
if (ibuf_length < ibuf_size) {
ibuf[ibuf_length] = i < argc-1 ? ' ' : '\n';
ibuf_length++;
}
}
ibuf_eof = true;
}
if (!ibuf_eof && isatty(STDIN_FILENO)) {
/* send hello to enable interactive mode (welcome message, prompt) */
if (pa_write(fd, "hello\n", 6, &fd_type) < 0) {
pa_log(_("write(): %s"), strerror(errno));
goto quit;
}
}
for (;;) {
struct pollfd *p;
if (ibuf_eof &&
obuf_eof &&
ibuf_length <= 0 &&
obuf_length <= 0)
break;
if (ibuf_length <= 0 && ibuf_eof && !ibuf_closed) {
shutdown(fd, SHUT_WR);
ibuf_closed = true;
}
if (obuf_length <= 0 && obuf_eof && !obuf_closed) {
shutdown(fd, SHUT_RD);
obuf_closed = true;
}
pa_zero(pollfd);
p = pollfd;
if (ibuf_length > 0 || (!obuf_eof && obuf_length <= 0)) {
watch_socket = p++;
watch_socket->fd = fd;
watch_socket->events =
(ibuf_length > 0 ? POLLOUT : 0) |
(!obuf_eof && obuf_length <= 0 ? POLLIN : 0);
} else
watch_socket = NULL;
if (!ibuf_eof && ibuf_length <= 0) {
watch_stdin = p++;
watch_stdin->fd = STDIN_FILENO;
watch_stdin->events = POLLIN;
} else
watch_stdin = NULL;
if (obuf_length > 0) {
watch_stdout = p++;
watch_stdout->fd = STDOUT_FILENO;
watch_stdout->events = POLLOUT;
} else
watch_stdout = NULL;
if (pa_poll(pollfd, p-pollfd, -1) < 0) {
if (errno == EINTR)
continue;
pa_log(_("poll(): %s"), strerror(errno));
goto quit;
}
if (watch_stdin) {
if (watch_stdin->revents & POLLIN) {
ssize_t r;
pa_assert(ibuf_length <= 0);
if ((r = pa_read(STDIN_FILENO, ibuf, ibuf_size, &stdin_type)) <= 0) {
if (r < 0) {
pa_log(_("read(): %s"), strerror(errno));
goto quit;
}
ibuf_eof = true;
} else {
ibuf_length = (size_t) r;
ibuf_index = 0;
}
} else if (watch_stdin->revents & POLLHUP)
ibuf_eof = true;
}
if (watch_socket) {
if (watch_socket->revents & POLLIN) {
ssize_t r;
pa_assert(obuf_length <= 0);
if ((r = pa_read(fd, obuf, obuf_size, &fd_type)) <= 0) {
if (r < 0) {
pa_log(_("read(): %s"), strerror(errno));
goto quit;
}
obuf_eof = true;
} else {
obuf_length = (size_t) r;
obuf_index = 0;
}
} else if (watch_socket->revents & POLLHUP)
obuf_eof = true;
}
if (watch_stdout) {
if (watch_stdout->revents & POLLHUP) {
obuf_eof = true;
obuf_length = 0;
} else if (watch_stdout->revents & POLLOUT) {
ssize_t r;
pa_assert(obuf_length > 0);
if ((r = pa_write(STDOUT_FILENO, obuf + obuf_index, obuf_length, &stdout_type)) < 0) {
pa_log(_("write(): %s"), strerror(errno));
goto quit;
}
obuf_length -= (size_t) r;
obuf_index += obuf_index;
}
}
if (watch_socket) {
if (watch_socket->revents & POLLHUP) {
ibuf_eof = true;
ibuf_length = 0;
} if (watch_socket->revents & POLLOUT) {
ssize_t r;
pa_assert(ibuf_length > 0);
if ((r = pa_write(fd, ibuf + ibuf_index, ibuf_length, &fd_type)) < 0) {
pa_log(_("write(): %s"), strerror(errno));
goto quit;
}
ibuf_length -= (size_t) r;
ibuf_index += obuf_index;
}
}
}
ret = 0;
quit:
if (fd >= 0)
pa_close(fd);
pa_xfree(obuf);
pa_xfree(ibuf);
return ret;
}
