4 This file is part of polypaudio.
6 polypaudio is free software; you can redistribute it and/or modify
7 it under the terms of the GNU Lesser General Public License as published
8 by the Free Software Foundation; either version 2 of the License,
9 or (at your option) any later version.
11 polypaudio is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public License
17 along with polypaudio; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
31 #include "polyplib-simple.h"
34 #include "native-common.h"
39 pa_mainloop
*mainloop
;
42 pa_stream_direction_t direction
;
47 size_t read_index
, read_length
;
51 static void read_callback(pa_stream
*s
, const void*data
, size_t length
, void *userdata
);
53 static int check_error(pa_simple
*p
, int *rerror
) {
54 pa_context_state_t cst
;
55 pa_stream_state_t sst
;
58 if ((cst
= pa_context_get_state(p
->context
)) == PA_CONTEXT_FAILED
)
61 assert(cst
!= PA_CONTEXT_TERMINATED
);
64 if ((sst
= pa_stream_get_state(p
->stream
)) == PA_STREAM_FAILED
)
67 assert(sst
!= PA_STREAM_TERMINATED
);
74 *rerror
= pa_context_errno(p
->context
);
81 static int iterate(pa_simple
*p
, int block
, int *rerror
) {
82 assert(p
&& p
->context
&& p
->mainloop
);
84 if (check_error(p
, rerror
) < 0)
87 if (!block
&& !pa_context_is_pending(p
->context
))
91 if (pa_mainloop_iterate(p
->mainloop
, 1, NULL
) < 0) {
93 *rerror
= PA_ERROR_INTERNAL
;
97 if (check_error(p
, rerror
) < 0)
100 } while (pa_context_is_pending(p
->context
));
103 while (pa_mainloop_deferred_pending(p
->mainloop
)) {
105 if (pa_mainloop_iterate(p
->mainloop
, 0, NULL
) < 0) {
107 *rerror
= PA_ERROR_INTERNAL
;
111 if (check_error(p
, rerror
) < 0)
118 pa_simple
* pa_simple_new(
121 pa_stream_direction_t dir
,
123 const char *stream_name
,
124 const pa_sample_spec
*ss
,
125 const pa_buffer_attr
*attr
,
129 int error
= PA_ERROR_INTERNAL
;
130 assert(ss
&& (dir
== PA_STREAM_PLAYBACK
|| dir
== PA_STREAM_RECORD
));
132 p
= pa_xmalloc(sizeof(pa_simple
));
135 p
->mainloop
= pa_mainloop_new();
140 p
->read_index
= p
->read_length
= 0;
143 if (!(p
->context
= pa_context_new(pa_mainloop_get_api(p
->mainloop
), name
)))
146 pa_context_connect(p
->context
, server
, 1, NULL
);
148 /* Wait until the context is ready */
149 while (pa_context_get_state(p
->context
) != PA_CONTEXT_READY
) {
150 if (iterate(p
, 1, &error
) < 0)
154 if (!(p
->stream
= pa_stream_new(p
->context
, stream_name
, ss
, NULL
)))
157 if (dir
== PA_STREAM_PLAYBACK
)
158 pa_stream_connect_playback(p
->stream
, dev
, attr
, 0, NULL
);
160 pa_stream_connect_record(p
->stream
, dev
, attr
, 0);
162 /* Wait until the stream is ready */
163 while (pa_stream_get_state(p
->stream
) != PA_STREAM_READY
) {
164 if (iterate(p
, 1, &error
) < 0)
168 pa_stream_set_read_callback(p
->stream
, read_callback
, p
);
179 void pa_simple_free(pa_simple
*s
) {
182 pa_xfree(s
->read_data
);
185 pa_stream_unref(s
->stream
);
188 pa_context_unref(s
->context
);
191 pa_mainloop_free(s
->mainloop
);
196 int pa_simple_write(pa_simple
*p
, const void*data
, size_t length
, int *rerror
) {
197 assert(p
&& data
&& p
->direction
== PA_STREAM_PLAYBACK
);
201 *rerror
= pa_context_errno(p
->context
);
209 while (!(l
= pa_stream_writable_size(p
->stream
)))
210 if (iterate(p
, 1, rerror
) < 0)
216 pa_stream_write(p
->stream
, data
, l
, NULL
, 0);
217 data
= (const uint8_t*) data
+ l
;
221 /* Make sure that no data is pending for write */
222 if (iterate(p
, 0, rerror
) < 0)
228 static void read_callback(pa_stream
*s
, const void*data
, size_t length
, void *userdata
) {
229 pa_simple
*p
= userdata
;
230 assert(s
&& data
&& length
&& p
);
233 pa_log(__FILE__
": Buffer overflow, dropping incoming memory blocks.\n");
234 pa_xfree(p
->read_data
);
237 p
->read_data
= pa_xmemdup(data
, p
->read_length
= length
);
241 int pa_simple_read(pa_simple
*p
, void*data
, size_t length
, int *rerror
) {
242 assert(p
&& data
&& p
->direction
== PA_STREAM_RECORD
);
246 *rerror
= pa_context_errno(p
->context
);
255 if (p
->read_length
<= l
)
258 memcpy(data
, (uint8_t*) p
->read_data
+p
->read_index
, l
);
260 data
= (uint8_t*) data
+ l
;
266 if (!p
->read_length
) {
267 pa_xfree(p
->read_data
);
275 assert(!p
->read_data
);
278 if (iterate(p
, 1, rerror
) < 0)
285 static void drain_or_flush_complete(pa_stream
*s
, int success
, void *userdata
) {
286 pa_simple
*p
= userdata
;
292 int pa_simple_drain(pa_simple
*p
, int *rerror
) {
294 assert(p
&& p
->direction
== PA_STREAM_PLAYBACK
);
298 *rerror
= pa_context_errno(p
->context
);
303 o
= pa_stream_drain(p
->stream
, drain_or_flush_complete
, p
);
305 while (pa_operation_get_state(o
) == PA_OPERATION_RUNNING
) {
306 if (iterate(p
, 1, rerror
) < 0) {
307 pa_operation_cancel(o
);
308 pa_operation_unref(o
);
313 pa_operation_unref(o
);
315 if (p
->dead
&& rerror
)
316 *rerror
= pa_context_errno(p
->context
);
318 return p
->dead
? -1 : 0;
321 static void latency_complete(pa_stream
*s
, const pa_latency_info
*l
, void *userdata
) {
322 pa_simple
*p
= userdata
;
329 p
->latency
= pa_stream_get_latency(s
, l
, &negative
);
335 pa_usec_t
pa_simple_get_playback_latency(pa_simple
*p
, int *rerror
) {
337 assert(p
&& p
->direction
== PA_STREAM_PLAYBACK
);
341 *rerror
= pa_context_errno(p
->context
);
343 return (pa_usec_t
) -1;
347 o
= pa_stream_get_latency_info(p
->stream
, latency_complete
, p
);
349 while (pa_operation_get_state(o
) == PA_OPERATION_RUNNING
) {
351 if (iterate(p
, 1, rerror
) < 0) {
352 pa_operation_cancel(o
);
353 pa_operation_unref(o
);
358 pa_operation_unref(o
);
360 if (p
->dead
&& rerror
)
361 *rerror
= pa_context_errno(p
->context
);
363 return p
->dead
? (pa_usec_t
) -1 : p
->latency
;
366 int pa_simple_flush(pa_simple
*p
, int *rerror
) {
368 assert(p
&& p
->direction
== PA_STREAM_PLAYBACK
);
372 *rerror
= pa_context_errno(p
->context
);
377 o
= pa_stream_flush(p
->stream
, drain_or_flush_complete
, p
);
379 while (pa_operation_get_state(o
) == PA_OPERATION_RUNNING
) {
380 if (iterate(p
, 1, rerror
) < 0) {
381 pa_operation_cancel(o
);
382 pa_operation_unref(o
);
387 pa_operation_unref(o
);
389 if (p
->dead
&& rerror
)
390 *rerror
= pa_context_errno(p
->context
);
392 return p
->dead
? -1 : 0;