def.h

#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 <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 */00040typedefenumpa_context_state {
00041PA_CONTEXT_UNCONNECTED, /**< The context hasn't been connected yet */00042PA_CONTEXT_CONNECTING, /**< A connection is being established */00043PA_CONTEXT_AUTHORIZING, /**< The client is authorizing itself to the daemon */00044PA_CONTEXT_SETTING_NAME, /**< The client is passing its application name to the daemon */00045PA_CONTEXT_READY, /**< The connection is established, the context is ready to execute operations */00046PA_CONTEXT_FAILED, /**< The connection failed or was disconnected */00047PA_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 */00051staticinlineintPA_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_IS_GOOD PA_CONTEXT_IS_GOOD/** \endcond *//** The state of a stream */00070typedefenumpa_stream_state {
00071PA_STREAM_UNCONNECTED, /**< The stream is not yet connected to any sink or source */00072PA_STREAM_CREATING, /**< The stream is being created */00073PA_STREAM_READY, /**< The stream is established, you may pass audio data to it now */00074PA_STREAM_FAILED, /**< An error occurred that made the stream invalid */00075PA_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 */00079staticinlineintPA_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 */00095typedefenumpa_operation_state {
00096PA_OPERATION_RUNNING, /**< The operation is still running */00097PA_OPERATION_DONE, /**< The operation has been completed */00098PA_OPERATION_CANCELED/**< The operation has been canceled */
} 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_CANCELED/** \endcond *//** An invalid index */00108#define PA_INVALID_INDEX ((uint32_t) -1)/** Some special flags for contexts. */00111typedefenumpa_context_flags {
00112PA_CONTEXT_NOAUTOSPAWN = 0x0001U, /**< Disabled autospawning of the PulseAudio daemon if required */00114PA_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 *//** The direction of a pa_stream object */00125typedefenumpa_stream_direction {
00126PA_STREAM_NODIRECTION, /**< Invalid direction */00127PA_STREAM_PLAYBACK, /**< Playback stream */00128PA_STREAM_RECORD, /**< Record stream */00129PA_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. */00140typedefenumpa_stream_flags {
00142PA_STREAM_START_CORKED = 0x0001U, /**< Create the stream corked, requiring an explicit * pa_stream_cork() call to uncork it. */00146PA_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. */00158PA_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. */00170PA_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.*/00177PA_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 */00183PA_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 */00189PA_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 */00201PA_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 */00207PA_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 */00214PA_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 */00223PA_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 */00229PA_STREAM_PEAK_DETECT = 0x0800U, /**< Find peaks instead of resampling. \since 0.9.11 */00232PA_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 */00238PA_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 */00245PA_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 */00262PA_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 */00267PA_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 */00273PA_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_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/** \endcond *//** Playback and record buffer metrics */00308typedefstruct pa_buffer_attr {
uint32_t maxlength;00310 /**< Maximum length of the buffer. Setting this to (uint32_t) -1 * will initialize this to the maximum value supported by server, * which is recommended. */
uint32_t tlength;00315 /**< 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;00333 /**< 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_corked() needs to be called explicitly. If you set * this value to 0 you should also set PA_STREAM_START_CORKED. */
uint32_t minreq;00344 /**< 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;00354 /**< 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 */enum {
00371PA_OK = 0, /**< No error */00372PA_ERR_ACCESS, /**< Access failure */00373PA_ERR_COMMAND, /**< Unknown command */00374PA_ERR_INVALID, /**< Invalid argument */00375PA_ERR_EXIST, /**< Entity exists */00376PA_ERR_NOENTITY, /**< No such entity */00377PA_ERR_CONNECTIONREFUSED, /**< Connection refused */00378PA_ERR_PROTOCOL, /**< Protocol error */00379PA_ERR_TIMEOUT, /**< Timeout */00380PA_ERR_AUTHKEY, /**< No authorization key */00381PA_ERR_INTERNAL, /**< Internal error */00382PA_ERR_CONNECTIONTERMINATED, /**< Connection terminated */00383PA_ERR_KILLED, /**< Entity killed */00384PA_ERR_INVALIDSERVER, /**< Invalid server */00385PA_ERR_MODINITFAILED, /**< Module initialization failed */00386PA_ERR_BADSTATE, /**< Bad state */00387PA_ERR_NODATA, /**< No data */00388PA_ERR_VERSION, /**< Incompatible protocol version */00389PA_ERR_TOOLARGE, /**< Data too large */00390PA_ERR_NOTSUPPORTED, /**< Operation not supported \since 0.9.5 */00391PA_ERR_UNKNOWN, /**< The error code was unknown to the client */00392PA_ERR_NOEXTENSION, /**< Extension does not exist. \since 0.9.12 */00393PA_ERR_OBSOLETE, /**< Obsolete functionality. \since 0.9.15 */00394PA_ERR_NOTIMPLEMENTED, /**< Missing implementation. \since 0.9.15 */00395PA_ERR_FORKED, /**< The caller forked without calling execve() and tried to reuse the context. \since 0.9.15 */00396PA_ERR_IO, /**< An IO error happened. \since 0.9.16 */00397PA_ERR_BUSY, /**< Device or resource busy. \since 0.9.17 */00398PA_ERR_MAX/**< Not really an error but the first invalid error code */
};
/** \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() */00431typedefenumpa_subscription_mask {
00432PA_SUBSCRIPTION_MASK_NULL = 0x0000U, /**< No events */00435PA_SUBSCRIPTION_MASK_SINK = 0x0001U, /**< Sink events */00438PA_SUBSCRIPTION_MASK_SOURCE = 0x0002U, /**< Source events */00441PA_SUBSCRIPTION_MASK_SINK_INPUT = 0x0004U, /**< Sink input events */00444PA_SUBSCRIPTION_MASK_SOURCE_OUTPUT = 0x0008U, /**< Source output events */00447PA_SUBSCRIPTION_MASK_MODULE = 0x0010U, /**< Module events */00450PA_SUBSCRIPTION_MASK_CLIENT = 0x0020U, /**< Client events */00453PA_SUBSCRIPTION_MASK_SAMPLE_CACHE = 0x0040U, /**< Sample cache events */00456PA_SUBSCRIPTION_MASK_SERVER = 0x0080U, /**< Other global server changes. *//** \cond fulldocs */
PA_SUBSCRIPTION_MASK_AUTOLOAD = 0x0100U, /**< \deprecated Autoload table events. *//** \endcond */00464PA_SUBSCRIPTION_MASK_CARD = 0x0200U, /**< Card events. \since 0.9.15 */00467PA_SUBSCRIPTION_MASK_ALL = 0x02ffU /**< Catch all events */
} pa_subscription_mask_t;
/** Subscription event types, as used by pa_context_subscribe() */00472typedefenumpa_subscription_event_type {
00473PA_SUBSCRIPTION_EVENT_SINK = 0x0000U, /**< Event type: Sink */00476PA_SUBSCRIPTION_EVENT_SOURCE = 0x0001U, /**< Event type: Source */00479PA_SUBSCRIPTION_EVENT_SINK_INPUT = 0x0002U, /**< Event type: Sink input */00482PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT = 0x0003U, /**< Event type: Source output */00485PA_SUBSCRIPTION_EVENT_MODULE = 0x0004U, /**< Event type: Module */00488PA_SUBSCRIPTION_EVENT_CLIENT = 0x0005U, /**< Event type: Client */00491PA_SUBSCRIPTION_EVENT_SAMPLE_CACHE = 0x0006U, /**< Event type: Sample cache item */00494PA_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 */00502PA_SUBSCRIPTION_EVENT_CARD = 0x0009U, /**< Event type: Card \since 0.9.15 */00505PA_SUBSCRIPTION_EVENT_FACILITY_MASK = 0x000FU, /**< A mask to extract the event type from an event value */00508PA_SUBSCRIPTION_EVENT_NEW = 0x0000U, /**< A new object was created */00511PA_SUBSCRIPTION_EVENT_CHANGE = 0x0010U, /**< A property of the object was modified */00514PA_SUBSCRIPTION_EVENT_REMOVE = 0x0020U, /**< An object was removed */00517PA_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 */00523#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.*/00573typedefstruct pa_timing_info {
00574struct timeval timestamp; /**< The time when this timing info structure was current */intsynchronized_clocks;00578 /**< 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_tsink_usec;00585 /**< 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_tsource_usec;00590 /**< Time in usecs a sample takes from being recorded to being * delivered to the application. Only for record streams. */pa_usec_ttransport_usec;00594 /**< Estimated time in usecs a sample takes to be transferred * to/from the daemon. For both playback and record streams. */intplaying;00598 /**< 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.*/intwrite_index_corrupt;00605 /**< 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;00612 /**< 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. */intread_index_corrupt;00618 /**< 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;00623 /**< 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_tconfigured_sink_usec;00629 /**< The configured latency for the sink. \since 0.9.11 */pa_usec_tconfigured_source_usec;00632 /**< The configured latency for the source. \since 0.9.11 */
int64_t since_underrun;00635 /**< 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. */00649typedefstruct 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(). */00667typedefenumpa_seek_mode {
00668PA_SEEK_RELATIVE = 0, /**< Seek relatively to the write index */00671PA_SEEK_ABSOLUTE = 1, /**< Seek relatively to the start of the buffer queue */00674PA_SEEK_RELATIVE_ON_READ = 2, /**< Seek relatively to the read index. */00677PA_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. */00689typedefenumpa_sink_flags {
00690PA_SINK_HW_VOLUME_CTRL = 0x0001U, /**< Supports hardware volume control */00693PA_SINK_LATENCY = 0x0002U, /**< Supports latency querying */00696PA_SINK_HARDWARE = 0x0004U, /**< Is a hardware sink of some kind, in contrast to * "virtual"/software sinks \since 0.9.3 */00700PA_SINK_NETWORK = 0x0008U, /**< Is a networked sink of some kind. \since 0.9.7 */00703PA_SINK_HW_MUTE_CTRL = 0x0010U, /**< Supports hardware mute control \since 0.9.11 */00706PA_SINK_DECIBEL_VOLUME = 0x0020U, /**< Volume can be translated to dB with pa_sw_volume_to_dB() * \since 0.9.11 */00710PA_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 */00714PA_SINK_DYNAMIC_LATENCY = 0x0080U /**< The latency can be adjusted dynamically depending on the * needs of the connected streams. \since 0.9.15 */
} 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/** \endcond *//** Sink state. \since 0.9.15 */00731typedefenumpa_sink_state { /* enum serialized in u8 */00732PA_SINK_INVALID_STATE = -1, /**< This state is used when the server does not support sink state introspection \since 0.9.15 */00735PA_SINK_RUNNING = 0, /**< Running, sink is playing and used by at least one non-corked sink-input \since 0.9.15 */00738PA_SINK_IDLE = 1, /**< When idle, the sink is playing but there is no non-corked sink-input attached to it \since 0.9.15 */00741PA_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 */00761staticinlineintPA_SINK_IS_OPENED(pa_sink_state_t x) {
return x == PA_SINK_RUNNING || x == PA_SINK_IDLE;
}
/** \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. */00776typedefenumpa_source_flags {
00777PA_SOURCE_HW_VOLUME_CTRL = 0x0001U, /**< Supports hardware volume control */00780PA_SOURCE_LATENCY = 0x0002U, /**< Supports latency querying */00783PA_SOURCE_HARDWARE = 0x0004U, /**< Is a hardware source of some kind, in contrast to * "virtual"/software source \since 0.9.3 */00787PA_SOURCE_NETWORK = 0x0008U, /**< Is a networked source of some kind. \since 0.9.7 */00790PA_SOURCE_HW_MUTE_CTRL = 0x0010U, /**< Supports hardware mute control \since 0.9.11 */00793PA_SOURCE_DECIBEL_VOLUME = 0x0020U, /**< Volume can be translated to dB with pa_sw_volume_to_dB() * \since 0.9.11 */00797PA_SOURCE_DYNAMIC_LATENCY = 0x0040U /**< The latency can be adjusted dynamically depending on the * needs of the connected streams. \since 0.9.15 */
} 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/** \endcond *//** Source state. \since 0.9.15 */00813typedefenumpa_source_state {
00814PA_SOURCE_INVALID_STATE = -1, /**< This state is used when the server does not support source state introspection \since 0.9.15 */00817PA_SOURCE_RUNNING = 0, /**< Running, source is recording and used by at least one non-corked source-output \since 0.9.15 */00820PA_SOURCE_IDLE = 1, /**< When idle, the source is still recording but there is no non-corked source-output \since 0.9.15 */00823PA_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 */00843staticinlineintPA_SOURCE_IS_OPENED(pa_source_state_t x) {
return x == PA_SOURCE_RUNNING || x == PA_SOURCE_IDLE;
}
/** \cond fulldocs */#define PA_SOURCE_INVALID_STATE PA_SOURCE_INVALID_STATE#define PA_SOURCE_RUNNING PA_SOURCE_RUNNING#define PA_SOURCE_IDLE PA_SOURCE_IDLE#define PA_SOURCE_SUSPENDED PA_SOURCE_SUSPENDED#define PA_SOURCE_INIT PA_SOURCE_INIT#define PA_SOURCE_UNLINKED PA_SOURCE_UNLINKED#define PA_SOURCE_IS_OPENED PA_SOURCE_IS_OPENED/** \endcond *//** A generic free() like callback prototype */00858typedef void (*pa_free_cb_t)(void *p);
/** A stream policy/meta event requesting that an application should * cork a specific stream. See pa_stream_event_cb_t for more * information, \since 0.9.15 */00863#define PA_STREAM_EVENT_REQUEST_CORK "request-cork"/** A stream policy/meta event requesting that an application should * cork a specific stream. See pa_stream_event_cb_t for more * information, \since 0.9.15 */00868#define PA_STREAM_EVENT_REQUEST_UNCORK "request-uncork"PA_C_DECL_END#endif