mirrors/pulseaudio
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pulseaudio/pulseaudio.git synced 2025-11-05 13:29:57 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

Reorganised the source tree. We now have src/ with a couple of subdirs:

Browse source 
* daemon/ - Contains the files specific to the polypaudio daemon.
 * modules/ - All loadable modules.
 * polyp/ - Files that are part of the public, application interface or
   are only used in libpolyp.
 * polypcore/ - All other shared files.
 * tests/ - Test programs.
 * utils/ - Utility programs.


git-svn-id: file:///home/lennart/svn/public/pulseaudio/trunk@487 fefdeb5f-60dc-0310-8127-8f9354f1896f
This commit is contained in:
Pierre Ossman 2006-02-16 19:19:58 +00:00
parent 5b881e6228
commit e205b25d65
246 changed files with 724 additions and 689 deletions
Download patch file Download diff file Expand all files Collapse all files

98
src/utils/esdcompat.sh.in Executable file
View file

@ -0,0 +1,98 @@
#!/bin/sh
# $Id$
#
# This file is part of polypaudio.
#
# polypaudio is free software; you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# polypaudio is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with polypaudio; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
# USA.
VERSION_STRING="@PACKAGE_NAME@ esd wrapper @PACKAGE_VERSION@"
fail() {
echo "ERROR: $1"
exit 1
}
ARGS=" --log-target=syslog"
for N in $(seq $#) ; do
case "$1" in
"")
;;
-v|--version)
echo "$VERSION_STRING"
exit 0
;;
-h|--help)
cat <<EOF
$VERSION_STRING
Usage: $0 [options]
-v --version print version information
-h --help show this help
Ignored directives:
-tcp use tcp/ip sockets in addition to unix domain
-promiscuous don't require authentication
-d DEVICE force esd to use sound device DEVICE
-b run server in 8 bit sound mode
-r RATE run server at sample rate of RATE
-as SECS free audio device after SECS of inactivity
-unix use unix domain sockets instead of tcp/ip
-public make tcp/ip access public (other than localhost)
-terminate terminate esd daemone after last client exits
-nobeeps disable startup beeps
-trust start esd even if use of /tmp/.esd can be insecure
-port PORT listen for connections at PORT (only for tcp/ip)
-bind ADDRESS binds to ADDRESS (only for tcp/ip)
EOF
exit 0
;;
-spawnpid)
shift
ARGS="$ARGS '-Lmodule-esound-compat-spawnpid pid=$1'"
;;
-spawnfd)
shift
ARGS="$ARGS '-Lmodule-esound-compat-spawnfd fd=$1'"
;;
-unix|-b|-public|-terminate|-nobeeps|-trust|-tcp|-promiscuous)
# Ignore these commands
;;
-d|-r|-as|-port|-bind)
# Ignore these commands and their arguments
shift
;;
*)
fail "Unknown command: $1"
;;
esac
shift
done
eval "exec '@POLYPAUDIO_BINARY@'$ARGS"

139
src/utils/pabrowse.c Normal file
View file

@ -0,0 +1,139 @@
/* $Id$ */
/***
This file is part of polypaudio.
polypaudio is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.
polypaudio is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with polypaudio; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
USA.
***/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <stdio.h>
#include <assert.h>
#include <signal.h>
#include <polyp/mainloop.h>
#include <polyp/mainloop-signal.h>
#include <polyp/polyplib-browser.h>
#include <polyp/typeid.h>
static void exit_signal_callback(pa_mainloop_api*m, pa_signal_event *e, int sig, void *userdata) {
fprintf(stderr, "Got signal, exiting\n");
m->quit(m, 0);
}
static void dump_server(const pa_browse_info *i) {
char t[16];
if (i->cookie)
snprintf(t, sizeof(t), "0x%08x", *i->cookie);
printf("server: %s\n"
"server-version: %s\n"
"user-name: %s\n"
"fqdn: %s\n"
"cookie: %s\n",
i->server,
i->server_version ? i->server_version : "n/a",
i->user_name ? i->user_name : "n/a",
i->fqdn ? i->fqdn : "n/a",
i->cookie ? t : "n/a");
}
static void dump_device(const pa_browse_info *i) {
char t[16], ss[PA_SAMPLE_SPEC_SNPRINT_MAX];
if (i->sample_spec)
pa_sample_spec_snprint(ss, sizeof(ss), i->sample_spec);
if (i->typeid)
pa_typeid_to_string(*i->typeid, t, sizeof(t));
printf("device: %s\n"
"description: %s\n"
"type: %s\n"
"sample spec: %s\n",
i->device,
i->description ? i->description : "n/a",
i->typeid ? t : "n/a",
i->sample_spec ? ss : "n/a");
}
static void browser_callback(pa_browser *b, pa_browse_opcode c, const pa_browse_info *i, void *userdata) {
assert(b && i);
switch (c) {
case PA_BROWSE_NEW_SERVER:
printf("\n=> new server <%s>\n", i->name);
dump_server(i);
break;
case PA_BROWSE_NEW_SINK:
printf("\n=> new sink <%s>\n", i->name);
dump_server(i);
dump_device(i);
break;
case PA_BROWSE_NEW_SOURCE:
printf("\n=> new source <%s>\n", i->name);
dump_server(i);
dump_device(i);
break;
case PA_BROWSE_REMOVE:
printf("\n=> removed service <%s>\n", i->name);
break;
default:
;
}
}
int main(int argc, char *argv[]) {
pa_mainloop *mainloop = NULL;
pa_browser *browser = NULL;
int ret = 1, r;
if (!(mainloop = pa_mainloop_new()))
goto finish;
r = pa_signal_init(pa_mainloop_get_api(mainloop));
assert(r == 0);
pa_signal_new(SIGINT, exit_signal_callback, NULL);
pa_signal_new(SIGTERM, exit_signal_callback, NULL);
signal(SIGPIPE, SIG_IGN);
if (!(browser = pa_browser_new(pa_mainloop_get_api(mainloop))))
goto finish;
pa_browser_set_callback(browser, browser_callback, NULL);
ret = 0;
pa_mainloop_run(mainloop, &ret);
finish:
if (mainloop) {
pa_signal_done();
pa_mainloop_free(mainloop);
}
return ret;
}

541
src/utils/pacat.c Normal file
View file

