source: roaraudio/libroarpulse/stream.c @ 3432:0c3347ed155b

Last change on this file since 3432:0c3347ed155b was 3432:0c3347ed155b, checked in by phi, 14 years ago

wrote pa_stream_write()

File size: 16.0 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 struct roar_buffer * buf;
218 void               * bufdata;
219
220 // TODO: implement seeking in output buffer
221
222 if ( p == NULL )
223  return -1;
224
225 if ( offset != 0 || seek != PA_SEEK_RELATIVE )
226  return -1;
227
228 if ( data == NULL ) {
229  if ( length == 0 ) {
230   if ( free_cb != NULL )
231    free_cb(NULL);
232
233   return 0;
234  } else {
235   return -1;
236  }
237 }
238
239 // seems we have a valid write from here.
240
241 if ( roar_buffer_new(&buf, length) == -1 ) {
242  if ( free_cb != NULL )
243   free_cb((void*)data);
244
245  return -1;
246 }
247
248 if ( roar_buffer_get_data(buf, &bufdata) == -1 ) {
249  if ( free_cb != NULL )
250   free_cb((void*)data);
251
252  return -1;
253 }
254
255 memcpy(bufdata, data, length);
256 if ( free_cb != NULL )
257  free_cb((void*)data);
258
259 if ( p->iobuffer == NULL ) {
260  p->iobuffer = buf;
261 } else {
262  if ( roar_buffer_add(p->iobuffer, buf) == -1 )
263   return -1;
264 }
265
266 return 0;
267}
268
269/** Read the next fragment from the buffer (for recording).
270 * data will point to the actual data and length will contain the size
271 * of the data in bytes (which can be less than a complete framgnet).
272 * Use pa_stream_drop() to actually remove the data from the
273 * buffer. If no data is available will return a NULL pointer  \since 0.8 */
274int pa_stream_peek(
275        pa_stream *p                 /**< The stream to use */,
276        const void **data            /**< Pointer to pointer that will point to data */,
277        size_t *length              /**< The length of the data read */) {
278 if ( data == NULL || length == NULL )
279  return -1;
280
281 *data   = NULL;
282 *length = 0;
283
284 if ( p == NULL )
285  return -1;
286
287 if ( p->iobuffer == NULL )
288  return 0;
289
290 if ( roar_buffer_get_len(p->iobuffer, length) == -1 ) {
291  *length = 0;
292  return -1;
293 }
294
295 if ( roar_buffer_get_data(p->iobuffer, (void**)data) == -1 ) {
296  *length = 0;
297  *data   = NULL;
298  return -1;
299 }
300
301 return 0;
302}
303
304/** Remove the current fragment on record streams. It is invalid to do this without first
305 * calling pa_stream_peek(). \since 0.8 */
306int pa_stream_drop(pa_stream *p) {
307 if ( p == NULL )
308  return -1;
309
310 if ( p->iobuffer == NULL )
311  return -1;
312
313 return roar_buffer_next(&(p->iobuffer));
314}
315
316/** Return the nember of bytes that may be written using pa_stream_write() */
317size_t pa_stream_writable_size(pa_stream *p) {
318 struct roar_buffer_stats stats;
319
320 if ( p == NULL )
321  return 0;
322
323 if ( p->iobuffer == NULL )
324  return 0;
325
326 if ( roar_buffer_ring_stats(p->iobuffer, &stats) == -1 )
327  return 0;
328
329 if ( stats.parts > p->fragments.num )
330  return 0;
331
332 return (p->fragments.num - stats.parts)*p->fragments.size;
333}
334
335/** Return the number of bytes that may be read using pa_stream_read() \since 0.8 */
336size_t pa_stream_readable_size(pa_stream *p) {
337 struct roar_buffer_stats stats;
338
339 if ( p == NULL )
340  return 0;
341
342 if ( p->iobuffer == NULL )
343  return 0;
344
345 if ( roar_buffer_ring_stats(p->iobuffer, &stats) == -1 )
346  return 0;
347
348 return stats.bytes;
349}
350
351/** Drain a playback stream. Use this for notification when the buffer is empty */
352pa_operation* pa_stream_drain(pa_stream *s, pa_stream_success_cb_t cb, void *userdata);
353
354/** Request a timing info structure update for a stream. Use
355 * pa_stream_get_timing_info() to get access to the raw timing data,
356 * or pa_stream_get_time() or pa_stream_get_latency() to get cleaned
357 * up values. */
358pa_operation* pa_stream_update_timing_info(pa_stream *p, pa_stream_success_cb_t cb, void *userdata);
359
360/** Set the callback function that is called whenever the state of the stream changes */
361void pa_stream_set_state_callback(pa_stream *s, pa_stream_notify_cb_t cb, void *userdata) {
362 if ( s == NULL )
363  return;
364
365 s->cb.change_state.cb.ncb    = cb;
366 s->cb.change_state.userdata  = userdata;
367}
368
369void pa_stream_set_state(pa_stream *s, pa_stream_state_t st) {
370 if ( s == NULL )
371  return;
372
373 s->state = st;
374
375 if ( s->cb.change_state.cb.ncb == NULL ) {
376  s->cb.change_state.cb.ncb(s, s->cb.change_state.userdata);
377 }
378}
379
380/** Set the callback function that is called when new data may be
381 * written to the stream. */
382void pa_stream_set_write_callback(pa_stream *p, pa_stream_request_cb_t cb, void *userdata) {
383 if ( p == NULL )
384  return;
385
386 p->cb.write.cb.rcb    = cb;
387 p->cb.write.userdata  = userdata;
388}
389
390/** Set the callback function that is called when new data is available from the stream.
391 * Return the number of bytes read. \since 0.8 */
392void pa_stream_set_read_callback(pa_stream *p, pa_stream_request_cb_t cb, void *userdata) {
393 if ( p == NULL )
394  return;
395
396 p->cb.read.cb.rcb    = cb;
397 p->cb.read.userdata  = userdata;
398}
399
400/** Set the callback function that is called when a buffer overflow happens. (Only for playback streams) \since 0.8 */
401void pa_stream_set_overflow_callback(pa_stream *p, pa_stream_notify_cb_t cb, void *userdata) {
402 if ( p == NULL )
403  return;
404
405 p->cb.overflow.cb.ncb    = cb;
406 p->cb.overflow.userdata  = userdata;
407}
408
409/** Set the callback function that is called when a buffer underflow happens. (Only for playback streams) \since 0.8 */
410void pa_stream_set_underflow_callback(pa_stream *p, pa_stream_notify_cb_t cb, void *userdata) {
411 if ( p == NULL )
412  return;
413
414 p->cb.underflow.cb.ncb    = cb;
415 p->cb.underflow.userdata  = userdata;
416}
417
418/** 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 */
419void pa_stream_set_latency_update_callback(pa_stream *p, pa_stream_notify_cb_t cb, void *userdata) {
420 if ( p == NULL )
421  return;
422
423 p->cb.latency.cb.ncb    = cb;
424 p->cb.latency.userdata  = userdata;
425}
426
427/** Pause (or resume) playback of this stream temporarily. Available on both playback and recording streams. \since 0.3 */
428pa_operation* pa_stream_cork(pa_stream *s, int b, pa_stream_success_cb_t cb, void *userdata);
429
430/** Flush the playback buffer of this stream. Most of the time you're
431 * better off using the parameter delta of pa_stream_write() instead of this
432 * function. Available on both playback and recording streams. \since 0.3 */
433pa_operation* pa_stream_flush(pa_stream *s, pa_stream_success_cb_t cb, void *userdata);
434/** Reenable prebuffering as specified in the pa_buffer_attr
435 * structure. Available for playback streams only. \since 0.6 */
436pa_operation* pa_stream_prebuf(pa_stream *s, pa_stream_success_cb_t cb, void *userdata);
437
438/** Request immediate start of playback on this stream. This disables
439 * prebuffering as specified in the pa_buffer_attr
440 * structure, temporarily. Available for playback streams only. \since 0.3 */
441pa_operation* pa_stream_trigger(pa_stream *s, pa_stream_success_cb_t cb, void *userdata);
442
443/** Rename the stream. \since 0.5 */
444pa_operation* pa_stream_set_name(pa_stream *s, const char *name, pa_stream_success_cb_t cb, void *userdata);
445
446/** Return the current playback/recording time. This is based on the
447 * data in the timing info structure returned by
448 * pa_stream_get_timing_info(). This function will usually only return
449 * new data if a timing info update has been recieved. Only if timing
450 * interpolation has been requested (PA_STREAM_INTERPOLATE_TIMING)
451 * the data from the last timing update is used for an estimation of
452 * the current playback/recording time based on the local time that
453 * passed since the timing info structure has been acquired. The time
454 * value returned by this function is guaranteed to increase
455 * monotonically. (that means: the returned value is always greater or
456 * equal to the value returned on the last call) This behaviour can
457 * be disabled by using PA_STREAM_NOT_MONOTONOUS. This may be
458 * desirable to deal better with bad estimations of transport
459 * latencies, but may have strange effects if the application is not
460 * able to deal with time going 'backwards'. \since 0.6 */
461int pa_stream_get_time(pa_stream *s, pa_usec_t *r_usec);
462
463/** Return the total stream latency. This function is based on
464 * pa_stream_get_time(). In case the stream is a monitoring stream the
465 * result can be negative, i.e. the captured samples are not yet
466 * played. In this case *negative is set to 1. \since 0.6 */
467int pa_stream_get_latency(pa_stream *s, pa_usec_t *r_usec, int *negative);
468
469/** Return the latest raw timing data structure. The returned pointer
470 * points to an internal read-only instance of the timing
471 * structure. The user should make a copy of this structure if he
472 * wants to modify it. An in-place update to this data structure may
473 * be requested using pa_stream_update_timing_info(). If no
474 * pa_stream_update_timing_info() call was issued before, this
475 * function will fail with PA_ERR_NODATA. Please note that the
476 * write_index member field (and only this field) is updated on each
477 * pa_stream_write() call, not just when a timing update has been
478 * recieved. \since 0.8 */
479const pa_timing_info* pa_stream_get_timing_info(pa_stream *s);
480
481/** Return a pointer to the stream's sample specification. \since 0.6 */
482const pa_sample_spec* pa_stream_get_sample_spec(pa_stream *s) {
483 if ( s == NULL )
484  return NULL;
485
486 return &(s->sspec);
487}
488
489/** Return a pointer to the stream's channel map. \since 0.8 */
490const pa_channel_map* pa_stream_get_channel_map(pa_stream *s);
491
492/** Return the buffer metrics of the stream. Only valid after the
493 * stream has been connected successfuly and if the server is at least
494 * PulseAudio 0.9. \since 0.9.0 */
495const pa_buffer_attr* pa_stream_get_buffer_attr(pa_stream *s);
496
497//ll
Note: See TracBrowser for help on using the repository browser.