1 #ifndef foostreamhfoo 2 #define foostreamhfoo 3 4 /*** 5 This file is part of PulseAudio. 6 7 Copyright 2004-2006 Lennart Poettering 8 Copyright 2006 Pierre Ossman <[email protected]> for Cendio AB 9 10 PulseAudio is free software; you can redistribute it and/or modify 11 it under the terms of the GNU Lesser General Public License as published 12 by the Free Software Foundation; either version 2.1 of the License, 13 or (at your option) any later version. 14 15 PulseAudio is distributed in the hope that it will be useful, but 16 WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 18 General Public License for more details. 19 20 You should have received a copy of the GNU Lesser General Public License 21 along with PulseAudio; if not, write to the Free Software 22 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 23 USA. 24 ***/ 25 26 #include <sys/types.h> 27 28 #include <pulse/sample.h> 29 #include <pulse/format.h> 30 #include <pulse/channelmap.h> 31 #include <pulse/volume.h> 32 #include <pulse/def.h> 33 #include <pulse/cdecl.h> 34 #include <pulse/operation.h> 35 #include <pulse/context.h> 36 #include <pulse/proplist.h> 37 38 /** \page streams Audio Streams 39 * 40 * \section overv_sec Overview 41 * 42 * Audio streams form the central functionality of the sound server. Data is 43 * routed, converted and mixed from several sources before it is passed along 44 * to a final output. Currently, there are three forms of audio streams: 45 * 46 * \li Playback streams - Data flows from the client to the server. 47 * \li Record streams - Data flows from the server to the client. 48 * \li Upload streams - Similar to playback streams, but the data is stored in 49 * the sample cache. See \ref scache for more information 50 * about controlling the sample cache. 51 * 52 * \section create_sec Creating 53 * 54 * To access a stream, a pa_stream object must be created using 55 * pa_stream_new(). At this point the audio sample format and mapping of 56 * channels must be specified. See \ref sample and \ref channelmap for more 57 * information about those structures. 58 * 59 * This first step will only create a client-side object, representing the 60 * stream. To use the stream, a server-side object must be created and 61 * associated with the local object. Depending on which type of stream is 62 * desired, a different function is needed: 63 * 64 * \li Playback stream - pa_stream_connect_playback() 65 * \li Record stream - pa_stream_connect_record() 66 * \li Upload stream - pa_stream_connect_upload() (see \ref scache) 67 * 68 * Similar to how connections are done in contexts, connecting a stream will 69 * not generate a pa_operation object. Also like contexts, the application 70 * should register a state change callback, using 71 * pa_stream_set_state_callback(), and wait for the stream to enter an active 72 * state. 73 * 74 * \subsection bufattr_subsec Buffer Attributes 75 * 76 * Playback and record streams always have a server-side buffer as 77 * part of the data flow. The size of this buffer needs to be chosen 78 * in a compromise between low latency and sensitivity for buffer 79 * overflows/underruns. 80 * 81 * The buffer metrics may be controlled by the application. They are 82 * described with a pa_buffer_attr structure which contains a number 83 * of fields: 84 * 85 * \li maxlength - The absolute maximum number of bytes that can be 86 * stored in the buffer. If this value is exceeded 87 * then data will be lost. It is recommended to pass 88 * (uint32_t) -1 here which will cause the server to 89 * fill in the maximum possible value. 90 * 91 * \li tlength - The target fill level of the playback buffer. The 92 * server will only send requests for more data as long 93 * as the buffer has less than this number of bytes of 94 * data. If you pass (uint32_t) -1 (which is 95 * recommended) here the server will choose the longest 96 * target buffer fill level possible to minimize the 97 * number of necessary wakeups and maximize drop-out 98 * safety. This can exceed 2s of buffering. For 99 * low-latency applications or applications where 100 * latency matters you should pass a proper value here. 101 * 102 * \li prebuf - Number of bytes that need to be in the buffer before 103 * playback will commence. Start of playback can be 104 * forced using pa_stream_trigger() even though the 105 * prebuffer size hasn't been reached. If a buffer 106 * underrun occurs, this prebuffering will be again 107 * enabled. If the playback shall never stop in case of a 108 * buffer underrun, this value should be set to 0. In 109 * that case the read index of the output buffer 110 * overtakes the write index, and hence the fill level of 111 * the buffer is negative. If you pass (uint32_t) -1 here 112 * (which is recommended) the server will choose the same 113 * value as tlength here. 114 * 115 * \li minreq - Minimum free number of the bytes in the playback 116 * buffer before the server will request more data. It is 117 * recommended to fill in (uint32_t) -1 here. This value 118 * influences how much time the sound server has to move 119 * data from the per-stream server-side playback buffer 120 * to the hardware playback buffer. 121 * 122 * \li fragsize - Maximum number of bytes that the server will push in 123 * one chunk for record streams. If you pass (uint32_t) 124 * -1 (which is recommended) here, the server will 125 * choose the longest fragment setting possible to 126 * minimize the number of necessary wakeups and 127 * maximize drop-out safety. This can exceed 2s of 128 * buffering. For low-latency applications or 129 * applications where latency matters you should pass a 130 * proper value here. 131 * 132 * If PA_STREAM_ADJUST_LATENCY is set, then the tlength/fragsize 133 * parameters will be interpreted slightly differently than described 134 * above when passed to pa_stream_connect_record() and 135 * pa_stream_connect_playback(): the overall latency that is comprised 136 * of both the server side playback buffer length, the hardware 137 * playback buffer length and additional latencies will be adjusted in 138 * a way that it matches tlength resp. fragsize. Set 139 * PA_STREAM_ADJUST_LATENCY if you want to control the overall 140 * playback latency for your stream. Unset it if you want to control 141 * only the latency induced by the server-side, rewritable playback 142 * buffer. The server will try to fulfill the clients latency requests 143 * as good as possible. However if the underlying hardware cannot 144 * change the hardware buffer length or only in a limited range, the 145 * actually resulting latency might be different from what the client 146 * requested. Thus, for synchronization clients always need to check 147 * the actual measured latency via pa_stream_get_latency() or a 148 * similar call, and not make any assumptions. about the latency 149 * available. The function pa_stream_get_buffer_attr() will always 150 * return the actual size of the server-side per-stream buffer in 151 * tlength/fragsize, regardless whether PA_STREAM_ADJUST_LATENCY is 152 * set or not. 153 * 154 * The server-side per-stream playback buffers are indexed by a write and a read 155 * index. The application writes to the write index and the sound 156 * device reads from the read index. The read index is increased 157 * monotonically, while the write index may be freely controlled by 158 * the application. Subtracting the read index from the write index 159 * will give you the current fill level of the buffer. The read/write 160 * indexes are 64bit values and measured in bytes, they will never 161 * wrap. The current read/write index may be queried using 162 * pa_stream_get_timing_info() (see below for more information). In 163 * case of a buffer underrun the read index is equal or larger than 164 * the write index. Unless the prebuf value is 0, PulseAudio will 165 * temporarily pause playback in such a case, and wait until the 166 * buffer is filled up to prebuf bytes again. If prebuf is 0, the 167 * read index may be larger than the write index, in which case 168 * silence is played. If the application writes data to indexes lower 169 * than the read index, the data is immediately lost. 170 * 171 * \section transfer_sec Transferring Data 172 * 173 * Once the stream is up, data can start flowing between the client and the 174 * server. Two different access models can be used to transfer the data: 175 * 176 * \li Asynchronous - The application register a callback using 177 * pa_stream_set_write_callback() and 178 * pa_stream_set_read_callback() to receive notifications 179 * that data can either be written or read. 180 * \li Polled - Query the library for available data/space using 181 * pa_stream_writable_size() and pa_stream_readable_size() and 182 * transfer data as needed. The sizes are stored locally, in the 183 * client end, so there is no delay when reading them. 184 * 185 * It is also possible to mix the two models freely. 186 * 187 * Once there is data/space available, it can be transferred using either 188 * pa_stream_write() for playback, or pa_stream_peek() / pa_stream_drop() for 189 * record. Make sure you do not overflow the playback buffers as data will be 190 * dropped. 191 * 192 * \section bufctl_sec Buffer Control 193 * 194 * The transfer buffers can be controlled through a number of operations: 195 * 196 * \li pa_stream_cork() - Start or stop the playback or recording. 197 * \li pa_stream_trigger() - Start playback immediately and do not wait for 198 * the buffer to fill up to the set trigger level. 199 * \li pa_stream_prebuf() - Reenable the playback trigger level. 200 * \li pa_stream_drain() - Wait for the playback buffer to go empty. Will 201 * return a pa_operation object that will indicate when 202 * the buffer is completely drained. 203 * \li pa_stream_flush() - Drop all data from the playback buffer and do not 204 * wait for it to finish playing. 205 * 206 * \section seek_modes Seeking in the Playback Buffer 207 * 208 * A client application may freely seek in the playback buffer. To 209 * accomplish that the pa_stream_write() function takes a seek mode 210 * and an offset argument. The seek mode is one of: 211 * 212 * \li PA_SEEK_RELATIVE - seek relative to the current write index 213 * \li PA_SEEK_ABSOLUTE - seek relative to the beginning of the playback buffer, (i.e. the first that was ever played in the stream) 214 * \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 215 * \li PA_SEEK_RELATIVE_END - seek relative to the last byte ever written. 216 * 217 * If an application just wants to append some data to the output 218 * buffer, PA_SEEK_RELATIVE and an offset of 0 should be used. 219 * 220 * After a call to pa_stream_write() the write index will be left at 221 * the position right after the last byte of the written data. 222 * 223 * \section latency_sec Latency 224 * 225 * A major problem with networked audio is the increased latency caused by 226 * the network. To remedy this, PulseAudio supports an advanced system of 227 * monitoring the current latency. 228 * 229 * To get the raw data needed to calculate latencies, call 230 * pa_stream_get_timing_info(). This will give you a pa_timing_info 231 * structure that contains everything that is known about the server 232 * side buffer transport delays and the backend active in the 233 * server. (Besides other things it contains the write and read index 234 * values mentioned above.) 235 * 236 * This structure is updated every time a 237 * pa_stream_update_timing_info() operation is executed. (i.e. before 238 * the first call to this function the timing information structure is 239 * not available!) Since it is a lot of work to keep this structure 240 * up-to-date manually, PulseAudio can do that automatically for you: 241 * if PA_STREAM_AUTO_TIMING_UPDATE is passed when connecting the 242 * stream PulseAudio will automatically update the structure every 243 * 100ms and every time a function is called that might invalidate the 244 * previously known timing data (such as pa_stream_write() or 245 * pa_stream_flush()). Please note however, that there always is a 246 * short time window when the data in the timing information structure 247 * is out-of-date. PulseAudio tries to mark these situations by 248 * setting the write_index_corrupt and read_index_corrupt fields 249 * accordingly. 250 * 251 * The raw timing data in the pa_timing_info structure is usually hard 252 * to deal with. Therefore a simpler interface is available: 253 * you can call pa_stream_get_time() or pa_stream_get_latency(). The 254 * former will return the current playback time of the hardware since 255 * the stream has been started. The latter returns the overall time a sample 256 * that you write now takes to be played by the hardware. These two 257 * functions base their calculations on the same data that is returned 258 * by pa_stream_get_timing_info(). Hence the same rules for keeping 259 * the timing data up-to-date apply here. In case the write or read 260 * index is corrupted, these two functions will fail with 261 * -PA_ERR_NODATA set. 262 * 263 * Since updating the timing info structure usually requires a full 264 * network round trip and some applications monitor the timing very 265 * often PulseAudio offers a timing interpolation system. If 266 * PA_STREAM_INTERPOLATE_TIMING is passed when connecting the stream, 267 * pa_stream_get_time() and pa_stream_get_latency() will try to 268 * interpolate the current playback time/latency by estimating the 269 * number of samples that have been played back by the hardware since 270 * the last regular timing update. It is especially useful to combine 271 * this option with PA_STREAM_AUTO_TIMING_UPDATE, which will enable 272 * you to monitor the current playback time/latency very precisely and 273 * very frequently without requiring a network round trip every time. 274 * 275 * \section flow_sec Overflow and underflow 276 * 277 * Even with the best precautions, buffers will sometime over - or 278 * underflow. To handle this gracefully, the application can be 279 * notified when this happens. Callbacks are registered using 280 * pa_stream_set_overflow_callback() and 281 * pa_stream_set_underflow_callback(). 282 * 283 * \section sync_streams Synchronizing Multiple Playback Streams 284 * 285 * PulseAudio allows applications to fully synchronize multiple 286 * playback streams that are connected to the same output device. That 287 * means the streams will always be played back sample-by-sample 288 * synchronously. If stream operations like pa_stream_cork() are 289 * issued on one of the synchronized streams, they are simultaneously 290 * issued on the others. 291 * 292 * To synchronize a stream to another, just pass the "master" stream 293 * as last argument to pa_stream_connect_playback(). To make sure that 294 * the freshly created stream doesn't start playback right-away, make 295 * sure to pass PA_STREAM_START_CORKED and -- after all streams have 296 * been created -- uncork them all with a single call to 297 * pa_stream_cork() for the master stream. 298 * 299 * To make sure that a particular stream doesn't stop to play when a 300 * server side buffer underrun happens on it while the other 301 * synchronized streams continue playing and hence deviate, you need to 302 * pass a "prebuf" pa_buffer_attr of 0 when connecting it. 303 * 304 * \section disc_sec Disconnecting 305 * 306 * When a stream has served is purpose it must be disconnected with 307 * pa_stream_disconnect(). If you only unreference it, then it will live on 308 * and eat resources both locally and on the server until you disconnect the 309 * context. 310 * 311 */ 312 313 /** \file 314 * Audio streams for input, output and sample upload 315 * 316 * See also \subpage streams 317 */ 318 319 PA_C_DECL_BEGIN 320 321 /** An opaque stream for playback or recording */ 322 typedef struct pa_stream pa_stream; 323 324 /** A generic callback for operation completion */ 325 typedef void (*pa_stream_success_cb_t) (pa_stream*s, int success, void *userdata); 326 327 /** A generic request callback */ 328 typedef void (*pa_stream_request_cb_t)(pa_stream *p, size_t nbytes, void *userdata); 329 330 /** A generic notification callback */ 331 typedef void (*pa_stream_notify_cb_t)(pa_stream *p, void *userdata); 332 333 /** A callback for asynchronous meta/policy event messages. Well known 334 * event names are PA_STREAM_EVENT_REQUEST_CORK and 335 * PA_STREAM_EVENT_REQUEST_UNCORK. The set of defined events can be 336 * extended at any time. Also, server modules may introduce additional 337 * message types so make sure that your callback function ignores messages 338 * it doesn't know. \since 0.9.15 */ 339 typedef void (*pa_stream_event_cb_t)(pa_stream *p, const char *name, pa_proplist *pl, void *userdata); 340 341 /** Create a new, unconnected stream with the specified name and 342 * sample type. It is recommended to use pa_stream_new_with_proplist() 343 * instead and specify some initial properties. */ 344 pa_stream* pa_stream_new( 345 pa_context *c /**< The context to create this stream in */, 346 const char *name /**< A name for this stream */, 347 const pa_sample_spec *ss /**< The desired sample format */, 348 const pa_channel_map *map /**< The desired channel map, or NULL for default */); 349 350 /** Create a new, unconnected stream with the specified name and 351 * sample type, and specify the initial stream property 352 * list. \since 0.9.11 */ 353 pa_stream* pa_stream_new_with_proplist( 354 pa_context *c /**< The context to create this stream in */, 355 const char *name /**< A name for this stream */, 356 const pa_sample_spec *ss /**< The desired sample format */, 357 const pa_channel_map *map /**< The desired channel map, or NULL for default */, 358 pa_proplist *p /**< The initial property list */); 359 360 /** Create a new, unconnected stream with the specified name, the set of formats 361 * this client can provide, and an initial list of properties. While 362 * connecting, the server will select the most appropriate format which the 363 * client must then provide. \since 1.0 */ 364 pa_stream *pa_stream_new_extended( 365 pa_context *c /**< The context to create this stream in */, 366 const char *name /**< A name for this stream */, 367 pa_format_info * const * formats /**< The list of formats that can be provided */, 368 unsigned int n_formats /**< The number of formats being passed in */, 369 pa_proplist *p /**< The initial property list */); 370 371 /** Decrease the reference counter by one. */ 372 void pa_stream_unref(pa_stream *s); 373 374 /** Increase the reference counter by one. */ 375 pa_stream *pa_stream_ref(pa_stream *s); 376 377 /** Return the current state of the stream. */ 378 pa_stream_state_t pa_stream_get_state(pa_stream *p); 379 380 /** Return the context this stream is attached to. */ 381 pa_context* pa_stream_get_context(pa_stream *p); 382 383 /** Return the sink input resp.\ source output index this stream is 384 * identified in the server with. This is useful with the 385 * introspection functions such as pa_context_get_sink_input_info() 386 * or pa_context_get_source_output_info(). */ 387 uint32_t pa_stream_get_index(pa_stream *s); 388 389 /** Return the index of the sink or source this stream is connected to 390 * in the server. This is useful with the introspection 391 * functions such as pa_context_get_sink_info_by_index() or 392 * pa_context_get_source_info_by_index(). 393 * 394 * Please note that streams may be moved between sinks/sources and thus 395 * it is recommended to use pa_stream_set_moved_callback() to be notified 396 * about this. This function will return with -PA_ERR_NOTSUPPORTED when the 397 * server is older than 0.9.8. \since 0.9.8 */ 398 uint32_t pa_stream_get_device_index(pa_stream *s); 399 400 /** Return the name of the sink or source this stream is connected to 401 * in the server. This is useful with the introspection 402 * functions such as pa_context_get_sink_info_by_name() 403 * or pa_context_get_source_info_by_name(). 404 * 405 * Please note that streams may be moved between sinks/sources and thus 406 * it is recommended to use pa_stream_set_moved_callback() to be notified 407 * about this. This function will return with -PA_ERR_NOTSUPPORTED when the 408 * server is older than 0.9.8. \since 0.9.8 */ 409 const char *pa_stream_get_device_name(pa_stream *s); 410 411 /** Return 1 if the sink or source this stream is connected to has 412 * been suspended. This will return 0 if not, and a negative value on 413 * error. This function will return with -PA_ERR_NOTSUPPORTED when the 414 * server is older than 0.9.8. \since 0.9.8 */ 415 int pa_stream_is_suspended(pa_stream *s); 416 417 /** Return 1 if the this stream has been corked. This will return 0 if 418 * not, and a negative value on error. \since 0.9.11 */ 419 int pa_stream_is_corked(pa_stream *s); 420 421 /** Connect the stream to a sink. It is strongly recommended to pass 422 * NULL in both \a dev and \a volume and not to set either 423 * PA_STREAM_START_MUTED nor PA_STREAM_START_UNMUTED -- unless these 424 * options are directly dependent on user input or configuration. 425 * 426 * If you follow this rule then the sound server will have the full 427 * flexibility to choose the device, volume and mute status 428 * automatically, based on server-side policies, heuristics and stored 429 * information from previous uses. Also the server may choose to 430 * reconfigure audio devices to make other sinks/sources or 431 * capabilities available to be able to accept the stream. 432 * 433 * Before 0.9.20 it was not defined whether the \a volume parameter was 434 * interpreted relative to the sink's current volume or treated as 435 * an absolute device volume. Since 0.9.20 it is an absolute volume when 436 * the sink is in flat volume mode, and relative otherwise, thus 437 * making sure the volume passed here has always the same semantics as 438 * the volume passed to pa_context_set_sink_input_volume(). */ 439 int pa_stream_connect_playback( 440 pa_stream *s /**< The stream to connect to a sink */, 441 const char *dev /**< Name of the sink to connect to, or NULL for default */ , 442 const pa_buffer_attr *attr /**< Buffering attributes, or NULL for default */, 443 pa_stream_flags_t flags /**< Additional flags, or 0 for default */, 444 const pa_cvolume *volume /**< Initial volume, or NULL for default */, 445 pa_stream *sync_stream /**< Synchronize this stream with the specified one, or NULL for a standalone stream */); 446 447 /** Connect the stream to a source. */ 448 int pa_stream_connect_record( 449 pa_stream *s /**< The stream to connect to a source */ , 450 const char *dev /**< Name of the source to connect to, or NULL for default */, 451 const pa_buffer_attr *attr /**< Buffer attributes, or NULL for default */, 452 pa_stream_flags_t flags /**< Additional flags, or 0 for default */); 453 454 /** Disconnect a stream from a source/sink. */ 455 int pa_stream_disconnect(pa_stream *s); 456 457 /** Prepare writing data to the server (for playback streams). This 458 * function may be used to optimize the number of memory copies when 459 * doing playback ("zero-copy"). It is recommended to call this 460 * function before each call to pa_stream_write(). 461 * 462 * Pass in the address to a pointer and an address of the number of 463 * bytes you want to write. On return the two values will contain a 464 * pointer where you can place the data to write and the maximum number 465 * of bytes you can write. \a *nbytes can be smaller or have the same 466 * value as you passed in. You need to be able to handle both cases. 467 * Accessing memory beyond the returned \a *nbytes value is invalid. 468 * Accessing the memory returned after the following pa_stream_write() 469 * or pa_stream_cancel_write() is invalid. 470 * 471 * On invocation only \a *nbytes needs to be initialized, on return both 472 * *data and *nbytes will be valid. If you place (size_t) -1 in *nbytes 473 * on invocation the memory size will be chosen automatically (which is 474 * recommended to do). After placing your data in the memory area 475 * returned, call pa_stream_write() with \a data set to an address 476 * within this memory area and an \a nbytes value that is smaller or 477 * equal to what was returned by this function to actually execute the 478 * write. 479 * 480 * An invocation of pa_stream_write() should follow "quickly" on 481 * pa_stream_begin_write(). It is not recommended letting an unbounded 482 * amount of time pass after calling pa_stream_begin_write() and 483 * before calling pa_stream_write(). If you want to cancel a 484 * previously called pa_stream_begin_write() without calling 485 * pa_stream_write() use pa_stream_cancel_write(). Calling 486 * pa_stream_begin_write() twice without calling pa_stream_write() or 487 * pa_stream_cancel_write() in between will return exactly the same 488 * \a data pointer and \a nbytes values. \since 0.9.16 */ 489 int pa_stream_begin_write( 490 pa_stream *p, 491 void **data, 492 size_t *nbytes); 493 494 /** Reverses the effect of pa_stream_begin_write() dropping all data 495 * that has already been placed in the memory area returned by 496 * pa_stream_begin_write(). Only valid to call if 497 * pa_stream_begin_write() was called before and neither 498 * pa_stream_cancel_write() nor pa_stream_write() have been called 499 * yet. Accessing the memory previously returned by 500 * pa_stream_begin_write() after this call is invalid. Any further 501 * explicit freeing of the memory area is not necessary. \since 502 * 0.9.16 */ 503 int pa_stream_cancel_write( 504 pa_stream *p); 505 506 /** Write some data to the server (for playback streams). 507 * If \a free_cb is non-NULL this routine is called when all data has 508 * been written out. An internal reference to the specified data is 509 * kept, the data is not copied. If NULL, the data is copied into an 510 * internal buffer. 511 * 512 * The client may freely seek around in the output buffer. For 513 * most applications it is typical to pass 0 and PA_SEEK_RELATIVE 514 * as values for the arguments \a offset and \a seek. After the write 515 * call succeeded the write index will be at the position after where 516 * this chunk of data has been written to. 517 * 518 * As an optimization for avoiding needless memory copies you may call 519 * pa_stream_begin_write() before this call and then place your audio 520 * data directly in the memory area returned by that call. Then, pass 521 * a pointer to that memory area to pa_stream_write(). After the 522 * invocation of pa_stream_write() the memory area may no longer be 523 * accessed. Any further explicit freeing of the memory area is not 524 * necessary. It is OK to write the memory area returned by 525 * pa_stream_begin_write() only partially with this call, skipping 526 * bytes both at the end and at the beginning of the reserved memory 527 * area.*/ 528 int pa_stream_write( 529 pa_stream *p /**< The stream to use */, 530 const void *data /**< The data to write */, 531 size_t nbytes /**< The length of the data to write in bytes */, 532 pa_free_cb_t free_cb /**< A cleanup routine for the data or NULL to request an internal copy */, 533 int64_t offset, /**< Offset for seeking, must be 0 for upload streams */ 534 pa_seek_mode_t seek /**< Seek mode, must be PA_SEEK_RELATIVE for upload streams */); 535 536 /** Read the next fragment from the buffer (for recording streams). 537 * If there is data at the current read index, \a data will point to 538 * the actual data and \a nbytes will contain the size of the data in 539 * bytes (which can be less or more than a complete fragment). 540 * 541 * If there is no data at the current read index, it means that either 542 * the buffer is empty or it contains a hole (that is, the write index 543 * is ahead of the read index but there's no data where the read index 544 * points at). If the buffer is empty, \a data will be NULL and 545 * \a nbytes will be 0. If there is a hole, \a data will be NULL and 546 * \a nbytes will contain the length of the hole. 547 * 548 * Use pa_stream_drop() to actually remove the data from the buffer 549 * and move the read index forward. pa_stream_drop() should not be 550 * called if the buffer is empty, but it should be called if there is 551 * a hole. */ 552 int pa_stream_peek( 553 pa_stream *p /**< The stream to use */, 554 const void **data /**< Pointer to pointer that will point to data */, 555 size_t *nbytes /**< The length of the data read in bytes */); 556 557 /** Remove the current fragment on record streams. It is invalid to do this without first 558 * calling pa_stream_peek(). */ 559 int pa_stream_drop(pa_stream *p); 560 561 /** Return the number of bytes that may be written using pa_stream_write(). */ 562 size_t pa_stream_writable_size(pa_stream *p); 563 564 /** Return the number of bytes that may be read using pa_stream_peek(). */ 565 size_t pa_stream_readable_size(pa_stream *p); 566 567 /** Drain a playback stream. Use this for notification when the 568 * playback buffer is empty after playing all the audio in the buffer. 569 * Please note that only one drain operation per stream may be issued 570 * at a time. */ 571 pa_operation* pa_stream_drain(pa_stream *s, pa_stream_success_cb_t cb, void *userdata); 572 573 /** Request a timing info structure update for a stream. Use 574 * pa_stream_get_timing_info() to get access to the raw timing data, 575 * or pa_stream_get_time() or pa_stream_get_latency() to get cleaned 576 * up values. */ 577 pa_operation* pa_stream_update_timing_info(pa_stream *p, pa_stream_success_cb_t cb, void *userdata); 578 579 /** Set the callback function that is called whenever the state of the stream changes. */ 580 void pa_stream_set_state_callback(pa_stream *s, pa_stream_notify_cb_t cb, void *userdata); 581 582 /** Set the callback function that is called when new data may be 583 * written to the stream. */ 584 void pa_stream_set_write_callback(pa_stream *p, pa_stream_request_cb_t cb, void *userdata); 585 586 /** Set the callback function that is called when new data is available from the stream. */ 587 void pa_stream_set_read_callback(pa_stream *p, pa_stream_request_cb_t cb, void *userdata); 588 589 /** Set the callback function that is called when a buffer overflow happens. (Only for playback streams) */ 590 void pa_stream_set_overflow_callback(pa_stream *p, pa_stream_notify_cb_t cb, void *userdata); 591 592 /** Return at what position the latest underflow occurred, or -1 if this information is not 593 * known (e.g.\ if no underflow has occurred, or server is older than 1.0). 594 * Can be used inside the underflow callback to get information about the current underflow. 595 * (Only for playback streams) \since 1.0 */ 596 int64_t pa_stream_get_underflow_index(pa_stream *p); 597 598 /** Set the callback function that is called when a buffer underflow happens. (Only for playback streams) */ 599 void pa_stream_set_underflow_callback(pa_stream *p, pa_stream_notify_cb_t cb, void *userdata); 600 601 /** Set the callback function that is called when a the server starts 602 * playback after an underrun or on initial startup. This only informs 603 * that audio is flowing again, it is no indication that audio started 604 * to reach the speakers already. (Only for playback streams) \since 605 * 0.9.11 */ 606 void pa_stream_set_started_callback(pa_stream *p, pa_stream_notify_cb_t cb, void *userdata); 607 608 /** Set the callback function that is called whenever a latency 609 * information update happens. Useful on PA_STREAM_AUTO_TIMING_UPDATE 610 * streams only. (Only for playback streams) */ 611 void pa_stream_set_latency_update_callback(pa_stream *p, pa_stream_notify_cb_t cb, void *userdata); 612 613 /** Set the callback function that is called whenever the stream is 614 * moved to a different sink/source. Use pa_stream_get_device_name() or 615 * pa_stream_get_device_index() to query the new sink/source. This 616 * notification is only generated when the server is at least 617 * 0.9.8. \since 0.9.8 */ 618 void pa_stream_set_moved_callback(pa_stream *p, pa_stream_notify_cb_t cb, void *userdata); 619 620 /** Set the callback function that is called whenever the sink/source 621 * this stream is connected to is suspended or resumed. Use 622 * pa_stream_is_suspended() to query the new suspend status. Please 623 * note that the suspend status might also change when the stream is 624 * moved between devices. Thus if you call this function you very 625 * likely want to call pa_stream_set_moved_callback() too. This 626 * notification is only generated when the server is at least 627 * 0.9.8. \since 0.9.8 */ 628 void pa_stream_set_suspended_callback(pa_stream *p, pa_stream_notify_cb_t cb, void *userdata); 629 630 /** Set the callback function that is called whenever a meta/policy 631 * control event is received. \since 0.9.15 */ 632 void pa_stream_set_event_callback(pa_stream *p, pa_stream_event_cb_t cb, void *userdata); 633 634 /** Set the callback function that is called whenever the buffer 635 * attributes on the server side change. Please note that the buffer 636 * attributes can change when moving a stream to a different 637 * sink/source too, hence if you use this callback you should use 638 * pa_stream_set_moved_callback() as well. \since 0.9.15 */ 639 void pa_stream_set_buffer_attr_callback(pa_stream *p, pa_stream_notify_cb_t cb, void *userdata); 640 641 /** Pause (or resume) playback of this stream temporarily. Available 642 * on both playback and recording streams. If \a b is 1 the stream is 643 * paused. If \a b is 0 the stream is resumed. The pause/resume operation 644 * is executed as quickly as possible. If a cork is very quickly 645 * followed by an uncork or the other way round, this might not 646 * actually have any effect on the stream that is output. You can use 647 * pa_stream_is_corked() to find out whether the stream is currently 648 * paused or not. Normally a stream will be created in uncorked 649 * state. If you pass PA_STREAM_START_CORKED as a flag when connecting 650 * the stream, it will be created in corked state. */ 651 pa_operation* pa_stream_cork(pa_stream *s, int b, pa_stream_success_cb_t cb, void *userdata); 652 653 /** Flush the playback buffer of this stream. This discards any audio data 654 * in the buffer. Most of the time you're better off using the parameter 655 * delta of pa_stream_write() instead of this function. Available on both 656 * playback and recording streams. */ 657 pa_operation* pa_stream_flush(pa_stream *s, pa_stream_success_cb_t cb, void *userdata); 658 659 /** Reenable prebuffering if specified in the pa_buffer_attr 660 * structure. Available for playback streams only. */ 661 pa_operation* pa_stream_prebuf(pa_stream *s, pa_stream_success_cb_t cb, void *userdata); 662 663 /** Request immediate start of playback on this stream. This disables 664 * prebuffering temporarily if specified in the pa_buffer_attr structure. 665 * Available for playback streams only. */ 666 pa_operation* pa_stream_trigger(pa_stream *s, pa_stream_success_cb_t cb, void *userdata); 667 668 /** Rename the stream. */ 669 pa_operation* pa_stream_set_name(pa_stream *s, const char *name, pa_stream_success_cb_t cb, void *userdata); 670 671 /** Return the current playback/recording time. This is based on the 672 * data in the timing info structure returned by 673 * pa_stream_get_timing_info(). 674 * 675 * This function will usually only return new data if a timing info 676 * update has been received. Only if timing interpolation has been 677 * requested (PA_STREAM_INTERPOLATE_TIMING) the data from the last 678 * timing update is used for an estimation of the current 679 * playback/recording time based on the local time that passed since 680 * the timing info structure has been acquired. 681 * 682 * The time value returned by this function is guaranteed to increase 683 * monotonically (the returned value is always greater 684 * or equal to the value returned by the last call). This behaviour 685 * can be disabled by using PA_STREAM_NOT_MONOTONIC. This may be 686 * desirable to better deal with bad estimations of transport 687 * latencies, but may have strange effects if the application is not 688 * able to deal with time going 'backwards'. 689 * 690 * The time interpolator activated by PA_STREAM_INTERPOLATE_TIMING 691 * favours 'smooth' time graphs over accurate ones to improve the 692 * smoothness of UI operations that are tied to the audio clock. If 693 * accuracy is more important to you, you might need to estimate your 694 * timing based on the data from pa_stream_get_timing_info() yourself 695 * or not work with interpolated timing at all and instead always 696 * query the server side for the most up to date timing with 697 * pa_stream_update_timing_info(). 698 * 699 * If no timing information has been 700 * received yet this call will return -PA_ERR_NODATA. For more details 701 * see pa_stream_get_timing_info(). */ 702 int pa_stream_get_time(pa_stream *s, pa_usec_t *r_usec); 703 704 /** Determine the total stream latency. This function is based on 705 * pa_stream_get_time(). 706 * 707 * The latency is stored in \a *r_usec. In case the stream is a 708 * monitoring stream the result can be negative, i.e. the captured 709 * samples are not yet played. In this case \a *negative is set to 1. 710 * 711 * If no timing information has been received yet, this call will 712 * return -PA_ERR_NODATA. On success, it will return 0. 713 * 714 * For more details see pa_stream_get_timing_info() and 715 * pa_stream_get_time(). */ 716 int pa_stream_get_latency(pa_stream *s, pa_usec_t *r_usec, int *negative); 717 718 /** Return the latest raw timing data structure. The returned pointer 719 * refers to an internal read-only instance of the timing 720 * structure. The user should make a copy of this structure if he 721 * wants to modify it. An in-place update to this data structure may 722 * be requested using pa_stream_update_timing_info(). 723 * 724 * If no timing information has been received before (i.e. by 725 * requesting pa_stream_update_timing_info() or by using 726 * PA_STREAM_AUTO_TIMING_UPDATE), this function will fail with 727 * -PA_ERR_NODATA. 728 * 729 * Please note that the write_index member field (and only this field) 730 * is updated on each pa_stream_write() call, not just when a timing 731 * update has been received. */ 732 const pa_timing_info* pa_stream_get_timing_info(pa_stream *s); 733 734 /** Return a pointer to the stream's sample specification. */ 735 const pa_sample_spec* pa_stream_get_sample_spec(pa_stream *s); 736 737 /** Return a pointer to the stream's channel map. */ 738 const pa_channel_map* pa_stream_get_channel_map(pa_stream *s); 739 740 /** Return a pointer to the stream's format. \since 1.0 */ 741 const pa_format_info* pa_stream_get_format_info(pa_stream *s); 742 743 /** Return the per-stream server-side buffer metrics of the 744 * stream. Only valid after the stream has been connected successfully 745 * and if the server is at least PulseAudio 0.9. This will return the 746 * actual configured buffering metrics, which may differ from what was 747 * requested during pa_stream_connect_record() or 748 * pa_stream_connect_playback(). This call will always return the 749 * actual per-stream server-side buffer metrics, regardless whether 750 * PA_STREAM_ADJUST_LATENCY is set or not. \since 0.9.0 */ 751 const pa_buffer_attr* pa_stream_get_buffer_attr(pa_stream *s); 752 753 /** Change the buffer metrics of the stream during playback. The 754 * server might have chosen different buffer metrics then 755 * requested. The selected metrics may be queried with 756 * pa_stream_get_buffer_attr() as soon as the callback is called. Only 757 * valid after the stream has been connected successfully and if the 758 * server is at least PulseAudio 0.9.8. Please be aware of the 759 * slightly different semantics of the call depending whether 760 * PA_STREAM_ADJUST_LATENCY is set or not. \since 0.9.8 */ 761 pa_operation *pa_stream_set_buffer_attr(pa_stream *s, const pa_buffer_attr *attr, pa_stream_success_cb_t cb, void *userdata); 762 763 /** Change the stream sampling rate during playback. You need to pass 764 * PA_STREAM_VARIABLE_RATE in the flags parameter of 765 * pa_stream_connect_playback() if you plan to use this function. Only valid 766 * after the stream has been connected successfully and if the server 767 * is at least PulseAudio 0.9.8. \since 0.9.8 */ 768 pa_operation *pa_stream_update_sample_rate(pa_stream *s, uint32_t rate, pa_stream_success_cb_t cb, void *userdata); 769 770 /** Update the property list of the sink input/source output of this 771 * stream, adding new entries. Please note that it is highly 772 * recommended to set as many properties initially via 773 * pa_stream_new_with_proplist() as possible instead a posteriori with 774 * this function, since that information may be used to route 775 * this stream to the right device. \since 0.9.11 */ 776 pa_operation *pa_stream_proplist_update(pa_stream *s, pa_update_mode_t mode, pa_proplist *p, pa_stream_success_cb_t cb, void *userdata); 777 778 /** Update the property list of the sink input/source output of this 779 * stream, remove entries. \since 0.9.11 */ 780 pa_operation *pa_stream_proplist_remove(pa_stream *s, const char *const keys[], pa_stream_success_cb_t cb, void *userdata); 781 782 /** For record streams connected to a monitor source: monitor only a 783 * very specific sink input of the sink. This function needs to be 784 * called before pa_stream_connect_record() is called. \since 785 * 0.9.11 */ 786 int pa_stream_set_monitor_stream(pa_stream *s, uint32_t sink_input_idx); 787 788 /** Return the sink input index previously set with 789 * pa_stream_set_monitor_stream(). 790 * \since 0.9.11 */ 791 uint32_t pa_stream_get_monitor_stream(pa_stream *s); 792 793 PA_C_DECL_END 794 795 #endif 796