@ -0,0 +1,541 @@
/* $Id$ */
/***
This file is part of polypaudio.
polypaudio is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.
polypaudio is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with polypaudio; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
USA.
***/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <signal.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <getopt.h>
#include <polyp/polyplib.h>
#include <polyp/polyplib-error.h>
#include <polyp/mainloop.h>
#include <polyp/mainloop-signal.h>
#include <polyp/polyplib-version.h>
#if PA_API_VERSION != 8
#error Invalid Polypaudio API version
#endif
static enum { RECORD, PLAYBACK } mode = PLAYBACK;
static pa_context *context = NULL;
static pa_stream *stream = NULL;
static pa_mainloop_api *mainloop_api = NULL;
static void *buffer = NULL;
static size_t buffer_length = 0, buffer_index = 0;
static pa_io_event* stdio_event = NULL;
static char *stream_name = NULL, *client_name = NULL, *device = NULL;
static int verbose = 0;
static pa_volume_t volume = PA_VOLUME_NORM;
static pa_sample_spec sample_spec = {
.format = PA_SAMPLE_S16LE,
.rate = 44100,
.channels = 2
};
/* A shortcut for terminating the application */
static void quit(int ret) {
assert(mainloop_api);
mainloop_api->quit(mainloop_api, ret);
}
/* Write some data to the stream */
static void do_stream_write(size_t length) {
size_t l;
assert(length);
if (!buffer || !buffer_length)
return;
l = length;
if (l > buffer_length)
l = buffer_length;
pa_stream_write(stream, (uint8_t*) buffer + buffer_index, l, NULL, 0);
buffer_length -= l;
buffer_index += l;
if (!buffer_length) {
free(buffer);
buffer = NULL;
buffer_index = buffer_length = 0;
}
}
/* This is called whenever new data may be written to the stream */
static void stream_write_callback(pa_stream *s, size_t length, void *userdata) {
assert(s && length);
if (stdio_event)
mainloop_api->io_enable(stdio_event, PA_IO_EVENT_INPUT);
if (!buffer)
return;
do_stream_write(length);
}
/* This is called whenever new data may is available */
static void stream_read_callback(pa_stream *s, const void*data, size_t length, void *userdata) {
assert(s && data && length);
if (stdio_event)
mainloop_api->io_enable(stdio_event, PA_IO_EVENT_OUTPUT);
if (buffer) {
fprintf(stderr, "Buffer overrun, dropping incoming data\n");
return;
}
buffer = malloc(buffer_length = length);
assert(buffer);
memcpy(buffer, data, length);
buffer_index = 0;
}
/* This routine is called whenever the stream state changes */
static void stream_state_callback(pa_stream *s, void *userdata) {
assert(s);
switch (pa_stream_get_state(s)) {
case PA_STREAM_CREATING:
case PA_STREAM_TERMINATED:
break;
case PA_STREAM_READY:
if (verbose)
fprintf(stderr, "Stream successfully created\n");
break;
case PA_STREAM_FAILED:
default:
fprintf(stderr, "Stream error: %s\n", pa_strerror(pa_context_errno(pa_stream_get_context(s))));
quit(1);
}
}
/* This is called whenever the context status changes */
static void context_state_callback(pa_context *c, void *userdata) {
assert(c);
switch (pa_context_get_state(c)) {
case PA_CONTEXT_CONNECTING:
case PA_CONTEXT_AUTHORIZING:
case PA_CONTEXT_SETTING_NAME:
break;
case PA_CONTEXT_READY:
assert(c && !stream);
if (verbose)
fprintf(stderr, "Connection established.\n");
stream = pa_stream_new(c, stream_name, &sample_spec, NULL);
assert(stream);
pa_stream_set_state_callback(stream, stream_state_callback, NULL);
pa_stream_set_write_callback(stream, stream_write_callback, NULL);
pa_stream_set_read_callback(stream, stream_read_callback, NULL);
if (mode == PLAYBACK) {
pa_cvolume cv;
pa_stream_connect_playback(stream, device, NULL, 0, pa_cvolume_set(&cv, PA_CHANNELS_MAX, volume));
} else
pa_stream_connect_record(stream, device, NULL, 0);
break;
case PA_CONTEXT_TERMINATED:
quit(0);
break;
case PA_CONTEXT_FAILED:
default:
fprintf(stderr, "Connection failure: %s\n", pa_strerror(pa_context_errno(c)));
quit(1);
}
}
/* Connection draining complete */
static void context_drain_complete(pa_context*c, void *userdata) {
pa_context_disconnect(c);
}
/* Stream draining complete */
static void stream_drain_complete(pa_stream*s, int success, void *userdata) {
pa_operation *o;
if (!success) {
fprintf(stderr, "Failed to drain stream: %s\n", pa_strerror(pa_context_errno(context)));
quit(1);
}
if (verbose)
fprintf(stderr, "Playback stream drained.\n");
pa_stream_disconnect(stream);
pa_stream_unref(stream);
stream = NULL;
if (!(o = pa_context_drain(context, context_drain_complete, NULL)))
pa_context_disconnect(context);
else {
pa_operation_unref(o);
if (verbose)
fprintf(stderr, "Draining connection to server.\n");
}
}
/* New data on STDIN **/
static void stdin_callback(pa_mainloop_api*a, pa_io_event *e, int fd, pa_io_event_flags_t f, void *userdata) {
size_t l, w = 0;
ssize_t r;
assert(a == mainloop_api && e && stdio_event == e);
if (buffer) {
mainloop_api->io_enable(stdio_event, PA_IO_EVENT_NULL);
return;
}
if (!stream || pa_stream_get_state(stream) != PA_STREAM_READY || !(l = w = pa_stream_writable_size(stream)))
l = 4096;
buffer = malloc(l);
assert(buffer);
if ((r = read(fd, buffer, l)) <= 0) {
if (r == 0) {
if (verbose)
fprintf(stderr, "Got EOF.\n");
pa_operation_unref(pa_stream_drain(stream, stream_drain_complete, NULL));
} else {
fprintf(stderr, "read() failed: %s\n", strerror(errno));
quit(1);
}
mainloop_api->io_free(stdio_event);
stdio_event = NULL;
return;
}
buffer_length = r;
buffer_index = 0;
if (w)
do_stream_write(w);
}
/* Some data may be written to STDOUT */
static void stdout_callback(pa_mainloop_api*a, pa_io_event *e, int fd, pa_io_event_flags_t f, void *userdata) {
ssize_t r;
assert(a == mainloop_api && e && stdio_event == e);
if (!buffer) {
mainloop_api->io_enable(stdio_event, PA_IO_EVENT_NULL);
return;
}
assert(buffer_length);
if ((r = write(fd, (uint8_t*) buffer+buffer_index, buffer_length)) <= 0) {
fprintf(stderr, "write() failed: %s\n", strerror(errno));
quit(1);
mainloop_api->io_free(stdio_event);
stdio_event = NULL;
return;
}
buffer_length -= r;
buffer_index += r;
if (!buffer_length) {
free(buffer);
buffer = NULL;
buffer_length = buffer_index = 0;
}
}
/* UNIX signal to quit recieved */
static void exit_signal_callback(pa_mainloop_api*m, pa_signal_event *e, int sig, void *userdata) {
if (verbose)
fprintf(stderr, "Got signal, exiting.\n");
quit(0);
}
/* Show the current latency */
static void stream_get_latency_callback(pa_stream *s, const pa_latency_info *i, void *userdata) {
pa_usec_t total;
int negative = 0;
assert(s);
if (!i) {
fprintf(stderr, "Failed to get latency: %s\n", pa_strerror(pa_context_errno(context)));
quit(1);
return;
}
total = pa_stream_get_latency(s, i, &negative);
fprintf(stderr, "Latency: buffer: %0.0f usec; sink: %0.0f usec; source: %0.0f usec; transport: %0.0f usec; total: %0.0f usec; synchronized clocks: %s.\n",
(float) i->buffer_usec, (float) i->sink_usec, (float) i->source_usec, (float) i->transport_usec, (float) total * (negative?-1:1),
i->synchronized_clocks ? "yes" : "no");
}
/* Someone requested that the latency is shown */
static void sigusr1_signal_callback(pa_mainloop_api*m, pa_signal_event *e, int sig, void *userdata) {
fprintf(stderr, "Got SIGUSR1, requesting latency.\n");
pa_operation_unref(pa_stream_get_latency_info(stream, stream_get_latency_callback, NULL));
}
static void help(const char *argv0) {
printf("%s [options]\n\n"
" -h, --help Show this help\n"
" --version Show version\n\n"
" -r, --record Create a connection for recording\n"
" -p, --playback Create a connection for playback\n\n"
" -v, --verbose Enable verbose operations\n\n"
" -s, --server=SERVER The name of the server to connect to\n"
" -d, --device=DEVICE The name of the sink/source to connect to\n"
" -n, --client-name=NAME How to call this client on the server\n"
" --stream-name=NAME How to call this stream on the server\n"
" --volume=VOLUME Specify the initial (linear) volume in range 0...256\n"
" --rate=SAMPLERATE The sample rate in Hz (defaults to 44100)\n"
" --format=SAMPLEFORMAT The sample type, one of s16le, s16be, u8, float32le,\n"
" float32be, ulaw, alaw (defaults to s16ne)\n"
" --channels=CHANNELS The number of channels, 1 for mono, 2 for stereo\n"
" (defaults to 2)\n",
argv0);
}
enum {
ARG_VERSION = 256,
ARG_STREAM_NAME,
ARG_VOLUME,
ARG_SAMPLERATE,
ARG_SAMPLEFORMAT,
ARG_CHANNELS
};
int main(int argc, char *argv[]) {
pa_mainloop* m = NULL;
int ret = 1, r, c;
char *bn, *server = NULL;
static const struct option long_options[] = {
{"record", 0, NULL, 'r'},
{"playback", 0, NULL, 'p'},
{"device", 1, NULL, 'd'},
{"server", 1, NULL, 's'},
{"client-name", 1, NULL, 'n'},
{"stream-name", 1, NULL, ARG_STREAM_NAME},
{"version", 0, NULL, ARG_VERSION},
{"help", 0, NULL, 'h'},
{"verbose", 0, NULL, 'v'},
{"volume", 1, NULL, ARG_VOLUME},
{"rate", 1, NULL, ARG_SAMPLERATE},
{"format", 1, NULL, ARG_SAMPLEFORMAT},
{"channels", 1, NULL, ARG_CHANNELS},
{NULL, 0, NULL, 0}
};
if (!(bn = strrchr(argv[0], '/')))
bn = argv[0];
else
bn++;
if (strstr(bn, "rec") || strstr(bn, "mon"))
mode = RECORD;
else if (strstr(bn, "cat") || strstr(bn, "play"))
mode = PLAYBACK;
while ((c = getopt_long(argc, argv, "rpd:s:n:hv", long_options, NULL)) != -1) {
switch (c) {
case 'h' :
help(bn);
ret = 0;
goto quit;
case ARG_VERSION:
printf("pacat "PACKAGE_VERSION"\nCompiled with libpolyp %s\nLinked with libpolyp %s\n", pa_get_headers_version(), pa_get_library_version());
ret = 0;
goto quit;
case 'r':
mode = RECORD;
break;
case 'p':
mode = PLAYBACK;
break;
case 'd':
free(device);
device = strdup(optarg);
break;
case 's':
free(server);
server = strdup(optarg);
break;
case 'n':
free(client_name);
client_name = strdup(optarg);
break;
case ARG_STREAM_NAME:
free(stream_name);
stream_name = strdup(optarg);
break;
case 'v':
verbose = 1;
break;
case ARG_VOLUME: {
int v = atoi(optarg);
volume = v < 0 ? 0 : v;
break;
}
case ARG_CHANNELS:
sample_spec.channels = atoi(optarg);
break;
case ARG_SAMPLEFORMAT:
sample_spec.format = pa_parse_sample_format(optarg);
break;
case ARG_SAMPLERATE:
sample_spec.rate = atoi(optarg);
break;
default:
goto quit;
}
}
if (!client_name)
client_name = strdup(bn);
if (!stream_name)
stream_name = strdup(client_name);
if (!pa_sample_spec_valid(&sample_spec)) {
fprintf(stderr, "Invalid sample specification\n");
goto quit;
}
if (verbose) {
char t[PA_SAMPLE_SPEC_SNPRINT_MAX];
pa_sample_spec_snprint(t, sizeof(t), &sample_spec);
fprintf(stderr, "Opening a %s stream with sample specification '%s'.\n", mode == RECORD ? "recording" : "playback", t);
}
/* Set up a new main loop */
if (!(m = pa_mainloop_new())) {
fprintf(stderr, "pa_mainloop_new() failed.\n");
goto quit;
}
mainloop_api = pa_mainloop_get_api(m);
r = pa_signal_init(mainloop_api);
assert(r == 0);
pa_signal_new(SIGINT, exit_signal_callback, NULL);
pa_signal_new(SIGTERM, exit_signal_callback, NULL);
#ifdef SIGUSR1
pa_signal_new(SIGUSR1, sigusr1_signal_callback, NULL);
#endif
#ifdef SIGPIPE
signal(SIGPIPE, SIG_IGN);
#endif
if (!(stdio_event = mainloop_api->io_new(mainloop_api,
mode == PLAYBACK ? STDIN_FILENO : STDOUT_FILENO,
mode == PLAYBACK ? PA_IO_EVENT_INPUT : PA_IO_EVENT_OUTPUT,
mode == PLAYBACK ? stdin_callback : stdout_callback, NULL))) {
fprintf(stderr, "source_io() failed.\n");
goto quit;
}
/* Create a new connection context */
if (!(context = pa_context_new(mainloop_api, client_name))) {
fprintf(stderr, "pa_context_new() failed.\n");
goto quit;
}
pa_context_set_state_callback(context, context_state_callback, NULL);
/* Connect the context */
pa_context_connect(context, server, 1, NULL);
/* Run the main loop */
if (pa_mainloop_run(m, &ret) < 0) {
fprintf(stderr, "pa_mainloop_run() failed.\n");
goto quit;
}
quit:
if (stream)
pa_stream_unref(stream);
if (context)
pa_context_unref(context);
if (stdio_event) {
assert(mainloop_api);
mainloop_api->io_free(stdio_event);
}
if (m) {
pa_signal_done();
pa_mainloop_free(m);
}
free(buffer);
free(server);
free(device);
free(client_name);
free(stream_name);
return ret;
}

