PA_CMD_CHECK
} pa_daemon_conf_cmd_t;
-/* A structure containing configuration data for the Polypaudio server . */
+/* A structure containing configuration data for the PulseAudio server . */
typedef struct pa_daemon_conf {
pa_daemon_conf_cmd_t cmd;
int daemonize,
*(p++) = ESD_PROTO_STREAM_PLAY;
*(p++) = u->format;
*(p++) = u->rate;
- pa_strlcpy((char*) p, "Polypaudio Tunnel", ESD_NAME_MAX);
+ pa_strlcpy((char*) p, "PulseAudio Tunnel", ESD_NAME_MAX);
u->write_index = 0;
u->state = STATE_RUNNING;
/* Yes, here is a race condition */
if (!pa_x11_get_prop(pa_x11_wrapper_get_display(u->x11_wrapper), "POLYP_ID", t, sizeof(t)) || strcmp(t, u->id))
- pa_log_warn(__FILE__": Polypaudio information vanished from X11!");
+ pa_log_warn(__FILE__": PulseAudio information vanished from X11!");
else {
pa_x11_del_prop(pa_x11_wrapper_get_display(u->x11_wrapper), "POLYP_ID");
pa_x11_del_prop(pa_x11_wrapper_get_display(u->x11_wrapper), "POLYP_SERVER");
*
* \li \subpage mainloop - A minimal but fast implementation based on poll().
* \li \subpage threaded_mainloop - A special version of the previous
- * implementation where all of Polypaudio's
+ * implementation where all of PulseAudio's
* internal handling runs in a separate
* thread.
* \li \subpage glib-mainloop - A wrapper around GLIB's main loop. Available
* \section overv_sec Overview
*
* Sometimes it is necessary to query and modify global settings in the
- * server. For this, Polypaudio has the introspection API. It can list sinks,
+ * server. For this, PulseAudio has the introspection API. It can list sinks,
* sources, samples and other aspects of the server. It can also modify the
* attributes of the server that will affect operations on a global level,
* and not just the application's context.
*
* \subsection module_subsec Driver Modules
*
- * Polypaudio driver modules are identified by index and are retrieved using either
+ * PulseAudio driver modules are identified by index and are retrieved using either
* pa_context_get_module_info() or pa_context_get_module_info_list(). The
* information structure is called pa_module_info.
*
*
* \subsection client_subsec Clients
*
- * Polypaudio clients are also identified by index and are retrieved using
+ * PulseAudio clients are also identified by index and are retrieved using
* either pa_context_get_client_info() or pa_context_get_client_info_list().
* The information structure is called pa_client_info.
*
* \li The complete but somewhat complicated to use asynchronous API
* \li The simplified, easy to use, but limited synchronous API
*
- * All strings in Polypaudio are in the UTF-8 encoding, regardless of current
+ * All strings in PulseAudio are in the UTF-8 encoding, regardless of current
* locale. Some functions will filter invalid sequences from the string, some
* will simply fail. To ensure reliable behaviour, make sure everything you
* pass to the API is already in UTF-8.
*
* \section overv_sec Overview
*
- * Polypaudio is capable of handling a multitude of sample formats, rates
+ * PulseAudio is capable of handling a multitude of sample formats, rates
* and channels, transparently converting and mixing them as needed.
*
* \section format_sec Sample Format
*
- * Polypaudio supports the following sample formats:
+ * PulseAudio supports the following sample formats:
*
* \li PA_SAMPLE_U8 - Unsigned 8 bit PCM.
* \li PA_SAMPLE_S16LE - Signed 16 bit PCM, little endian.
*
* \section rate_sec Sample Rates
*
- * Polypaudio supports any sample rate between 1 Hz and 4 GHz. There is no
+ * PulseAudio supports any sample rate between 1 Hz and 4 GHz. There is no
* point trying to exceed the sample rate of the output device though as the
* signal will only get downsampled, consuming CPU on the machine running the
* server.
*
* \section chan_sec Channels
*
- * Polypaudio supports up to 16 individiual channels. The order of the
+ * PulseAudio supports up to 16 individiual channels. The order of the
* channels is up to the application, but they must be continous. To map
* channels to speakers, see \ref channelmap.
*
* \section calc_sec Calculations
*
- * The Polypaudio library contains a number of convenience functions to do
+ * The PulseAudio library contains a number of convenience functions to do
* calculations on sample formats:
*
* \li pa_bytes_per_second() - The number of bytes one second of audio will
* wrap. The current read/write index may be queried using
* pa_stream_get_timing_info() (see below for more information). In
* case of a buffer underrun the read index is equal or larger than
- * the write index. Unless the prebuf value is 0, Polypaudio will
+ * the write index. Unless the prebuf value is 0, PulseAudio will
* temporarily pause playback in such a case, and wait until the
* buffer is filled up to prebuf bytes again. If prebuf is 0, the
* read index may be larger than the write index, in which case
* \section latency_sec Latency
*
* A major problem with networked audio is the increased latency caused by
- * the network. To remedy this, Polypaudio supports an advanced system of
+ * the network. To remedy this, PulseAudio supports an advanced system of
* monitoring the current latency.
*
* To get the raw data needed to calculate latencies, call
* pa_stream_update_timing_info() operation is executed. (i.e. before
* the first call to this function the timing information structure is
* not available!) Since it is a lot of work to keep this structure
- * up-to-date manually, Polypaudio can do that automatically for you:
+ * up-to-date manually, PulseAudio can do that automatically for you:
* if PA_STREAM_AUTO_TIMING_UPDATE is passed when connecting the
- * stream Polypaudio will automatically update the structure every
+ * stream PulseAudio will automatically update the structure every
* 100ms and every time a function is called that might invalidate the
* previously known timing data (such as pa_stream_write() or
* pa_stream_flush()). Please note however, that there always is a
* short time window when the data in the timing information structure
- * is out-of-date. Polypaudio tries to mark these situations by
+ * is out-of-date. PulseAudio tries to mark these situations by
* setting the write_index_corrupt and read_index_corrupt fields
* accordingly.
*
*
* Since updating the timing info structure usually requires a full
* network round trip and some applications monitor the timing very
- * often Polypaudio offers a timing interpolation system. If
+ * often PulseAudio offers a timing interpolation system. If
* PA_STREAM_INTERPOLATE_TIMING is passed when connecting the stream,
* pa_stream_get_time() and pa_stream_get_latency() will try to
* interpolate the current playback time/latency by estimating the
*
* \section sync_streams Sychronizing Multiple Playback Streams
*
- * Polypaudio allows applications to fully synchronize multiple
+ * PulseAudio allows applications to fully synchronize multiple
* playback streams that are connected to the same output device. That
* means the streams will always be played back sample-by-sample
* synchronously. If stream operations like pa_stream_cork() are
/** Return the buffer metrics of the stream. Only valid after the
* stream has been connected successfuly and if the server is at least
- * Polypaudio 0.9. \since 0.9.0 */
+ * PulseAudio 0.9. \since 0.9.0 */
const pa_buffer_attr* pa_stream_get_buffer_attr(pa_stream *s);
PA_C_DECL_END
*
* The added feature in the threaded main loop is that it spawns a new thread
* that runs the real main loop. This allows a synchronous application to use
- * the asynchronous API without risking to stall the Polypaudio library.
+ * the asynchronous API without risking to stall the PulseAudio library.
*
* \section creat_sec Creation
*
*
* \section destr_sec Destruction
*
- * When the Polypaudio connection has been terminated, the thread must be
+ * When the PulseAudio connection has been terminated, the thread must be
* stopped and the resources freed. Stopping the thread is done using
* pa_threaded_mainloop_stop(), which must be called without the lock (see
* below) held. When that function returns, the thread is stopped and the
*
* \section lock_sec Locking
*
- * Since the Polypaudio API doesn't allow concurrent accesses to objects,
+ * Since the PulseAudio API doesn't allow concurrent accesses to objects,
* a locking scheme must be used to guarantee safe usage. The threaded main
* loop API provides such a scheme through the functions
* pa_threaded_mainloop_lock() and pa_threaded_mainloop_unlock().
* thread. Just make sure you call pa_threaded_mainloop_unlock() the same
* number of times you called pa_threaded_mainloop_lock().
*
- * The lock needs to be held whenever you call any Polypaudio function that
+ * The lock needs to be held whenever you call any PulseAudio function that
* uses an object associated with this main loop. Make sure you do not hold
* on to the lock more than necessary though, as the threaded main loop stops
* while the lock is held.
*
* \section cb_sec Callbacks
*
- * Callbacks in Polypaudio are asynchronous, so they require extra care when
+ * Callbacks in PulseAudio are asynchronous, so they require extra care when
* using them together with a threaded main loop.
*
* The easiest way to turn the callback based operations into synchronous
* ones, is to simply wait for the callback to be called and continue from
- * there. This is the approach chosen in Polypaudio's threaded API.
+ * there. This is the approach chosen in PulseAudio's threaded API.
*
* \subsection basic_subsec Basic callbacks
*
*
* \subsection async_subsec Asynchronous callbacks
*
- * Polypaudio also has callbacks that are completely asynchronous, meaning
+ * PulseAudio also has callbacks that are completely asynchronous, meaning
* that they can be called at any time. The threading main loop API provides
* the locking mechanism to handle concurrent accesses, but nothing else.
* Applications will have to handle communication from the callback to the
/** Return the version of the library the current application is linked to. */
const char* pa_get_library_version(void);
-/** The current API version. Version 6 relates to pulseaudio
+/** The current API version. Version 6 relates to Polypaudio
* 0.6. Prior versions (i.e. Polypaudio 0.5.1 and older) have
* PA_API_VERSION undefined. */
#define PA_API_VERSION @PA_API_VERSION@
-/** The current protocol version. Version 8 relates to pulseaudio 0.8.
+/** The current protocol version. Version 8 relates to Polypaudio 0.8/PulseAudio 0.9.
* \since 0.8 */
#define PA_PROTOCOL_VERSION @PA_PROTOCOL_VERSION@
* \section overv_sec Overview
*
* Sinks, sources, sink inputs and samples can all have their own volumes.
- * To deal with these, The Polypaudio libray contains a number of functions
+ * To deal with these, The PulseAudio libray contains a number of functions
* that ease handling.
*
- * The basic volume type in Polypaudio is the \ref pa_volume_t type. Most of
+ * The basic volume type in PulseAudio is the \ref pa_volume_t type. Most of
* the time, applications will use the aggregated pa_cvolume structure that
* can store the volume of all channels at once.
*
*
* \section calc_sec Calculations
*
- * The volumes in Polypaudio are logarithmic in nature and applications
+ * The volumes in PulseAudio are logarithmic in nature and applications
* shouldn't perform calculations with them directly. Instead, they should
* be converted to and from either dB or a linear scale:
*
*
* \section conv_sec Convenience Functions
*
- * To handle the pa_cvolume structure, the Polypaudio library provides a
+ * To handle the pa_cvolume structure, the PulseAudio library provides a
* number of convenienc functions:
*
* \li pa_cvolume_valid() - Tests if a pa_cvolume structure is valid.
#include <sys/types.h>
#include <inttypes.h>
-/* A pa_memblock is a reference counted memory block. Polypaudio
+/* A pa_memblock is a reference counted memory block. PulseAudio
* passed references to pa_memblocks around instead of copying
* data. See pa_memchunk for a structure that describes parts of
* memory blocks. */
USA.
***/
-/* Some functions for reading module meta data from Polypaudio modules */
+/* Some functions for reading module meta data from PulseAudio modules */
typedef struct pa_modinfo {
char *author;
#define TIME_EVENT_USEC 50000
#if PA_API_VERSION != 9
-#error Invalid Polypaudio API version
+#error Invalid PulseAudio API version
#endif
static enum { RECORD, PLAYBACK } mode = PLAYBACK;
fd_set ifds, ofds;
if (pa_pid_file_check_running(&pid) < 0) {
- pa_log(__FILE__": no Polypaudio daemon running");
+ pa_log(__FILE__": no PulseAudio daemon running");
goto fail;
}
break;
if (pa_pid_file_kill(SIGUSR2, NULL) < 0) {
- pa_log(__FILE__": failed to kill Polypaudio daemon.");
+ pa_log(__FILE__": failed to kill PulseAudio daemon.");
goto fail;
}
#include <pulse/pulseaudio.h>
#if PA_API_VERSION != 9
-#error Invalid Polypaudio API version
+#error Invalid PulseAudio API version
#endif
#define BUFSIZE 1024
export PADSP_DEBUG
;;
*)
- echo "$0 - redirect OSS audio devices to Polypaudio"
+ echo "$0 - redirect OSS audio devices to PulseAudio"
echo " "
echo "$0 [options] application [arguments]"
echo " "
echo "options:"
echo " -h show brief help"
- echo " -s <host>[:<port>] contact a specific Polypaudio server"
+ echo " -s <host>[:<port>] contact a specific PulseAudio server"
echo " -n <name> client name to report to the server"
echo " -m <name> stream name to report to the server"
echo " -M disable /dev/mixer emulation"
static int sndstat_open(int flags, int *_errno) {
static const char sndstat[] =
- "Sound Driver:3.8.1a-980706 (Polypaudio Virtual OSS)\n"
+ "Sound Driver:3.8.1a-980706 (PulseAudio Virtual OSS)\n"
"Kernel: POSIX\n"
"Config options: 0\n"
"\n"
"Installed drivers:\n"
- "Type 255: Polypaudio Virtual OSS\n"
+ "Type 255: PulseAudio Virtual OSS\n"
"\n"
"Card config:\n"
- "Polypaudio Virtual OSS\n"
+ "PulseAudio Virtual OSS\n"
"\n"
"Audio devices:\n"
- "0: Polypaudio Virtual OSS\n"
+ "0: PulseAudio Virtual OSS\n"
"\n"
"Synth devices: NOT ENABLED IN CONFIG\n"
"\n"
"Timers:\n"
"\n"
"Mixers:\n"
- "0: Polypaudio Virtual OSS\n";
+ "0: PulseAudio Virtual OSS\n";
char fn[] = "/tmp/padsp-sndstat-XXXXXX";
mode_t u;
memset(mi, 0, sizeof(mixer_info));
strncpy(mi->id, "POLYPAUDIO", sizeof(mi->id));
- strncpy(mi->name, "Polypaudio Virtual OSS", sizeof(mi->name));
+ strncpy(mi->name, "PulseAudio Virtual OSS", sizeof(mi->name));
pa_threaded_mainloop_lock(i->mainloop);
mi->modify_counter = i->volume_modify_count;
pa_threaded_mainloop_unlock(i->mainloop);
#include <pulse/pulseaudio.h>
#if PA_API_VERSION != 9
-#error Invalid Polypaudio API version
+#error Invalid PulseAudio API version
#endif
static pa_context *context = NULL;
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",
+ " -d Show current PulseAudio data attached to X11 display (default)\n"
+ " -e Export local PulseAudio data to X11 display\n"
+ " -i Import PulseAudio data from X11 display to local environment variables and cookie file.\n"
+ " -r Remove PulseAudio data from X11 display\n",
pa_path_get_filename(argv[0]));
ret = 0;
goto finish;