Search packages:
 Sourcecode: pulseaudio version 0.9.100.9.10-1ubuntu10.9.10-20.9.10-2.10.9.10-2ubuntu30.9.10-2ubuntu60.9.10-2ubuntu70.9.10-2ubuntu80.9.10-2ubuntu90.9.10-30.9.10-3+lenny10.9.10-3+lenny20.9.130.9.13-10.9.13-1ubuntu10.9.13-1ubuntu20.9.13-1ubuntu30.9.13-20.9.13-2ubuntu10.9.13-2ubuntu20.9.13-2ubuntu30.9.14-0ubuntu100.9.14-0ubuntu110.9.14-0ubuntu130.9.14-0ubuntu140.9.14-0ubuntu150.9.14-0ubuntu30.9.14-0ubuntu40.9.14-0ubuntu70.9.14-10.9.14-20.9.150.9.15-10.9.15-20.9.15-4.10.9.15~test50.9.15~test5-10.9.160.9.16~test2~20090726git59659e1db0.9.16~test2~20090726git59659e1db-10.9.16~test40.9.16~test50.9.16~test5-10.9.16~test6-3-g57e10.9.16~test7-14-g7ca810.9.170.9.17-10.9.180.9.190.9.19-20.9.200.9.20-10.9.210.9.21-10.9.21-1.10.9.21-1.20.9.21-20.9.21-30.9.21-3+squeeze10.9.21-40.9.21-4.10.9.220.9.22+stable-queue-18-geb9660.9.22+stable-queue-24-g67d180.9.22-10.9.22-1.10.9.22~0.9.21+341-g62bf0.9.22~0.9.21+stable-queue-24-gfa640.9.22~0.9.21+stable-queue-32-g84780.9.22~0.9.21+stable-queue-98-ga8d70.9.230.9.23-10.9.50.9.5-5etch10.9.5-5ubuntu40.9.60.9.6-1ubuntu20.99.1-10.99.21.01.1-21:0.9.14-0ubuntu161:0.9.14-0ubuntu201:0.9.15-1ubuntu31:0.9.15-2ubuntu11:0.9.15-3ubuntu11:0.9.15-4ubuntu11:0.9.15-4ubuntu21:0.9.15-4ubuntu31:0.9.16-0ubuntu11:0.9.16~test4-0ubuntu11:0.9.16~test4-0ubuntu21:0.9.16~test4-0ubuntu41:0.9.16~test6-3-g57e1-0ubuntu21:0.9.16~test7-14-g7ca81-0ubuntu11:0.9.16~test7-14-g7ca81-0ubuntu21:0.9.17-0ubuntu11:0.9.17-0ubuntu21:0.9.18-0ubuntu21:0.9.18-0ubuntu31:0.9.19-0ubuntu11:0.9.19-0ubuntu41:0.9.21-0ubuntu21:0.9.21-0ubuntu51:0.9.21-0ubuntu61:0.9.22+stable-queue-18-geb966-0ubuntu11:0.9.22+stable-queue-18-geb966-0ubuntu21:0.9.22+stable-queue-24-g67d18-0ubuntu21:0.9.22+stable-queue-24-g67d18-0ubuntu31:0.9.22-0ubuntu11:0.9.22-0ubuntu31:0.9.22~0.9.21+341-g62bf-0ubuntu11:0.9.22~0.9.21+stable-queue-24-gfa64-0ubuntu11:0.9.22~0.9.21+stable-queue-32-g8478-0ubuntu11:0.9.22~0.9.21+stable-queue-32-g8478-0ubuntu101:0.9.22~0.9.21+stable-queue-32-g8478-0ubuntu111:0.9.22~0.9.21+stable-queue-32-g8478-0ubuntu121:0.9.22~0.9.21+stable-queue-32-g8478-0ubuntu141:0.9.22~0.9.21+stable-queue-32-g8478-0ubuntu151:0.9.22~0.9.21+stable-queue-32-g8478-0ubuntu161:0.9.22~0.9.21+stable-queue-32-g8478-0ubuntu171:0.9.22~0.9.21+stable-queue-32-g8478-0ubuntu191:0.9.22~0.9.21+stable-queue-32-g8478-0ubuntu201:0.9.22~0.9.21+stable-queue-32-g8478-0ubuntu211:0.9.22~0.9.21+stable-queue-32-g8478-0ubuntu41:0.9.22~0.9.21+stable-queue-32-g8478-0ubuntu51:0.9.22~0.9.21+stable-queue-32-g8478-0ubuntu61:0.9.22~0.9.21+stable-queue-32-g8478-0ubuntu91:0.9.22~0.9.21+stable-queue-98-ga8d7-0ubuntu31:0.9.23-0ubuntu21:0.99.2-0ubuntu21:1.0-0ubuntu3

