source: roaraudio/libroarpulse/stream.c @ 3431:a62fa829e0af

Last change on this file since 3431:a62fa829e0af was 3431:a62fa829e0af, checked in by phi, 14 years ago

added pa_stream_drop() and pa_stream_peek()

File size: 15.1 KB
Line 
1//stream.c:
2
3/*
4 *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2010
5 *  The code (may) include prototypes and comments (and maybe
6 *  other code fragements) from libpulse*. They are mostly copyrighted by:
7 *  Lennart Poettering <poettering@users.sourceforge.net> and
8 *  Pierre Ossman <drzeus@drzeus.cx>
9 *
10 *  This file is part of libroarpulse a part of RoarAudio,
11 *  a cross-platform sound system for both, home and professional use.
12 *  See README for details.
13 *
14 *  This file is free software; you can redistribute it and/or modify
15 *  it under the terms of the GNU General Public License version 3
16 *  as published by the Free Software Foundation.
17 *
18 *  RoarAudio is distributed in the hope that it will be useful,
19 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
20 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21 *  GNU General Public License for more details.
22 *
23 *  You should have received a copy of the GNU General Public License
24 *  along with this software; see the file COPYING.  If not, write to
25 *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
26 *
27 *  NOTE for everyone want's to change something and send patches:
28 *  read README and HACKING! There a addition information on
29 *  the license of this document you need to read before you send
30 *  any patches.
31 *
32 *  NOTE for uses of non-GPL (LGPL,...) software using libesd, libartsc
33 *  or libpulse*:
34 *  The libs libroaresd, libroararts and libroarpulse link this libroar
35 *  and are therefore GPL. Because of this it may be illigal to use
36 *  them with any software that uses libesd, libartsc or libpulse*.
37 */
38
39#include <libroarpulse/libroarpulse.h>
40
41struct _roar_pa_stream_cb {
42 union {
43  pa_stream_notify_cb_t  ncb;
44  pa_stream_request_cb_t rcb;
45  pa_stream_success_cb_t scb;
46 } cb;
47 void * userdata;
48};
49
50struct pa_stream {
51 size_t refc;
52 pa_context * c;
53 struct roar_vio_calls vio;
54 struct roar_stream stream;
55 pa_stream_state_t state;
56 pa_sample_spec    sspec;
57 struct roar_buffer * iobuffer;
58 struct {
59  size_t size;
60  size_t num;
61 } fragments;
62 struct {
63  struct _roar_pa_stream_cb change_state;
64  struct _roar_pa_stream_cb write;
65  struct _roar_pa_stream_cb read;
66  struct _roar_pa_stream_cb overflow;
67  struct _roar_pa_stream_cb underflow;
68  struct _roar_pa_stream_cb latency;
69 } cb;
70};
71
72typedef void pa_proplist;
73void pa_stream_set_state(pa_stream *s, pa_stream_state_t st);
74
75pa_stream* pa_stream_new_with_proplist(
76        pa_context *c                     ,
77        const char *name                  ,
78        const pa_sample_spec *ss          ,
79        const pa_channel_map *map         ,
80        pa_proplist *p                    );
81
82/** Create a new, unconnected stream with the specified name and sample type */
83pa_stream* pa_stream_new(
84        pa_context *c                     /**< The context to create this stream in */,
85        const char *name                  /**< A name for this stream */,
86        const pa_sample_spec *ss          /**< The desired sample format */,
87        const pa_channel_map *map         /**< The desired channel map, or NULL for default */) {
88 return pa_stream_new_with_proplist(c, name, ss, map, NULL);
89}
90
91pa_stream* pa_stream_new_with_proplist(
92        pa_context *c                     ,
93        const char *name                  ,
94        const pa_sample_spec *ss          ,
95        const pa_channel_map *map         ,
96        pa_proplist *p                    ) {
97 pa_stream * s;
98
99 if ( p != NULL )
100  return NULL;
101
102 if ( (s = roar_mm_malloc(sizeof(pa_stream))) == NULL )
103  return NULL;
104
105 memset(s, 0, sizeof(pa_stream));
106
107 memcpy(&(s->sspec), ss, sizeof(pa_sample_spec));
108
109 if ( roar_pa_sspec2auinfo(&(s->stream.info), ss) == -1 ) {
110  roar_mm_free(s);
111  return NULL;
112 }
113
114 s->fragments.num  = 4;
115 s->fragments.size = 2048;
116
117 s->state = PA_STREAM_UNCONNECTED;
118 s->c     = c;
119 pa_context_ref(c);
120
121 return s;
122}
123
124static void _pa_stream_free(pa_stream * s) {
125 pa_stream_disconnect(s);
126 pa_context_unref(s->c);
127 roar_mm_free(s);
128}
129
130/** Decrease the reference counter by one */
131void pa_stream_unref(pa_stream *s) {
132 if ( s == NULL )
133  return;
134
135 s->refc--;
136
137 if (s->refc < 1 )
138  _pa_stream_free(s);
139}
140
141/** Increase the reference counter by one */
142pa_stream *pa_stream_ref(pa_stream *s) {
143 if ( s == NULL )
144  return NULL;
145
146 s->refc++;
147
148 return s;
149}
150
151/** Return the current state of the stream */
152pa_stream_state_t pa_stream_get_state(pa_stream *p) {
153 if ( p == NULL )
154  return PA_STREAM_FAILED;
155
156 return p->state;
157}
158
159/** Return the context this stream is attached to */
160pa_context* pa_stream_get_context(pa_stream *p) {
161 if ( p == NULL )
162  return NULL;
163
164 return p->c;
165}
166
167/** Return the device (sink input or source output) index this stream is connected to */
168uint32_t pa_stream_get_index(pa_stream *s) {
169 return 0;
170}
171
172/** Connect the stream to a sink */
173int pa_stream_connect_playback(
174        pa_stream *s                  /**< The stream to connect to a sink */,
175        const char *dev               /**< Name of the sink to connect to, or NULL for default */ ,
176        const pa_buffer_attr *attr    /**< Buffering attributes, or NULL for default */,
177        pa_stream_flags_t flags       /**< Additional flags, or 0 for default */,
178        pa_cvolume *volume            /**< Initial volume, or NULL for default */,
179        pa_stream *sync_stream        /**< Synchronize this stream with the specified one, or NULL for a standalone stream*/);
180
181/** Connect the stream to a source */
182int pa_stream_connect_record(
183        pa_stream *s                  /**< The stream to connect to a source */ ,
184        const char *dev               /**< Name of the source to connect to, or NULL for default */,
185        const pa_buffer_attr *attr    /**< Buffer attributes, or NULL for default */,
186        pa_stream_flags_t flags       /**< Additional flags, or 0 for default */);
187
188/** Disconnect a stream from a source/sink */
189int pa_stream_disconnect(pa_stream *s) {
190 if ( s == NULL )
191  return -1;
192
193 if ( s->state != PA_STREAM_READY )
194  return -1;
195
196 roar_vio_close(&(s->vio));
197
198 pa_stream_set_state(s, PA_STREAM_TERMINATED);
199
200 return 0;
201}
202
203/** Write some data to the server (for playback sinks), if free_cb is
204 * non-NULL this routine is called when all data has been written out
205 * and an internal reference to the specified data is kept, the data
206 * is not copied. If NULL, the data is copied into an internal
207 * buffer. The client my freely seek around in the output buffer. For
208 * most applications passing 0 and PA_SEEK_RELATIVE as arguments for
209 * offset and seek should be useful.*/
210int pa_stream_write(
211        pa_stream *p             /**< The stream to use */,
212        const void *data         /**< The data to write */,
213        size_t length            /**< The length of the data to write */,
214        pa_free_cb_t free_cb     /**< A cleanup routine for the data or NULL to request an internal copy */,
215        int64_t offset,          /**< Offset for seeking, must be 0 for upload streams */
216        pa_seek_mode_t seek      /**< Seek mode, must be PA_SEEK_RELATIVE for upload streams */);
217
218/** Read the next fragment from the buffer (for recording).
219 * data will point to the actual data and length will contain the size
220 * of the data in bytes (which can be less than a complete framgnet).
221 * Use pa_stream_drop() to actually remove the data from the
222 * buffer. If no data is available will return a NULL pointer  \since 0.8 */
223int pa_stream_peek(
224        pa_stream *p                 /**< The stream to use */,
225        const void **data            /**< Pointer to pointer that will point to data */,
226        size_t *length              /**< The length of the data read */) {
227 if ( data == NULL || length == NULL )
228  return -1;
229
230 *data   = NULL;
231 *length = 0;
232
233 if ( p == NULL )
234  return -1;
235
236 if ( p->iobuffer == NULL )
237  return 0;
238
239 if ( roar_buffer_get_len(p->iobuffer, length) == -1 ) {
240  *length = 0;
241  return -1;
242 }
243
244 if ( roar_buffer_get_data(p->iobuffer, (void**)data) == -1 ) {
245  *length = 0;
246  *data   = NULL;
247  return -1;
248 }
249
250 return 0;
251}
252
253/** Remove the current fragment on record streams. It is invalid to do this without first
254 * calling pa_stream_peek(). \since 0.8 */
255int pa_stream_drop(pa_stream *p) {
256 if ( p == NULL )
257  return -1;
258
259 if ( p->iobuffer == NULL )
260  return -1;
261
262 return roar_buffer_next(&(p->iobuffer));
263}
264
265/** Return the nember of bytes that may be written using pa_stream_write() */
266size_t pa_stream_writable_size(pa_stream *p) {
267 struct roar_buffer_stats stats;
268
269 if ( p == NULL )
270  return 0;
271
272 if ( p->iobuffer == NULL )
273  return 0;
274
275 if ( roar_buffer_ring_stats(p->iobuffer, &stats) == -1 )
276  return 0;
277
278 if ( stats.parts > p->fragments.num )
279  return 0;
280
281 return (p->fragments.num - stats.parts)*p->fragments.size;
282}
283
284/** Return the number of bytes that may be read using pa_stream_read() \since 0.8 */
285size_t pa_stream_readable_size(pa_stream *p) {
286 struct roar_buffer_stats stats;
287
288 if ( p == NULL )
289  return 0;
290
291 if ( p->iobuffer == NULL )
292  return 0;
293
294 if ( roar_buffer_ring_stats(p->iobuffer, &stats) == -1 )
295  return 0;
296
297 return stats.bytes;
298}
299
300/** Drain a playback stream. Use this for notification when the buffer is empty */
301pa_operation* pa_stream_drain(pa_stream *s, pa_stream_success_cb_t cb, void *userdata);
302
303/** Request a timing info structure update for a stream. Use
304 * pa_stream_get_timing_info() to get access to the raw timing data,
305 * or pa_stream_get_time() or pa_stream_get_latency() to get cleaned
306 * up values. */
307pa_operation* pa_stream_update_timing_info(pa_stream *p, pa_stream_success_cb_t cb, void *userdata);
308
309/** Set the callback function that is called whenever the state of the stream changes */
310void pa_stream_set_state_callback(pa_stream *s, pa_stream_notify_cb_t cb, void *userdata) {
311 if ( s == NULL )
312  return;
313
314 s->cb.change_state.cb.ncb    = cb;
315 s->cb.change_state.userdata  = userdata;
316}
317
318void pa_stream_set_state(pa_stream *s, pa_stream_state_t st) {
319 if ( s == NULL )
320  return;
321
322 s->state = st;
323
324 if ( s->cb.change_state.cb.ncb == NULL ) {
325  s->cb.change_state.cb.ncb(s, s->cb.change_state.userdata);
326 }
327}
328
329/** Set the callback function that is called when new data may be
330 * written to the stream. */
331void pa_stream_set_write_callback(pa_stream *p, pa_stream_request_cb_t cb, void *userdata) {
332 if ( p == NULL )
333  return;
334
335 p->cb.write.cb.rcb    = cb;
336 p->cb.write.userdata  = userdata;
337}
338
339/** Set the callback function that is called when new data is available from the stream.
340 * Return the number of bytes read. \since 0.8 */
341void pa_stream_set_read_callback(pa_stream *p, pa_stream_request_cb_t cb, void *userdata) {
342 if ( p == NULL )
343  return;
344
345 p->cb.read.cb.rcb    = cb;
346 p->cb.read.userdata  = userdata;
347}
348
349/** Set the callback function that is called when a buffer overflow happens. (Only for playback streams) \since 0.8 */
350void pa_stream_set_overflow_callback(pa_stream *p, pa_stream_notify_cb_t cb, void *userdata) {
351 if ( p == NULL )
352  return;
353
354 p->cb.overflow.cb.ncb    = cb;
355 p->cb.overflow.userdata  = userdata;
356}
357
358/** Set the callback function that is called when a buffer underflow happens. (Only for playback streams) \since 0.8 */
359void pa_stream_set_underflow_callback(pa_stream *p, pa_stream_notify_cb_t cb, void *userdata) {
360 if ( p == NULL )
361  return;
362
363 p->cb.underflow.cb.ncb    = cb;
364 p->cb.underflow.userdata  = userdata;
365}
366
367/** 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 */
368void pa_stream_set_latency_update_callback(pa_stream *p, pa_stream_notify_cb_t cb, void *userdata) {
369 if ( p == NULL )
370  return;
371
372 p->cb.latency.cb.ncb    = cb;
373 p->cb.latency.userdata  = userdata;
374}
375
376/** Pause (or resume) playback of this stream temporarily. Available on both playback and recording streams. \since 0.3 */
377pa_operation* pa_stream_cork(pa_stream *s, int b, pa_stream_success_cb_t cb, void *userdata);
378
379/** Flush the playback buffer of this stream. Most of the time you're
380 * better off using the parameter delta of pa_stream_write() instead of this
381 * function. Available on both playback and recording streams. \since 0.3 */
382pa_operation* pa_stream_flush(pa_stream *s, pa_stream_success_cb_t cb, void *userdata);
383/** Reenable prebuffering as specified in the pa_buffer_attr
384 * structure. Available for playback streams only. \since 0.6 */
385pa_operation* pa_stream_prebuf(pa_stream *s, pa_stream_success_cb_t cb, void *userdata);
386
387/** Request immediate start of playback on this stream. This disables
388 * prebuffering as specified in the pa_buffer_attr
389 * structure, temporarily. Available for playback streams only. \since 0.3 */
390pa_operation* pa_stream_trigger(pa_stream *s, pa_stream_success_cb_t cb, void *userdata);
391
392/** Rename the stream. \since 0.5 */
393pa_operation* pa_stream_set_name(pa_stream *s, const char *name, pa_stream_success_cb_t cb, void *userdata);
394
395/** Return the current playback/recording time. This is based on the
396 * data in the timing info structure returned by
397 * pa_stream_get_timing_info(). This function will usually only return
398 * new data if a timing info update has been recieved. Only if timing
399 * interpolation has been requested (PA_STREAM_INTERPOLATE_TIMING)
400 * the data from the last timing update is used for an estimation of
401 * the current playback/recording time based on the local time that
402 * passed since the timing info structure has been acquired. The time
403 * value returned by this function is guaranteed to increase
404 * monotonically. (that means: the returned value is always greater or
405 * equal to the value returned on the last call) This behaviour can
406 * be disabled by using PA_STREAM_NOT_MONOTONOUS. This may be
407 * desirable to deal better with bad estimations of transport
408 * latencies, but may have strange effects if the application is not
409 * able to deal with time going 'backwards'. \since 0.6 */
410int pa_stream_get_time(pa_stream *s, pa_usec_t *r_usec);
411
412/** Return the total stream latency. This function is based on
413 * pa_stream_get_time(). In case the stream is a monitoring stream the
414 * result can be negative, i.e. the captured samples are not yet
415 * played. In this case *negative is set to 1. \since 0.6 */
416int pa_stream_get_latency(pa_stream *s, pa_usec_t *r_usec, int *negative);
417
418/** Return the latest raw timing data structure. The returned pointer
419 * points to an internal read-only instance of the timing
420 * structure. The user should make a copy of this structure if he
421 * wants to modify it. An in-place update to this data structure may
422 * be requested using pa_stream_update_timing_info(). If no
423 * pa_stream_update_timing_info() call was issued before, this
424 * function will fail with PA_ERR_NODATA. Please note that the
425 * write_index member field (and only this field) is updated on each
426 * pa_stream_write() call, not just when a timing update has been
427 * recieved. \since 0.8 */
428const pa_timing_info* pa_stream_get_timing_info(pa_stream *s);
429
430/** Return a pointer to the stream's sample specification. \since 0.6 */
431const pa_sample_spec* pa_stream_get_sample_spec(pa_stream *s) {
432 if ( s == NULL )
433  return NULL;
434
435 return &(s->sspec);
436}
437
438/** Return a pointer to the stream's channel map. \since 0.8 */
439const pa_channel_map* pa_stream_get_channel_map(pa_stream *s);
440
441/** Return the buffer metrics of the stream. Only valid after the
442 * stream has been connected successfuly and if the server is at least
443 * PulseAudio 0.9. \since 0.9.0 */
444const pa_buffer_attr* pa_stream_get_buffer_attr(pa_stream *s);
445
446//ll
Note: See TracBrowser for help on using the repository browser.