183
src/utils/pacmd.c Normal file
View file

@ -0,0 +1,183 @@
/* $Id$ */
/***
This file is part of polypaudio.
polypaudio is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.
polypaudio is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with polypaudio; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
USA.
***/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <assert.h>
#include <signal.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/un.h>
#include <polypcore/util.h>
#include <polypcore/log.h>
#include <polypcore/pid.h>
int main(PA_GCC_UNUSED int main, PA_GCC_UNUSED char*argv[]) {
pid_t pid ;
int fd = -1;
int ret = 1, i;
struct sockaddr_un sa;
char ibuf[256], obuf[256];
size_t ibuf_index, ibuf_length, obuf_index, obuf_length;
fd_set ifds, ofds;
if (pa_pid_file_check_running(&pid) < 0) {
pa_log(__FILE__": no Polypaudio daemon running\n");
goto fail;
}
if ((fd = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
pa_log(__FILE__": socket(PF_UNIX, SOCK_STREAM, 0): %s\n", strerror(errno));
goto fail;
}
memset(&sa, 0, sizeof(sa));
sa.sun_family = AF_UNIX;
pa_runtime_path("cli", sa.sun_path, sizeof(sa.sun_path));
for (i = 0; i < 5; i++) {
int r;
if ((r = connect(fd, (struct sockaddr*) &sa, sizeof(sa))) < 0 && (errno != ECONNREFUSED && errno != ENOENT)) {
pa_log(__FILE__": connect() failed: %s\n", strerror(errno));
goto fail;
}
if (r >= 0)
break;
if (pa_pid_file_kill(SIGUSR2, NULL) < 0) {
pa_log(__FILE__": failed to kill Polypaudio daemon.\n");
goto fail;
}
pa_msleep(50);
}
if (i >= 5) {
pa_log(__FILE__": daemon not responding.\n");
goto fail;
}
ibuf_index = ibuf_length = obuf_index = obuf_length = 0;
FD_ZERO(&ifds);
FD_SET(0, &ifds);
FD_SET(fd, &ifds);
FD_ZERO(&ofds);
for (;;) {
if (select(FD_SETSIZE, &ifds, &ofds, NULL, NULL) < 0) {
pa_log(__FILE__": select() failed: %s\n", strerror(errno));
goto fail;
}
if (FD_ISSET(0, &ifds)) {
ssize_t r;
assert(!ibuf_length);
if ((r = read(0, ibuf, sizeof(ibuf))) <= 0) {
if (r == 0)
break;
pa_log(__FILE__": read() failed: %s\n", strerror(errno));
goto fail;
}
ibuf_length = (size_t) r;
ibuf_index = 0;
}
if (FD_ISSET(fd, &ifds)) {
ssize_t r;
assert(!obuf_length);
if ((r = read(fd, obuf, sizeof(obuf))) <= 0) {
if (r == 0)
break;
pa_log(__FILE__": read() failed: %s\n", strerror(errno));
goto fail;
}
obuf_length = (size_t) r;
obuf_index = 0;
}
if (FD_ISSET(1, &ofds)) {
ssize_t r;
assert(obuf_length);
if ((r = write(1, obuf + obuf_index, obuf_length)) < 0) {
pa_log(__FILE__": write() failed: %s\n", strerror(errno));
goto fail;
}
obuf_length -= (size_t) r;
obuf_index += obuf_index;
}
if (FD_ISSET(fd, &ofds)) {
ssize_t r;
assert(ibuf_length);
if ((r = write(fd, ibuf + ibuf_index, ibuf_length)) < 0) {
pa_log(__FILE__": write() failed: %s\n", strerror(errno));
goto fail;
}
ibuf_length -= (size_t) r;
ibuf_index += obuf_index;
}
FD_ZERO(&ifds);
FD_ZERO(&ofds);
if (obuf_length <= 0)
FD_SET(fd, &ifds);
else
FD_SET(1, &ofds);
if (ibuf_length <= 0)
FD_SET(0, &ifds);
else
FD_SET(fd, &ofds);
}
ret = 0;
fail:
if (fd >= 0)
close(fd);
return ret;
}

784
src/utils/pactl.c Normal file
View file

@ -0,0 +1,784 @@
/* $Id$ */
/***
This file is part of polypaudio.
polypaudio is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.
polypaudio is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with polypaudio; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
USA.
***/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <signal.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <getopt.h>
#include <sndfile.h>
#include <polyp/polyplib.h>
#include <polyp/polyplib-error.h>
#include <polyp/mainloop.h>
#include <polyp/mainloop-signal.h>
#include <polyp/sample.h>
#if PA_API_VERSION != 8
#error Invalid Polypaudio API version
#endif
#define BUFSIZE 1024
static pa_context *context = NULL;
static pa_mainloop_api *mainloop_api = NULL;
static char *device = NULL, *sample_name = NULL;
static SNDFILE *sndfile = NULL;
static pa_stream *sample_stream = NULL;
static pa_sample_spec sample_spec;
static size_t sample_length = 0;
static int actions = 1;
static int nl = 0;
static enum {
NONE,
EXIT,
STAT,
UPLOAD_SAMPLE,
PLAY_SAMPLE,
REMOVE_SAMPLE,
LIST
} action = NONE;
static void quit(int ret) {
assert(mainloop_api);
mainloop_api->quit(mainloop_api, ret);
}
static void context_drain_complete(pa_context *c, void *userdata) {
pa_context_disconnect(c);
}
static void drain(void) {
pa_operation *o;
if (!(o = pa_context_drain(context, context_drain_complete, NULL)))
pa_context_disconnect(context);
else
pa_operation_unref(o);
}
static void complete_action(void) {
assert(actions > 0);
if (!(--actions))
drain();
}
static void stat_callback(pa_context *c, const pa_stat_info *i, void *userdata) {
char s[128];
if (!i) {
fprintf(stderr, "Failed to get statistics: %s\n", pa_strerror(pa_context_errno(c)));
quit(1);
return;
}
pa_bytes_snprint(s, sizeof(s), i->memblock_total_size);
printf("Currently in use: %u blocks containing %s bytes total.\n", i->memblock_total, s);
pa_bytes_snprint(s, sizeof(s), i->memblock_allocated_size);
printf("Allocated during whole lifetime: %u blocks containing %s bytes total.\n", i->memblock_allocated, s);
pa_bytes_snprint(s, sizeof(s), i->scache_size);
printf("Sample cache size: %s\n", s);
complete_action();
}
static void get_server_info_callback(pa_context *c, const pa_server_info *i, void *useerdata) {
char s[PA_SAMPLE_SPEC_SNPRINT_MAX];
if (!i) {
fprintf(stderr, "Failed to get server information: %s\n", pa_strerror(pa_context_errno(c)));
quit(1);
return;
}
pa_sample_spec_snprint(s, sizeof(s), &i->sample_spec);
printf("User name: %s\n"
"Host Name: %s\n"
"Server Name: %s\n"
"Server Version: %s\n"
"Default Sample Specification: %s\n"
"Default Sink: %s\n"
"Default Source: %s\n"
"Cookie: %08x\n",
i->user_name,
i->host_name,
i->server_name,
i->server_version,
s,
i->default_sink_name,
i->default_source_name,
i->cookie);
complete_action();
}
static void get_sink_info_callback(pa_context *c, const pa_sink_info *i, int is_last, void *userdata) {
char s[PA_SAMPLE_SPEC_SNPRINT_MAX], cv[PA_CVOLUME_SNPRINT_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX];
if (is_last < 0) {
fprintf(stderr, "Failed to get sink information: %s\n", pa_strerror(pa_context_errno(c)));
quit(1);
return;
}
if (is_last) {
complete_action();
return;
}
assert(i);
if (nl)
printf("\n");
nl = 1;
printf("*** Sink #%u ***\n"
"Name: %s\n"
"Driver: %s\n"
"Description: %s\n"
"Sample Specification: %s\n"
"Channel Map: %s\n"
"Owner Module: %u\n"
"Volume: %s\n"
"Monitor Source: %u\n"
"Latency: %0.0f usec\n",
i->index,
i->name,
i->driver,
i->description,
pa_sample_spec_snprint(s, sizeof(s), &i->sample_spec),
pa_channel_map_snprint(cm, sizeof(cm), &i->channel_map),
i->owner_module,
pa_cvolume_snprint(cv, sizeof(cv), &i->volume),
i->monitor_source,
(double) i->latency);
}
static void get_source_info_callback(pa_context *c, const pa_source_info *i, int is_last, void *userdata) {
char s[PA_SAMPLE_SPEC_SNPRINT_MAX], t[32], cm[PA_CHANNEL_MAP_SNPRINT_MAX];
if (is_last < 0) {
fprintf(stderr, "Failed to get source information: %s\n", pa_strerror(pa_context_errno(c)));
quit(1);
return;
}
if (is_last) {
complete_action();
return;
}
assert(i);
if (nl)
printf("\n");
nl = 1;
snprintf(t, sizeof(t), "%u", i->monitor_of_sink);
printf("*** Source #%u ***\n"
"Name: %s\n"
"Driver: %s\n"
"Description: %s\n"
"Sample Specification: %s\n"
"Channel Map: %s\n"
"Owner Module: %u\n"
"Monitor of Sink: %s\n"
"Latency: %0.0f usec\n",
i->index,
i->driver,
i->name,
i->description,
pa_sample_spec_snprint(s, sizeof(s), &i->sample_spec),
pa_channel_map_snprint(cm, sizeof(cm), &i->channel_map),
i->owner_module,
i->monitor_of_sink != PA_INVALID_INDEX ? t : "no",
(double) i->latency);
}
static void get_module_info_callback(pa_context *c, const pa_module_info *i, int is_last, void *userdata) {
char t[32];
if (is_last < 0) {
fprintf(stderr, "Failed to get module information: %s\n", pa_strerror(pa_context_errno(c)));
quit(1);
return;
}
if (is_last) {
complete_action();
return;
}
assert(i);
if (nl)
printf("\n");
nl = 1;
snprintf(t, sizeof(t), "%u", i->n_used);
printf("*** Module #%u ***\n"
"Name: %s\n"
"Argument: %s\n"
"Usage counter: %s\n"
"Auto unload: %s\n",
i->index,
i->name,
i->argument,
i->n_used != PA_INVALID_INDEX ? t : "n/a",
i->auto_unload ? "yes" : "no");
}
static void get_client_info_callback(pa_context *c, const pa_client_info *i, int is_last, void *userdata) {
char t[32];
if (is_last < 0) {
fprintf(stderr, "Failed to get client information: %s\n", pa_strerror(pa_context_errno(c)));
quit(1);
return;
}
if (is_last) {
complete_action();
return;
}
assert(i);
if (nl)
printf("\n");
nl = 1;
snprintf(t, sizeof(t), "%u", i->owner_module);
printf("*** Client #%u ***\n"
"Name: %s\n"
"Driver: %s\n"
"Owner Module: %s\n",
i->index,
i->name,
i->driver,
i->owner_module != PA_INVALID_INDEX ? t : "n/a");
}
static void get_sink_input_info_callback(pa_context *c, const pa_sink_input_info *i, int is_last, void *userdata) {
char t[32], k[32], s[PA_SAMPLE_SPEC_SNPRINT_MAX], cv[PA_CVOLUME_SNPRINT_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX];
if (is_last < 0) {
fprintf(stderr, "Failed to get sink input information: %s\n", pa_strerror(pa_context_errno(c)));
quit(1);
return;
}
if (is_last) {
complete_action();
return;
}
assert(i);
if (nl)
printf("\n");
nl = 1;
snprintf(t, sizeof(t), "%u", i->owner_module);
snprintf(k, sizeof(k), "%u", i->client);
printf("*** Sink Input #%u ***\n"
"Name: %s\n"
"Driver: %s\n"
"Owner Module: %s\n"
"Client: %s\n"
"Sink: %u\n"
"Sample Specification: %s\n"
"Channel Map: %s\n"
"Volume: %s\n"
"Buffer Latency: %0.0f usec\n"
"Sink Latency: %0.0f usec\n"
"Resample method: %s\n",
i->index,
i->name,
i->driver,
i->owner_module != PA_INVALID_INDEX ? t : "n/a",
i->client != PA_INVALID_INDEX ? k : "n/a",
i->sink,
pa_sample_spec_snprint(s, sizeof(s), &i->sample_spec),
pa_channel_map_snprint(cm, sizeof(cm), &i->channel_map),
pa_cvolume_snprint(cv, sizeof(cv), &i->volume),
(double) i->buffer_usec,
(double) i->sink_usec,
i->resample_method ? i->resample_method : "n/a");
}
static void get_source_output_info_callback(pa_context *c, const pa_source_output_info *i, int is_last, void *userdata) {
char t[32], k[32], s[PA_SAMPLE_SPEC_SNPRINT_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX];
if (is_last < 0) {
fprintf(stderr, "Failed to get source output information: %s\n", pa_strerror(pa_context_errno(c)));
quit(1);
return;
}
if (is_last) {
complete_action();
return;
}
assert(i);
if (nl)
printf("\n");
nl = 1;
snprintf(t, sizeof(t), "%u", i->owner_module);
snprintf(k, sizeof(k), "%u", i->client);
printf("*** Source Output #%u ***\n"
"Name: %s\n"
"Driver: %s\n"
"Owner Module: %s\n"
"Client: %s\n"
"Source: %u\n"
"Sample Specification: %s\n"
"Channel Map: %s\n"
"Buffer Latency: %0.0f usec\n"
"Source Latency: %0.0f usec\n"
"Resample method: %s\n",
i->index,
i->name,
i->driver,
i->owner_module != PA_INVALID_INDEX ? t : "n/a",
i->client != PA_INVALID_INDEX ? k : "n/a",
i->source,
pa_sample_spec_snprint(s, sizeof(s), &i->sample_spec),
pa_channel_map_snprint(cm, sizeof(cm), &i->channel_map),
(double) i->buffer_usec,
(double) i->source_usec,
i->resample_method ? i->resample_method : "n/a");
}
static void get_sample_info_callback(pa_context *c, const pa_sample_info *i, int is_last, void *userdata) {
char t[32], s[PA_SAMPLE_SPEC_SNPRINT_MAX], cv[PA_CVOLUME_SNPRINT_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX];
if (is_last < 0) {
fprintf(stderr, "Failed to get sample information: %s\n", pa_strerror(pa_context_errno(c)));
quit(1);
return;
}
if (is_last) {
complete_action();
return;
}
assert(i);
if (nl)
printf("\n");
nl = 1;
pa_bytes_snprint(t, sizeof(t), i->bytes);
printf("*** Sample #%u ***\n"
"Name: %s\n"
"Volume: %s\n"
"Sample Specification: %s\n"
"Channel Map: %s\n"
"Duration: %0.1fs\n"
"Size: %s\n"
"Lazy: %s\n"
"Filename: %s\n",
i->index,
i->name,
pa_cvolume_snprint(cv, sizeof(cv), &i->volume),
pa_sample_spec_valid(&i->sample_spec) ? pa_sample_spec_snprint(s, sizeof(s), &i->sample_spec) : "n/a",
pa_sample_spec_valid(&i->sample_spec) ? pa_channel_map_snprint(cm, sizeof(cm), &i->channel_map) : "n/a",
(double) i->duration/1000000,
t,
i->lazy ? "yes" : "no",
i->filename ? i->filename : "n/a");
}
static void get_autoload_info_callback(pa_context *c, const pa_autoload_info *i, int is_last, void *userdata) {
if (is_last < 0) {
fprintf(stderr, "Failed to get autoload information: %s\n", pa_strerror(pa_context_errno(c)));
quit(1);
return;
}
if (is_last) {
complete_action();
return;
}
assert(i);
if (nl)
printf("\n");
nl = 1;
printf("*** Autoload Entry #%u ***\n"
"Name: %s\n"
"Type: %s\n"
"Module: %s\n"
"Argument: %s\n",
i->index,
i->name,
i->type == PA_AUTOLOAD_SINK ? "sink" : "source",
i->module,
i->argument);
}
static void simple_callback(pa_context *c, int success, void *userdata) {
if (!success) {
fprintf(stderr, "Failure: %s\n", pa_strerror(pa_context_errno(c)));
quit(1);
return;
}
complete_action();
}
static void stream_state_callback(pa_stream *s, void *userdata) {
assert(s);
switch (pa_stream_get_state(s)) {
case PA_STREAM_CREATING:
case PA_STREAM_READY:
break;
case PA_STREAM_TERMINATED:
drain();
break;
case PA_STREAM_FAILED:
default:
fprintf(stderr, "Failed to upload sample: %s\n", pa_strerror(pa_context_errno(pa_stream_get_context(s))));
quit(1);
}
}
static void stream_write_callback(pa_stream *s, size_t length, void *userdata) {
sf_count_t l;
float *d;
assert(s && length && sndfile);
d = malloc(length);
assert(d);
assert(sample_length >= length);
l = length/pa_frame_size(&sample_spec);
if ((sf_readf_float(sndfile, d, l)) != l) {
free(d);
fprintf(stderr, "Premature end of file\n");
quit(1);
}
pa_stream_write(s, d, length, free, 0);
sample_length -= length;
if (sample_length <= 0) {
pa_stream_set_write_callback(sample_stream, NULL, NULL);
pa_stream_finish_upload(sample_stream);
}
}
static void context_state_callback(pa_context *c, void *userdata) {
assert(c);
switch (pa_context_get_state(c)) {
case PA_CONTEXT_CONNECTING:
case PA_CONTEXT_AUTHORIZING:
case PA_CONTEXT_SETTING_NAME:
break;
case PA_CONTEXT_READY:
switch (action) {
case STAT:
actions = 2;
pa_operation_unref(pa_context_stat(c, stat_callback, NULL));
pa_operation_unref(pa_context_get_server_info(c, get_server_info_callback, NULL));
break;
case PLAY_SAMPLE:
pa_operation_unref(pa_context_play_sample(c, sample_name, device, PA_VOLUME_NORM, simple_callback, NULL));
break;
case REMOVE_SAMPLE:
pa_operation_unref(pa_context_remove_sample(c, sample_name, simple_callback, NULL));
break;
case UPLOAD_SAMPLE:
sample_stream = pa_stream_new(c, sample_name, &sample_spec, NULL);
assert(sample_stream);
pa_stream_set_state_callback(sample_stream, stream_state_callback, NULL);
pa_stream_set_write_callback(sample_stream, stream_write_callback, NULL);
pa_stream_connect_upload(sample_stream, sample_length);
break;
case EXIT:
pa_context_exit_daemon(c);
drain();
case LIST:
actions = 8;
pa_operation_unref(pa_context_get_module_info_list(c, get_module_info_callback, NULL));
pa_operation_unref(pa_context_get_sink_info_list(c, get_sink_info_callback, NULL));
pa_operation_unref(pa_context_get_source_info_list(c, get_source_info_callback, NULL));
pa_operation_unref(pa_context_get_sink_input_info_list(c, get_sink_input_info_callback, NULL));
pa_operation_unref(pa_context_get_source_output_info_list(c, get_source_output_info_callback, NULL));
pa_operation_unref(pa_context_get_client_info_list(c, get_client_info_callback, NULL));
pa_operation_unref(pa_context_get_sample_info_list(c, get_sample_info_callback, NULL));
pa_operation_unref(pa_context_get_autoload_info_list(c, get_autoload_info_callback, NULL));
break;
default:
assert(0);
}
break;
case PA_CONTEXT_TERMINATED:
quit(0);
break;
case PA_CONTEXT_FAILED:
default:
fprintf(stderr, "Connection failure: %s\n", pa_strerror(pa_context_errno(c)));
quit(1);
}
}
static void exit_signal_callback(pa_mainloop_api *m, pa_signal_event *e, int sig, void *userdata) {
fprintf(stderr, "Got SIGINT, exiting.\n");
quit(0);
}
static void help(const char *argv0) {
printf("%s [options] stat\n"
"%s [options] list\n"
"%s [options] exit\n"
"%s [options] upload-sample FILENAME [NAME]\n"
"%s [options] play-sample NAME [SINK]\n"
"%s [options] remove-sample NAME\n\n"
" -h, --help Show this help\n"
" --version Show version\n\n"
" -s, --server=SERVER The name of the server to connect to\n"
" -n, --client-name=NAME How to call this client on the server\n",
argv0, argv0, argv0, argv0, argv0, argv0);
}
enum { ARG_VERSION = 256 };
int main(int argc, char *argv[]) {
pa_mainloop* m = NULL;
char tmp[PATH_MAX];
int ret = 1, r, c;
char *server = NULL, *client_name = NULL, *bn;
static const struct option long_options[] = {
{"server", 1, NULL, 's'},
{"client-name", 1, NULL, 'n'},
{"version", 0, NULL, ARG_VERSION},
{"help", 0, NULL, 'h'},
{NULL, 0, NULL, 0}
};
if (!(bn = strrchr(argv[0], '/')))
bn = argv[0];
else
bn++;
while ((c = getopt_long(argc, argv, "s:n:h", long_options, NULL)) != -1) {
switch (c) {
case 'h' :
help(bn);
ret = 0;
goto quit;
case ARG_VERSION:
printf("pactl "PACKAGE_VERSION"\nCompiled with libpolyp %s\nLinked with libpolyp %s\n", pa_get_headers_version(), pa_get_library_version());
ret = 0;
goto quit;
case 's':
free(server);
server = strdup(optarg);
break;
case 'n':
free(client_name);
client_name = strdup(optarg);
break;
default:
goto quit;
}
}
if (!client_name)
client_name = strdup(bn);
if (optind < argc) {
if (!strcmp(argv[optind], "stat"))
action = STAT;
else if (!strcmp(argv[optind], "exit"))
action = EXIT;
else if (!strcmp(argv[optind], "list"))
action = LIST;
else if (!strcmp(argv[optind], "upload-sample")) {
struct SF_INFO sfinfo;
action = UPLOAD_SAMPLE;
if (optind+1 >= argc) {
fprintf(stderr, "Please specify a sample file to load\n");
goto quit;
}
if (optind+2 < argc)
sample_name = strdup(argv[optind+2]);
else {
char *f = strrchr(argv[optind+1], '/');
size_t n;
if (f)
f++;
else
f = argv[optind];
n = strcspn(f, ".");
strncpy(tmp, f, n);
tmp[n] = 0;
sample_name = strdup(tmp);
}
memset(&sfinfo, 0, sizeof(sfinfo));
if (!(sndfile = sf_open(argv[optind+1], SFM_READ, &sfinfo))) {
fprintf(stderr, "Failed to open sound file.\n");
goto quit;
}
sample_spec.format = PA_SAMPLE_FLOAT32;
sample_spec.rate = sfinfo.samplerate;
sample_spec.channels = sfinfo.channels;
sample_length = sfinfo.frames*pa_frame_size(&sample_spec);
} else if (!strcmp(argv[optind], "play-sample")) {
action = PLAY_SAMPLE;
if (optind+1 >= argc) {
fprintf(stderr, "You have to specify a sample name to play\n");
goto quit;
}
sample_name = strdup(argv[optind+1]);
if (optind+2 < argc)
device = strdup(argv[optind+2]);
} else if (!strcmp(argv[optind], "remove-sample")) {
action = REMOVE_SAMPLE;
if (optind+1 >= argc) {
fprintf(stderr, "You have to specify a sample name to remove\n");
goto quit;
}
sample_name = strdup(argv[optind+1]);
}
}
if (action == NONE) {
fprintf(stderr, "No valid command specified.\n");
goto quit;
}
if (!(m = pa_mainloop_new())) {
fprintf(stderr, "pa_mainloop_new() failed.\n");
goto quit;
}
mainloop_api = pa_mainloop_get_api(m);
r = pa_signal_init(mainloop_api);
assert(r == 0);
pa_signal_new(SIGINT, exit_signal_callback, NULL);
#ifdef SIGPIPE
signal(SIGPIPE, SIG_IGN);
#endif
if (!(context = pa_context_new(mainloop_api, client_name))) {
fprintf(stderr, "pa_context_new() failed.\n");
goto quit;
}
pa_context_set_state_callback(context, context_state_callback, NULL);
pa_context_connect(context, server, 1, NULL);
if (pa_mainloop_run(m, &ret) < 0) {
fprintf(stderr, "pa_mainloop_run() failed.\n");
goto quit;
}
quit:
if (sample_stream)
pa_stream_unref(sample_stream);
if (context)
pa_context_unref(context);
if (m) {
pa_signal_done();
pa_mainloop_free(m);
}
if (sndfile)
sf_close(sndfile);
free(server);
free(device);
free(sample_name);
return ret;
}

386
src/utils/paplay.c Normal file
View file

@ -0,0 +1,386 @@
/* $Id$ */
/***
This file is part of polypaudio.
polypaudio is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.
polypaudio is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with polypaudio; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
USA.
***/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <signal.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <getopt.h>
#include <sndfile.h>
#include <polyp/polyplib.h>
#include <polyp/polyplib-error.h>
#include <polyp/mainloop.h>
#include <polyp/mainloop-signal.h>
#include <polyp/polyplib-version.h>
#if PA_API_VERSION != 8
#error Invalid Polypaudio API version
#endif
static pa_context *context = NULL;
static pa_stream *stream = NULL;
static pa_mainloop_api *mainloop_api = NULL;
static char *stream_name = NULL, *client_name = NULL, *device = NULL;
static int verbose = 0;
static pa_volume_t volume = PA_VOLUME_NORM;
static SNDFILE* sndfile = NULL;
static pa_sample_spec sample_spec = { 0, 0, 0 };
static sf_count_t (*readf_function)(SNDFILE *_sndfile, void *ptr, sf_count_t frames);
/* A shortcut for terminating the application */
static void quit(int ret) {
assert(mainloop_api);
mainloop_api->quit(mainloop_api, ret);
}
/* Connection draining complete */
static void context_drain_complete(pa_context*c, void *userdata) {
pa_context_disconnect(c);
}
/* Stream draining complete */
static void stream_drain_complete(pa_stream*s, int success, void *userdata) {
pa_operation *o;
if (!success) {
fprintf(stderr, "Failed to drain stream: %s\n", pa_strerror(pa_context_errno(context)));
quit(1);
}
if (verbose)
fprintf(stderr, "Playback stream drained.\n");
pa_stream_disconnect(stream);
pa_stream_unref(stream);
stream = NULL;
if (!(o = pa_context_drain(context, context_drain_complete, NULL)))
pa_context_disconnect(context);
else {
pa_operation_unref(o);
if (verbose)
fprintf(stderr, "Draining connection to server.\n");
}
}
/* This is called whenever new data may be written to the stream */
static void stream_write_callback(pa_stream *s, size_t length, void *userdata) {
size_t k;
sf_count_t f, n;
void *data;
assert(s && length);
if (!sndfile)
return;
k = pa_frame_size(&sample_spec);
data = malloc(length);
n = length/k;
f = readf_function(sndfile, data, n);
if (f > 0)
pa_stream_write(s, data, f*k, free, 0);
if (f < n) {
sf_close(sndfile);
sndfile = NULL;
pa_operation_unref(pa_stream_drain(s, stream_drain_complete, NULL));
}
}
/* This routine is called whenever the stream state changes */
static void stream_state_callback(pa_stream *s, void *userdata) {
assert(s);
switch (pa_stream_get_state(s)) {
case PA_STREAM_CREATING:
case PA_STREAM_TERMINATED:
break;
case PA_STREAM_READY:
if (verbose)
fprintf(stderr, "Stream successfully created\n");
break;
case PA_STREAM_FAILED:
default:
fprintf(stderr, "Stream errror: %s\n", pa_strerror(pa_context_errno(pa_stream_get_context(s))));
quit(1);
}
}
/* This is called whenever the context status changes */
static void context_state_callback(pa_context *c, void *userdata) {
assert(c);
switch (pa_context_get_state(c)) {
case PA_CONTEXT_CONNECTING:
case PA_CONTEXT_AUTHORIZING:
case PA_CONTEXT_SETTING_NAME:
break;
case PA_CONTEXT_READY: {
pa_cvolume cv;
assert(c && !stream);
if (verbose)
fprintf(stderr, "Connection established.\n");
stream = pa_stream_new(c, stream_name, &sample_spec, NULL);
assert(stream);
pa_stream_set_state_callback(stream, stream_state_callback, NULL);
pa_stream_set_write_callback(stream, stream_write_callback, NULL);
pa_stream_connect_playback(stream, device, NULL, 0, pa_cvolume_set(&cv, PA_CHANNELS_MAX, volume));
break;
}
case PA_CONTEXT_TERMINATED:
quit(0);
break;
case PA_CONTEXT_FAILED:
default:
fprintf(stderr, "Connection failure: %s\n", pa_strerror(pa_context_errno(c)));
quit(1);
}
}
/* UNIX signal to quit recieved */
static void exit_signal_callback(pa_mainloop_api*m, pa_signal_event *e, int sig, void *userdata) {
if (verbose)
fprintf(stderr, "Got SIGINT, exiting.\n");
quit(0);
}
static void help(const char *argv0) {
printf("%s [options] [FILE]\n\n"
" -h, --help Show this help\n"
" --version Show version\n\n"
" -v, --verbose Enable verbose operations\n\n"
" -s, --server=SERVER The name of the server to connect to\n"
" -d, --device=DEVICE The name of the sink/source to connect to\n"
" -n, --client-name=NAME How to call this client on the server\n"
" --stream-name=NAME How to call this stream on the server\n"
" --volume=VOLUME Specify the initial (linear) volume in range 0...256\n",
argv0);
}
enum {
ARG_VERSION = 256,
ARG_STREAM_NAME,
ARG_VOLUME
};
int main(int argc, char *argv[]) {
pa_mainloop* m = NULL;
int ret = 1, r, c;
char *bn, *server = NULL;
const char *filename;
SF_INFO sfinfo;
static const struct option long_options[] = {
{"device", 1, NULL, 'd'},
{"server", 1, NULL, 's'},
{"client-name", 1, NULL, 'n'},
{"stream-name", 1, NULL, ARG_STREAM_NAME},
{"version", 0, NULL, ARG_VERSION},
{"help", 0, NULL, 'h'},
{"verbose", 0, NULL, 'v'},
{"volume", 1, NULL, ARG_VOLUME},
{NULL, 0, NULL, 0}
};
if (!(bn = strrchr(argv[0], '/')))
bn = argv[0];
else
bn++;
while ((c = getopt_long(argc, argv, "d:s:n:hv", long_options, NULL)) != -1) {
switch (c) {
case 'h' :
help(bn);
ret = 0;
goto quit;
case ARG_VERSION:
printf("paplay "PACKAGE_VERSION"\nCompiled with libpolyp %s\nLinked with libpolyp %s\n", pa_get_headers_version(), pa_get_library_version());
ret = 0;
goto quit;
case 'd':
free(device);
device = strdup(optarg);
break;
case 's':
free(server);
server = strdup(optarg);
break;
case 'n':
free(client_name);
client_name = strdup(optarg);
break;
case ARG_STREAM_NAME:
free(stream_name);
stream_name = strdup(optarg);
break;
case 'v':
verbose = 1;
break;
case ARG_VOLUME: {
int v = atoi(optarg);
volume = v < 0 ? 0 : v;
break;
}
default:
goto quit;
}
}
filename = optind < argc ? argv[optind] : "STDIN";
if (!client_name)
client_name = strdup(bn);
if (!stream_name)
stream_name = strdup(filename);
memset(&sfinfo, 0, sizeof(sfinfo));
if (optind < argc)
sndfile = sf_open(filename, SFM_READ, &sfinfo);
else
sndfile = sf_open_fd(STDIN_FILENO, SFM_READ, &sfinfo, 0);
if (!sndfile) {
fprintf(stderr, "Failed to open file '%s'\n", filename);
goto quit;
}
sample_spec.rate = sfinfo.samplerate;
sample_spec.channels = sfinfo.channels;
switch (sfinfo.format & 0xFF) {
case SF_FORMAT_PCM_16:
case SF_FORMAT_PCM_U8:
case SF_FORMAT_ULAW:
case SF_FORMAT_ALAW:
sample_spec.format = PA_SAMPLE_S16NE;
readf_function = (sf_count_t (*)(SNDFILE *_sndfile, void *ptr, sf_count_t frames)) sf_readf_short;
break;
case SF_FORMAT_FLOAT:
default:
sample_spec.format = PA_SAMPLE_FLOAT32NE;
readf_function = (sf_count_t (*)(SNDFILE *_sndfile, void *ptr, sf_count_t frames)) sf_readf_float;
break;
}
if (verbose) {
char t[PA_SAMPLE_SPEC_SNPRINT_MAX];
pa_sample_spec_snprint(t, sizeof(t), &sample_spec);
fprintf(stderr, "Using sample spec '%s'\n", t);
}
/* Set up a new main loop */
if (!(m = pa_mainloop_new())) {
fprintf(stderr, "pa_mainloop_new() failed.\n");
goto quit;
}
mainloop_api = pa_mainloop_get_api(m);
r = pa_signal_init(mainloop_api);
assert(r == 0);
pa_signal_new(SIGINT, exit_signal_callback, NULL);
#ifdef SIGPIPE
signal(SIGPIPE, SIG_IGN);
#endif
/* Create a new connection context */
if (!(context = pa_context_new(mainloop_api, client_name))) {
fprintf(stderr, "pa_context_new() failed.\n");
goto quit;
}
pa_context_set_state_callback(context, context_state_callback, NULL);
/* Connect the context */
pa_context_connect(context, server, 1, NULL);
/* Run the main loop */
if (pa_mainloop_run(m, &ret) < 0) {
fprintf(stderr, "pa_mainloop_run() failed.\n");
goto quit;
}
quit:
if (stream)
pa_stream_unref(stream);
if (context)
pa_context_unref(context);
if (m) {
pa_signal_done();
pa_mainloop_free(m);
}
free(server);
free(device);
free(client_name);
free(stream_name);
if (sndfile)
sf_close(sndfile);
return ret;
}

217
src/utils/pax11publish.c Normal file
View file

@ -0,0 +1,217 @@
/* $Id$ */
/***
This file is part of polypaudio.
polypaudio is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.
polypaudio is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with polypaudio; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
USA.
***/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <stdio.h>
#include <getopt.h>
#include <string.h>
#include <assert.h>
#include <X11/Xlib.h>
#include <X11/Xatom.h>
#include <polypcore/util.h>
#include <polypcore/log.h>
#include <polypcore/authkey.h>
#include <polypcore/native-common.h>
#include <polyp/client-conf.h>
#include <polypcore/x11prop.h>
int main(int argc, char *argv[]) {
const char *dname = NULL, *sink = NULL, *source = NULL, *server = NULL, *cookie_file = PA_NATIVE_COOKIE_FILE;
int c, ret = 1;
Display *d = NULL;
enum { DUMP, EXPORT, IMPORT, REMOVE } mode = DUMP;
while ((c = getopt(argc, argv, "deiD:S:O:I:c:hr")) != -1) {
switch (c) {
case 'D' :
dname = optarg;
break;
case 'h':
printf("%s [-D display] [-S server] [-O sink] [-I source] [-c file] [-d|-e|-i|-r]\n\n"
" -d Show current Polypaudio data attached to X11 display (default)\n"
" -e Export local Polypaudio data to X11 display\n"
" -i Import Polypaudio data from X11 display to local environment variables and cookie file.\n"
" -r Remove Polypaudio data from X11 display\n",
pa_path_get_filename(argv[0]));
ret = 0;
goto finish;
case 'd':
mode = DUMP;
break;
case 'e':
mode = EXPORT;
break;
case 'i':
mode = IMPORT;
break;
case 'r':
mode = REMOVE;
break;
case 'c':
cookie_file = optarg;
break;
case 'I':
source = optarg;
break;
case 'O':
sink = optarg;
break;
case 'S':
server = optarg;
break;
default:
fprintf(stderr, "Failed to parse command line.\n");
goto finish;
}
}
if (!(d = XOpenDisplay(dname))) {
pa_log(__FILE__": XOpenDisplay() failed\n");
goto finish;
}
switch (mode) {
case DUMP: {
char t[1024];
if (pa_x11_get_prop(d, "POLYP_SERVER", t, sizeof(t)))
printf("Server: %s\n", t);
if (pa_x11_get_prop(d, "POLYP_SOURCE", t, sizeof(t)))
printf("Source: %s\n", t);
if (pa_x11_get_prop(d, "POLYP_SINK", t, sizeof(t)))
printf("Sink: %s\n", t);
if (pa_x11_get_prop(d, "POLYP_COOKIE", t, sizeof(t)))
printf("Cookie: %s\n", t);
break;
}
case IMPORT: {
char t[1024];
if (pa_x11_get_prop(d, "POLYP_SERVER", t, sizeof(t)))
printf("POLYP_SERVER='%s'\nexport POLYP_SERVER\n", t);
if (pa_x11_get_prop(d, "POLYP_SOURCE", t, sizeof(t)))
printf("POLYP_SOURCE='%s'\nexport POLYP_SOURCE\n", t);
if (pa_x11_get_prop(d, "POLYP_SINK", t, sizeof(t)))
printf("POLYP_SINK='%s'\nexport POLYP_SINK\n", t);
if (pa_x11_get_prop(d, "POLYP_COOKIE", t, sizeof(t))) {
uint8_t cookie[PA_NATIVE_COOKIE_LENGTH];
size_t l;
if ((l = pa_parsehex(t, cookie, sizeof(cookie))) != sizeof(cookie)) {
fprintf(stderr, "Failed to parse cookie data\n");
goto finish;
}
if (pa_authkey_save(cookie_file, cookie, l) < 0) {
fprintf(stderr, "Failed to save cookie data\n");
goto finish;
}
}
break;
}
case EXPORT: {
pa_client_conf *conf = pa_client_conf_new();
uint8_t cookie[PA_NATIVE_COOKIE_LENGTH];
char hx[PA_NATIVE_COOKIE_LENGTH*2+1];
assert(conf);
if (pa_client_conf_load(conf, NULL) < 0) {
fprintf(stderr, "Failed to load client configuration file.\n");
goto finish;
}
if (pa_client_conf_env(conf) < 0) {
fprintf(stderr, "Failed to read environment configuration data.\n");
goto finish;
}
pa_x11_del_prop(d, "POLYP_SERVER");
pa_x11_del_prop(d, "POLYP_SINK");
pa_x11_del_prop(d, "POLYP_SOURCE");
pa_x11_del_prop(d, "POLYP_ID");
pa_x11_del_prop(d, "POLYP_COOKIE");
if (server)
pa_x11_set_prop(d, "POLYP_SERVER", server);
else if (conf->default_server)
pa_x11_set_prop(d, "POLYP_SERVER", conf->default_server);
else {
char hn[256];
if (!pa_get_fqdn(hn, sizeof(hn))) {
fprintf(stderr, "Failed to get FQDN.\n");
goto finish;
}
pa_x11_set_prop(d, "POLYP_SERVER", hn);
}
if (sink)
pa_x11_set_prop(d, "POLYP_SINK", sink);
else if (conf->default_sink)
pa_x11_set_prop(d, "POLYP_SINK", conf->default_sink);
if (source)
pa_x11_set_prop(d, "POLYP_SOURCE", source);
if (conf->default_source)
pa_x11_set_prop(d, "POLYP_SOURCE", conf->default_source);
pa_client_conf_free(conf);
if (pa_authkey_load_auto(cookie_file, cookie, sizeof(cookie)) < 0) {
fprintf(stderr, "Failed to load cookie data\n");
goto finish;
}
pa_x11_set_prop(d, "POLYP_COOKIE", pa_hexstr(cookie, sizeof(cookie), hx, sizeof(hx)));
break;
}
case REMOVE:
pa_x11_del_prop(d, "POLYP_SERVER");
pa_x11_del_prop(d, "POLYP_SINK");
pa_x11_del_prop(d, "POLYP_SOURCE");
pa_x11_del_prop(d, "POLYP_ID");
pa_x11_del_prop(d, "POLYP_COOKIE");
break;
default:
fprintf(stderr, "No yet implemented.\n");
goto finish;
}
ret = 0;
finish:
if (d) {
XSync(d, False);
XCloseDisplay(d);
}
return ret;
}