# stream.h

Go to the documentation of this file.
#ifndef foostreamhfoo
#define foostreamhfoo

/* $Id: stream.h 2067 2007-11-21 01:30:40Z lennart$ */

/***
This file is part of PulseAudio.

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 of the License,
or (at your option) any later version.

PulseAudio is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with PulseAudio; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
USA.
***/

#include <sys/types.h>

#include <pulse/sample.h>
#include <pulse/channelmap.h>
#include <pulse/volume.h>
#include <pulse/def.h>
#include <pulse/cdecl.h>
#include <pulse/operation.h>

/** \page streams Audio Streams
*
* \section overv_sec Overview
*
* Audio streams form the central functionality of the sound server. Data is
* routed, converted and mixed from several sources before it is passed along
* to a final output. Currently, there are three forms of audio streams:
*
* \li Playback streams - Data flows from the client to the server.
* \li Record streams - Data flows from the server to the client.
* \li Upload streams - Similar to playback streams, but the data is stored in
*                      about controlling the sample cache.
*
* \section create_sec Creating
*
* To access a stream, a pa_stream object must be created using
* pa_stream_new(). At this point the audio sample format and mapping of
* channels must be specified. See \ref sample and \ref channelmap for more
*
* This first step will only create a client-side object, representing the
* stream. To use the stream, a server-side object must be created and
* associated with the local object. Depending on which type of stream is
* desired, a different function is needed:
*
* \li Playback stream - pa_stream_connect_playback()
* \li Record stream - pa_stream_connect_record()
*
* Similar to how connections are done in contexts, connecting a stream will
* not generate a pa_operation object. Also like contexts, the application
* should register a state change callback, using
* pa_stream_set_state_callback(), and wait for the stream to enter an active
* state.
*
* \subsection bufattr_subsec Buffer Attributes
*
* Playback and record streams always have a server side buffer as
* part of the data flow.  The size of this buffer strikes a
* compromise between low latency and sensitivity for buffer
* overflows/underruns.
*
* The buffer metrics may be controlled by the application. They are
* described with a pa_buffer_attr structure which contains a number
* of fields:
*
* \li maxlength - The absolute maximum number of bytes that can be stored in
*                 the buffer. If this value is exceeded then data will be
*                 lost.
* \li tlength - The target length of a playback buffer. The server will only
*               send requests for more data as long as the buffer has less
*               than this number of bytes of data.
* \li prebuf - Number of bytes that need to be in the buffer before
* playback will commence. Start of playback can be forced using
* pa_stream_trigger() even though the prebuffer size hasn't been
* reached. If a buffer underrun occurs, this prebuffering will be
* again enabled. If the playback shall never stop in case of a buffer
* underrun, this value should be set to 0. In that case the read
* index of the output buffer overtakes the write index, and hence the
* fill level of the buffer is negative.
* \li minreq - Minimum free number of the bytes in the playback buffer before
*              the server will request more data.
* \li fragsize - Maximum number of bytes that the server will push in one
*                chunk for record streams.
*
* The server side playback buffers are indexed by a write and a read
* index. The application writes to the write index and the sound
* monotonically, while the write index may be freely controlled by
* the application. Substracting the read index from the write index
* will give you the current fill level of the buffer. The read/write
* indexes are 64bit values and measured in bytes, they will never
* wrap. The current read/write index may be queried using
* case of a buffer underrun the read index is equal or larger than
* the write index. Unless the prebuf value is 0, PulseAudio will
* temporarily pause playback in such a case, and wait until the
* buffer is filled up to prebuf bytes again. If prebuf is 0, the
* read index may be larger than the write index, in which case
* silence is played. If the application writes data to indexes lower
* than the read index, the data is immediately lost.
*
* \section transfer_sec Transferring Data
*
* Once the stream is up, data can start flowing between the client and the
* server. Two different access models can be used to transfer the data:
*
* \li Asynchronous - The application register a callback using
*                    pa_stream_set_write_callback() and
*                    that data can either be written or read.
* \li Polled - Query the library for available data/space using
*              transfer data as needed. The sizes are stored locally, in the
*              client end, so there is no delay when reading them.
*
* It is also possible to mix the two models freely.
*
* Once there is data/space available, it can be transferred using either
* pa_stream_write() for playback, or pa_stream_peek() / pa_stream_drop() for
* record. Make sure you do not overflow the playback buffers as data will be
* dropped.
*
* \section bufctl_sec Buffer Control
*
* The transfer buffers can be controlled through a number of operations:
*
* \li pa_stream_cork() - Start or stop the playback or recording.
* \li pa_stream_trigger() - Start playback immediatly and do not wait for
*                           the buffer to fill up to the set trigger level.
* \li pa_stream_prebuf() - Reenable the playback trigger level.
* \li pa_stream_drain() - Wait for the playback buffer to go empty. Will
*                         return a pa_operation object that will indicate when
*                         the buffer is completely drained.
* \li pa_stream_flush() - Drop all data from the playback buffer and do not
*                         wait for it to finish playing.
*
* \section seek_modes Seeking in the Playback Buffer
*
* A client application may freely seek in the playback buffer. To
* accomplish that the pa_stream_write() function takes a seek mode
* and an offset argument. The seek mode is one of:
*
* \li PA_SEEK_RELATIVE - seek relative to the current write index
* \li PA_SEEK_ABSOLUTE - seek relative to the beginning of the playback buffer, (i.e. the first that was ever played in the stream)
* \li PA_SEEK_RELATIVE_ON_READ - seek relative to the current read index. Use this to write data to the output buffer that should be played as soon as possible
* \li PA_SEEK_RELATIVE_END - seek relative to the last byte ever written.
*
* If an application just wants to append some data to the output
* buffer, PA_SEEK_RELATIVE and an offset of 0 should be used.
*
* After a call to pa_stream_write() the write index will be left at
* the position right after the last byte of the written data.
*
* \section latency_sec Latency
*
* A major problem with networked audio is the increased latency caused by
* the network. To remedy this, PulseAudio supports an advanced system of
* monitoring the current latency.
*
* To get the raw data needed to calculate latencies, call
* pa_stream_get_timing_info(). This will give you a pa_timing_info
* structure that contains everything that is known about the server
* side buffer transport delays and the backend active in the
* server. (Besides other things it contains the write and read index
* values mentioned above.)
*
* This structure is updated every time a
* pa_stream_update_timing_info() operation is executed. (i.e. before
* the first call to this function the timing information structure is
* not available!) Since it is a lot of work to keep this structure
* up-to-date manually, PulseAudio can do that automatically for you:
* if PA_STREAM_AUTO_TIMING_UPDATE is passed when connecting the
* stream PulseAudio will automatically update the structure every
* 100ms and every time a function is called that might invalidate the
* previously known timing data (such as pa_stream_write() or
* pa_stream_flush()). Please note however, that there always is a
* short time window when the data in the timing information structure
* is out-of-date. PulseAudio tries to mark these situations by
* setting the write_index_corrupt and read_index_corrupt fields
* accordingly.
*
* The raw timing data in the pa_timing_info structure is usually hard
* to deal with. Therefore a more simplistic interface is available:
* you can call pa_stream_get_time() or pa_stream_get_latency(). The
* former will return the current playback time of the hardware since
* the stream has been started. The latter returns the time a sample
* that you write now takes to be played by the hardware. These two
* functions base their calculations on the same data that is returned
* by pa_stream_get_timing_info(). Hence the same rules for keeping
* the timing data up-to-date apply here. In case the write or read
* index is corrupted, these two functions will fail with
* PA_ERR_NODATA set.
*
* Since updating the timing info structure usually requires a full
* network round trip and some applications monitor the timing very
* often PulseAudio offers a timing interpolation system. If
* PA_STREAM_INTERPOLATE_TIMING is passed when connecting the stream,
* pa_stream_get_time() and pa_stream_get_latency() will try to
* interpolate the current playback time/latency by estimating the
* number of samples that have been played back by the hardware since
* the last regular timing update. It is espcially useful to combine
* this option with PA_STREAM_AUTO_TIMING_UPDATE, which will enable
* you to monitor the current playback time/latency very precisely and
* very frequently without requiring a network round trip every time.
*
* \section flow_sec Overflow and underflow
*
* Even with the best precautions, buffers will sometime over - or
* underflow.  To handle this gracefully, the application can be
* notified when this happens. Callbacks are registered using
* pa_stream_set_overflow_callback() and
* pa_stream_set_underflow_callback().
*
* \section sync_streams Sychronizing Multiple Playback Streams
*
* PulseAudio allows applications to fully synchronize multiple
* playback streams that are connected to the same output device. That
* means the streams will always be played back sample-by-sample
* synchronously. If stream operations like pa_stream_cork() are
* issued on one of the synchronized streams, they are simultaneously
* issued on the others.
*
* To synchronize a stream to another, just pass the "master" stream
* as last argument to pa_stream_connect_playack(). To make sure that
* the freshly created stream doesn't start playback right-away, make
* sure to pass PA_STREAM_START_CORKED and - after all streams have
* been created - uncork them all with a single call to
* pa_stream_cork() for the master stream.
*
* To make sure that a particular stream doesn't stop to play when a
* server side buffer underrun happens on it while the other
* synchronized streams continue playing and hence deviate you need to
* pass a "prebuf" pa_buffer_attr of 0 when connecting it.
*
* \section disc_sec Disconnecting
*
* When a stream has served is purpose it must be disconnected with
* pa_stream_disconnect(). If you only unreference it, then it will live on
* and eat resources both locally and on the server until you disconnect the
* context.
*
*/

