1) Add flexible seeking support (including absolute) for memory block queues and playback streams

2) Add support to synchronize multiple playback streams
3) add two tests for 1) and 2)
4) s/PA_ERROR/PA_ERR/
5) s/PA_ERROR_OK/PA_OK/
6) update simple API to deal properly with new peek/drop recording API
7) add beginnings of proper validity checking on API calls in client libs (needs to be extended)
8) report playback buffer overflows/underflows to the client
9) move client side recording mcalign stuff into the memblockq 
10) create typedefs for a bunch of API callback prototypes
11) simplify handling of HUP poll() events

Yes, i know, it's usually better to commit a lot of small patches instead of a
single big one. In this case however, this would have contradicted the other
rule: never commit broken or incomplete stuff.

*** This stuff needs a lot of additional testing! ***


git-svn-id: file:///home/lennart/svn/public/pulseaudio/trunk@511 fefdeb5f-60dc-0310-8127-8f9354f1896f

1 files changed, 17 insertions, 28 deletions

diff --git a/src/polypcore/iochannel.c b/src/polypcore/iochannel.c
index 7fd09152..c33f593e 100644
--- a/src/polypcore/iochannel.c
+++ b/src/polypcore/iochannel.c
@@ -59,17 +59,17 @@ static void enable_mainloop_sources(pa_iochannel *io) {
         pa_io_event_flags_t f = PA_IO_EVENT_NULL;
         assert(io->input_event);
         
-        if (!io->readable)
+        if (!pa_iochannel_is_readable(io))
             f |= PA_IO_EVENT_INPUT;
-        if (!io->writable)
+        if (!pa_iochannel_is_writable(io))
             f |= PA_IO_EVENT_OUTPUT;
 
         io->mainloop->io_enable(io->input_event, f);
     } else {
         if (io->input_event)
-            io->mainloop->io_enable(io->input_event, io->readable ? PA_IO_EVENT_NULL : PA_IO_EVENT_INPUT);
+            io->mainloop->io_enable(io->input_event, pa_iochannel_is_readable(io) ? PA_IO_EVENT_NULL : PA_IO_EVENT_INPUT);
         if (io->output_event)
-            io->mainloop->io_enable(io->output_event, io->writable ? PA_IO_EVENT_NULL : PA_IO_EVENT_OUTPUT);
+            io->mainloop->io_enable(io->output_event, pa_iochannel_is_writable(io) ? PA_IO_EVENT_NULL : PA_IO_EVENT_OUTPUT);
     }
 }
 
@@ -82,33 +82,21 @@ static void callback(pa_mainloop_api* m, pa_io_event *e, int fd, pa_io_event_fla
     assert(fd >= 0);
     assert(userdata);
 
-    if ((f & (PA_IO_EVENT_HANGUP|PA_IO_EVENT_ERROR)) && !io->hungup) {
+    if ((f & (PA_IO_EVENT_HANGUP|PA_IO_EVENT_ERROR)) & !io->hungup) {
         io->hungup = 1;
         changed = 1;
+    }
 
-        if (e == io->input_event) {
-            io->mainloop->io_free(io->input_event);
-            io->input_event = NULL;
-
-            if (io->output_event == e)
-                io->output_event = NULL;
-        } else if (e == io->output_event) {
-            io->mainloop->io_free(io->output_event);
-            io->output_event = NULL;
-        }
-    } else {
-
-        if ((f & PA_IO_EVENT_INPUT) && !io->readable) {
-            io->readable = 1;
-            changed = 1;
-            assert(e == io->input_event);
-        }
-        
-        if ((f & PA_IO_EVENT_OUTPUT) && !io->writable) {
-            io->writable = 1;
-            changed = 1;
-            assert(e == io->output_event);
-        }
+    if ((f & PA_IO_EVENT_INPUT) && !io->readable) {
+        io->readable = 1;
+        changed = 1;
+        assert(e == io->input_event);
+    }
+    
+    if ((f & PA_IO_EVENT_OUTPUT) && !io->writable) {
+        io->writable = 1;
+        changed = 1;
+        assert(e == io->output_event);
     }
 
     if (changed) {
@@ -217,6 +205,7 @@ ssize_t pa_iochannel_write(pa_iochannel*io, const void*data, size_t l) {
     if (r < 0)
 #endif
         r = write(io->ofd, data, l);
+
     if (r >= 0) {
         io->writable = 0;
         enable_mainloop_sources(io);