X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fpulse%2Fdef.h;h=d3481474020cd63282714f484cdf5faaa33ac718;hb=7c03c5f6ff5aa1ef3185c6fec544ab14847e2ee1;hp=ace565740cb1c0fb4cc3bfefbccad04312a44687;hpb=adc2973c8dfab862d4333e0c1206995cd2df20c6;p=profile%2Fivi%2Fpulseaudio.git diff --git a/src/pulse/def.h b/src/pulse/def.h index ace5657..d348147 100644 --- a/src/pulse/def.h +++ b/src/pulse/def.h @@ -25,10 +25,10 @@ #include #include -#include #include #include +#include /** \file * Global definitions */ @@ -46,7 +46,7 @@ typedef enum pa_context_state { 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 */ +/** 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 || @@ -55,41 +55,98 @@ static inline int PA_CONTEXT_IS_GOOD(pa_context_state_t x) { 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 occured that made the stream invalid */ + 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 */ +/** 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 been completed */ - PA_OPERATION_CANCELED /**< The operation has been canceled */ + PA_OPERATION_CANCELLED /**< The operation has been cancelled. Before 0.9.18 this was called PA_OPERATION_CANCELED. That name is still available for compatibility. */ } 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_NOAUTOSPAWN = 1 + 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 */ @@ -100,9 +157,19 @@ typedef enum pa_stream_direction { 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. */ @@ -180,7 +247,7 @@ typedef enum pa_stream_flags { * 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 whith a different sample spec/channel map. Only + * 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 */ @@ -214,7 +281,7 @@ typedef enum pa_stream_flags { * 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 compatiblity with a fragment-based + * 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() @@ -226,13 +293,35 @@ typedef enum pa_stream_flags { 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.14 */ + * auto-suspend. \since 0.9.15 */ - PA_STREAM_START_UNMUTED = 0x10000U + 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.14 */ + * 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_START_RAMP_MUTED = 0x100000U + /**< Used to tag content that the stream will be started ramp volume + * muted so that you can nicely fade it in */ } pa_stream_flags_t; @@ -259,13 +348,17 @@ typedef enum pa_stream_flags { #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 +#define PA_STREAM_START_RAMP_MUTED PA_STREAM_START_RAMP_MUTED /** \endcond */ /** Playback and record buffer metrics */ typedef struct pa_buffer_attr { uint32_t maxlength; - /**< Maximum length of the buffer. Setting this to (uint32_t) -1 + /**< 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. */ @@ -284,18 +377,18 @@ typedef struct pa_buffer_attr { * 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-sider per-stream playback buffer + * 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 prebug bytes are available in the + * 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 + * 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; @@ -310,7 +403,7 @@ typedef struct pa_buffer_attr { uint32_t fragsize; /**< Recording only: fragment size. The server sends data in - * blocks of fragsize bytes size. Large values deminish + * 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 @@ -325,7 +418,7 @@ typedef struct pa_buffer_attr { } pa_buffer_attr; /** Error values as used by pa_context_errno(). Use pa_strerror() to convert these values to human readable strings */ -enum { +typedef enum pa_error_code { PA_OK = 0, /**< No error */ PA_ERR_ACCESS, /**< Access failure */ PA_ERR_COMMAND, /**< Unknown command */ @@ -348,8 +441,42 @@ enum { 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 { @@ -380,10 +507,15 @@ typedef enum pa_subscription_mask { PA_SUBSCRIPTION_MASK_SERVER = 0x0080U, /**< Other global server changes. */ +/** \cond fulldocs */ PA_SUBSCRIPTION_MASK_AUTOLOAD = 0x0100U, - /**< Autoload table events. */ + /**< \deprecated Autoload table events. */ +/** \endcond */ - PA_SUBSCRIPTION_MASK_ALL = 0x01ffU + PA_SUBSCRIPTION_MASK_CARD = 0x0200U, + /**< Card events. \since 0.9.15 */ + + PA_SUBSCRIPTION_MASK_ALL = 0x02ffU /**< Catch all events */ } pa_subscription_mask_t; @@ -411,10 +543,15 @@ typedef enum pa_subscription_event_type { /**< Event type: Sample cache item */ PA_SUBSCRIPTION_EVENT_SERVER = 0x0007U, - /**< Event type: Global server change, only occuring with PA_SUBSCRIPTION_EVENT_CHANGE. */ + /**< Event type: Global server change, only occurring with PA_SUBSCRIPTION_EVENT_CHANGE. */ +/** \cond fulldocs */ PA_SUBSCRIPTION_EVENT_AUTOLOAD = 0x0008U, - /**< Event type: Autoload table changes. */ + /**< \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 */ @@ -428,7 +565,7 @@ typedef enum pa_subscription_event_type { PA_SUBSCRIPTION_EVENT_REMOVE = 0x0020U, /**< An object was removed */ - PA_SUBSCRIPTION_EVENT_TYPE_MASK = 0x0030U, + PA_SUBSCRIPTION_EVENT_TYPE_MASK = 0x0030U /**< A mask to extract the event operation from an event value */ } pa_subscription_event_type_t; @@ -436,6 +573,36 @@ typedef enum pa_subscription_event_type { /** 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 @@ -462,7 +629,7 @@ typedef struct pa_timing_info { /**< 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 und unreliable + * that detects synchronized clocks is very limited and unreliable * itself. */ pa_usec_t sink_usec; @@ -513,7 +680,7 @@ typedef struct pa_timing_info { /**< 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 */ + /**< 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 @@ -562,10 +729,21 @@ typedef enum pa_seek_mode { /**< 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 */ + /**< 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 */ @@ -578,11 +756,42 @@ typedef enum pa_sink_flags { /**< Is a networked sink of some kind. \since 0.9.7 */ PA_SINK_HW_MUTE_CTRL = 0x0010U, - /**< Supports hardware mute control \since 0.9.11 */ + /**< 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() + 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 */ @@ -590,14 +799,75 @@ typedef enum pa_sink_flags { #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_VOLUME_CTRL PA_SINK_HW_VOLUME_CTRL +#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 */ + /**< 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 */ @@ -607,14 +877,38 @@ typedef enum pa_source_flags { * "virtual"/software source \since 0.9.3 */ PA_SOURCE_NETWORK = 0x0008U, - /**< Is a networked sink of some kind. \since 0.9.7 */ + /**< Is a networked source of some kind. \since 0.9.7 */ PA_SOURCE_HW_MUTE_CTRL = 0x0010U, - /**< Supports hardware mute control \since 0.9.11 */ + /**< 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() + 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 */ @@ -622,13 +916,107 @@ typedef enum pa_source_flags { #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_VOLUME_CTRL PA_SOURCE_HW_VOLUME_CTRL +#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 */ +static inline int PA_SOURCE_IS_RUNNING(pa_source_state_t x) { + return x == PA_SOURCE_RUNNING; +} + +/** \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 */ typedef 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 */ +#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 */ +#define PA_STREAM_EVENT_REQUEST_UNCORK "request-uncork" + +/** A stream event notifying that the stream is going to be + * disconnected because the underlying sink changed and no longer + * supports the format that was originally negotiated. Clients need + * to connect a new stream to renegotiate a format and continue + * playback, \since 1.0 */ +#define PA_STREAM_EVENT_FORMAT_LOST "format-lost" + +/** Port availability / jack detection status + * \since 2.0 */ +typedef enum pa_port_available { + PA_PORT_AVAILABLE_UNKNOWN = 0, /**< This port does not support jack detection \since 2.0 */ + PA_PORT_AVAILABLE_NO = 1, /**< This port is not available, likely because the jack is not plugged in. \since 2.0 */ + PA_PORT_AVAILABLE_YES = 2, /**< This port is available, likely because the jack is plugged in. \since 2.0 */ +} pa_port_available_t; + +/** \cond fulldocs */ +#define PA_PORT_AVAILABLE_UNKNOWN PA_PORT_AVAILABLE_UNKNOWN +#define PA_PORT_AVAILABLE_NO PA_PORT_AVAILABLE_NO +#define PA_PORT_AVAILABLE_YES PA_PORT_AVAILABLE_YES + +/** \endcond */ + +/** \cond fulldocs */ +#define PA_VOLUMER_RAMP_TYPE_LINEAR PA_VOLUMER_RAMP_TYPE_LINEAR +#define PA_VOLUMER_RAMP_TYPE_LOGARITHMIC PA_VOLUMER_RAMP_TYPE_LOGARITHMIC +#define PA_VOLUMER_RAMP_TYPE_CUBIC PA_VOLUMER_RAMP_TYPE_CUBIC +/** \endcond */ + PA_C_DECL_END #endif