/** \file
* Audio streams for input, output and sample upload */

PA_C_DECL_BEGIN

/** An opaque stream for playback or recording */
00268 typedef struct pa_stream pa_stream;

/** A generic callback for operation completion */
00271 typedef void (*pa_stream_success_cb_t) (pa_stream*s, int success, void *userdata);

/** A generic request callback */
00274 typedef void (*pa_stream_request_cb_t)(pa_stream *p, size_t bytes, void *userdata);

/** A generic notification callback */
00277 typedef void (*pa_stream_notify_cb_t)(pa_stream *p, void *userdata);

/** Create a new, unconnected stream with the specified name and sample type */
pa_stream* pa_stream_new(
pa_context *c                     /**< The context to create this stream in */,
const char *name                  /**< A name for this stream */,
const pa_sample_spec *ss          /**< The desired sample format */,
const pa_channel_map *map         /**< The desired channel map, or NULL for default */);

/** Decrease the reference counter by one */
void pa_stream_unref(pa_stream *s);

/** Increase the reference counter by one */
pa_stream *pa_stream_ref(pa_stream *s);

/** Return the current state of the stream */
pa_stream_state_t pa_stream_get_state(pa_stream *p);

/** Return the context this stream is attached to */
pa_context* pa_stream_get_context(pa_stream *p);

