source: roaraudio/libroarpulse/stream.c @ 3426:c3fe58581556

Last change on this file since 3426:c3fe58581556 was 3426:c3fe58581556, checked in by phi, 10 years ago

wrote pa_stream_get_index()

File size: 13.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 pa_stream {
42 size_t refc;
43 pa_context * c;
44 struct roar_vio_calls vio;
45 struct roar_stream stream;
46 pa_stream_state_t state;
47 struct {
48  pa_stream_notify_cb_t   change_state;
49  void                  * change_state_ud;
50 } cb;
51};
52
53typedef void pa_proplist;
54void pa_stream_set_state(pa_stream *s, pa_stream_state_t st);
55
56pa_stream* pa_stream_new_with_proplist(
57        pa_context *c                     ,
58        const char *name                  ,
59        const pa_sample_spec *ss          ,
60        const pa_channel_map *map         ,
61        pa_proplist *p                    );
62
63/** Create a new, unconnected stream with the specified name and sample type */
64pa_stream* pa_stream_new(
65        pa_context *c                     /**< The context to create this stream in */,
66        const char *name                  /**< A name for this stream */,
67        const pa_sample_spec *ss          /**< The desired sample format */,
68        const pa_channel_map *map         /**< The desired channel map, or NULL for default */) {
69 return pa_stream_new_with_proplist(c, name, ss, map, NULL);
70}
71
72pa_stream* pa_stream_new_with_proplist(
73        pa_context *c                     ,
74        const char *name                  ,
75        const pa_sample_spec *ss          ,
76        const pa_channel_map *map         ,
77        pa_proplist *p                    ) {
78 pa_stream * s;
79
80 if ( p != NULL )
81  return NULL;
82
83 if ( (s = roar_mm_malloc(sizeof(pa_stream))) == NULL )
84  return NULL;
85
86 memset(s, 0, sizeof(pa_stream));
87
88 if ( roar_pa_sspec2auinfo(&(s->stream.info), ss) == -1 ) {
89  roar_mm_free(s);
90  return NULL;
91 }
92
93 s->state = PA_STREAM_UNCONNECTED;
94 s->c     = c;
95 pa_context_ref(c);
96
97 return s;
98}
99
100static void _pa_stream_free(pa_stream * s) {
101 pa_stream_disconnect(s);
102 pa_context_unref(s->c);
103 roar_mm_free(s);
104}
105
106/** Decrease the reference counter by one */
107void pa_stream_unref(pa_stream *s) {
108 if ( s == NULL )
109  return;
110
111 s->refc--;
112
113 if (s->refc < 1 )
114  _pa_stream_free(s);
115}
116
117/** Increase the reference counter by one */
118pa_stream *pa_stream_ref(pa_stream *s) {
119 if ( s == NULL )
120  return NULL;
121
122 s->refc++;
123
124 return s;
125}
126
127/** Return the current state of the stream */
128pa_stream_state_t pa_stream_get_state(pa_stream *p) {
129 if ( p == NULL )
130  return PA_STREAM_FAILED;
131
132 return p->state;
133}
134
135/** Return the context this stream is attached to */
136pa_context* pa_stream_get_context(pa_stream *p) {
137 if ( p == NULL )
138  return NULL;
139
140 return p->c;
141}
142
143/** Return the device (sink input or source output) index this stream is connected to */
144uint32_t pa_stream_get_index(pa_stream *s) {
145 return 0;
146}
147
148/** Connect the stream to a sink */
149int pa_stream_connect_playback(
150        pa_stream *s                  /**< The stream to connect to a sink */,
151        const char *dev               /**< Name of the sink to connect to, or NULL for default */ ,
152        const pa_buffer_attr *attr    /**< Buffering attributes, or NULL for default */,
153        pa_stream_flags_t flags       /**< Additional flags, or 0 for default */,
154        pa_cvolume *volume            /**< Initial volume, or NULL for default */,
155        pa_stream *sync_stream        /**< Synchronize this stream with the specified one, or NULL for a standalone stream*/);
156
157/** Connect the stream to a source */
158int pa_stream_connect_record(
159        pa_stream *s                  /**< The stream to connect to a source */ ,
160        const char *dev               /**< Name of the source to connect to, or NULL for default */,
161        const pa_buffer_attr *attr    /**< Buffer attributes, or NULL for default */,
162        pa_stream_flags_t flags       /**< Additional flags, or 0 for default */);
163
164/** Disconnect a stream from a source/sink */
165int pa_stream_disconnect(pa_stream *s) {
166 if ( s == NULL )
167  return -1;
168
169 if ( s->state != PA_STREAM_READY )
170  return -1;
171
172 roar_vio_close(&(s->vio));
173
174 pa_stream_set_state(s, PA_STREAM_TERMINATED);
175
176 return 0;
177}
178
179/** Write some data to the server (for playback sinks), if free_cb is
180 * non-NULL this routine is called when all data has been written out
181 * and an internal reference to the specified data is kept, the data
182 * is not copied. If NULL, the data is copied into an internal
183 * buffer. The client my freely seek around in the output buffer. For
184 * most applications passing 0 and PA_SEEK_RELATIVE as arguments for
185 * offset and seek should be useful.*/
186int pa_stream_write(
187        pa_stream *p             /**< The stream to use */,
188        const void *data         /**< The data to write */,
189        size_t length            /**< The length of the data to write */,
190        pa_free_cb_t free_cb     /**< A cleanup routine for the data or NULL to request an internal copy */,
191        int64_t offset,          /**< Offset for seeking, must be 0 for upload streams */
192        pa_seek_mode_t seek      /**< Seek mode, must be PA_SEEK_RELATIVE for upload streams */);
193
194/** Read the next fragment from the buffer (for recording).
195 * data will point to the actual data and length will contain the size
196 * of the data in bytes (which can be less than a complete framgnet).
197 * Use pa_stream_drop() to actually remove the data from the
198 * buffer. If no data is available will return a NULL pointer  \since 0.8 */
199int pa_stream_peek(
200        pa_stream *p                 /**< The stream to use */,
201        const void **data            /**< Pointer to pointer that will point to data */,
202        size_t *length              /**< The length of the data read */);
203
204/** Remove the current fragment on record streams. It is invalid to do this without first
205 * calling pa_stream_peek(). \since 0.8 */
206int pa_stream_drop(pa_stream *p);
207
208/** Return the nember of bytes that may be written using pa_stream_write() */
209size_t pa_stream_writable_size(pa_stream *p);
210
211/** Return the number of bytes that may be read using pa_stream_read() \since 0.8 */
212size_t pa_stream_readable_size(pa_stream *p);
213
214/** Drain a playback stream. Use this for notification when the buffer is empty */
215pa_operation* pa_stream_drain(pa_stream *s, pa_stream_success_cb_t cb, void *userdata);
216
217/** Request a timing info structure update for a stream. Use
218 * pa_stream_get_timing_info() to get access to the raw timing data,
219 * or pa_stream_get_time() or pa_stream_get_latency() to get cleaned
220 * up values. */
221pa_operation* pa_stream_update_timing_info(pa_stream *p, pa_stream_success_cb_t cb, void *userdata);
222
223/** Set the callback function that is called whenever the state of the stream changes */
224void pa_stream_set_state_callback(pa_stream *s, pa_stream_notify_cb_t cb, void *userdata) {
225 if ( s == NULL )
226  return;
227
228 s->cb.change_state    = cb;
229 s->cb.change_state_ud = userdata;
230}
231
232void pa_stream_set_state(pa_stream *s, pa_stream_state_t st) {
233 if ( s == NULL )
234  return;
235
236 s->state = st;
237
238 if ( s->cb.change_state == NULL ) {
239  s->cb.change_state(s, s->cb.change_state_ud);
240 }
241}
242
243/** Set the callback function that is called when new data may be
244 * written to the stream. */
245void pa_stream_set_write_callback(pa_stream *p, pa_stream_request_cb_t cb, void *userdata);
246
247/** Set the callback function that is called when new data is available from the stream.
248 * Return the number of bytes read. \since 0.8 */
249void pa_stream_set_read_callback(pa_stream *p, pa_stream_request_cb_t cb, void *userdata);
250
251/** Set the callback function that is called when a buffer overflow happens. (Only for playback streams) \since 0.8 */
252void pa_stream_set_overflow_callback(pa_stream *p, pa_stream_notify_cb_t cb, void *userdata);
253
254/** Set the callback function that is called when a buffer underflow happens. (Only for playback streams) \since 0.8 */
255void pa_stream_set_underflow_callback(pa_stream *p, pa_stream_notify_cb_t cb, void *userdata);
256
257/** 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 */
258void pa_stream_set_latency_update_callback(pa_stream *p, pa_stream_notify_cb_t cb, void *userdata);
259
260/** Pause (or resume) playback of this stream temporarily. Available on both playback and recording streams. \since 0.3 */
261pa_operation* pa_stream_cork(pa_stream *s, int b, pa_stream_success_cb_t cb, void *userdata);
262
263/** Flush the playback buffer of this stream. Most of the time you're
264 * better off using the parameter delta of pa_stream_write() instead of this
265 * function. Available on both playback and recording streams. \since 0.3 */
266pa_operation* pa_stream_flush(pa_stream *s, pa_stream_success_cb_t cb, void *userdata);
267/** Reenable prebuffering as specified in the pa_buffer_attr
268 * structure. Available for playback streams only. \since 0.6 */
269pa_operation* pa_stream_prebuf(pa_stream *s, pa_stream_success_cb_t cb, void *userdata);
270
271/** Request immediate start of playback on this stream. This disables
272 * prebuffering as specified in the pa_buffer_attr
273 * structure, temporarily. Available for playback streams only. \since 0.3 */
274pa_operation* pa_stream_trigger(pa_stream *s, pa_stream_success_cb_t cb, void *userdata);
275
276/** Rename the stream. \since 0.5 */
277pa_operation* pa_stream_set_name(pa_stream *s, const char *name, pa_stream_success_cb_t cb, void *userdata);
278
279/** Return the current playback/recording time. This is based on the
280 * data in the timing info structure returned by
281 * pa_stream_get_timing_info(). This function will usually only return
282 * new data if a timing info update has been recieved. Only if timing
283 * interpolation has been requested (PA_STREAM_INTERPOLATE_TIMING)
284 * the data from the last timing update is used for an estimation of
285 * the current playback/recording time based on the local time that
286 * passed since the timing info structure has been acquired. The time
287 * value returned by this function is guaranteed to increase
288 * monotonically. (that means: the returned value is always greater or
289 * equal to the value returned on the last call) This behaviour can
290 * be disabled by using PA_STREAM_NOT_MONOTONOUS. This may be
291 * desirable to deal better with bad estimations of transport
292 * latencies, but may have strange effects if the application is not
293 * able to deal with time going 'backwards'. \since 0.6 */
294int pa_stream_get_time(pa_stream *s, pa_usec_t *r_usec);
295
296/** Return the total stream latency. This function is based on
297 * pa_stream_get_time(). In case the stream is a monitoring stream the
298 * result can be negative, i.e. the captured samples are not yet
299 * played. In this case *negative is set to 1. \since 0.6 */
300int pa_stream_get_latency(pa_stream *s, pa_usec_t *r_usec, int *negative);
301
302/** Return the latest raw timing data structure. The returned pointer
303 * points to an internal read-only instance of the timing
304 * structure. The user should make a copy of this structure if he
305 * wants to modify it. An in-place update to this data structure may
306 * be requested using pa_stream_update_timing_info(). If no
307 * pa_stream_update_timing_info() call was issued before, this
308 * function will fail with PA_ERR_NODATA. Please note that the
309 * write_index member field (and only this field) is updated on each
310 * pa_stream_write() call, not just when a timing update has been
311 * recieved. \since 0.8 */
312const pa_timing_info* pa_stream_get_timing_info(pa_stream *s);
313
314/** Return a pointer to the stream's sample specification. \since 0.6 */
315const pa_sample_spec* pa_stream_get_sample_spec(pa_stream *s);
316
317/** Return a pointer to the stream's channel map. \since 0.8 */
318const pa_channel_map* pa_stream_get_channel_map(pa_stream *s);
319
320/** Return the buffer metrics of the stream. Only valid after the
321 * stream has been connected successfuly and if the server is at least
322 * PulseAudio 0.9. \since 0.9.0 */
323const pa_buffer_attr* pa_stream_get_buffer_attr(pa_stream *s);
324
325//ll
Note: See TracBrowser for help on using the repository browser.