diff options
Diffstat (limited to 'src/pulse')
| -rw-r--r-- | src/pulse/channelmap.h | 29 | ||||
| -rw-r--r-- | src/pulse/context.c | 2 | ||||
| -rw-r--r-- | src/pulse/def.h | 765 | ||||
| -rw-r--r-- | src/pulse/ext-stream-restore.h | 27 | ||||
| -rw-r--r-- | src/pulse/gccmacro.h | 20 | ||||
| -rw-r--r-- | src/pulse/introspect.h | 2 | ||||
| -rw-r--r-- | src/pulse/proplist.h | 16 | ||||
| -rw-r--r-- | src/pulse/sample.h | 75 | ||||
| -rw-r--r-- | src/pulse/simple.c | 2 | ||||
| -rw-r--r-- | src/pulse/stream.c | 20 | ||||
| -rw-r--r-- | src/pulse/stream.h | 2 | ||||
| -rw-r--r-- | src/pulse/utf8.c | 18 | ||||
| -rw-r--r-- | src/pulse/volume.c | 2 | ||||
| -rw-r--r-- | src/pulse/volume.h | 2 | ||||
| -rw-r--r-- | src/pulse/xmalloc.c | 4 | ||||
| -rw-r--r-- | src/pulse/xmalloc.h | 32 |
16 files changed, 609 insertions, 409 deletions
diff --git a/src/pulse/channelmap.h b/src/pulse/channelmap.h index 7c32b868..f9086d19 100644 --- a/src/pulse/channelmap.h +++ b/src/pulse/channelmap.h @@ -142,21 +142,34 @@ typedef enum pa_channel_position { /** 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 */ - PA_CHANNEL_MAP_ALSA, /**< The default mapping used by ALSA */ - PA_CHANNEL_MAP_AUX, /**< Only aux channels */ - PA_CHANNEL_MAP_WAVEEX, /**< Microsoft's WAVEFORMATEXTENSIBLE mapping */ - PA_CHANNEL_MAP_OSS, /**< The default channel mapping used by OSS as defined in the OSS 4.0 API specs */ + PA_CHANNEL_MAP_AIFF, + /**< The mapping from RFC3551, which is based on AIFF-C */ - PA_CHANNEL_MAP_DEFAULT = PA_CHANNEL_MAP_AIFF /**< The default channel map */ + PA_CHANNEL_MAP_ALSA, + /**< The default mapping used by ALSA */ + + PA_CHANNEL_MAP_AUX, + /**< Only aux channels */ + + PA_CHANNEL_MAP_WAVEEX, + /**< Microsoft's WAVEFORMATEXTENSIBLE mapping */ + + PA_CHANNEL_MAP_OSS, + /**< The default channel mapping used by OSS as defined in the OSS 4.0 API specs */ + + PA_CHANNEL_MAP_DEFAULT = PA_CHANNEL_MAP_AIFF + /**< The default channel map */ } pa_channel_map_def_t; /** 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 */ + 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 */ diff --git a/src/pulse/context.c b/src/pulse/context.c index 99a47a18..f1aa4987 100644 --- a/src/pulse/context.c +++ b/src/pulse/context.c @@ -201,7 +201,7 @@ pa_context *pa_context_new_with_proplist(pa_mainloop_api *mainloop, const char * if (!(c->mempool = pa_mempool_new(!c->conf->disable_shm))) { if (!c->conf->disable_shm) - c->mempool = pa_mempool_new(0); + c->mempool = pa_mempool_new(FALSE); if (!c->mempool) { context_free(c); diff --git a/src/pulse/def.h b/src/pulse/def.h index aa07d1c9..66d9aff8 100644 --- a/src/pulse/def.h +++ b/src/pulse/def.h @@ -57,7 +57,7 @@ static inline int PA_CONTEXT_IS_GOOD(pa_context_state_t x) { /** 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_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 */ @@ -83,9 +83,15 @@ typedef enum pa_operation_state { /** Some special flags for contexts. */ typedef enum pa_context_flags { - PA_CONTEXT_NOAUTOSPAWN = 1 /**< Disabled autospawning of the PulseAudio daemon if required */ + PA_CONTEXT_NOAUTOSPAWN = 1 + /**< Disabled autospawning of the PulseAudio daemon if required */ } pa_context_flags_t; +/** \cond fulldocs */ +/* Allow clients to check with #ifdef for those flags */ +#define PA_CONTEXT_NOAUTOSPAWN PA_CONTEXT_NOAUTOSPAWN +/** \endcond */ + /** The direction of a pa_stream object */ typedef enum pa_stream_direction { PA_STREAM_NODIRECTION, /**< Invalid direction */ @@ -96,237 +102,210 @@ typedef enum pa_stream_direction { /** Some special flags for stream connections. */ typedef enum pa_stream_flags { - PA_STREAM_START_CORKED = 1, /**< Create the stream corked, requiring an explicit pa_stream_cork() call to uncork it. */ - PA_STREAM_INTERPOLATE_TIMING = 2, /**< 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 = 4, /**< 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 = 8, /**< 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 = 16, /**< 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 = 32, /**< 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 = 64, /**< 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 = 128, /**< 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 = 256, /**< 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 = 512, /**< 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 whith 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 = 1024, /**< 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 = 2048, /**< Find peaks instead of - * resampling. \since 0.9.11 */ - - PA_STREAM_START_MUTED = 4096, /**< Create in muted state. \since 0.9.11 */ - - PA_STREAM_ADJUST_LATENCY = 8192, /**< Try to adjust the latency of - * the sink/source based on the - * requested buffer metrics and - * adjust buffer metrics - * accordingly. See pa_buffer_attr \since 0.9.11 */ + + 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 whith 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. \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 compatiblity 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_flags_t; +/** \cond fulldocs */ -/** English is an evil language */ +/* 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 + +/** \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 will - * initialize this to the maximum value - * supported by server, which is - * recommended. */ - 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-sider 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 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; /**< 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 - * deminish 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. */ + uint32_t maxlength; + /**< 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; + /**< 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-sider 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 + * 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; + /**< 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 deminish + * 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 */ @@ -358,36 +337,84 @@ enum { /** Subscription event mask, as used by pa_context_subscribe() */ typedef enum pa_subscription_mask { - PA_SUBSCRIPTION_MASK_NULL = 0, /**< No events */ - PA_SUBSCRIPTION_MASK_SINK = 1, /**< Sink events */ - PA_SUBSCRIPTION_MASK_SOURCE = 2, /**< Source events */ - PA_SUBSCRIPTION_MASK_SINK_INPUT = 4, /**< Sink input events */ - PA_SUBSCRIPTION_MASK_SOURCE_OUTPUT = 8, /**< Source output events */ - PA_SUBSCRIPTION_MASK_MODULE = 16, /**< Module events */ - PA_SUBSCRIPTION_MASK_CLIENT = 32, /**< Client events */ - PA_SUBSCRIPTION_MASK_SAMPLE_CACHE = 64, /**< Sample cache events */ - PA_SUBSCRIPTION_MASK_SERVER = 128, /**< Other global server changes. */ - PA_SUBSCRIPTION_MASK_AUTOLOAD = 256, /**< Autoload table events. */ - PA_SUBSCRIPTION_MASK_ALL = 511 /**< Catch all events */ + 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. */ + + PA_SUBSCRIPTION_MASK_AUTOLOAD = 0x0100U, + /**< Autoload table events. */ + + PA_SUBSCRIPTION_MASK_ALL = 0x01ffU + /**< 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 = 0, /**< Event type: Sink */ - PA_SUBSCRIPTION_EVENT_SOURCE = 1, /**< Event type: Source */ - PA_SUBSCRIPTION_EVENT_SINK_INPUT = 2, /**< Event type: Sink input */ - PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT = 3, /**< Event type: Source output */ - PA_SUBSCRIPTION_EVENT_MODULE = 4, /**< Event type: Module */ - PA_SUBSCRIPTION_EVENT_CLIENT = 5, /**< Event type: Client */ - PA_SUBSCRIPTION_EVENT_SAMPLE_CACHE = 6, /**< Event type: Sample cache item */ - PA_SUBSCRIPTION_EVENT_SERVER = 7, /**< Event type: Global server change, only occuring with PA_SUBSCRIPTION_EVENT_CHANGE. */ - PA_SUBSCRIPTION_EVENT_AUTOLOAD = 8, /**< Event type: Autoload table changes. */ - PA_SUBSCRIPTION_EVENT_FACILITY_MASK = 15, /**< A mask to extract the event type from an event value */ - - PA_SUBSCRIPTION_EVENT_NEW = 0, /**< A new object was created */ - PA_SUBSCRIPTION_EVENT_CHANGE = 16, /**< A property of the object was modified */ - PA_SUBSCRIPTION_EVENT_REMOVE = 32, /**< An object was removed */ - PA_SUBSCRIPTION_EVENT_TYPE_MASK = 16+32 /**< A mask to extract the event operation from an event value */ + 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 occuring with PA_SUBSCRIPTION_EVENT_CHANGE. */ + + PA_SUBSCRIPTION_EVENT_AUTOLOAD = 0x0008U, + /**< Event type: Autoload table changes. */ + + 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 */ @@ -412,69 +439,71 @@ typedef enum pa_subscription_event_type { * 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 und 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 */ + 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 und 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; @@ -486,45 +515,101 @@ typedef struct pa_timing_info { * 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. */ + 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_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; /** Special sink flags. */ typedef enum pa_sink_flags { - PA_SINK_HW_VOLUME_CTRL = 1, /**< Supports hardware volume control */ - PA_SINK_LATENCY = 2, /**< Supports latency querying */ - PA_SINK_HARDWARE = 4, /**< Is a hardware sink of some kind, in contrast to "virtual"/software sinks \since 0.9.3 */ - PA_SINK_NETWORK = 8, /**< Is a networked sink of some kind. \since 0.9.7 */ - PA_SINK_HW_MUTE_CTRL = 16, /**< Supports hardware mute control \since 0.9.11 */ - PA_SINK_DECIBEL_VOLUME = 32 /**< Volume can be translated to dB with pa_sw_volume_to_dB() \since 0.9.11 */ + PA_SINK_HW_VOLUME_CTRL = 0x0001U, + /**< Supports hardware volume control */ + + 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 \since 0.9.11 */ + + PA_SINK_DECIBEL_VOLUME = 0x0020U + /**< Volume can be translated to dB with pa_sw_volume_to_dB() + * \since 0.9.11 */ } 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_VOLUME_CTRL PA_SINK_HW_VOLUME_CTRL +#define PA_SINK_DECIBEL_VOLUME PA_SINK_DECIBEL_VOLUME +/** \endcond */ + /** Special source flags. */ typedef enum pa_source_flags { - PA_SOURCE_HW_VOLUME_CTRL = 1, /**< Supports hardware volume control */ - PA_SOURCE_LATENCY = 2, /**< Supports latency querying */ - PA_SOURCE_HARDWARE = 4, /**< Is a hardware source of some kind, in contrast to "virtual"/software source \since 0.9.3 */ - PA_SOURCE_NETWORK = 8, /**< Is a networked sink of some kind. \since 0.9.7 */ - PA_SOURCE_HW_MUTE_CTRL = 16, /**< Supports hardware mute control \since 0.9.11 */ - PA_SOURCE_DECIBEL_VOLUME = 32 /**< Volume can be translated to dB with pa_sw_volume_to_dB() \since 0.9.11 */ + PA_SOURCE_HW_VOLUME_CTRL = 0x0001U, + /**< Supports hardware volume control */ + + 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 sink of some kind. \since 0.9.7 */ + + PA_SOURCE_HW_MUTE_CTRL = 0x0010U, + /**< Supports hardware mute control \since 0.9.11 */ + + PA_SOURCE_DECIBEL_VOLUME = 0x0020U + /**< Volume can be translated to dB with pa_sw_volume_to_dB() + * \since 0.9.11 */ } 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_VOLUME_CTRL PA_SOURCE_HW_VOLUME_CTRL +#define PA_SOURCE_DECIBEL_VOLUME PA_SOURCE_DECIBEL_VOLUME +/** \endcond */ + /** A generic free() like callback prototype */ typedef void (*pa_free_cb_t)(void *p); diff --git a/src/pulse/ext-stream-restore.h b/src/pulse/ext-stream-restore.h index a8eceaf1..2038eb4a 100644 --- a/src/pulse/ext-stream-restore.h +++ b/src/pulse/ext-stream-restore.h @@ -24,37 +24,49 @@ #include <pulse/context.h> +/** \file + * + * Routines for controlling module-stream-restore + */ + PA_C_DECL_BEGIN +/** Stores information about one entry in the stream database that is + * maintained by module-stream-restore. \since 0.9.12 */ typedef struct pa_ext_stream_restore_info { - const char *name; - pa_channel_map channel_map; - pa_cvolume volume; - const char *device; - int mute; + const char *name; /**< Identifier string of the stream. A string like "sink-input-by-role:" or similar followed by some arbitrary property value. */ + pa_channel_map channel_map; /**< The channel map for the volume field */ + pa_cvolume volume; /**< The volume of the stream when it was seen last, if applicable */ + const char *device; /**< The sink/source of the stream when it was last seen */ + int mute; /**< The boolean mute state of the stream when it was last seen, if applicable */ } pa_ext_stream_restore_info; +/** Callback prototype for pa_ext_stream_restore_test(). \since 0.9.12 */ typedef void (*pa_ext_stream_restore_test_cb_t)( pa_context *c, uint32_t version, void *userdata); +/** Test if this extension module is available in the server. \since 0.9.12 */ pa_operation *pa_ext_stream_restore_test( pa_context *c, pa_ext_stream_restore_test_cb_t cb, void *userdata); +/** Callback prototype for pa_ext_stream_restore_read(). \since 0.9.12 */ typedef void (*pa_ext_stream_restore_read_cb_t)( pa_context *c, const pa_ext_stream_restore_info *info, int eol, void *userdata); +/** Read all entries from the stream database. \since 0.9.12 */ pa_operation *pa_ext_stream_restore_read( pa_context *c, pa_ext_stream_restore_read_cb_t cb, void *userdata); +/** Store entries in the stream database. \since 0.9.12 */ pa_operation *pa_ext_stream_restore_write( pa_context *c, pa_update_mode_t mode, @@ -64,22 +76,27 @@ pa_operation *pa_ext_stream_restore_write( pa_context_success_cb_t cb, void *userdata); +/** Delete entries from the stream database. \since 0.9.12 */ pa_operation *pa_ext_stream_restore_delete( pa_context *c, const char *const s[], pa_context_success_cb_t cb, void *userdata); +/** Subscribe to changes in the stream database. \since 0.9.12 */ pa_operation *pa_ext_stream_restore_subscribe( pa_context *c, int enable, pa_context_success_cb_t cb, void *userdata); +/** Callback prototype for pa_ext_stream_restore_set_subscribe_cb(). \since 0.9.12 */ typedef void (*pa_ext_stream_restore_subscribe_cb_t)( pa_context *c, void *userdata); +/** Set the subscription callback that is called when + * pa_ext_stream_restore_subscribe() was called. \since 0.9.12 */ void pa_ext_stream_restore_set_subscribe_cb( pa_context *c, pa_ext_stream_restore_subscribe_cb_t cb, diff --git a/src/pulse/gccmacro.h b/src/pulse/gccmacro.h index e4062033..0533b109 100644 --- a/src/pulse/gccmacro.h +++ b/src/pulse/gccmacro.h @@ -93,4 +93,24 @@ #endif #endif +#ifndef PA_GCC_ALLOC_SIZE +#if defined(__GNUC__) && (__GNUC__ >= 4) && (__GNUC_MINOR__ >= 3) +#define PA_GCC_ALLOC_SIZE(x) __attribute__ ((__alloc_size__(x))) +#define PA_GCC_ALLOC_SIZE2(x,y) __attribute__ ((__alloc_size__(x,y))) +#else +/** Macro for usage of GCC's alloc_size attribute */ +#define PA_GCC_ALLOC_SIZE(x) +#define PA_GCC_ALLOC_SIZE2(x,y) +#endif +#endif + +#ifndef PA_GCC_MALLOC +#ifdef __GNUCC__ +#define PA_GCC_MALLOC __attribute__ ((malloc)) +#else +/** Macro for usage of GCC's malloc attribute */ +#define PA_GCC_MALLOC +#endif +#endif + #endif diff --git a/src/pulse/introspect.h b/src/pulse/introspect.h index ca79f5b7..087bd9f9 100644 --- a/src/pulse/introspect.h +++ b/src/pulse/introspect.h @@ -561,7 +561,7 @@ typedef enum pa_autoload_type { typedef struct pa_autoload_info { uint32_t index; /**< Index of this autoload entry */ const char *name; /**< Name of the sink or source */ - pa_autoload_type_t type; /**< Type of the autoload entry */ + pa_autoload_type_t type; /**< Type of the autoload entry */ const char *module; /**< Module name to load */ const char *argument; /**< Argument string for module */ } pa_autoload_info; diff --git a/src/pulse/proplist.h b/src/pulse/proplist.h index 39d53303..c23ef238 100644 --- a/src/pulse/proplist.h +++ b/src/pulse/proplist.h @@ -168,9 +168,19 @@ int pa_proplist_get(pa_proplist *p, const char *key, const void **data, size_t * /** Update mode enum for pa_proplist_update(). \since 0.9.11 */ typedef enum pa_update_mode { - PA_UPDATE_SET, /*< Replace the entirey property list with the new one. Don't keep any of the old data around */ - PA_UPDATE_MERGE, /*< Merge new property list into the existing one, not replacing any old entries if they share a common key with the new property list. */ - PA_UPDATE_REPLACE /*< Merge new property list into the existing one, replacing all old entries that share a common key with the new property list. */ + PA_UPDATE_SET, + /*< Replace the entirey property list with the new one. Don't keep + * any of the old data around */ + + PA_UPDATE_MERGE, + /*< Merge new property list into the existing one, not replacing + * any old entries if they share a common key with the new + * property list. */ + + PA_UPDATE_REPLACE + /*< Merge new property list into the existing one, replacing all + * old entries that share a common key with the new property + * list. */ } pa_update_mode_t; /** Merge property list "other" into "p", adhering the merge mode as diff --git a/src/pulse/sample.h b/src/pulse/sample.h index 2680cf7e..3f1b2fcf 100644 --- a/src/pulse/sample.h +++ b/src/pulse/sample.h @@ -120,17 +120,38 @@ PA_C_DECL_BEGIN /** Sample format */ typedef enum pa_sample_format { - PA_SAMPLE_U8, /**< Unsigned 8 Bit PCM */ - PA_SAMPLE_ALAW, /**< 8 Bit a-Law */ - PA_SAMPLE_ULAW, /**< 8 Bit mu-Law */ - PA_SAMPLE_S16LE, /**< Signed 16 Bit PCM, little endian (PC) */ - PA_SAMPLE_S16BE, /**< Signed 16 Bit PCM, big endian */ - PA_SAMPLE_FLOAT32LE, /**< 32 Bit IEEE floating point, little endian, range -1 to 1 */ - PA_SAMPLE_FLOAT32BE, /**< 32 Bit IEEE floating point, big endian, range -1 to 1 */ - PA_SAMPLE_S32LE, /**< Signed 32 Bit PCM, little endian (PC) */ - PA_SAMPLE_S32BE, /**< Signed 32 Bit PCM, big endian (PC) */ - PA_SAMPLE_MAX, /**< Upper limit of valid sample types */ - PA_SAMPLE_INVALID = -1 /**< An invalid value */ + PA_SAMPLE_U8, + /**< Unsigned 8 Bit PCM */ + + PA_SAMPLE_ALAW, + /**< 8 Bit a-Law */ + + PA_SAMPLE_ULAW, + /**< 8 Bit mu-Law */ + + PA_SAMPLE_S16LE, + /**< Signed 16 Bit PCM, little endian (PC) */ + + PA_SAMPLE_S16BE, + /**< Signed 16 Bit PCM, big endian */ + + PA_SAMPLE_FLOAT32LE, + /**< 32 Bit IEEE floating point, little endian, range -1 to 1 */ + + PA_SAMPLE_FLOAT32BE, + /**< 32 Bit IEEE floating point, big endian, range -1 to 1 */ + + PA_SAMPLE_S32LE, + /**< Signed 32 Bit PCM, little endian (PC) */ + + PA_SAMPLE_S32BE, + /**< Signed 32 Bit PCM, big endian (PC) */ + + PA_SAMPLE_MAX, + /**< Upper limit of valid sample types */ + + PA_SAMPLE_INVALID = -1 + /**< An invalid value */ } pa_sample_format_t; #ifdef WORDS_BIGENDIAN @@ -164,11 +185,29 @@ typedef enum pa_sample_format { /** A Shortcut for PA_SAMPLE_FLOAT32NE */ #define PA_SAMPLE_FLOAT32 PA_SAMPLE_FLOAT32NE +/** \cond fulldocs */ +/* Allow clients to check with #ifdef for thse sample formats */ +#define PA_SAMPLE_U8 PA_SAMPLE_U8 +#define PA_SAMPLE_ALAW PA_SAMPLE_ALAW +#define PA_SAMPLE_ULAW PA_SAMPLE_ULAW +#define PA_SAMPLE_S16LE PA_SAMPLE_S16LE +#define PA_SAMPLE_S16BE PA_SAMPLE_S16BE +#define PA_SAMPLE_FLOAT32LE PA_SAMPLE_FLOAT32LE +#define PA_SAMPLE_FLOAT32BE PA_SAMPLE_FLOAT32BE +#define PA_SAMPLE_S32LE PA_SAMPLE_S32LE +#define PA_SAMPLE_S32BE PA_SAMPLE_S32BE +/** \endcond */ + /** A sample format and attribute specification */ typedef struct pa_sample_spec { - pa_sample_format_t format; /**< The sample format */ - uint32_t rate; /**< The sample rate. (e.g. 44100) */ - uint8_t channels; /**< Audio channels. (1 for mono, 2 for stereo, ...) */ + pa_sample_format_t format; + /**< The sample format */ + + uint32_t rate; + /**< The sample rate. (e.g. 44100) */ + + uint8_t channels; + /**< Audio channels. (1 for mono, 2 for stereo, ...) */ } pa_sample_spec; /** Type for usec specifications (unsigned). Always 64 bit. */ @@ -183,10 +222,14 @@ size_t pa_frame_size(const pa_sample_spec *spec) PA_GCC_PURE; /** Return the size of a sample with the specific sample type */ size_t pa_sample_size(const pa_sample_spec *spec) PA_GCC_PURE; -/** Calculate the time the specified bytes take to play with the specified sample type */ +/** Calculate the time the specified bytes take to play with the + * specified sample type. The return value will always be rounded + * down for non-integral return values. */ pa_usec_t pa_bytes_to_usec(uint64_t length, const pa_sample_spec *spec) PA_GCC_PURE; -/** Calculates the number of bytes that are required for the specified time. \since 0.9 */ +/** Calculates the number of bytes that are required for the specified + * time. The return value will always be rounded down for non-integral + * return values. \since 0.9 */ size_t pa_usec_to_bytes(pa_usec_t t, const pa_sample_spec *spec) PA_GCC_PURE; /** Return non-zero when the sample type specification is valid */ diff --git a/src/pulse/simple.c b/src/pulse/simple.c index 51160ad7..79e39ebb 100644 --- a/src/pulse/simple.c +++ b/src/pulse/simple.c @@ -272,7 +272,7 @@ int pa_simple_write(pa_simple *p, const void*data, size_t length, int *rerror) { if (l > length) l = length; - r = pa_stream_write(p->stream, data, l, NULL, 0, PA_SEEK_RELATIVE); + r = pa_stream_write(p->stream, data, l, NULL, 0LL, PA_SEEK_RELATIVE); CHECK_SUCCESS_GOTO(p, rerror, r >= 0, unlock_and_fail); data = (const uint8_t*) data + l; diff --git a/src/pulse/stream.c b/src/pulse/stream.c index 536a82ce..d0c7d67e 100644 --- a/src/pulse/stream.c +++ b/src/pulse/stream.c @@ -886,7 +886,8 @@ static int create_stream( PA_STREAM_VARIABLE_RATE| PA_STREAM_PEAK_DETECT| PA_STREAM_START_MUTED| - PA_STREAM_ADJUST_LATENCY)), PA_ERR_INVALID); + PA_STREAM_ADJUST_LATENCY| + PA_STREAM_EARLY_REQUESTS)), PA_ERR_INVALID); PA_CHECK_VALIDITY(s->context, s->context->version >= 12 || !(flags & PA_STREAM_VARIABLE_RATE), PA_ERR_NOTSUPPORTED); PA_CHECK_VALIDITY(s->context, s->context->version >= 13 || !(flags & PA_STREAM_PEAK_DETECT), PA_ERR_NOTSUPPORTED); @@ -899,6 +900,7 @@ static int create_stream( PA_CHECK_VALIDITY(s->context, direction == PA_STREAM_RECORD || !(flags & (PA_STREAM_PEAK_DETECT)), PA_ERR_INVALID); PA_CHECK_VALIDITY(s->context, !volume || volume->channels == s->sample_spec.channels, PA_ERR_INVALID); PA_CHECK_VALIDITY(s->context, !sync_stream || (direction == PA_STREAM_PLAYBACK && sync_stream->direction == PA_STREAM_PLAYBACK), PA_ERR_INVALID); + PA_CHECK_VALIDITY(s->context, (flags & (PA_STREAM_ADJUST_LATENCY|PA_STREAM_EARLY_REQUESTS)) != (PA_STREAM_ADJUST_LATENCY|PA_STREAM_EARLY_REQUESTS), PA_ERR_INVALID); pa_stream_ref(s); @@ -997,13 +999,12 @@ static int create_stream( pa_tagstruct_putu32(t, s->direct_on_input); } - if (s->context->version >= 14 && - s->direction == PA_STREAM_PLAYBACK) { + if (s->context->version >= 14) { - pa_tagstruct_put( - t, - PA_TAG_BOOLEAN, volume_set, - PA_TAG_INVALID); + if (s->direction == PA_STREAM_PLAYBACK) + pa_tagstruct_put_boolean(t, volume_set); + + pa_tagstruct_put_boolean(t, flags & PA_STREAM_EARLY_REQUESTS); } pa_pstream_send_tagstruct(s->context->pstream, t); @@ -1962,7 +1963,7 @@ const pa_timing_info* pa_stream_get_timing_info(pa_stream *s) { PA_CHECK_VALIDITY_RETURN_NULL(s->context, s->state == PA_STREAM_READY, PA_ERR_BADSTATE); PA_CHECK_VALIDITY_RETURN_NULL(s->context, s->direction != PA_STREAM_UPLOAD, PA_ERR_BADSTATE); - PA_CHECK_VALIDITY_RETURN_NULL(s->context, s->timing_info_valid, PA_ERR_BADSTATE); + PA_CHECK_VALIDITY_RETURN_NULL(s->context, s->timing_info_valid, PA_ERR_NODATA); return &s->timing_info; } @@ -2079,6 +2080,9 @@ pa_operation* pa_stream_set_buffer_attr(pa_stream *s, const pa_buffer_attr *attr if (s->context->version >= 13) pa_tagstruct_put_boolean(t, !!(s->flags & PA_STREAM_ADJUST_LATENCY)); + if (s->context->version >= 14) + pa_tagstruct_put_boolean(t, !!(s->flags & PA_STREAM_EARLY_REQUESTS)); + pa_pstream_send_tagstruct(s->context->pstream, t); pa_pdispatch_register_reply(s->context->pdispatch, tag, DEFAULT_TIMEOUT, stream_set_buffer_attr_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref); diff --git a/src/pulse/stream.h b/src/pulse/stream.h index 2a8f7a8b..6cb363c8 100644 --- a/src/pulse/stream.h +++ b/src/pulse/stream.h @@ -473,7 +473,7 @@ void pa_stream_set_underflow_callback(pa_stream *p, pa_stream_notify_cb_t cb, vo /** Set the callback function that is called when a the server starts * playback after an underrun or on initial startup. This only informs - * that audio is flowing again, it is no indication that audio startet + * that audio is flowing again, it is no indication that audio started * to reach the speakers already. (Only for playback streams). \since * 0.9.11 */ void pa_stream_set_started_callback(pa_stream *p, pa_stream_notify_cb_t cb, void *userdata); diff --git a/src/pulse/utf8.c b/src/pulse/utf8.c index 91aa9c81..7671be46 100644 --- a/src/pulse/utf8.c +++ b/src/pulse/utf8.c @@ -64,24 +64,24 @@ #define FILTER_CHAR '_' -static inline int is_unicode_valid(uint32_t ch) { +static inline pa_bool_t is_unicode_valid(uint32_t ch) { if (ch >= 0x110000) /* End of unicode space */ - return 0; + return FALSE; if ((ch & 0xFFFFF800) == 0xD800) /* Reserved area for UTF-16 */ - return 0; + return FALSE; if ((ch >= 0xFDD0) && (ch <= 0xFDEF)) /* Reserved */ - return 0; + return FALSE; if ((ch & 0xFFFE) == 0xFFFE) /* BOM (Byte Order Mark) */ - return 0; + return FALSE; - return 1; + return TRUE; } -static inline int is_continuation_char(uint8_t ch) { +static inline pa_bool_t is_continuation_char(uint8_t ch) { if ((ch & 0xc0) != 0x80) /* 10xxxxxx */ - return 0; - return 1; + return FALSE; + return TRUE; } static inline void merge_continuation_char(uint32_t *u_ch, uint8_t ch) { diff --git a/src/pulse/volume.c b/src/pulse/volume.c index 768bf49c..15938cbc 100644 --- a/src/pulse/volume.c +++ b/src/pulse/volume.c @@ -122,7 +122,7 @@ double pa_sw_volume_to_linear(pa_volume_t v) { if (v == PA_VOLUME_MUTED) return 0; - return pow(10, pa_sw_volume_to_dB(v)/20); + return pow(10.0, pa_sw_volume_to_dB(v)/20.0); } char *pa_cvolume_snprint(char *s, size_t l, const pa_cvolume *c) { diff --git a/src/pulse/volume.h b/src/pulse/volume.h index a356f749..d612c7f9 100644 --- a/src/pulse/volume.h +++ b/src/pulse/volume.h @@ -62,7 +62,7 @@ * * The functions described above are only valid when used with * software volumes. Hence it is usually a better idea to treat all - * volume values as opaque with a range from PA_VOLUME_MUTE (0%) to + * volume values as opaque with a range from PA_VOLUME_MUTED (0%) to * PA_VOLUME_NORM (100%) and to refrain from any calculations with * them. * diff --git a/src/pulse/xmalloc.c b/src/pulse/xmalloc.c index d1138d65..c570e40f 100644 --- a/src/pulse/xmalloc.c +++ b/src/pulse/xmalloc.c @@ -36,7 +36,7 @@ #include "xmalloc.h" /* Make sure not to allocate more than this much memory. */ -#define MAX_ALLOC_SIZE (1024*1024*20) /* 20MB */ +#define MAX_ALLOC_SIZE (1024*1024*96) /* 96MB */ /* #undef malloc */ /* #undef free */ @@ -46,7 +46,7 @@ static void oom(void) PA_GCC_NORETURN; -/** called in case of an OOM situation. Prints an error message and +/* called in case of an OOM situation. Prints an error message and * exits */ static void oom(void) { static const char e[] = "Not enough memory\n"; diff --git a/src/pulse/xmalloc.h b/src/pulse/xmalloc.h index c453138b..b2643588 100644 --- a/src/pulse/xmalloc.h +++ b/src/pulse/xmalloc.h @@ -26,7 +26,9 @@ #include <stdlib.h> #include <limits.h> #include <assert.h> + #include <pulse/cdecl.h> +#include <pulse/gccmacro.h> /** \file * Memory allocation functions. @@ -35,52 +37,58 @@ PA_C_DECL_BEGIN /** Allocate the specified number of bytes, just like malloc() does. However, in case of OOM, terminate */ -void* pa_xmalloc(size_t l); +void* pa_xmalloc(size_t l) PA_GCC_MALLOC PA_GCC_ALLOC_SIZE(1); /** Same as pa_xmalloc(), but initialize allocated memory to 0 */ -void *pa_xmalloc0(size_t l); +void *pa_xmalloc0(size_t l) PA_GCC_MALLOC PA_GCC_ALLOC_SIZE(1); /** The combination of pa_xmalloc() and realloc() */ -void *pa_xrealloc(void *ptr, size_t size); +void *pa_xrealloc(void *ptr, size_t size) PA_GCC_ALLOC_SIZE(2); /** Free allocated memory */ void pa_xfree(void *p); /** Duplicate the specified string, allocating memory with pa_xmalloc() */ -char *pa_xstrdup(const char *s); +char *pa_xstrdup(const char *s) PA_GCC_MALLOC; /** Duplicate the specified string, but truncate after l characters */ -char *pa_xstrndup(const char *s, size_t l); +char *pa_xstrndup(const char *s, size_t l) PA_GCC_MALLOC; /** Duplicate the specified memory block */ -void* pa_xmemdup(const void *p, size_t l); +void* pa_xmemdup(const void *p, size_t l) PA_GCC_MALLOC PA_GCC_ALLOC_SIZE(2); /** Internal helper for pa_xnew() */ -static inline void* pa_xnew_internal(unsigned n, size_t k) { +static void* _pa_xnew_internal(size_t n, size_t k) PA_GCC_MALLOC PA_GCC_ALLOC_SIZE2(1,2); + +static inline void* _pa_xnew_internal(size_t n, size_t k) { assert(n < INT_MAX/k); return pa_xmalloc(n*k); } /** Allocate n new structures of the specified type. */ -#define pa_xnew(type, n) ((type*) pa_xnew_internal((n), sizeof(type))) +#define pa_xnew(type, n) ((type*) _pa_xnew_internal((n), sizeof(type))) /** Internal helper for pa_xnew0() */ -static inline void* pa_xnew0_internal(unsigned n, size_t k) { +static void* _pa_xnew0_internal(size_t n, size_t k) PA_GCC_MALLOC PA_GCC_ALLOC_SIZE2(1,2); + +static inline void* _pa_xnew0_internal(size_t n, size_t k) { assert(n < INT_MAX/k); return pa_xmalloc0(n*k); } /** Same as pa_xnew() but set the memory to zero */ -#define pa_xnew0(type, n) ((type*) pa_xnew0_internal((n), sizeof(type))) +#define pa_xnew0(type, n) ((type*) _pa_xnew0_internal((n), sizeof(type))) /** Internal helper for pa_xnew0() */ -static inline void* pa_xnewdup_internal(const void *p, unsigned n, size_t k) { +static void* _pa_xnewdup_internal(const void *p, size_t n, size_t k) PA_GCC_MALLOC PA_GCC_ALLOC_SIZE2(2,3); + +static inline void* _pa_xnewdup_internal(const void *p, size_t n, size_t k) { assert(n < INT_MAX/k); return pa_xmemdup(p, n*k); } /** Same as pa_xnew() but set the memory to zero */ -#define pa_xnewdup(type, p, n) ((type*) pa_xnewdup_internal((p), (n), sizeof(type))) +#define pa_xnewdup(type, p, n) ((type*) _pa_xnewdup_internal((p), (n), sizeof(type))) PA_C_DECL_END |