/** Return the sink input resp. source output index this stream is
* identified in the server with. This is useful for usage with the
* introspection functions, such as pa_context_get_sink_input_info()
* resp. pa_context_get_source_output_info(). */
uint32_t pa_stream_get_index(pa_stream *s);

/** Return the index of the sink or source this stream is connected to
* in the server. This is useful for usage with the introspection
* functions, such as pa_context_get_sink_info_by_index()
* resp. pa_context_get_source_info_by_index(). Please note that
* streams may be moved between sinks/sources and thus it is
* recommended to use pa_stream_set_moved_callback() to be notified
* server is older than 0.9.8. \since 0.9.8 */
uint32_t pa_stream_get_device_index(pa_stream *s);

/** Return the name of the sink or source this stream is connected to
* in the server. This is useful for usage with the introspection
* functions, such as pa_context_get_sink_info_by_name()
* resp. pa_context_get_source_info_by_name(). Please note that
* streams may be moved between sinks/sources and thus it is
* recommended to use pa_stream_set_moved_callback() to be notified
* server is older than 0.9.8. \since 0.9.8 */
const char *pa_stream_get_device_name(pa_stream *s);

/** Return 1 if the sink or source this stream is connected to has
* been suspended. This will return 0 if not, and negative on
* error. This function will return with PA_ERR_NOTSUPPORTED when the
* server is older than 0.9.8. \since 0.9.8 */
int pa_stream_is_suspended(pa_stream *s);

