...
 
Commits (1)
......@@ -117,7 +117,7 @@ VLC_CONFIGURE_ARGS="\
--enable-zvbi \
--disable-fluidsynth \
--disable-jack \
--disable-pulse \
--enable-pulse \
--disable-alsa \
--disable-samplerate \
--disable-sdl \
......@@ -286,12 +286,35 @@ cd ../../
###################
VLC_BUILD_DIR=build-tizen-${TARGET_TUPLE}
mkdir -p $VLC_BUILD_DIR && cd $VLC_BUILD_DIR
mkdir -p ${PROJECTPATH}/vlc/${VLC_BUILD_DIR}
#####################
# FAKE VLC DEPS #
#####################
VLC_HACK_PREFIX=${PROJECTPATH}/vlc/${VLC_BUILD_DIR}/prefix
VLC_HACK_INCLUDES="${PROJECTPATH}/hacks/vlc/include"
VLC_HACK_LIB="${VLC_HACK_PREFIX}/lib"
mkdir -p ${VLC_HACK_LIB}
echo ${VLC_HACK_PREFIX}
cd ${PROJECTPATH}/hacks/vlc
for symbols in *.symbols; do
so_file="`basename $symbols .symbols`"
c_file="`basename $so_file .so`.c"
rm -f ${VLC_HACK_PREFIX}/$c_file ${VLC_HACK_LIB}/$so_file
for s in `cat $symbols`; do echo "void $s() {}" >> ${VLC_HACK_PREFIX}/$c_file; done
${CC} ${VLC_HACK_PREFIX}/$c_file -shared -o ${VLC_HACK_LIB}/$so_file -fPIC
done
#############
# CONFIGURE #
#############
cd ${PROJECTPATH}/vlc/${VLC_BUILD_DIR}
if [ ! -e ./config.h -o "$RELEASE" = 1 ]; then
CPPFLAGS="$CPPFLAGS" \
CFLAGS="$CFLAGS ${EXTRA_CFLAGS}" \
......@@ -303,6 +326,8 @@ NM="${CROSS_COMPILE}nm" \
STRIP="${CROSS_COMPILE}strip" \
RANLIB="${CROSS_COMPILE}ranlib" \
AR="${CROSS_COMPILE}ar" \
PULSE_CFLAGS="-I${VLC_HACK_INCLUDES}" \
PULSE_LIBS="-L${VLC_HACK_LIB} -lpulse" \
PKG_CONFIG_LIBDIR=../contrib/$TARGET_TUPLE/lib/pkgconfig \
sh ../configure --host=$TARGET_TUPLE --build=x86_64-unknown-linux \
${EXTRA_PARAMS} ${VLC_CONFIGURE_ARGS} ${OPTS}
......
#!/bin/sh
for i in *.so; do
nm -D --defined-only $i | awk '{print $3}' \
| grep -vE "^(__aeabi|__bss_start|__bss_end__|_bss_end__|_edata|__end__|_init|_fini|_end)" > $i.symbols
done
#ifndef foopulsecdeclhfoo
#define foopulsecdeclhfoo
/***
This file is part of PulseAudio.
Copyright 2004-2006 Lennart Poettering
PulseAudio 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.1 of the License,
or (at your option) any later version.
PulseAudio 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 PulseAudio; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
USA.
***/
/** \file
* C++ compatibility support */
#ifdef __cplusplus
/** If using C++ this macro enables C mode, otherwise does nothing */
#define PA_C_DECL_BEGIN extern "C" {
/** If using C++ this macros switches back to C++ mode, otherwise does nothing */
#define PA_C_DECL_END }
#else
/** If using C++ this macro enables C mode, otherwise does nothing */
#define PA_C_DECL_BEGIN
/** If using C++ this macros switches back to C++ mode, otherwise does nothing */
#define PA_C_DECL_END
#endif
#endif
#ifndef foochannelmaphfoo
#define foochannelmaphfoo
/***
This file is part of PulseAudio.
Copyright 2005-2006 Lennart Poettering
Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
PulseAudio 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.1 of the License,
or (at your option) any later version.
PulseAudio 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 PulseAudio; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
USA.
***/
#include <pulse/sample.h>
#include <pulse/cdecl.h>
#include <pulse/gccmacro.h>
#include <pulse/version.h>
/** \page channelmap Channel Maps
*
* \section overv_sec Overview
*
* Channel maps provide a way to associate channels in a stream with a
* specific speaker position. This relieves applications of having to
* make sure their channel order is identical to the final output.
*
* \section init_sec Initialisation
*
* A channel map consists of an array of \ref pa_channel_position values,
* one for each channel. This array is stored together with a channel count
* in a pa_channel_map structure.
*
* Before filling the structure, the application must initialise it using
* pa_channel_map_init(). There are also a number of convenience functions
* for standard channel mappings:
*
* \li pa_channel_map_init_mono() - Create a channel map with only mono audio.
* \li pa_channel_map_init_stereo() - Create a standard stereo mapping.
* \li pa_channel_map_init_auto() - Create a standard channel map for a specific number of channels
* \li pa_channel_map_init_extend() - Similar to
* pa_channel_map_init_auto() but synthesize a channel map if no
* predefined one is known for the specified number of channels.
*
* \section conv_sec Convenience Functions
*
* The library contains a number of convenience functions for dealing with
* channel maps:
*
* \li pa_channel_map_valid() - Tests if a channel map is valid.
* \li pa_channel_map_equal() - Tests if two channel maps are identical.
* \li pa_channel_map_snprint() - Creates a textual description of a channel
* map.
*/
/** \file
* Constants and routines for channel mapping handling
*
* See also \subpage channelmap
*/
PA_C_DECL_BEGIN
/** A list of channel labels */
typedef enum pa_channel_position {
PA_CHANNEL_POSITION_INVALID = -1,
PA_CHANNEL_POSITION_MONO = 0,
PA_CHANNEL_POSITION_FRONT_LEFT, /**< Apple, Dolby call this 'Left' */
PA_CHANNEL_POSITION_FRONT_RIGHT, /**< Apple, Dolby call this 'Right' */
PA_CHANNEL_POSITION_FRONT_CENTER, /**< Apple, Dolby call this 'Center' */
/** \cond fulldocs */
PA_CHANNEL_POSITION_LEFT = PA_CHANNEL_POSITION_FRONT_LEFT,
PA_CHANNEL_POSITION_RIGHT = PA_CHANNEL_POSITION_FRONT_RIGHT,
PA_CHANNEL_POSITION_CENTER = PA_CHANNEL_POSITION_FRONT_CENTER,
/** \endcond */
PA_CHANNEL_POSITION_REAR_CENTER, /**< Microsoft calls this 'Back Center', Apple calls this 'Center Surround', Dolby calls this 'Surround Rear Center' */
PA_CHANNEL_POSITION_REAR_LEFT, /**< Microsoft calls this 'Back Left', Apple calls this 'Left Surround' (!), Dolby calls this 'Surround Rear Left' */
PA_CHANNEL_POSITION_REAR_RIGHT, /**< Microsoft calls this 'Back Right', Apple calls this 'Right Surround' (!), Dolby calls this 'Surround Rear Right' */
PA_CHANNEL_POSITION_LFE, /**< Microsoft calls this 'Low Frequency', Apple calls this 'LFEScreen' */
/** \cond fulldocs */
PA_CHANNEL_POSITION_SUBWOOFER = PA_CHANNEL_POSITION_LFE,
/** \endcond */
PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER, /**< Apple, Dolby call this 'Left Center' */
PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER, /**< Apple, Dolby call this 'Right Center */
PA_CHANNEL_POSITION_SIDE_LEFT, /**< Apple calls this 'Left Surround Direct', Dolby calls this 'Surround Left' (!) */
PA_CHANNEL_POSITION_SIDE_RIGHT, /**< Apple calls this 'Right Surround Direct', Dolby calls this 'Surround Right' (!) */
PA_CHANNEL_POSITION_AUX0,
PA_CHANNEL_POSITION_AUX1,
PA_CHANNEL_POSITION_AUX2,
PA_CHANNEL_POSITION_AUX3,
PA_CHANNEL_POSITION_AUX4,
PA_CHANNEL_POSITION_AUX5,
PA_CHANNEL_POSITION_AUX6,
PA_CHANNEL_POSITION_AUX7,
PA_CHANNEL_POSITION_AUX8,
PA_CHANNEL_POSITION_AUX9,
PA_CHANNEL_POSITION_AUX10,
PA_CHANNEL_POSITION_AUX11,
PA_CHANNEL_POSITION_AUX12,
PA_CHANNEL_POSITION_AUX13,
PA_CHANNEL_POSITION_AUX14,
PA_CHANNEL_POSITION_AUX15,
PA_CHANNEL_POSITION_AUX16,
PA_CHANNEL_POSITION_AUX17,
PA_CHANNEL_POSITION_AUX18,
PA_CHANNEL_POSITION_AUX19,
PA_CHANNEL_POSITION_AUX20,
PA_CHANNEL_POSITION_AUX21,
PA_CHANNEL_POSITION_AUX22,
PA_CHANNEL_POSITION_AUX23,
PA_CHANNEL_POSITION_AUX24,
PA_CHANNEL_POSITION_AUX25,
PA_CHANNEL_POSITION_AUX26,
PA_CHANNEL_POSITION_AUX27,
PA_CHANNEL_POSITION_AUX28,
PA_CHANNEL_POSITION_AUX29,
PA_CHANNEL_POSITION_AUX30,
PA_CHANNEL_POSITION_AUX31,
PA_CHANNEL_POSITION_TOP_CENTER, /**< Apple calls this 'Top Center Surround' */
PA_CHANNEL_POSITION_TOP_FRONT_LEFT, /**< Apple calls this 'Vertical Height Left' */
PA_CHANNEL_POSITION_TOP_FRONT_RIGHT, /**< Apple calls this 'Vertical Height Right' */
PA_CHANNEL_POSITION_TOP_FRONT_CENTER, /**< Apple calls this 'Vertical Height Center' */
PA_CHANNEL_POSITION_TOP_REAR_LEFT, /**< Microsoft and Apple call this 'Top Back Left' */
PA_CHANNEL_POSITION_TOP_REAR_RIGHT, /**< Microsoft and Apple call this 'Top Back Right' */
PA_CHANNEL_POSITION_TOP_REAR_CENTER, /**< Microsoft and Apple call this 'Top Back Center' */
PA_CHANNEL_POSITION_MAX
} pa_channel_position_t;
/** \cond fulldocs */
#define PA_CHANNEL_POSITION_INVALID PA_CHANNEL_POSITION_INVALID
#define PA_CHANNEL_POSITION_MONO PA_CHANNEL_POSITION_MONO
#define PA_CHANNEL_POSITION_LEFT PA_CHANNEL_POSITION_LEFT
#define PA_CHANNEL_POSITION_RIGHT PA_CHANNEL_POSITION_RIGHT
#define PA_CHANNEL_POSITION_CENTER PA_CHANNEL_POSITION_CENTER
#define PA_CHANNEL_POSITION_FRONT_LEFT PA_CHANNEL_POSITION_FRONT_LEFT
#define PA_CHANNEL_POSITION_FRONT_RIGHT PA_CHANNEL_POSITION_FRONT_RIGHT
#define PA_CHANNEL_POSITION_FRONT_CENTER PA_CHANNEL_POSITION_FRONT_CENTER
#define PA_CHANNEL_POSITION_REAR_CENTER PA_CHANNEL_POSITION_REAR_CENTER
#define PA_CHANNEL_POSITION_REAR_LEFT PA_CHANNEL_POSITION_REAR_LEFT
#define PA_CHANNEL_POSITION_REAR_RIGHT PA_CHANNEL_POSITION_REAR_RIGHT
#define PA_CHANNEL_POSITION_LFE PA_CHANNEL_POSITION_LFE
#define PA_CHANNEL_POSITION_SUBWOOFER PA_CHANNEL_POSITION_SUBWOOFER
#define PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER
#define PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER
#define PA_CHANNEL_POSITION_SIDE_LEFT PA_CHANNEL_POSITION_SIDE_LEFT
#define PA_CHANNEL_POSITION_SIDE_RIGHT PA_CHANNEL_POSITION_SIDE_RIGHT
#define PA_CHANNEL_POSITION_AUX0 PA_CHANNEL_POSITION_AUX0
#define PA_CHANNEL_POSITION_AUX1 PA_CHANNEL_POSITION_AUX1
#define PA_CHANNEL_POSITION_AUX2 PA_CHANNEL_POSITION_AUX2
#define PA_CHANNEL_POSITION_AUX3 PA_CHANNEL_POSITION_AUX3
#define PA_CHANNEL_POSITION_AUX4 PA_CHANNEL_POSITION_AUX4
#define PA_CHANNEL_POSITION_AUX5 PA_CHANNEL_POSITION_AUX5
#define PA_CHANNEL_POSITION_AUX6 PA_CHANNEL_POSITION_AUX6
#define PA_CHANNEL_POSITION_AUX7 PA_CHANNEL_POSITION_AUX7
#define PA_CHANNEL_POSITION_AUX8 PA_CHANNEL_POSITION_AUX8
#define PA_CHANNEL_POSITION_AUX9 PA_CHANNEL_POSITION_AUX9
#define PA_CHANNEL_POSITION_AUX10 PA_CHANNEL_POSITION_AUX10
#define PA_CHANNEL_POSITION_AUX11 PA_CHANNEL_POSITION_AUX11
#define PA_CHANNEL_POSITION_AUX12 PA_CHANNEL_POSITION_AUX12
#define PA_CHANNEL_POSITION_AUX13 PA_CHANNEL_POSITION_AUX13
#define PA_CHANNEL_POSITION_AUX14 PA_CHANNEL_POSITION_AUX14
#define PA_CHANNEL_POSITION_AUX15 PA_CHANNEL_POSITION_AUX15
#define PA_CHANNEL_POSITION_AUX16 PA_CHANNEL_POSITION_AUX16
#define PA_CHANNEL_POSITION_AUX17 PA_CHANNEL_POSITION_AUX17
#define PA_CHANNEL_POSITION_AUX18 PA_CHANNEL_POSITION_AUX18
#define PA_CHANNEL_POSITION_AUX19 PA_CHANNEL_POSITION_AUX19
#define PA_CHANNEL_POSITION_AUX20 PA_CHANNEL_POSITION_AUX20
#define PA_CHANNEL_POSITION_AUX21 PA_CHANNEL_POSITION_AUX21
#define PA_CHANNEL_POSITION_AUX22 PA_CHANNEL_POSITION_AUX22
#define PA_CHANNEL_POSITION_AUX23 PA_CHANNEL_POSITION_AUX23
#define PA_CHANNEL_POSITION_AUX24 PA_CHANNEL_POSITION_AUX24
#define PA_CHANNEL_POSITION_AUX25 PA_CHANNEL_POSITION_AUX25
#define PA_CHANNEL_POSITION_AUX26 PA_CHANNEL_POSITION_AUX26
#define PA_CHANNEL_POSITION_AUX27 PA_CHANNEL_POSITION_AUX27
#define PA_CHANNEL_POSITION_AUX28 PA_CHANNEL_POSITION_AUX28
#define PA_CHANNEL_POSITION_AUX29 PA_CHANNEL_POSITION_AUX29
#define PA_CHANNEL_POSITION_AUX30 PA_CHANNEL_POSITION_AUX30
#define PA_CHANNEL_POSITION_AUX31 PA_CHANNEL_POSITION_AUX31
#define PA_CHANNEL_POSITION_TOP_CENTER PA_CHANNEL_POSITION_TOP_CENTER
#define PA_CHANNEL_POSITION_TOP_FRONT_LEFT PA_CHANNEL_POSITION_TOP_FRONT_LEFT
#define PA_CHANNEL_POSITION_TOP_FRONT_RIGHT PA_CHANNEL_POSITION_TOP_FRONT_RIGHT
#define PA_CHANNEL_POSITION_TOP_FRONT_CENTER PA_CHANNEL_POSITION_TOP_FRONT_CENTER
#define PA_CHANNEL_POSITION_TOP_REAR_LEFT PA_CHANNEL_POSITION_TOP_REAR_LEFT
#define PA_CHANNEL_POSITION_TOP_REAR_RIGHT PA_CHANNEL_POSITION_TOP_REAR_RIGHT
#define PA_CHANNEL_POSITION_TOP_REAR_CENTER PA_CHANNEL_POSITION_TOP_REAR_CENTER
#define PA_CHANNEL_POSITION_MAX PA_CHANNEL_POSITION_MAX
/** \endcond */
/** A mask of channel positions. \since 0.9.16 */
typedef uint64_t pa_channel_position_mask_t;
/** Makes a bit mask from a channel position. \since 0.9.16 */
#define PA_CHANNEL_POSITION_MASK(f) ((pa_channel_position_mask_t) (1ULL << (f)))
/** A list of channel mapping definitions for pa_channel_map_init_auto() */
typedef enum pa_channel_map_def {
PA_CHANNEL_MAP_AIFF,
/**< The mapping from RFC3551, which is based on AIFF-C */
/** \cond fulldocs */
PA_CHANNEL_MAP_ALSA,
/**< The default mapping used by ALSA. This mapping is probably
* not too useful since ALSA's default channel mapping depends on
* the device string used. */
/** \endcond */
PA_CHANNEL_MAP_AUX,
/**< Only aux channels */
PA_CHANNEL_MAP_WAVEEX,
/**< Microsoft's WAVEFORMATEXTENSIBLE mapping. This mapping works
* as if all LSBs of dwChannelMask are set. */
/** \cond fulldocs */
PA_CHANNEL_MAP_OSS,
/**< The default channel mapping used by OSS as defined in the OSS
* 4.0 API specs. This mapping is probably not too useful since
* the OSS API has changed in this respect and no longer knows a
* default channel mapping based on the number of channels. */
/** \endcond */
/**< Upper limit of valid channel mapping definitions */
PA_CHANNEL_MAP_DEF_MAX,
PA_CHANNEL_MAP_DEFAULT = PA_CHANNEL_MAP_AIFF
/**< The default channel map */
} pa_channel_map_def_t;
/** \cond fulldocs */
#define PA_CHANNEL_MAP_AIFF PA_CHANNEL_MAP_AIFF
#define PA_CHANNEL_MAP_ALSA PA_CHANNEL_MAP_ALSA
#define PA_CHANNEL_MAP_AUX PA_CHANNEL_MAP_AUX
#define PA_CHANNEL_MAP_WAVEEX PA_CHANNEL_MAP_WAVEEX
#define PA_CHANNEL_MAP_OSS PA_CHANNEL_MAP_OSS
#define PA_CHANNEL_MAP_DEF_MAX PA_CHANNEL_MAP_DEF_MAX
#define PA_CHANNEL_MAP_DEFAULT PA_CHANNEL_MAP_DEFAULT
/** \endcond */
/** A channel map which can be used to attach labels to specific
* channels of a stream. These values are relevant for conversion and
* mixing of streams */
typedef struct pa_channel_map {
uint8_t channels;
/**< Number of channels */
pa_channel_position_t map[PA_CHANNELS_MAX];
/**< Channel labels */
} pa_channel_map;
/** Initialize the specified channel map and return a pointer to
* it. The channel map will have a defined state but
* pa_channel_map_valid() will fail for it. */
pa_channel_map* pa_channel_map_init(pa_channel_map *m);
/** Initialize the specified channel map for monaural audio and return a pointer to it */
pa_channel_map* pa_channel_map_init_mono(pa_channel_map *m);
/** Initialize the specified channel map for stereophonic audio and return a pointer to it */
pa_channel_map* pa_channel_map_init_stereo(pa_channel_map *m);
/** Initialize the specified channel map for the specified number of
* channels using default labels and return a pointer to it. This call
* will fail (return NULL) if there is no default channel map known for this
* specific number of channels and mapping. */
pa_channel_map* pa_channel_map_init_auto(pa_channel_map *m, unsigned channels, pa_channel_map_def_t def);
/** Similar to pa_channel_map_init_auto() but instead of failing if no
* default mapping is known with the specified parameters it will
* synthesize a mapping based on a known mapping with fewer channels
* and fill up the rest with AUX0...AUX31 channels \since 0.9.11 */
pa_channel_map* pa_channel_map_init_extend(pa_channel_map *m, unsigned channels, pa_channel_map_def_t def);
/** Return a text label for the specified channel position */
const char* pa_channel_position_to_string(pa_channel_position_t pos) PA_GCC_PURE;
/** The inverse of pa_channel_position_to_string(). \since 0.9.16 */
pa_channel_position_t pa_channel_position_from_string(const char *s) PA_GCC_PURE;
/** Return a human readable text label for the specified channel position. \since 0.9.7 */
const char* pa_channel_position_to_pretty_string(pa_channel_position_t pos);
/** The maximum length of strings returned by
* pa_channel_map_snprint(). Please note that this value can change
* with any release without warning and without being considered API
* or ABI breakage. You should not use this definition anywhere where
* it might become part of an ABI. */
#define PA_CHANNEL_MAP_SNPRINT_MAX 336
/** Make a human readable string from the specified channel map */
char* pa_channel_map_snprint(char *s, size_t l, const pa_channel_map *map);
/** Parse a channel position list or well-known mapping name into a
* channel map structure. This turns the output of
* pa_channel_map_snprint() and pa_channel_map_to_name() back into a
* pa_channel_map */
pa_channel_map *pa_channel_map_parse(pa_channel_map *map, const char *s);
/** Compare two channel maps. Return 1 if both match. */
int pa_channel_map_equal(const pa_channel_map *a, const pa_channel_map *b) PA_GCC_PURE;
/** Return non-zero if the specified channel map is considered valid */
int pa_channel_map_valid(const pa_channel_map *map) PA_GCC_PURE;
/** Return non-zero if the specified channel map is compatible with
* the specified sample spec. \since 0.9.12 */
int pa_channel_map_compatible(const pa_channel_map *map, const pa_sample_spec *ss) PA_GCC_PURE;
/** Returns non-zero if every channel defined in b is also defined in a. \since 0.9.15 */
int pa_channel_map_superset(const pa_channel_map *a, const pa_channel_map *b) PA_GCC_PURE;
/** Returns non-zero if it makes sense to apply a volume 'balance'
* with this mapping, i.e.\ if there are left/right channels
* available. \since 0.9.15 */
int pa_channel_map_can_balance(const pa_channel_map *map) PA_GCC_PURE;
/** Returns non-zero if it makes sense to apply a volume 'fade'
* (i.e.\ 'balance' between front and rear) with this mapping, i.e.\ if
* there are front/rear channels available. \since 0.9.15 */
int pa_channel_map_can_fade(const pa_channel_map *map) PA_GCC_PURE;
/** Tries to find a well-known channel mapping name for this channel
* mapping, i.e.\ "stereo", "surround-71" and so on. If the channel
* mapping is unknown NULL will be returned. This name can be parsed
* with pa_channel_map_parse() \since 0.9.15 */
const char* pa_channel_map_to_name(const pa_channel_map *map) PA_GCC_PURE;
/** Tries to find a human readable text label for this channel
mapping, i.e.\ "Stereo", "Surround 7.1" and so on. If the channel
mapping is unknown NULL will be returned. \since 0.9.15 */
const char* pa_channel_map_to_pretty_name(const pa_channel_map *map) PA_GCC_PURE;
/** Returns TRUE if the specified channel position is available at
* least once in the channel map. \since 0.9.16 */
int pa_channel_map_has_position(const pa_channel_map *map, pa_channel_position_t p) PA_GCC_PURE;
/** Generates a bit mask from a channel map. \since 0.9.16 */
pa_channel_position_mask_t pa_channel_map_mask(const pa_channel_map *map) PA_GCC_PURE;
PA_C_DECL_END
#endif
#ifndef foocontexthfoo
#define foocontexthfoo
/***
This file is part of PulseAudio.
Copyright 2004-2006 Lennart Poettering
Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
PulseAudio 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.1 of the License,
or (at your option) any later version.
PulseAudio 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 PulseAudio; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
USA.
***/
#include <pulse/sample.h>
#include <pulse/def.h>
#include <pulse/mainloop-api.h>
#include <pulse/cdecl.h>
#include <pulse/operation.h>
#include <pulse/proplist.h>
#include <pulse/version.h>
/** \page async Asynchronous API
*
* \section overv_sec Overview
*
* The asynchronous API is the native interface to the PulseAudio library.
* It allows full access to all available functionality. This however means that
* it is rather complex and can take some time to fully master.
*
* \section mainloop_sec Main Loop Abstraction
*
* The API is based around an asynchronous event loop, or main loop,
* abstraction. This abstraction contains three basic elements:
*
* \li Deferred events - Events that will trigger as soon as possible. Note
* that some implementations may block all other events
* when a deferred event is active.
* \li I/O events - Events that trigger on file descriptor activities.
* \li Times events - Events that trigger after a fixed amount of time.
*
* The abstraction is represented as a number of function pointers in the
* pa_mainloop_api structure.
*
* To actually be able to use these functions, an implementation needs to
* be coupled to the abstraction. There are three of these shipped with
* PulseAudio, but any other can be used with a minimal amount of work,
* provided it supports the three basic events listed above.
*
* The implementations shipped with PulseAudio are:
*
* \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 PulseAudio's
* internal handling runs in a separate
* thread.
* \li \subpage glib-mainloop - A wrapper around GLib's main loop.
*
* UNIX signals may be hooked to a main loop using the functions from
* \ref mainloop-signal.h. These rely only on the main loop abstraction
* and can therefore be used with any of the implementations.
*
* \section refcnt_sec Reference Counting
*
* Almost all objects in PulseAudio are reference counted. What that means
* is that you rarely malloc() or free() any objects. Instead you increase
* and decrease their reference counts. Whenever an object's reference
* count reaches zero, that object gets destroy and any resources it uses
* get freed.
*
* The benefit of this design is that an application need not worry about
* whether or not it needs to keep an object around in case the library is
* using it internally. If it is, then it has made sure it has its own
* reference to it.
*
* Whenever the library creates an object, it will have an initial
* reference count of one. Most of the time, this single reference will be
* sufficient for the application, so all required reference count
* interaction will be a single call to the objects unref function.
*
* \section context_sec Context
*
* A context is the basic object for a connection to a PulseAudio server.
* It multiplexes commands, data streams and events through a single
* channel.
*
* There is no need for more than one context per application, unless
* connections to multiple servers are needed.
*
* \subsection ops_subsec Operations
*
* All operations on the context are performed asynchronously. I.e. the
* client will not wait for the server to complete the request. To keep
* track of all these in-flight operations, the application is given a
* pa_operation object for each asynchronous operation.
*
* There are only two actions (besides reference counting) that can be
* performed on a pa_operation: querying its state with
* pa_operation_get_state() and aborting it with pa_operation_cancel().
*
* A pa_operation object is reference counted, so an application must
* make sure to unreference it, even if it has no intention of using it.
*
* \subsection conn_subsec Connecting
*
* A context must be connected to a server before any operation can be
* issued. Calling pa_context_connect() will initiate the connection
* procedure. Unlike most asynchronous operations, connecting does not
* result in a pa_operation object. Instead, the application should
* register a callback using pa_context_set_state_callback().
*
* \subsection disc_subsec Disconnecting
*
* When the sound support is no longer needed, the connection needs to be
* closed using pa_context_disconnect(). This is an immediate function that
* works synchronously.
*
* Since the context object has references to other objects it must be
* disconnected after use or there is a high risk of memory leaks. If the
* connection has terminated by itself, then there is no need to explicitly
* disconnect the context using pa_context_disconnect().
*
* \section Functions
*
* The sound server's functionality can be divided into a number of
* subsections:
*
* \li \subpage streams
* \li \subpage scache
* \li \subpage introspect
* \li \subpage subscribe
*/
/** \file
* Connection contexts for asynchronous communication with a
* server. A pa_context object wraps a connection to a PulseAudio
* server using its native protocol.
*
* See also \subpage async
*/
PA_C_DECL_BEGIN
/** An opaque connection context to a daemon */
typedef struct pa_context pa_context;
/** Generic notification callback prototype */
typedef void (*pa_context_notify_cb_t)(pa_context *c, void *userdata);
/** A generic callback for operation completion */
typedef void (*pa_context_success_cb_t) (pa_context *c, int success, void *userdata);
/** A callback for asynchronous meta/policy event messages. The set
* of defined events can be extended at any time. Also, server modules
* may introduce additional message types so make sure that your
* callback function ignores messages it doesn't know. \since
* 0.9.15 */
typedef void (*pa_context_event_cb_t)(pa_context *c, const char *name, pa_proplist *p, void *userdata);
/** Instantiate a new connection context with an abstract mainloop API
* and an application name. It is recommended to use pa_context_new_with_proplist()
* instead and specify some initial properties.*/
pa_context *pa_context_new(pa_mainloop_api *mainloop, const char *name);
/** Instantiate a new connection context with an abstract mainloop API
* and an application name, and specify the initial client property
* list. \since 0.9.11 */
pa_context *pa_context_new_with_proplist(pa_mainloop_api *mainloop, const char *name, pa_proplist *proplist);
/** Decrease the reference counter of the context by one */
void pa_context_unref(pa_context *c);
/** Increase the reference counter of the context by one */
pa_context* pa_context_ref(pa_context *c);
/** Set a callback function that is called whenever the context status changes */
void pa_context_set_state_callback(pa_context *c, pa_context_notify_cb_t cb, void *userdata);
/** Set a callback function that is called whenever a meta/policy
* control event is received. \since 0.9.15 */
void pa_context_set_event_callback(pa_context *p, pa_context_event_cb_t cb, void *userdata);
/** Return the error number of the last failed operation */
int pa_context_errno(pa_context *c);
/** Return non-zero if some data is pending to be written to the connection */
int pa_context_is_pending(pa_context *c);
/** Return the current context status */
pa_context_state_t pa_context_get_state(pa_context *c);
/** Connect the context to the specified server. If server is NULL,
connect to the default server. This routine may but will not always
return synchronously on error. Use pa_context_set_state_callback() to
be notified when the connection is established. If flags doesn't have
PA_CONTEXT_NOAUTOSPAWN set and no specific server is specified or
accessible a new daemon is spawned. If api is non-NULL, the functions
specified in the structure are used when forking a new child
process. */
int pa_context_connect(pa_context *c, const char *server, pa_context_flags_t flags, const pa_spawn_api *api);
/** Terminate the context connection immediately */
void pa_context_disconnect(pa_context *c);
/** Drain the context. If there is nothing to drain, the function returns NULL */
pa_operation* pa_context_drain(pa_context *c, pa_context_notify_cb_t cb, void *userdata);
/** Tell the daemon to exit. The returned operation is unlikely to
* complete successfully, since the daemon probably died before
* returning a success notification */
pa_operation* pa_context_exit_daemon(pa_context *c, pa_context_success_cb_t cb, void *userdata);
/** Set the name of the default sink. */
pa_operation* pa_context_set_default_sink(pa_context *c, const char *name, pa_context_success_cb_t cb, void *userdata);
/** Set the name of the default source. */
pa_operation* pa_context_set_default_source(pa_context *c, const char *name, pa_context_success_cb_t cb, void *userdata);
/** Returns 1 when the connection is to a local daemon. Returns negative when no connection has been made yet. */
int pa_context_is_local(pa_context *c);
/** Set a different application name for context on the server. */
pa_operation* pa_context_set_name(pa_context *c, const char *name, pa_context_success_cb_t cb, void *userdata);
/** Return the server name this context is connected to. */
const char* pa_context_get_server(pa_context *c);
/** Return the protocol version of the library. */
uint32_t pa_context_get_protocol_version(pa_context *c);
/** Return the protocol version of the connected server. */
uint32_t pa_context_get_server_protocol_version(pa_context *c);
/** Update the property list of the client, adding new entries. Please
* note that it is highly recommended to set as much properties
* initially via pa_context_new_with_proplist() as possible instead a
* posteriori with this function, since that information may then be
* used to route streams of the client to the right device. \since 0.9.11 */
pa_operation *pa_context_proplist_update(pa_context *c, pa_update_mode_t mode, pa_proplist *p, pa_context_success_cb_t cb, void *userdata);
/** Update the property list of the client, remove entries. \since 0.9.11 */
pa_operation *pa_context_proplist_remove(pa_context *c, const char *const keys[], pa_context_success_cb_t cb, void *userdata);
/** Return the client index this context is
* identified in the server with. This is useful for usage with the
* introspection functions, such as pa_context_get_client_info(). \since 0.9.11 */
uint32_t pa_context_get_index(pa_context *s);
/** Create a new timer event source for the specified time (wrapper
* for mainloop->time_new). \since 0.9.16 */
pa_time_event* pa_context_rttime_new(pa_context *c, pa_usec_t usec, pa_time_event_cb_t cb, void *userdata);
/** Restart a running or expired timer event source (wrapper for
* mainloop->time_restart). \since 0.9.16 */
void pa_context_rttime_restart(pa_context *c, pa_time_event *e, pa_usec_t usec);
/** Return the optimal block size for passing around audio buffers. It
* is recommended to allocate buffers of the size returned here when
* writing audio data to playback streams, if the latency constraints
* permit this. It is not recommended writing larger blocks than this
* because usually they will then be split up internally into chunks
* of this size. It is not recommended writing smaller blocks than
* this (unless required due to latency demands) because this
* increases CPU usage. If ss is NULL you will be returned the
* byte-exact tile size. If you pass a valid ss, then the tile size
* will be rounded down to multiple of the frame size. This is
* supposed to be used in a construct such as
* pa_context_get_tile_size(pa_stream_get_context(s),
* pa_stream_get_sample_spec(ss)); \since 0.9.20 */
size_t pa_context_get_tile_size(pa_context *c, const pa_sample_spec *ss);
PA_C_DECL_END
#endif
#ifndef foodefhfoo
#define foodefhfoo
/***
This file is part of PulseAudio.
Copyright 2004-2006 Lennart Poettering
Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
PulseAudio 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.1 of the
License, or (at your option) any later version.
PulseAudio 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with PulseAudio; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
USA.
***/
#include <inttypes.h>
#include <sys/time.h>
#include <pulse/cdecl.h>
#include <pulse/sample.h>
#include <pulse/version.h>
/** \file
* Global definitions */
PA_C_DECL_BEGIN
/** The state of a connection context */
typedef enum pa_context_state {
PA_CONTEXT_UNCONNECTED, /**< The context hasn't been connected yet */
PA_CONTEXT_CONNECTING, /**< A connection is being established */
PA_CONTEXT_AUTHORIZING, /**< The client is authorizing itself to the daemon */
PA_CONTEXT_SETTING_NAME, /**< The client is passing its application name to the daemon */
PA_CONTEXT_READY, /**< The connection is established, the context is ready to execute operations */
PA_CONTEXT_FAILED, /**< The connection failed or was disconnected */
PA_CONTEXT_TERMINATED /**< The connection was terminated cleanly */
} pa_context_state_t;
/** Return non-zero if the passed state is one of the connected states. \since 0.9.11 */
static inline int PA_CONTEXT_IS_GOOD(pa_context_state_t x) {
return
x == PA_CONTEXT_CONNECTING ||
x == PA_CONTEXT_AUTHORIZING ||
x == PA_CONTEXT_SETTING_NAME ||
x == PA_CONTEXT_READY;
}
/** \cond fulldocs */
#define PA_CONTEXT_UNCONNECTED PA_CONTEXT_UNCONNECTED
#define PA_CONTEXT_CONNECTING PA_CONTEXT_CONNECTING
#define PA_CONTEXT_AUTHORIZING PA_CONTEXT_AUTHORIZING
#define PA_CONTEXT_SETTING_NAME PA_CONTEXT_SETTING_NAME
#define PA_CONTEXT_READY PA_CONTEXT_READY
#define PA_CONTEXT_FAILED PA_CONTEXT_FAILED
#define PA_CONTEXT_TERMINATED PA_CONTEXT_TERMINATED
#define PA_CONTEXT_IS_GOOD PA_CONTEXT_IS_GOOD
/** \endcond */
/** The state of a stream */
typedef enum pa_stream_state {
PA_STREAM_UNCONNECTED, /**< The stream is not yet connected to any sink or source */
PA_STREAM_CREATING, /**< The stream is being created */
PA_STREAM_READY, /**< The stream is established, you may pass audio data to it now */
PA_STREAM_FAILED, /**< An error occurred that made the stream invalid */
PA_STREAM_TERMINATED /**< The stream has been terminated cleanly */
} pa_stream_state_t;
/** Return non-zero if the passed state is one of the connected states. \since 0.9.11 */
static inline int PA_STREAM_IS_GOOD(pa_stream_state_t x) {
return
x == PA_STREAM_CREATING ||
x == PA_STREAM_READY;
}
/** \cond fulldocs */
#define PA_STREAM_UNCONNECTED PA_STREAM_UNCONNECTED
#define PA_STREAM_CREATING PA_STREAM_CREATING
#define PA_STREAM_READY PA_STREAM_READY
#define PA_STREAM_FAILED PA_STREAM_FAILED
#define PA_STREAM_TERMINATED PA_STREAM_TERMINATED
#define PA_STREAM_IS_GOOD PA_STREAM_IS_GOOD
/** \endcond */
/** The state of an operation */
typedef enum pa_operation_state {
PA_OPERATION_RUNNING,
/**< The operation is still running */
PA_OPERATION_DONE,
/**< The operation has completed */
PA_OPERATION_CANCELLED
/**< The operation has been cancelled. Operations may get cancelled by the
* application, or as a result of the context getting disconneted while the
* operation is pending. */
} pa_operation_state_t;
/** \cond fulldocs */
#define PA_OPERATION_RUNNING PA_OPERATION_RUNNING
#define PA_OPERATION_DONE PA_OPERATION_DONE
#define PA_OPERATION_CANCELED PA_OPERATION_CANCELLED
#define PA_OPERATION_CANCELLED PA_OPERATION_CANCELLED
/** \endcond */
/** An invalid index */
#define PA_INVALID_INDEX ((uint32_t) -1)
/** Some special flags for contexts. */
typedef enum pa_context_flags {
PA_CONTEXT_NOFLAGS = 0x0000U,
/**< Flag to pass when no specific options are needed (used to avoid casting) \since 0.9.19 */
PA_CONTEXT_NOAUTOSPAWN = 0x0001U,
/**< Disabled autospawning of the PulseAudio daemon if required */
PA_CONTEXT_NOFAIL = 0x0002U
/**< Don't fail if the daemon is not available when pa_context_connect() is called, instead enter PA_CONTEXT_CONNECTING state and wait for the daemon to appear. \since 0.9.15 */
} pa_context_flags_t;
/** \cond fulldocs */
/* Allow clients to check with #ifdef for those flags */
#define PA_CONTEXT_NOAUTOSPAWN PA_CONTEXT_NOAUTOSPAWN
#define PA_CONTEXT_NOFAIL PA_CONTEXT_NOFAIL
/** \endcond */
/** Direction bitfield - while we currently do not expose anything bidirectional,
one should test against the bit instead of the value (e.g.\ if (d & PA_DIRECTION_OUTPUT)),
because we might add bidirectional stuff in the future. \since 2.0
*/
typedef enum pa_direction {
PA_DIRECTION_OUTPUT = 0x0001U, /**< Output direction */
PA_DIRECTION_INPUT = 0x0002U /**< Input direction */
} pa_direction_t;
/** \cond fulldocs */
#define PA_DIRECTION_OUTPUT PA_DIRECTION_OUTPUT
#define PA_DIRECTION_INPUT PA_DIRECTION_INPUT
/** \endcond */
/** The type of device we are dealing with */
typedef enum pa_device_type {
PA_DEVICE_TYPE_SINK, /**< Playback device */
PA_DEVICE_TYPE_SOURCE /**< Recording device */
} pa_device_type_t;
/** \cond fulldocs */
#define PA_DEVICE_TYPE_SINK PA_DEVICE_TYPE_SINK
#define PA_DEVICE_TYPE_SOURCE PA_DEVICE_TYPE_SOURCE
/** \endcond */
/** The direction of a pa_stream object */
typedef enum pa_stream_direction {
PA_STREAM_NODIRECTION, /**< Invalid direction */
PA_STREAM_PLAYBACK, /**< Playback stream */
PA_STREAM_RECORD, /**< Record stream */
PA_STREAM_UPLOAD /**< Sample upload stream */
} pa_stream_direction_t;
/** \cond fulldocs */
#define PA_STREAM_NODIRECTION PA_STREAM_NODIRECTION
#define PA_STREAM_PLAYBACK PA_STREAM_PLAYBACK
#define PA_STREAM_RECORD PA_STREAM_RECORD
#define PA_STREAM_UPLOAD PA_STREAM_UPLOAD
/** \endcond */
/** Some special flags for stream connections. */
typedef enum pa_stream_flags {
PA_STREAM_NOFLAGS = 0x0000U,
/**< Flag to pass when no specific options are needed (used to avoid casting) \since 0.9.19 */
PA_STREAM_START_CORKED = 0x0001U,
/**< Create the stream corked, requiring an explicit
* pa_stream_cork() call to uncork it. */
PA_STREAM_INTERPOLATE_TIMING = 0x0002U,
/**< Interpolate the latency for this stream. When enabled,
* pa_stream_get_latency() and pa_stream_get_time() will try to
* estimate the current record/playback time based on the local
* time that passed since the last timing info update. Using this
* option has the advantage of not requiring a whole roundtrip
* when the current playback/recording time is needed. Consider
* using this option when requesting latency information
* frequently. This is especially useful on long latency network
* connections. It makes a lot of sense to combine this option
* with PA_STREAM_AUTO_TIMING_UPDATE. */
PA_STREAM_NOT_MONOTONIC = 0x0004U,
/**< Don't force the time to increase monotonically. If this
* option is enabled, pa_stream_get_time() will not necessarily
* return always monotonically increasing time values on each
* call. This may confuse applications which cannot deal with time
* going 'backwards', but has the advantage that bad transport
* latency estimations that caused the time to to jump ahead can
* be corrected quickly, without the need to wait. (Please note
* that this flag was named PA_STREAM_NOT_MONOTONOUS in releases
* prior to 0.9.11. The old name is still defined too, for
* compatibility reasons. */
PA_STREAM_AUTO_TIMING_UPDATE = 0x0008U,
/**< If set timing update requests are issued periodically
* automatically. Combined with PA_STREAM_INTERPOLATE_TIMING you
* will be able to query the current time and latency with
* pa_stream_get_time() and pa_stream_get_latency() at all times
* without a packet round trip.*/
PA_STREAM_NO_REMAP_CHANNELS = 0x0010U,
/**< Don't remap channels by their name, instead map them simply
* by their index. Implies PA_STREAM_NO_REMIX_CHANNELS. Only
* supported when the server is at least PA 0.9.8. It is ignored
* on older servers.\since 0.9.8 */
PA_STREAM_NO_REMIX_CHANNELS = 0x0020U,
/**< When remapping channels by name, don't upmix or downmix them
* to related channels. Copy them into matching channels of the
* device 1:1. Only supported when the server is at least PA
* 0.9.8. It is ignored on older servers. \since 0.9.8 */
PA_STREAM_FIX_FORMAT = 0x0040U,
/**< Use the sample format of the sink/device this stream is being
* connected to, and possibly ignore the format the sample spec
* contains -- but you still have to pass a valid value in it as a
* hint to PulseAudio what would suit your stream best. If this is
* used you should query the used sample format after creating the
* stream by using pa_stream_get_sample_spec(). Also, if you
* specified manual buffer metrics it is recommended to update
* them with pa_stream_set_buffer_attr() to compensate for the
* changed frame sizes. Only supported when the server is at least
* PA 0.9.8. It is ignored on older servers. \since 0.9.8 */
PA_STREAM_FIX_RATE = 0x0080U,
/**< Use the sample rate of the sink, and possibly ignore the rate
* the sample spec contains. Usage similar to
* PA_STREAM_FIX_FORMAT.Only supported when the server is at least
* PA 0.9.8. It is ignored on older servers. \since 0.9.8 */
PA_STREAM_FIX_CHANNELS = 0x0100,
/**< Use the number of channels and the channel map of the sink,
* and possibly ignore the number of channels and the map the
* sample spec and the passed channel map contains. Usage similar
* to PA_STREAM_FIX_FORMAT. Only supported when the server is at
* least PA 0.9.8. It is ignored on older servers. \since 0.9.8 */
PA_STREAM_DONT_MOVE = 0x0200U,
/**< Don't allow moving of this stream to another
* sink/device. Useful if you use any of the PA_STREAM_FIX_ flags
* and want to make sure that resampling never takes place --
* which might happen if the stream is moved to another
* sink/source with a different sample spec/channel map. Only
* supported when the server is at least PA 0.9.8. It is ignored
* on older servers. \since 0.9.8 */
PA_STREAM_VARIABLE_RATE = 0x0400U,
/**< Allow dynamic changing of the sampling rate during playback
* with pa_stream_update_sample_rate(). Only supported when the
* server is at least PA 0.9.8. It is ignored on older
* servers. \since 0.9.8 */
PA_STREAM_PEAK_DETECT = 0x0800U,
/**< Find peaks instead of resampling. \since 0.9.11 */
PA_STREAM_START_MUTED = 0x1000U,
/**< Create in muted state. If neither PA_STREAM_START_UNMUTED nor
* PA_STREAM_START_MUTED it is left to the server to decide
* whether to create the stream in muted or in unmuted
* state. \since 0.9.11 */
PA_STREAM_ADJUST_LATENCY = 0x2000U,
/**< Try to adjust the latency of the sink/source based on the
* requested buffer metrics and adjust buffer metrics
* accordingly. Also see pa_buffer_attr. This option may not be
* specified at the same time as PA_STREAM_EARLY_REQUESTS. \since
* 0.9.11 */
PA_STREAM_EARLY_REQUESTS = 0x4000U,
/**< Enable compatibility mode for legacy clients that rely on a
* "classic" hardware device fragment-style playback model. If
* this option is set, the minreq value of the buffer metrics gets
* a new meaning: instead of just specifying that no requests
* asking for less new data than this value will be made to the
* client it will also guarantee that requests are generated as
* early as this limit is reached. This flag should only be set in
* very few situations where compatibility with a fragment-based
* playback model needs to be kept and the client applications
* cannot deal with data requests that are delayed to the latest
* moment possible. (Usually these are programs that use usleep()
* or a similar call in their playback loops instead of sleeping
* on the device itself.) Also see pa_buffer_attr. This option may
* not be specified at the same time as
* PA_STREAM_ADJUST_LATENCY. \since 0.9.12 */
PA_STREAM_DONT_INHIBIT_AUTO_SUSPEND = 0x8000U,
/**< If set this stream won't be taken into account when we it is
* checked whether the device this stream is connected to should
* auto-suspend. \since 0.9.15 */
PA_STREAM_START_UNMUTED = 0x10000U,
/**< Create in unmuted state. If neither PA_STREAM_START_UNMUTED
* nor PA_STREAM_START_MUTED it is left to the server to decide
* whether to create the stream in muted or in unmuted
* state. \since 0.9.15 */
PA_STREAM_FAIL_ON_SUSPEND = 0x20000U,
/**< If the sink/source this stream is connected to is suspended
* during the creation of this stream, cause it to fail. If the
* sink/source is being suspended during creation of this stream,
* make sure this stream is terminated. \since 0.9.15 */
PA_STREAM_RELATIVE_VOLUME = 0x40000U,
/**< If a volume is passed when this stream is created, consider
* it relative to the sink's current volume, never as absolute
* device volume. If this is not specified the volume will be
* consider absolute when the sink is in flat volume mode,
* relative otherwise. \since 0.9.20 */
PA_STREAM_PASSTHROUGH = 0x80000U
/**< Used to tag content that will be rendered by passthrough sinks.
* The data will be left as is and not reformatted, resampled.
* \since 1.0 */
} pa_stream_flags_t;
/** \cond fulldocs */
/* English is an evil language */
#define PA_STREAM_NOT_MONOTONOUS PA_STREAM_NOT_MONOTONIC
/* Allow clients to check with #ifdef for those flags */
#define PA_STREAM_START_CORKED PA_STREAM_START_CORKED
#define PA_STREAM_INTERPOLATE_TIMING PA_STREAM_INTERPOLATE_TIMING
#define PA_STREAM_NOT_MONOTONIC PA_STREAM_NOT_MONOTONIC
#define PA_STREAM_AUTO_TIMING_UPDATE PA_STREAM_AUTO_TIMING_UPDATE
#define PA_STREAM_NO_REMAP_CHANNELS PA_STREAM_NO_REMAP_CHANNELS
#define PA_STREAM_NO_REMIX_CHANNELS PA_STREAM_NO_REMIX_CHANNELS
#define PA_STREAM_FIX_FORMAT PA_STREAM_FIX_FORMAT
#define PA_STREAM_FIX_RATE PA_STREAM_FIX_RATE
#define PA_STREAM_FIX_CHANNELS PA_STREAM_FIX_CHANNELS
#define PA_STREAM_DONT_MOVE PA_STREAM_DONT_MOVE
#define PA_STREAM_VARIABLE_RATE PA_STREAM_VARIABLE_RATE
#define PA_STREAM_PEAK_DETECT PA_STREAM_PEAK_DETECT
#define PA_STREAM_START_MUTED PA_STREAM_START_MUTED
#define PA_STREAM_ADJUST_LATENCY PA_STREAM_ADJUST_LATENCY
#define PA_STREAM_EARLY_REQUESTS PA_STREAM_EARLY_REQUESTS
#define PA_STREAM_DONT_INHIBIT_AUTO_SUSPEND PA_STREAM_DONT_INHIBIT_AUTO_SUSPEND
#define PA_STREAM_START_UNMUTED PA_STREAM_START_UNMUTED
#define PA_STREAM_FAIL_ON_SUSPEND PA_STREAM_FAIL_ON_SUSPEND
#define PA_STREAM_RELATIVE_VOLUME PA_STREAM_RELATIVE_VOLUME
#define PA_STREAM_PASSTHROUGH PA_STREAM_PASSTHROUGH
/** \endcond */
/** Playback and record buffer metrics */
typedef struct pa_buffer_attr {
uint32_t maxlength;
/**< Maximum length of the buffer in bytes. Setting this to (uint32_t) -1
* will initialize this to the maximum value supported by server,
* which is recommended.
*
* In strict low-latency playback scenarios you might want to set this to
* a lower value, likely together with the PA_STREAM_ADJUST_LATENCY flag.
* If you do so, you ensure that the latency doesn't grow beyond what is
* acceptable for the use case, at the cost of getting more underruns if
* the latency is lower than what the server can reliably handle. */
uint32_t tlength;
/**< Playback only: target length of the buffer. The server tries
* to assure that at least tlength bytes are always available in
* the per-stream server-side playback buffer. It is recommended
* to set this to (uint32_t) -1, which will initialize this to a
* value that is deemed sensible by the server. However, this
* value will default to something like 2s, i.e. for applications
* that have specific latency requirements this value should be
* set to the maximum latency that the application can deal
* with. When PA_STREAM_ADJUST_LATENCY is not set this value will
* influence only the per-stream playback buffer size. When
* PA_STREAM_ADJUST_LATENCY is set the overall latency of the sink
* plus the playback buffer size is configured to this value. Set
* PA_STREAM_ADJUST_LATENCY if you are interested in adjusting the
* overall latency. Don't set it if you are interested in
* configuring the server-side per-stream playback buffer
* size. */
uint32_t prebuf;
/**< Playback only: pre-buffering. The server does not start with
* playback before at least prebuf bytes are available in the
* buffer. It is recommended to set this to (uint32_t) -1, which
* will initialize this to the same value as tlength, whatever
* that may be. Initialize to 0 to enable manual start/stop
* control of the stream. This means that playback will not stop
* on underrun and playback will not start automatically. Instead
* pa_stream_cork() needs to be called explicitly. If you set
* this value to 0 you should also set PA_STREAM_START_CORKED. */
uint32_t minreq;
/**< Playback only: minimum request. The server does not request
* less than minreq bytes from the client, instead waits until the
* buffer is free enough to request more bytes at once. It is
* recommended to set this to (uint32_t) -1, which will initialize
* this to a value that is deemed sensible by the server. This
* should be set to a value that gives PulseAudio enough time to
* move the data from the per-stream playback buffer into the
* hardware playback buffer. */
uint32_t fragsize;
/**< Recording only: fragment size. The server sends data in
* blocks of fragsize bytes size. Large values diminish
* interactivity with other operations on the connection context
* but decrease control overhead. It is recommended to set this to
* (uint32_t) -1, which will initialize this to a value that is
* deemed sensible by the server. However, this value will default
* to something like 2s, i.e. for applications that have specific
* latency requirements this value should be set to the maximum
* latency that the application can deal with. If
* PA_STREAM_ADJUST_LATENCY is set the overall source latency will
* be adjusted according to this value. If it is not set the
* source latency is left unmodified. */
} pa_buffer_attr;
/** Error values as used by pa_context_errno(). Use pa_strerror() to convert these values to human readable strings */
typedef enum pa_error_code {
PA_OK = 0, /**< No error */
PA_ERR_ACCESS, /**< Access failure */
PA_ERR_COMMAND, /**< Unknown command */
PA_ERR_INVALID, /**< Invalid argument */
PA_ERR_EXIST, /**< Entity exists */
PA_ERR_NOENTITY, /**< No such entity */
PA_ERR_CONNECTIONREFUSED, /**< Connection refused */
PA_ERR_PROTOCOL, /**< Protocol error */
PA_ERR_TIMEOUT, /**< Timeout */
PA_ERR_AUTHKEY, /**< No authorization key */
PA_ERR_INTERNAL, /**< Internal error */
PA_ERR_CONNECTIONTERMINATED, /**< Connection terminated */
PA_ERR_KILLED, /**< Entity killed */
PA_ERR_INVALIDSERVER, /**< Invalid server */
PA_ERR_MODINITFAILED, /**< Module initialization failed */
PA_ERR_BADSTATE, /**< Bad state */
PA_ERR_NODATA, /**< No data */
PA_ERR_VERSION, /**< Incompatible protocol version */
PA_ERR_TOOLARGE, /**< Data too large */
PA_ERR_NOTSUPPORTED, /**< Operation not supported \since 0.9.5 */
PA_ERR_UNKNOWN, /**< The error code was unknown to the client */
PA_ERR_NOEXTENSION, /**< Extension does not exist. \since 0.9.12 */
PA_ERR_OBSOLETE, /**< Obsolete functionality. \since 0.9.15 */
PA_ERR_NOTIMPLEMENTED, /**< Missing implementation. \since 0.9.15 */
PA_ERR_FORKED, /**< The caller forked without calling execve() and tried to reuse the context. \since 0.9.15 */
PA_ERR_IO, /**< An IO error happened. \since 0.9.16 */
PA_ERR_BUSY, /**< Device or resource busy. \since 0.9.17 */
PA_ERR_MAX /**< Not really an error but the first invalid error code */
} pa_error_code_t;
/** \cond fulldocs */
#define PA_OK PA_OK
#define PA_ERR_ACCESS PA_ERR_ACCESS
#define PA_ERR_COMMAND PA_ERR_COMMAND
#define PA_ERR_INVALID PA_ERR_INVALID
#define PA_ERR_EXIST PA_ERR_EXIST
#define PA_ERR_NOENTITY PA_ERR_NOENTITY
#define PA_ERR_CONNECTIONREFUSED PA_ERR_CONNECTIONREFUSED
#define PA_ERR_PROTOCOL PA_ERR_PROTOCOL
#define PA_ERR_TIMEOUT PA_ERR_TIMEOUT
#define PA_ERR_AUTHKEY PA_ERR_AUTHKEY
#define PA_ERR_INTERNAL PA_ERR_INTERNAL
#define PA_ERR_CONNECTIONTERMINATED PA_ERR_CONNECTIONTERMINATED
#define PA_ERR_KILLED PA_ERR_KILLED
#define PA_ERR_INVALIDSERVER PA_ERR_INVALIDSERVER
#define PA_ERR_MODINITFAILED PA_ERR_MODINITFAILED
#define PA_ERR_BADSTATE PA_ERR_BADSTATE
#define PA_ERR_NODATA PA_ERR_NODATA
#define PA_ERR_VERSION PA_ERR_VERSION
#define PA_ERR_TOOLARGE PA_ERR_TOOLARGE
#define PA_ERR_NOTSUPPORTED PA_ERR_NOTSUPPORTED
#define PA_ERR_UNKNOWN PA_ERR_UNKNOWN
#define PA_ERR_NOEXTENSION PA_ERR_NOEXTENSION
#define PA_ERR_OBSOLETE PA_ERR_OBSOLETE
#define PA_ERR_NOTIMPLEMENTED PA_ERR_NOTIMPLEMENTED
#define PA_ERR_FORKED PA_ERR_FORKED
#define PA_ERR_MAX PA_ERR_MAX
/** \endcond */
/** Subscription event mask, as used by pa_context_subscribe() */
typedef enum pa_subscription_mask {
PA_SUBSCRIPTION_MASK_NULL = 0x0000U,
/**< No events */
PA_SUBSCRIPTION_MASK_SINK = 0x0001U,
/**< Sink events */
PA_SUBSCRIPTION_MASK_SOURCE = 0x0002U,
/**< Source events */
PA_SUBSCRIPTION_MASK_SINK_INPUT = 0x0004U,
/**< Sink input events */
PA_SUBSCRIPTION_MASK_SOURCE_OUTPUT = 0x0008U,
/**< Source output events */
PA_SUBSCRIPTION_MASK_MODULE = 0x0010U,
/**< Module events */
PA_SUBSCRIPTION_MASK_CLIENT = 0x0020U,
/**< Client events */
PA_SUBSCRIPTION_MASK_SAMPLE_CACHE = 0x0040U,
/**< Sample cache events */
PA_SUBSCRIPTION_MASK_SERVER = 0x0080U,
/**< Other global server changes. */
/** \cond fulldocs */
PA_SUBSCRIPTION_MASK_AUTOLOAD = 0x0100U,
/**< \deprecated Autoload table events. */
/** \endcond */
PA_SUBSCRIPTION_MASK_CARD = 0x0200U,
/**< Card events. \since 0.9.15 */
PA_SUBSCRIPTION_MASK_ALL = 0x02ffU
/**< Catch all events */
} pa_subscription_mask_t;
/** Subscription event types, as used by pa_context_subscribe() */
typedef enum pa_subscription_event_type {
PA_SUBSCRIPTION_EVENT_SINK = 0x0000U,
/**< Event type: Sink */
PA_SUBSCRIPTION_EVENT_SOURCE = 0x0001U,
/**< Event type: Source */
PA_SUBSCRIPTION_EVENT_SINK_INPUT = 0x0002U,
/**< Event type: Sink input */
PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT = 0x0003U,
/**< Event type: Source output */
PA_SUBSCRIPTION_EVENT_MODULE = 0x0004U,
/**< Event type: Module */
PA_SUBSCRIPTION_EVENT_CLIENT = 0x0005U,
/**< Event type: Client */
PA_SUBSCRIPTION_EVENT_SAMPLE_CACHE = 0x0006U,
/**< Event type: Sample cache item */
PA_SUBSCRIPTION_EVENT_SERVER = 0x0007U,
/**< Event type: Global server change, only occurring with PA_SUBSCRIPTION_EVENT_CHANGE. */
/** \cond fulldocs */
PA_SUBSCRIPTION_EVENT_AUTOLOAD = 0x0008U,
/**< \deprecated Event type: Autoload table changes. */
/** \endcond */
PA_SUBSCRIPTION_EVENT_CARD = 0x0009U,
/**< Event type: Card \since 0.9.15 */
PA_SUBSCRIPTION_EVENT_FACILITY_MASK = 0x000FU,
/**< A mask to extract the event type from an event value */
PA_SUBSCRIPTION_EVENT_NEW = 0x0000U,
/**< A new object was created */
PA_SUBSCRIPTION_EVENT_CHANGE = 0x0010U,
/**< A property of the object was modified */
PA_SUBSCRIPTION_EVENT_REMOVE = 0x0020U,
/**< An object was removed */
PA_SUBSCRIPTION_EVENT_TYPE_MASK = 0x0030U
/**< A mask to extract the event operation from an event value */
} pa_subscription_event_type_t;
/** Return one if an event type t matches an event mask bitfield */
#define pa_subscription_match_flags(m, t) (!!((m) & (1 << ((t) & PA_SUBSCRIPTION_EVENT_FACILITY_MASK))))
/** \cond fulldocs */
#define PA_SUBSCRIPTION_MASK_NULL PA_SUBSCRIPTION_MASK_NULL
#define PA_SUBSCRIPTION_MASK_SINK PA_SUBSCRIPTION_MASK_SINK
#define PA_SUBSCRIPTION_MASK_SOURCE PA_SUBSCRIPTION_MASK_SOURCE
#define PA_SUBSCRIPTION_MASK_SINK_INPUT PA_SUBSCRIPTION_MASK_SINK_INPUT
#define PA_SUBSCRIPTION_MASK_SOURCE_OUTPUT PA_SUBSCRIPTION_MASK_SOURCE_OUTPUT
#define PA_SUBSCRIPTION_MASK_MODULE PA_SUBSCRIPTION_MASK_MODULE
#define PA_SUBSCRIPTION_MASK_CLIENT PA_SUBSCRIPTION_MASK_CLIENT
#define PA_SUBSCRIPTION_MASK_SAMPLE_CACHE PA_SUBSCRIPTION_MASK_SAMPLE_CACHE
#define PA_SUBSCRIPTION_MASK_SERVER PA_SUBSCRIPTION_MASK_SERVER
#define PA_SUBSCRIPTION_MASK_AUTOLOAD PA_SUBSCRIPTION_MASK_AUTOLOAD
#define PA_SUBSCRIPTION_MASK_CARD PA_SUBSCRIPTION_MASK_CARD
#define PA_SUBSCRIPTION_MASK_ALL PA_SUBSCRIPTION_MASK_ALL
#define PA_SUBSCRIPTION_EVENT_SINK PA_SUBSCRIPTION_EVENT_SINK
#define PA_SUBSCRIPTION_EVENT_SOURCE PA_SUBSCRIPTION_EVENT_SOURCE
#define PA_SUBSCRIPTION_EVENT_SINK_INPUT PA_SUBSCRIPTION_EVENT_SINK_INPUT
#define PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT
#define PA_SUBSCRIPTION_EVENT_MODULE PA_SUBSCRIPTION_EVENT_MODULE
#define PA_SUBSCRIPTION_EVENT_CLIENT PA_SUBSCRIPTION_EVENT_CLIENT
#define PA_SUBSCRIPTION_EVENT_SAMPLE_CACHE PA_SUBSCRIPTION_EVENT_SAMPLE_CACHE
#define PA_SUBSCRIPTION_EVENT_SERVER PA_SUBSCRIPTION_EVENT_SERVER
#define PA_SUBSCRIPTION_EVENT_AUTOLOAD PA_SUBSCRIPTION_EVENT_AUTOLOAD
#define PA_SUBSCRIPTION_EVENT_CARD PA_SUBSCRIPTION_EVENT_CARD
#define PA_SUBSCRIPTION_EVENT_FACILITY_MASK PA_SUBSCRIPTION_EVENT_FACILITY_MASK
#define PA_SUBSCRIPTION_EVENT_NEW PA_SUBSCRIPTION_EVENT_NEW
#define PA_SUBSCRIPTION_EVENT_CHANGE PA_SUBSCRIPTION_EVENT_CHANGE
#define PA_SUBSCRIPTION_EVENT_REMOVE PA_SUBSCRIPTION_EVENT_REMOVE
#define PA_SUBSCRIPTION_EVENT_TYPE_MASK PA_SUBSCRIPTION_EVENT_TYPE_MASK
/** \endcond */
/** A structure for all kinds of timing information of a stream. See
* pa_stream_update_timing_info() and pa_stream_get_timing_info(). The
* total output latency a sample that is written with
* pa_stream_write() takes to be played may be estimated by
* sink_usec+buffer_usec+transport_usec. (where buffer_usec is defined
* as pa_bytes_to_usec(write_index-read_index)) The output buffer
* which buffer_usec relates to may be manipulated freely (with
* pa_stream_write()'s seek argument, pa_stream_flush() and friends),
* the buffers sink_usec and source_usec relate to are first-in
* first-out (FIFO) buffers which cannot be flushed or manipulated in
* any way. The total input latency a sample that is recorded takes to
* be delivered to the application is:
* source_usec+buffer_usec+transport_usec-sink_usec. (Take care of
* sign issues!) When connected to a monitor source sink_usec contains
* the latency of the owning sink. The two latency estimations
* described here are implemented in pa_stream_get_latency(). Please
* note that this structure can be extended as part of evolutionary
* API updates at any time in any new release.*/
typedef struct pa_timing_info {
struct timeval timestamp;
/**< The time when this timing info structure was current */
int synchronized_clocks;
/**< Non-zero if the local and the remote machine have
* synchronized clocks. If synchronized clocks are detected
* transport_usec becomes much more reliable. However, the code
* that detects synchronized clocks is very limited and unreliable
* itself. */
pa_usec_t sink_usec;
/**< Time in usecs a sample takes to be played on the sink. For
* playback streams and record streams connected to a monitor
* source. */
pa_usec_t source_usec;
/**< Time in usecs a sample takes from being recorded to being
* delivered to the application. Only for record streams. */
pa_usec_t transport_usec;
/**< Estimated time in usecs a sample takes to be transferred
* to/from the daemon. For both playback and record streams. */
int playing;
/**< Non-zero when the stream is currently not underrun and data
* is being passed on to the device. Only for playback
* streams. This field does not say whether the data is actually
* already being played. To determine this check whether
* since_underrun (converted to usec) is larger than sink_usec.*/
int write_index_corrupt;
/**< Non-zero if write_index is not up-to-date because a local
* write command that corrupted it has been issued in the time
* since this latency info was current . Only write commands with
* SEEK_RELATIVE_ON_READ and SEEK_RELATIVE_END can corrupt
* write_index. */
int64_t write_index;
/**< Current write index into the playback buffer in bytes. Think
* twice before using this for seeking purposes: it might be out
* of date a the time you want to use it. Consider using
* PA_SEEK_RELATIVE instead. */
int read_index_corrupt;
/**< Non-zero if read_index is not up-to-date because a local
* pause or flush request that corrupted it has been issued in the
* time since this latency info was current. */
int64_t read_index;
/**< Current read index into the playback buffer in bytes. Think
* twice before using this for seeking purposes: it might be out
* of date a the time you want to use it. Consider using
* PA_SEEK_RELATIVE_ON_READ instead. */
pa_usec_t configured_sink_usec;
/**< The configured latency for the sink. \since 0.9.11 */
pa_usec_t configured_source_usec;
/**< The configured latency for the source. \since 0.9.11 */
int64_t since_underrun;
/**< Bytes that were handed to the sink since the last underrun
* happened, or since playback started again after the last
* underrun. playing will tell you which case it is. \since
* 0.9.11 */
} pa_timing_info;
/** A structure for the spawn api. This may be used to integrate auto
* spawned daemons into your application. For more information see
* pa_context_connect(). When spawning a new child process the
* waitpid() is used on the child's PID. The spawn routine will not
* block or ignore SIGCHLD signals, since this cannot be done in a
* thread compatible way. You might have to do this in
* prefork/postfork. */
typedef struct pa_spawn_api {
void (*prefork)(void);
/**< Is called just before the fork in the parent process. May be
* NULL. */
void (*postfork)(void);
/**< Is called immediately after the fork in the parent
* process. May be NULL.*/
void (*atfork)(void);
/**< Is called immediately after the fork in the child
* process. May be NULL. It is not safe to close all file
* descriptors in this function unconditionally, since a UNIX
* socket (created using socketpair()) is passed to the new
* process. */
} pa_spawn_api;
/** Seek type for pa_stream_write(). */
typedef enum pa_seek_mode {
PA_SEEK_RELATIVE = 0,
/**< Seek relatively to the write index */
PA_SEEK_ABSOLUTE = 1,
/**< Seek relatively to the start of the buffer queue */
PA_SEEK_RELATIVE_ON_READ = 2,
/**< Seek relatively to the read index. */
PA_SEEK_RELATIVE_END = 3
/**< Seek relatively to the current end of the buffer queue. */
} pa_seek_mode_t;
/** \cond fulldocs */
#define PA_SEEK_RELATIVE PA_SEEK_RELATIVE
#define PA_SEEK_ABSOLUTE PA_SEEK_ABSOLUTE
#define PA_SEEK_RELATIVE_ON_READ PA_SEEK_RELATIVE_ON_READ
#define PA_SEEK_RELATIVE_END PA_SEEK_RELATIVE_END
/** \endcond */
/** Special sink flags. */
typedef enum pa_sink_flags {
PA_SINK_NOFLAGS = 0x0000U,
/**< Flag to pass when no specific options are needed (used to avoid casting) \since 0.9.19 */
PA_SINK_HW_VOLUME_CTRL = 0x0001U,
/**< Supports hardware volume control. This is a dynamic flag and may
* change at runtime after the sink has initialized */
PA_SINK_LATENCY = 0x0002U,
/**< Supports latency querying */
PA_SINK_HARDWARE = 0x0004U,
/**< Is a hardware sink of some kind, in contrast to
* "virtual"/software sinks \since 0.9.3 */
PA_SINK_NETWORK = 0x0008U,
/**< Is a networked sink of some kind. \since 0.9.7 */
PA_SINK_HW_MUTE_CTRL = 0x0010U,
/**< Supports hardware mute control. This is a dynamic flag and may
* change at runtime after the sink has initialized \since 0.9.11 */
PA_SINK_DECIBEL_VOLUME = 0x0020U,
/**< Volume can be translated to dB with pa_sw_volume_to_dB(). This is a
* dynamic flag and may change at runtime after the sink has initialized
* \since 0.9.11 */
PA_SINK_FLAT_VOLUME = 0x0040U,
/**< This sink is in flat volume mode, i.e.\ always the maximum of
* the volume of all connected inputs. \since 0.9.15 */
PA_SINK_DYNAMIC_LATENCY = 0x0080U,
/**< The latency can be adjusted dynamically depending on the
* needs of the connected streams. \since 0.9.15 */
PA_SINK_SET_FORMATS = 0x0100U,
/**< The sink allows setting what formats are supported by the connected
* hardware. The actual functionality to do this might be provided by an
* extension. \since 1.0 */
#ifdef __INCLUDED_FROM_PULSE_AUDIO
/** \cond fulldocs */
/* PRIVATE: Server-side values -- do not try to use these at client-side.
* The server will filter out these flags anyway, so you should never see
* these flags in sinks. */
PA_SINK_SHARE_VOLUME_WITH_MASTER = 0x1000000U,
/**< This sink shares the volume with the master sink (used by some filter
* sinks). */
PA_SINK_DEFERRED_VOLUME = 0x2000000U,
/**< The HW volume changes are syncronized with SW volume. */
/** \endcond */
#endif
} pa_sink_flags_t;
/** \cond fulldocs */
#define PA_SINK_HW_VOLUME_CTRL PA_SINK_HW_VOLUME_CTRL
#define PA_SINK_LATENCY PA_SINK_LATENCY
#define PA_SINK_HARDWARE PA_SINK_HARDWARE
#define PA_SINK_NETWORK PA_SINK_NETWORK
#define PA_SINK_HW_MUTE_CTRL PA_SINK_HW_MUTE_CTRL
#define PA_SINK_DECIBEL_VOLUME PA_SINK_DECIBEL_VOLUME
#define PA_SINK_FLAT_VOLUME PA_SINK_FLAT_VOLUME
#define PA_SINK_DYNAMIC_LATENCY PA_SINK_DYNAMIC_LATENCY
#define PA_SINK_SET_FORMATS PA_SINK_SET_FORMATS
#ifdef __INCLUDED_FROM_PULSE_AUDIO
#define PA_SINK_CLIENT_FLAGS_MASK 0xFFFFFF
#endif
/** \endcond */
/** Sink state. \since 0.9.15 */
typedef enum pa_sink_state { /* enum serialized in u8 */
PA_SINK_INVALID_STATE = -1,
/**< This state is used when the server does not support sink state introspection \since 0.9.15 */
PA_SINK_RUNNING = 0,
/**< Running, sink is playing and used by at least one non-corked sink-input \since 0.9.15 */
PA_SINK_IDLE = 1,
/**< When idle, the sink is playing but there is no non-corked sink-input attached to it \since 0.9.15 */
PA_SINK_SUSPENDED = 2,
/**< When suspended, actual sink access can be closed, for instance \since 0.9.15 */
/** \cond fulldocs */
/* PRIVATE: Server-side values -- DO NOT USE THIS ON THE CLIENT
* SIDE! These values are *not* considered part of the official PA
* API/ABI. If you use them your application might break when PA
* is upgraded. Also, please note that these values are not useful
* on the client side anyway. */
PA_SINK_INIT = -2,
/**< Initialization state */
PA_SINK_UNLINKED = -3
/**< The state when the sink is getting unregistered and removed from client access */
/** \endcond */
} pa_sink_state_t;
/** Returns non-zero if sink is playing: running or idle. \since 0.9.15 */
static inline int PA_SINK_IS_OPENED(pa_sink_state_t x) {
return x == PA_SINK_RUNNING || x == PA_SINK_IDLE;
}
/** Returns non-zero if sink is running. \since 1.0 */
static inline int PA_SINK_IS_RUNNING(pa_sink_state_t x) {
return x == PA_SINK_RUNNING;
}
/** \cond fulldocs */
#define PA_SINK_INVALID_STATE PA_SINK_INVALID_STATE
#define PA_SINK_RUNNING PA_SINK_RUNNING
#define PA_SINK_IDLE PA_SINK_IDLE
#define PA_SINK_SUSPENDED PA_SINK_SUSPENDED
#define PA_SINK_INIT PA_SINK_INIT
#define PA_SINK_UNLINKED PA_SINK_UNLINKED
#define PA_SINK_IS_OPENED PA_SINK_IS_OPENED
/** \endcond */
/** Special source flags. */
typedef enum pa_source_flags {
PA_SOURCE_NOFLAGS = 0x0000U,
/**< Flag to pass when no specific options are needed (used to avoid casting) \since 0.9.19 */
PA_SOURCE_HW_VOLUME_CTRL = 0x0001U,
/**< Supports hardware volume control. This is a dynamic flag and may
* change at runtime after the source has initialized */
PA_SOURCE_LATENCY = 0x0002U,
/**< Supports latency querying */
PA_SOURCE_HARDWARE = 0x0004U,
/**< Is a hardware source of some kind, in contrast to
* "virtual"/software source \since 0.9.3 */
PA_SOURCE_NETWORK = 0x0008U,
/**< Is a networked source of some kind. \since 0.9.7 */
PA_SOURCE_HW_MUTE_CTRL = 0x0010U,
/**< Supports hardware mute control. This is a dynamic flag and may
* change at runtime after the source has initialized \since 0.9.11 */
PA_SOURCE_DECIBEL_VOLUME = 0x0020U,
/**< Volume can be translated to dB with pa_sw_volume_to_dB(). This is a
* dynamic flag and may change at runtime after the source has initialized
* \since 0.9.11 */
PA_SOURCE_DYNAMIC_LATENCY = 0x0040U,
/**< The latency can be adjusted dynamically depending on the
* needs of the connected streams. \since 0.9.15 */
PA_SOURCE_FLAT_VOLUME = 0x0080U,
/**< This source is in flat volume mode, i.e.\ always the maximum of
* the volume of all connected outputs. \since 1.0 */
#ifdef __INCLUDED_FROM_PULSE_AUDIO
/** \cond fulldocs */
/* PRIVATE: Server-side values -- do not try to use these at client-side.
* The server will filter out these flags anyway, so you should never see
* these flags in sources. */
PA_SOURCE_SHARE_VOLUME_WITH_MASTER = 0x1000000U,
/**< This source shares the volume with the master source (used by some filter
* sources). */
PA_SOURCE_DEFERRED_VOLUME = 0x2000000U,
/**< The HW volume changes are syncronized with SW volume. */
#endif
} pa_source_flags_t;
/** \cond fulldocs */
#define PA_SOURCE_HW_VOLUME_CTRL PA_SOURCE_HW_VOLUME_CTRL
#define PA_SOURCE_LATENCY PA_SOURCE_LATENCY
#define PA_SOURCE_HARDWARE PA_SOURCE_HARDWARE
#define PA_SOURCE_NETWORK PA_SOURCE_NETWORK
#define PA_SOURCE_HW_MUTE_CTRL PA_SOURCE_HW_MUTE_CTRL
#define PA_SOURCE_DECIBEL_VOLUME PA_SOURCE_DECIBEL_VOLUME
#define PA_SOURCE_DYNAMIC_LATENCY PA_SOURCE_DYNAMIC_LATENCY
#define PA_SOURCE_FLAT_VOLUME PA_SOURCE_FLAT_VOLUME
#ifdef __INCLUDED_FROM_PULSE_AUDIO
#define PA_SOURCE_CLIENT_FLAGS_MASK 0xFFFFFF
#endif
/** \endcond */
/** Source state. \since 0.9.15 */
typedef enum pa_source_state {
PA_SOURCE_INVALID_STATE = -1,
/**< This state is used when the server does not support source state introspection \since 0.9.15 */
PA_SOURCE_RUNNING = 0,
/**< Running, source is recording and used by at least one non-corked source-output \since 0.9.15 */
PA_SOURCE_IDLE = 1,
/**< When idle, the source is still recording but there is no non-corked source-output \since 0.9.15 */
PA_SOURCE_SUSPENDED = 2,
/**< When suspended, actual source access can be closed, for instance \since 0.9.15 */
/** \cond fulldocs */
/* PRIVATE: Server-side values -- DO NOT USE THIS ON THE CLIENT
* SIDE! These values are *not* considered part of the official PA
* API/ABI. If you use them your application might break when PA
* is upgraded. Also, please note that these values are not useful
* on the client side anyway. */
PA_SOURCE_INIT = -2,
/**< Initialization state */
PA_SOURCE_UNLINKED = -3
/**< The state when the source is getting unregistered and removed from client access */
/** \endcond */
} pa_source_state_t;
/** Returns non-zero if source is recording: running or idle. \since 0.9.15 */
static inline int PA_SOURCE_IS_OPENED(pa_source_state_t x) {
return x == PA_SOURCE_RUNNING || x == PA_SOURCE_IDLE;
}
/** Returns non-zero if source is running \since 1.0 */