/** Connect the stream to a sink */
int pa_stream_connect_playback(
pa_stream *s                  /**< The stream to connect to a sink */,
const char *dev               /**< Name of the sink to connect to, or NULL for default */ ,
const pa_buffer_attr *attr    /**< Buffering attributes, or NULL for default */,
pa_stream_flags_t flags       /**< Additional flags, or 0 for default */,
pa_cvolume *volume            /**< Initial volume, or NULL for default */,
pa_stream *sync_stream        /**< Synchronize this stream with the specified one, or NULL for a standalone stream*/);

/** Connect the stream to a source */
int pa_stream_connect_record(
pa_stream *s                  /**< The stream to connect to a source */ ,
const char *dev               /**< Name of the source to connect to, or NULL for default */,
const pa_buffer_attr *attr    /**< Buffer attributes, or NULL for default */,
pa_stream_flags_t flags       /**< Additional flags, or 0 for default */);

/** Disconnect a stream from a source/sink */
int pa_stream_disconnect(pa_stream *s);

/** Write some data to the server (for playback sinks), if free_cb is
* non-NULL this routine is called when all data has been written out
* and an internal reference to the specified data is kept, the data
* is not copied. If NULL, the data is copied into an internal
* buffer. The client my freely seek around in the output buffer. For
* most applications passing 0 and PA_SEEK_RELATIVE as arguments for
* offset and seek should be useful.*/
int pa_stream_write(
pa_stream *p             /**< The stream to use */,
const void *data         /**< The data to write */,
size_t bytes             /**< The length of the data to write in bytes*/,
pa_free_cb_t free_cb     /**< A cleanup routine for the data or NULL to request an internal copy */,
int64_t offset,          /**< Offset for seeking, must be 0 for upload streams */
pa_seek_mode_t seek      /**< Seek mode, must be PA_SEEK_RELATIVE for upload streams */);

/** Read the next fragment from the buffer (for recording).
* data will point to the actual data and length will contain the size
* of the data in bytes (which can be less than a complete framgnet).
* Use pa_stream_drop() to actually remove the data from the
* buffer. If no data is available will return a NULL pointer  \since 0.8 */
int pa_stream_peek(
pa_stream *p                 /**< The stream to use */,
const void **data            /**< Pointer to pointer that will point to data */,
size_t *bytes                /**< The length of the data read in bytes */);

/** Remove the current fragment on record streams. It is invalid to do this without first
* calling pa_stream_peek(). \since 0.8 */
int pa_stream_drop(pa_stream *p);

/** Return the number of bytes that may be written using pa_stream_write() */
size_t pa_stream_writable_size(pa_stream *p);

/** Return the number of bytes that may be read using pa_stream_read() \since 0.8 */

/** Drain a playback stream. Use this for notification when the buffer is empty */
pa_operation* pa_stream_drain(pa_stream *s, pa_stream_success_cb_t cb, void *userdata);

/** Request a timing info structure update for a stream. Use
* or pa_stream_get_time() or pa_stream_get_latency() to get cleaned
* up values. */
pa_operation* pa_stream_update_timing_info(pa_stream *p, pa_stream_success_cb_t cb, void *userdata);

/** Set the callback function that is called whenever the state of the stream changes */
void pa_stream_set_state_callback(pa_stream *s, pa_stream_notify_cb_t cb, void *userdata);

/** Set the callback function that is called when new data may be
* written to the stream. */
void pa_stream_set_write_callback(pa_stream *p, pa_stream_request_cb_t cb, void *userdata);

/** Set the callback function that is called when new data is available from the stream.
* Return the number of bytes read. \since 0.8 */
void pa_stream_set_read_callback(pa_stream *p, pa_stream_request_cb_t cb, void *userdata);

/** Set the callback function that is called when a buffer overflow happens. (Only for playback streams) \since 0.8 */
void pa_stream_set_overflow_callback(pa_stream *p, pa_stream_notify_cb_t cb, void *userdata);

/** Set the callback function that is called when a buffer underflow happens. (Only for playback streams) \since 0.8 */
void pa_stream_set_underflow_callback(pa_stream *p, pa_stream_notify_cb_t cb, void *userdata);

/** Set the callback function that is called whenever a latency
* information update happens. Useful on PA_STREAM_AUTO_TIMING_UPDATE
* streams only. (Only for playback streams) \since 0.8.2 */
void pa_stream_set_latency_update_callback(pa_stream *p, pa_stream_notify_cb_t cb, void *userdata);

/** Set the callback function that is called whenever the stream is
* moved to a different sink/source. Use pa_stream_get_device_name()or
* pa_stream_get_device_index() to query the new sink/source. This
* notification is only generated when the server is at least
* 0.9.8. \since 0.9.8 */
void pa_stream_set_moved_callback(pa_stream *p, pa_stream_notify_cb_t cb, void *userdata);

/** Set the callback function that is called whenever the sink/source
* this stream is connected to is suspended or resumed. Use
* pa_stream_is_suspended() to query the new suspend status. Please
* note that the suspend status might also change when the stream is
* moved between devices. Thus if you call this function you very
* likely want to call pa_stream_set_moved_callback, too. This
* notification is only generated when the server is at least
* 0.9.8. \since 0.9.8 */
void pa_stream_set_suspended_callback(pa_stream *p, pa_stream_notify_cb_t cb, void *userdata);

/** Pause (or resume) playback of this stream temporarily. Available on both playback and recording streams. \since 0.3 */
pa_operation* pa_stream_cork(pa_stream *s, int b, pa_stream_success_cb_t cb, void *userdata);

/** Flush the playback buffer of this stream. Most of the time you're
* better off using the parameter delta of pa_stream_write() instead of this
* function. Available on both playback and recording streams. \since 0.3 */
pa_operation* pa_stream_flush(pa_stream *s, pa_stream_success_cb_t cb, void *userdata);

/** Reenable prebuffering as specified in the pa_buffer_attr
* structure. Available for playback streams only. \since 0.6 */
pa_operation* pa_stream_prebuf(pa_stream *s, pa_stream_success_cb_t cb, void *userdata);

/** Request immediate start of playback on this stream. This disables
* prebuffering as specified in the pa_buffer_attr
* structure, temporarily. Available for playback streams only. \since 0.3 */
pa_operation* pa_stream_trigger(pa_stream *s, pa_stream_success_cb_t cb, void *userdata);

/** Rename the stream. \since 0.5 */
pa_operation* pa_stream_set_name(pa_stream *s, const char *name, pa_stream_success_cb_t cb, void *userdata);

/** Return the current playback/recording time. This is based on the
* data in the timing info structure returned by
* pa_stream_get_timing_info(). This function will usually only return
* new data if a timing info update has been recieved. Only if timing
* interpolation has been requested (PA_STREAM_INTERPOLATE_TIMING)
* the data from the last timing update is used for an estimation of
* the current playback/recording time based on the local time that
* passed since the timing info structure has been acquired. The time
* value returned by this function is guaranteed to increase
* monotonically. (that means: the returned value is always greater or
* equal to the value returned on the last call) This behaviour can
* be disabled by using PA_STREAM_NOT_MONOTONOUS. This may be
* desirable to deal better with bad estimations of transport
* latencies, but may have strange effects if the application is not
* able to deal with time going 'backwards'. \since 0.6 */
int pa_stream_get_time(pa_stream *s, pa_usec_t *r_usec);

/** Return the total stream latency. This function is based on
* pa_stream_get_time(). In case the stream is a monitoring stream the
* result can be negative, i.e. the captured samples are not yet
* played. In this case *negative is set to 1. \since 0.6 */
int pa_stream_get_latency(pa_stream *s, pa_usec_t *r_usec, int *negative);

/** Return the latest raw timing data structure. The returned pointer
* points to an internal read-only instance of the timing
* structure. The user should make a copy of this structure if he
* wants to modify it. An in-place update to this data structure may
* be requested using pa_stream_update_timing_info(). If no
* pa_stream_update_timing_info() call was issued before, this
* function will fail with PA_ERR_NODATA. Please note that the
* write_index member field (and only this field) is updated on each
* pa_stream_write() call, not just when a timing update has been
* recieved. \since 0.8 */
const pa_timing_info* pa_stream_get_timing_info(pa_stream *s);

/** Return a pointer to the stream's sample specification. \since 0.6 */
const pa_sample_spec* pa_stream_get_sample_spec(pa_stream *s);

/** Return a pointer to the stream's channel map. \since 0.8 */
const pa_channel_map* pa_stream_get_channel_map(pa_stream *s);

/** Return the buffer metrics of the stream. Only valid after the
* stream has been connected successfuly and if the server is at least
* PulseAudio 0.9. \since 0.9.0 */
const pa_buffer_attr* pa_stream_get_buffer_attr(pa_stream *s);

/** Change the buffer metrics of the stream during playback. The
* server might have chosen different buffer metrics then
* requested. The selected metrics may be queried with
* pa_stream_get_buffer_attr() as soon as the callback is called. Only
* valid after the stream has been connected successfully and if the
* server is at least PulseAudio 0.9.8. \since 0.9.8 */
pa_operation *pa_stream_set_buffer_attr(pa_stream *s, const pa_buffer_attr *attr, pa_stream_success_cb_t cb, void *userdata);

/* Change the stream sampling rate during playback. You need to pass
* PA_STREAM_VARIABLE_RATE in the flags parameter of
* pa_stream_connect() if you plan to use this function. Only valid
* after the stream has been connected successfully and if the server
* is at least PulseAudio 0.9.8. \since 0.9.8 */
pa_operation *pa_stream_update_sample_rate(pa_stream *s, uint32_t rate, pa_stream_success_cb_t cb, void *userdata);

PA_C_DECL_END

#endif


Generated by  Doxygen 1.6.0   Back to index