Changeset 5276:0eb24ca6810e in roaraudio

Timestamp:

11/20/11 18:36:49 (12 years ago)

Author:

phi

Branch:

default

Phase:

public

Message:

merged VIO's _nonblock() into _ctl() (Closes: #135)

Files:

• ChangeLog (modified) (1 diff)
• include/libroar/vio.h (modified) (3 diffs)
• include/libroar/vio_ctl.h (modified) (1 diff)
• include/libroar/vio_winsock.h (modified) (1 diff)
• libroar/vio.c (modified) (8 diffs)
• libroar/vio_buffer.c (modified) (3 diffs)
• libroar/vio_buffer_store.c (modified) (3 diffs)
• libroar/vio_cmd.c (modified) (5 diffs)
• libroar/vio_jumbo.c (modified) (3 diffs)
• libroar/vio_misc.c (modified) (3 diffs)
• libroar/vio_pipe.c (modified) (5 diffs)
• libroar/vio_proto.c (modified) (2 diffs)
• libroar/vio_rtp.c (modified) (2 diffs)
• libroar/vio_stack.c (modified) (2 diffs)
• libroar/vio_stdvios.c (modified) (3 diffs)
• libroar/vio_stream.c (modified) (3 diffs)
• libroar/vio_winsock.c (modified) (2 diffs)
• libroar/vio_zlib.c (modified) (3 diffs)
• roard/container_framework.c (modified) (3 diffs)
• roard/driver.c (modified) (1 diff)
• roard/driver_alsa.c (modified) (2 diffs)
• roard/driver_ao.c (modified) (1 diff)
• roard/driver_artsc.c (modified) (3 diffs)
• roard/driver_jack.c (modified) (3 diffs)
• roard/driver_oss.c (modified) (3 diffs)
• roard/driver_portaudio.c (modified) (1 diff)
• roard/driver_pulsesimple.c (modified) (2 diffs)
• roard/driver_pwmled.c (modified) (1 diff)
• roard/driver_rsound.c (modified) (1 diff)
• roard/driver_shout.c (modified) (1 diff)
• roard/driver_sndio.c (modified) (1 diff)
• roard/driver_sysclock.c (modified) (1 diff)
• roard/driver_wmm.c (modified) (1 diff)
• roard/include/driver.h (modified) (1 diff)
• roard/include/driver_oss.h (modified) (1 diff)
• roard/include/midi.h (modified) (1 diff)
• roard/midi.c (modified) (2 diffs)
• roard/sources.c (modified) (2 diffs)

ChangeLog

@@ -1 +1 @@
 v. 1.0beta0 - ?
-        * Updated API (SONAME change) (Closes: #184, #185, #128)
+        * Updated API (SONAME change) (Closes: #184, #185, #128, #135)
         * Do not set errno to zero in ogg_vorbis codec filter (Closes: #191)
         * Updated data types for struct roar_audio_info (Closes: #189)

include/libroar/vio.h

@@ -53 +53 @@
  ssize_t (*write   )(struct roar_vio_calls * vio, void *buf, size_t count);
  off_t   (*lseek   )(struct roar_vio_calls * vio, off_t offset, int whence);
- int     (*nonblock)(struct roar_vio_calls * vio, int state);
+// int     (*nonblock)(struct roar_vio_calls * vio, int state);
  int     (*sync    )(struct roar_vio_calls * vio);
  int     (*ctl     )(struct roar_vio_calls * vio, int cmd, void * data);
@@ -104 +104 @@
 ssize_t roar_vio_basic_write   (struct roar_vio_calls * vio, void *buf, size_t count);
 off_t   roar_vio_basic_lseek   (struct roar_vio_calls * vio, off_t offset, int whence);
-int     roar_vio_basic_nonblock(struct roar_vio_calls * vio, int state);
 int     roar_vio_basic_sync    (struct roar_vio_calls * vio);
 int     roar_vio_basic_ctl     (struct roar_vio_calls * vio, int cmd, void * data);
@@ -120 +119 @@
 ssize_t roar_vio_pass_write   (struct roar_vio_calls * vio, void *buf, size_t count);
 off_t   roar_vio_pass_lseek   (struct roar_vio_calls * vio, off_t offset, int whence);
-int     roar_vio_pass_nonblock(struct roar_vio_calls * vio, int state);
 int     roar_vio_pass_sync    (struct roar_vio_calls * vio);
 int     roar_vio_pass_ctl     (struct roar_vio_calls * vio, int cmd, void * data);

include/libroar/vio_ctl.h

@@ -99 +99 @@
 #define ROAR_VIO_CTL_GET_USERPASS        (ROAR_VIO_CTL_GENERIC|ROAR_VIO_CTL_SET|0x0194)
 #define ROAR_VIO_CTL_SET_USERPASS        (ROAR_VIO_CTL_GENERIC|ROAR_VIO_CTL_SET|0x0194)
-// NOTE: continue with 0x01A0 from here.
+
+// Implement roar_vio_nonblock()...
+#define ROAR_VIO_CTL_NONBLOCK            (ROAR_VIO_CTL_GENERIC|0x01A0) /* roar_vio_nonblock(), int */
 
 // get or set data format used for read and write calls, see below

include/libroar/vio_winsock.h

@@ -42 +42 @@
 ssize_t roar_vio_winsock_read    (struct roar_vio_calls * vio, void *buf, size_t count);
 ssize_t roar_vio_winsock_write   (struct roar_vio_calls * vio, void *buf, size_t count);
-int     roar_vio_winsock_nonblock(struct roar_vio_calls * vio, int state);
 int     roar_vio_winsock_sync    (struct roar_vio_calls * vio);
 int     roar_vio_winsock_ctl     (struct roar_vio_calls * vio, int cmd, void * data);

libroar/vio.c

@@ -65 +65 @@
  calls->write    = roar_vio_basic_write;
  calls->lseek    = roar_vio_basic_lseek;
- calls->nonblock = roar_vio_basic_nonblock;
  calls->sync     = roar_vio_basic_sync;
  calls->ctl      = roar_vio_basic_ctl;
@@ -179 +178 @@
 
 int     roar_vio_nonblock(struct roar_vio_calls * vio, int state) {
- int ret;
-
  ROAR_DBG("roar_vio_nonblock(vio=%p, state=%i) = ?", vio, state);
 
@@ -188 +185 @@
  }
 
- if ( vio->nonblock == NULL ) {
-  roar_err_set(ROAR_ERROR_NOSYS);
-  return -1;
- }
-
- roar_err_clear_all();
- ret = vio->nonblock(vio, state);
- roar_err_update();
-
- return ret;
+ return roar_vio_ctl(vio, ROAR_VIO_CTL_NONBLOCK, &state);
 }
 
@@ -346 +334 @@
  calls->read     = roar_vio_winsock_read;
  calls->write    = roar_vio_winsock_write;
- calls->nonblock = roar_vio_winsock_nonblock;
  calls->sync     = roar_vio_winsock_sync;
  calls->ctl      = roar_vio_winsock_ctl;
@@ -414 +401 @@
  return -1;
 #endif
-}
-
-int     roar_vio_basic_nonblock(struct roar_vio_calls * vio, int state) {
- if ( roar_socket_nonblock(roar_vio_get_fh(vio), state) == -1 )
-  return -1;
-
- if ( state == ROAR_SOCKET_NONBLOCK )
-  return 0;
-
- roar_vio_sync(vio);
-
- return 0;
 }
 
@@ -666 +641 @@
    break;
 #endif
+  case ROAR_VIO_CTL_NONBLOCK:
+    if ( roar_socket_nonblock(roar_vio_get_fh(vio), *(int*)data) == -1 )
+     return -1;
+
+    if ( *(int*)data == ROAR_SOCKET_NONBLOCK )
+     return 0;
+
+    roar_vio_sync(vio);
+    return 0;
+   break;
  }
 
@@ -713 +698 @@
  calls->write    = roar_vio_pass_write;
  calls->lseek    = roar_vio_pass_lseek;
- calls->nonblock = roar_vio_pass_nonblock;
  calls->sync     = roar_vio_pass_sync;
  calls->ctl      = roar_vio_pass_ctl;
@@ -733 +717 @@
 off_t   roar_vio_pass_lseek(struct roar_vio_calls * vio, off_t offset, int whence) {
  return roar_vio_lseek((struct roar_vio_calls *) vio->inst, offset, whence);
-}
-
-int     roar_vio_pass_nonblock(struct roar_vio_calls * vio, int state) {
- return roar_vio_nonblock((struct roar_vio_calls *) vio->inst, state);
 }
 

libroar/vio_buffer.c

@@ -63 +63 @@
  calls->close    = roar_vio_buffer_close;
  calls->write    = roar_vio_buffer_write;
- calls->nonblock = roar_vio_buffer_nonblock;
  calls->ctl      = roar_vio_buffer_ctl;
  calls->sync     = roar_vio_buffer_sync;
@@ -327 +326 @@
     return 0;
    break;
+  case ROAR_VIO_CTL_NONBLOCK:
+    if ( self->use_re ) {
+     return roar_vio_ctl(&(self->re_vio), ROAR_VIO_CTL_NONBLOCK, data);
+    } else {
+     return roar_vio_ctl(self->backend, ROAR_VIO_CTL_NONBLOCK, data);
+    }
+   break;
  }
 
@@ -342 +348 @@
 }
 
-int     roar_vio_buffer_nonblock(struct roar_vio_calls * vio, int state) {
- struct roar_vio_buffer * self = vio->inst;
-
- if ( self->use_re ) {
-  return roar_vio_nonblock(&(self->re_vio), state);
- } else {
-  return roar_vio_nonblock(self->backend, state);
- }
-}
-
 //ll

libroar/vio_buffer_store.c

@@ -56 +56 @@
  calls->inst     = self;
  calls->close    = roar_vio_buffer_store_close;
- calls->nonblock = roar_vio_buffer_store_nonblock;
  calls->sync     = roar_vio_buffer_store_sync;
  calls->ctl      = roar_vio_buffer_store_ctl;
@@ -138 +137 @@
 }
 
-int     roar_vio_buffer_store_nonblock(struct roar_vio_calls * vio, int state) {
- return 0; // if we are in nonblock or not is the same for us.
-}
-
 int     roar_vio_buffer_store_sync    (struct roar_vio_calls * vio) {
  return 0; // we are always sync.
@@ -160 +155 @@
     return 0;
    break;
+  case ROAR_VIO_CTL_NONBLOCK:
+    return 0; // if we are in nonblock or not is the same for us.
+   break;
  }
 

libroar/vio_cmd.c

@@ -80 +80 @@
  calls->read     = roar_vio_cmd_read;
  calls->write    = roar_vio_cmd_write;
- calls->nonblock = roar_vio_cmd_nonblock;
  calls->sync     = roar_vio_cmd_sync;
  calls->ctl      = roar_vio_cmd_ctl;
@@ -514 +513 @@
 }
 
-int     roar_vio_cmd_nonblock(struct roar_vio_calls * vio, int state) {
- struct roar_vio_cmd_state * self = (struct roar_vio_cmd_state *)vio->inst;
-
- self->options |= ROAR_VIO_CMD_OPTS_NONBLOCK;
-
- if ( state == ROAR_SOCKET_BLOCK )
-  self->options -= ROAR_VIO_CMD_OPTS_NONBLOCK;
-
- _LIBROAR_IGNORE_RET(roar_vio_nonblock(self->next, state)); // this should help, but may not nessessery.
-
- return 0;
-}
-
 int     roar_vio_cmd_sync    (struct roar_vio_calls * vio) {
  struct roar_vio_cmd_state * state = (struct roar_vio_cmd_state *)vio->inst;
+ int newblock = ROAR_SOCKET_BLOCK;
  int oldblock;
  int ret = 0;
@@ -534 +521 @@
  oldblock = state->options & ROAR_VIO_CMD_OPTS_NONBLOCK ? ROAR_SOCKET_NONBLOCK : ROAR_SOCKET_BLOCK;
 
- if ( roar_vio_cmd_nonblock(vio, ROAR_SOCKET_BLOCK) == -1 )
+ if ( roar_vio_cmd_ctl(vio, ROAR_VIO_CTL_NONBLOCK, &newblock) == -1 )
   return -1;
 
@@ -543 +530 @@
   ret = -1;
 
- if ( roar_vio_cmd_nonblock(vio, oldblock) == -1 )
+ if ( roar_vio_cmd_ctl(vio, ROAR_VIO_CTL_NONBLOCK, &oldblock) == -1 )
   return -1;
 
@@ -586 +573 @@
     return -1;
    break;
+  case ROAR_VIO_CTL_NONBLOCK:
+    state->options |= ROAR_VIO_CMD_OPTS_NONBLOCK;
+
+    if ( *(int*)data == ROAR_SOCKET_BLOCK )
+     state->options -= ROAR_VIO_CMD_OPTS_NONBLOCK;
+
+    _LIBROAR_IGNORE_RET(roar_vio_ctl(state->next, cmd, data)); // this should help, but may not necessarily.
+   break;
   default:
     return -1;

libroar/vio_jumbo.c

@@ -58 +58 @@
  calls->write    = roar_vio_jumbo_write;
  calls->lseek    = roar_vio_jumbo_lseek;
- calls->nonblock = roar_vio_jumbo_nonblock;
  calls->sync     = roar_vio_jumbo_sync;
  calls->ctl      = roar_vio_jumbo_ctl;
@@ -130 +129 @@
 }
 
-int     roar_vio_jumbo_nonblock(struct roar_vio_calls * vio, int state) {
- struct roar_vio_jumbo * self = vio->inst;
-
- return roar_vio_nonblock(self->backend, state);
-}
-
 int     roar_vio_jumbo_sync    (struct roar_vio_calls * vio) {
  struct roar_vio_jumbo * self = vio->inst;
@@ -156 +149 @@
 
 int     roar_vio_jumbo_ctl     (struct roar_vio_calls * vio, int cmd, void * data) {
+ struct roar_vio_jumbo * self = vio->inst;
+
+ switch (cmd) {
+  case ROAR_VIO_CTL_NONBLOCK:
+    return roar_vio_ctl(self->backend, cmd, data);
+   break;
+ }
+
+ roar_err_set(ROAR_ERROR_BADRQC);
  return -1;
 }

libroar/vio_misc.c

@@ -59 +59 @@
 }
 
-static int     roar_vio_misc_nonblock(struct roar_vio_calls * vio, int state) {
- struct roar_vio_misc * self = vio->inst;
-
- if ( self->support_nonblocking )
-  return 0;
-
- if ( state == ROAR_SOCKET_BLOCK )
-  return 0;
-
- return -1;
-}
-
 static int     roar_vio_misc_sync    (struct roar_vio_calls * vio) {
  (void)vio;
@@ -94 +82 @@
     return 0;
    break;
+  case ROAR_VIO_CTL_NONBLOCK:
+    if ( self->support_nonblocking )
+     return 0;
+
+    if ( *(int*)data == ROAR_SOCKET_BLOCK )
+     return 0;
+
+    return -1;
+   break; 
  }
 
@@ -112 +109 @@
  calls->write    = roar_vio_misc_write;
  calls->lseek    = roar_vio_misc_lseek;
- calls->nonblock = roar_vio_misc_nonblock;
  calls->sync     = roar_vio_misc_sync;
  calls->ctl      = roar_vio_misc_ctl;

libroar/vio_pipe.c

@@ -119 +119 @@
 #ifndef ROAR_WITHOUT_VIO_PIPE
 int roar_vio_pipe_init (struct roar_vio_calls * s,  struct roar_vio_pipe * self, int flags) {
+ int nonblock = ROAR_SOCKET_NONBLOCK;
+
  if ( s == NULL || self == NULL )
   return -1;
@@ -127 +129 @@
  s->read     = roar_vio_pipe_read;
  s->write    = roar_vio_pipe_write;
- s->nonblock = roar_vio_pipe_nonblock;
  s->sync     = roar_vio_pipe_sync;
 
@@ -133 +134 @@
 
  if ( flags & O_NONBLOCK ) {
-  roar_vio_pipe_nonblock(s, ROAR_SOCKET_NONBLOCK);
+  roar_vio_pipe_ctl(s, ROAR_VIO_CTL_NONBLOCK, &nonblock);
  }
 
@@ -187 +188 @@
 }
 
-int     roar_vio_pipe_nonblock(struct roar_vio_calls * vio, int state) {
- struct roar_vio_pipe * self;
-
- if ( vio == NULL )
-  return -1;
-
- if ( (self = (struct roar_vio_pipe *)vio->inst) == NULL )
-  return -1;
-
- switch (self->type) {
-  case ROAR_VIO_PIPE_TYPE_PIPE:
-    if ( roar_socket_nonblock(self->b.p[ROAR_VIO_PIPE_S(self,vio)*2], state) == -1 )
-     return -1;
-    return roar_socket_nonblock(self->b.p[(ROAR_VIO_PIPE_SR(self,vio)*2)+1], state);
-   break;
-#ifdef ROAR_HAVE_UNIX
-  case ROAR_VIO_PIPE_TYPE_SOCKET:
-    return roar_socket_nonblock(self->b.p[ROAR_VIO_PIPE_S(self,vio)], state);
-   break;
-#endif
- }
-
- return -1;
-}
-
 int     roar_vio_pipe_sync    (struct roar_vio_calls * vio) {
  // we may add fdatasync() calls here depending on the type
@@ -276 +252 @@
        return 0;
       break;
+    }
+   break;
+  case ROAR_VIO_CTL_NONBLOCK:
+    switch (self->type) {
+     case ROAR_VIO_PIPE_TYPE_PIPE:
+       if ( roar_socket_nonblock(self->b.p[ROAR_VIO_PIPE_S(self,vio)*2], *(int*)data) == -1 )
+        return -1;
+       return roar_socket_nonblock(self->b.p[(ROAR_VIO_PIPE_SR(self,vio)*2)+1], *(int*)data);
+      break;
+#ifdef ROAR_HAVE_UNIX
+     case ROAR_VIO_PIPE_TYPE_SOCKET:
+       return roar_socket_nonblock(self->b.p[ROAR_VIO_PIPE_S(self,vio)], *(int*)data);
+      break;
+#endif
     }
    break;

libroar/vio_proto.c

@@ -121 +121 @@
  calls->write    = roar_vio_proto_write;
 // calls->lseek    = roar_vio_proto_lseek; // TODO: this is currently not supported
- calls->nonblock = roar_vio_proto_nonblock;
  calls->sync     = roar_vio_proto_sync;
  calls->ctl      = roar_vio_proto_ctl;
@@ -232 +231 @@
 // TODO: this is currently not implemented as this is hard to implement with buffers:
 off_t   roar_vio_proto_lseek   (struct roar_vio_calls * vio, off_t offset, int whence);
-
-int     roar_vio_proto_nonblock(struct roar_vio_calls * vio, int state) {
- struct roar_vio_proto * self = vio->inst;
-
- /* we can simply use the next layer's nonblock as all we do in addtion *
-  * to call there functions are our buffers which do not block normaly  */
-
- return roar_vio_nonblock(self->next, state);
-}
 
 int     roar_vio_proto_sync    (struct roar_vio_calls * vio) {

libroar/vio_rtp.c

@@ -115 +115 @@
  calls->write              = roar_vio_rtp_write;
 // calls->lseek              = roar_vio_rtp_lseek;
- calls->nonblock           = roar_vio_rtp_nonblock;
  calls->sync               = roar_vio_rtp_sync;
  calls->ctl                = roar_vio_rtp_ctl;
@@ -316 +315 @@
 off_t   roar_vio_rtp_lseek   (struct roar_vio_calls * vio, off_t offset, int whence);
 
-int     roar_vio_rtp_nonblock(struct roar_vio_calls * vio, int state) {
- struct roar_rtp_inst * self = vio->inst;
-
- ROAR_DBG("roar_vio_rtp_nonblock(vio=%p, state=%i) = ?", vio, state);
-
- return roar_vio_nonblock(self->vio, state);
-}
-
 int     roar_vio_rtp_sync    (struct roar_vio_calls * vio) {
  struct roar_rtp_inst * self = vio->inst;

libroar/vio_stack.c

@@ -65 +65 @@
  calls->write    = roar_vio_stack_write;
  calls->lseek    = roar_vio_stack_lseek;
- calls->nonblock = roar_vio_stack_nonblock;
  calls->sync     = roar_vio_stack_sync;
 
@@ -184 +183 @@
 }
 
-int     roar_vio_stack_nonblock(struct roar_vio_calls * vio, int state) {
- if ( vio == NULL )
-  return -1;
-
- if ( vio->inst == NULL )
-  return -1;
-
- if ( ((struct roar_vio_stack*)(vio->inst))->cur == NULL )
-  return -1;
-
- return roar_vio_nonblock(((struct roar_vio_stack*)(vio->inst))->cur, state);
-}
-
 int     roar_vio_stack_sync    (struct roar_vio_calls * vio) {
  if ( vio == NULL )

libroar/vio_stdvios.c

@@ -43 +43 @@
    .write    = roar_vio_basic_write,
    .lseek    = roar_vio_basic_lseek,
-   .nonblock = roar_vio_basic_nonblock,
    .sync     = roar_vio_basic_sync,
    .ctl      = roar_vio_basic_ctl,
@@ -54 +53 @@
    .write    = roar_vio_basic_write,
    .lseek    = roar_vio_basic_lseek,
-   .nonblock = roar_vio_basic_nonblock,
    .sync     = roar_vio_basic_sync,
    .ctl      = roar_vio_basic_ctl,
@@ -65 +63 @@
    .write    = roar_vio_basic_write,
    .lseek    = roar_vio_basic_lseek,
-   .nonblock = roar_vio_basic_nonblock,
    .sync     = roar_vio_basic_sync,
    .ctl      = roar_vio_basic_ctl,

libroar/vio_stream.c

@@ -47 +47 @@
  return roar_vio_lseek(roar_get_connection_vio2(vio->inst), offset, whence);
 }
-static int     _vio_stream_nonblock(struct roar_vio_calls * vio, int state) {
- return roar_vio_nonblock(roar_get_connection_vio2(vio->inst), state);
-}
 static int     _vio_stream_sync    (struct roar_vio_calls * vio) {
  return roar_vio_sync(roar_get_connection_vio2(vio->inst));
@@ -81 +78 @@
     roar_err_set(ROAR_ERROR_NOTSUP);
     return -1;
+   break;
+  case ROAR_VIO_CTL_NONBLOCK:
+    return roar_vio_ctl(roar_get_connection_vio2(vio->inst), ROAR_VIO_CTL_NONBLOCK, data);
    break;
  }
@@ -143 +143 @@
  calls->write      = _vio_stream_write;
  calls->lseek      = _vio_stream_lseek;
- calls->nonblock   = _vio_stream_nonblock;
  calls->sync       = _vio_stream_sync;
  calls->ctl        = _vio_stream_ctl;

libroar/vio_winsock.c

@@ -45 +45 @@
 }
 
-int     roar_vio_winsock_nonblock(struct roar_vio_calls * vio, int state) {
- return -1;
-}
 int     roar_vio_winsock_sync    (struct roar_vio_calls * vio) {
  return 0;
@@ -123 +120 @@
  }
 
+ roar_err_set(ROAR_ERROR_BADRQC);
  return -1;
 }

libroar/vio_zlib.c

@@ -435 +435 @@
 }
 
-static int     roar_vio_zlib_nonblock(struct roar_vio_calls * vio, int state) {
- struct roar_vio_gzip * self = vio->inst;
- return roar_vio_nonblock(self->next, state);
-}
-
 static int     roar_vio_zlib_sync    (struct roar_vio_calls * vio) {
  struct roar_vio_gzip * self = vio->inst;
@@ -483 +478 @@
     return -1;
    break;
+  case ROAR_VIO_CTL_NONBLOCK:
+    return roar_vio_ctl(self->next, cmd, data);
+   break;
   default:
     roar_err_set(ROAR_ERROR_BADRQC);
@@ -545 +543 @@
  calls->write      = roar_vio_zlib_write;
  calls->lseek      = roar_vio_zlib_lseek;
- calls->nonblock   = roar_vio_zlib_nonblock;
  calls->sync       = roar_vio_zlib_sync;
  calls->ctl        = roar_vio_zlib_ctl;

roard/container_framework.c

@@ -198 +198 @@
 
 off_t   cont_fw_lseek   (struct roar_vio_calls * vio, off_t offset, int whence);
-int     cont_fw_nonblock(struct roar_vio_calls * vio, int state);
 
 int     cont_fw_sync    (struct roar_vio_calls * vio) {
@@ -245 +244 @@
  vio->write    = cont_pvio_write;
  vio->lseek    = cont_pvio_lseek;
- vio->nonblock = cont_pvio_nonblock;
  vio->sync     = cont_pvio_sync;
  vio->ctl      = cont_pvio_ctl;
@@ -264 +262 @@
 off_t   cont_pvio_lseek   (struct roar_vio_calls * vio, off_t offset, int whence) {
  return roar_vio_lseek(&(((struct cont_fw_parent_inst*)(vio->inst))->stream.stream->vio), offset, whence);
-}
-
-int     cont_pvio_nonblock(struct roar_vio_calls * vio, int state) {
- return roar_vio_nonblock(&(((struct cont_fw_parent_inst*)(vio->inst))->stream.stream->vio), state);
 }
 

roard/driver.c

@@ -317 +317 @@
 #endif
 
-int  driver_dummy_nonblock(struct roar_vio_calls * vio, int state) {
- if ( state == ROAR_SOCKET_BLOCK )
-  return 0;
-
- roar_err_set(ROAR_ERROR_NOTSUP);
- return -1;
+int  driver_dummy_ctl(struct roar_vio_calls * vio, int cmd, void * data) {
+ switch (cmd) {
+  case ROAR_VIO_CTL_NONBLOCK:
+    if ( *(const int*)data == ROAR_SOCKET_BLOCK )
+     return 0;
+
+    roar_err_set(ROAR_ERROR_NOTSUP);
+    return -1;
+   break;
+  default:
+    roar_err_set(ROAR_ERROR_BADRQC);
+    return -1;
+   break;
+ }
 }
 

roard/driver_alsa.c

@@ -231 +231 @@
  inst->sync     = driver_alsa_sync;
  inst->ctl      = driver_alsa_ctl;
- inst->nonblock = driver_dummy_nonblock;
 
  ROAR_DBG("driver_alsa_open_vio(inst=%p, device='%s', info=%p, fh=%i, sstream=%p) = 0", inst, device, info, fh, sstream);
@@ -333 +332 @@
  switch (cmd) {
   case ROAR_VIO_CTL_GET_DELAY:
-   if ( snd_pcm_delay(device->handle, &alsa_delay) < 0 )
+    if ( snd_pcm_delay(device->handle, &alsa_delay) < 0 )
+     return -1;
+    else {
+     *(uint_least32_t *)data = snd_pcm_frames_to_bytes(device->handle, alsa_delay);
+     ROAR_DBG("driver_alsa_ctl(vio=%p, cmd=ROAR_VIO_CTL_GET_DELAY(0x%.8x), data=%p): %i bytes.", vio, cmd, data, (int)(*(uint_least32_t*)data));
+    }
+   break;
+
+  case ROAR_VIO_CTL_SET_SSTREAMID:
+    device->ssid = *(int *)data;
+    ROAR_DBG("driver_alsa_ctl(vio=%p, cmd=ROAR_VIO_CTL_SET_SSTREAMID(0x%.8x), data=%p): ssid=%i", vio, cmd, data, device->ssid);
+   break;
+
+  case ROAR_VIO_CTL_SET_SSTREAM:
+    device->sstream = data;
+    ROAR_DBG("driver_alsa_ctl(vio=%p, cmd=ROAR_VIO_CTL_SET_SSTREAM(0x%.8x), data=%p): sstream=%p", vio, cmd, data, device->sstream);
+   break;
+
+  case ROAR_VIO_CTL_GET_AUINFO:
+    ROAR_DBG("driver_alsa_ctl(vio=%p, cmd=ROAR_VIO_CTL_GET_AUINFO(0x%.8x), data=%p) = ?", vio, cmd, data);
+    memcpy(data, &(device->info), sizeof(struct roar_audio_info));
+   break;
+
+  case ROAR_VIO_CTL_SET_AUINFO:
+    ROAR_DBG("driver_alsa_ctl(vio=%p, cmd=ROAR_VIO_CTL_SET_AUINFO(0x%.8x), data=%p) = ?", vio, cmd, data);
+    memcpy(&(device->info), data, sizeof(struct roar_audio_info));
+    return driver_alsa_reopen_device(device);
+   break;
+
+  case ROAR_VIO_CTL_NONBLOCK:
+    if ( *(int*)data == ROAR_SOCKET_BLOCK )
+     return 0;
+    roar_err_set(ROAR_ERROR_NOTSUP);
     return -1;
-   else {
-    *(uint_least32_t *)data = snd_pcm_frames_to_bytes(device->handle, alsa_delay);
-    ROAR_DBG("driver_alsa_ctl(vio=%p, cmd=ROAR_VIO_CTL_GET_DELAY(0x%.8x), data=%p): %i bytes.", vio, cmd, data, (int)(*(uint_least32_t*)data));
-   }
-   break;
-
-  case ROAR_VIO_CTL_SET_SSTREAMID:
-   device->ssid = *(int *)data;
-   ROAR_DBG("driver_alsa_ctl(vio=%p, cmd=ROAR_VIO_CTL_SET_SSTREAMID(0x%.8x), data=%p): ssid=%i", vio, cmd, data, device->ssid);
-   break;
-
-  case ROAR_VIO_CTL_SET_SSTREAM:
-   device->sstream = data;
-   ROAR_DBG("driver_alsa_ctl(vio=%p, cmd=ROAR_VIO_CTL_SET_SSTREAM(0x%.8x), data=%p): sstream=%p", vio, cmd, data, device->sstream);
-   break;
-
-  case ROAR_VIO_CTL_GET_AUINFO:
-   ROAR_DBG("driver_alsa_ctl(vio=%p, cmd=ROAR_VIO_CTL_GET_AUINFO(0x%.8x), data=%p) = ?", vio, cmd, data);
-   memcpy(data, &(device->info), sizeof(struct roar_audio_info));
-   break;
-
-  case ROAR_VIO_CTL_SET_AUINFO:
-   ROAR_DBG("driver_alsa_ctl(vio=%p, cmd=ROAR_VIO_CTL_SET_AUINFO(0x%.8x), data=%p) = ?", vio, cmd, data);
-   memcpy(&(device->info), data, sizeof(struct roar_audio_info));
-   return driver_alsa_reopen_device(device);
+   break;
 
   default:

roard/driver_ao.c

@@ -134 +134 @@
  inst->write    = driver_ao_write;
  inst->close    = driver_ao_close;
- inst->nonblock = driver_dummy_nonblock;
+ inst->ctl      = driver_dummy_ctl;
 
  return 0;

roard/driver_artsc.c

@@ -124 +124 @@
  inst->close    = driver_artsc_close;
  inst->ctl      = driver_artsc_ctl;
- inst->nonblock = driver_artsc_nonblock;
 
  ROAR_DBG("driver_artsc_open_vio(*) = 0");
@@ -155 +154 @@
 
  return driver_artsc_init_shutdown(SHUTDOWN);
-}
-
-int     driver_artsc_nonblock(struct roar_vio_calls * vio, int state) {
- struct roar_artsc * self = vio->inst;
- int ret;
-
- switch (state) {
-  case ROAR_SOCKET_NONBLOCK:
-    ret = arts_stream_set(self->stream, ARTS_P_BLOCKING, 0);
-    if ( ret == 0 )
-     return 0;
-   break;
-  case ROAR_SOCKET_BLOCK:
-    ret = arts_stream_set(self->stream, ARTS_P_BLOCKING, 1);
-    if ( ret == 1 )
-     return 0;
-   break;
- }
-
- return -1;
 }
 
@@ -206 +185 @@
 
     return 0;
+  case ROAR_VIO_CTL_NONBLOCK:
+    switch (*(int*)data) {
+     case ROAR_SOCKET_NONBLOCK:
+       ret = arts_stream_set(self->stream, ARTS_P_BLOCKING, 0);
+       if ( ret == 0 )
+        return 0;
+       return -1;
+      break;
+     case ROAR_SOCKET_BLOCK:
+       ret = arts_stream_set(self->stream, ARTS_P_BLOCKING, 1);
+       if ( ret == 1 )
+        return 0;
+       return -1;
+      break;
+    }
+   break;
   default:
     return -1;

roard/driver_jack.c

@@ -65 +65 @@
  inst->write    = driver_jack_write;
  inst->lseek    = NULL; // no seeking on this device
- inst->nonblock = driver_jack_nonblock;
  inst->sync     = driver_jack_sync;
  inst->ctl      = driver_jack_ctl;
@@ -157 +156 @@
 }
 
-int     driver_jack_nonblock(struct roar_vio_calls * vio, int state) {
- struct driver_jack * self = vio->inst;
- // control if read and write calls should block untill all data is read or written.
- // state could be:
- //  ROAR_SOCKET_BLOCK    - Block untill the data is read or written
- //  ROAR_SOCKET_NONBLOCK - Return as soon as possible
- return -1;
-}
-
 int     driver_jack_sync    (struct roar_vio_calls * vio) {
  struct driver_jack * self = vio->inst;
@@ -200 +190 @@
     return 0;
    break;
-   case ROAR_VIO_CTL_GET_AUINFO:
-   case ROAR_VIO_CTL_SET_AUINFO:
+  case ROAR_VIO_CTL_NONBLOCK:
+ // control if read and write calls should block untill all data is read or written.
+ // state is in *(int*)data and could be:
+ //  ROAR_SOCKET_BLOCK    - Block untill the data is read or written
+ //  ROAR_SOCKET_NONBLOCK - Return as soon as possible
+   break;
+  case ROAR_VIO_CTL_GET_AUINFO:
+  case ROAR_VIO_CTL_SET_AUINFO:
     // get or set audio info, data is a struct roar_audio_info*.
     return -1;
    break;
-   case ROAR_VIO_CTL_GET_DBLKSIZE:
-   case ROAR_VIO_CTL_SET_DBLKSIZE:
+  case ROAR_VIO_CTL_GET_DBLKSIZE:
+  case ROAR_VIO_CTL_SET_DBLKSIZE:
      // get or set block size used, data is uint_least32_t*, number of bytes.
     return -1;
    break;
-   case ROAR_VIO_CTL_GET_DBLOCKS:
-   case ROAR_VIO_CTL_SET_DBLOCKS:
+  case ROAR_VIO_CTL_GET_DBLOCKS:
+  case ROAR_VIO_CTL_SET_DBLOCKS:
      // get or set number of blocks used, data is uint_least32_t*.
     return -1;
    break;
-   case ROAR_VIO_CTL_SET_SSTREAM:
+  case ROAR_VIO_CTL_SET_SSTREAM:
     // set server stream object for this stream, data is struct roar_stream_server*
     return -1;
    break;
-   case ROAR_VIO_CTL_SET_SSTREAMID:
+  case ROAR_VIO_CTL_SET_SSTREAMID:
     // set stream ID for this stream, data is int*
     return -1;
    break;
-   case ROAR_VIO_CTL_SET_VOLUME:
+  case ROAR_VIO_CTL_SET_VOLUME:
     // set volume for this device, data is struct roar_mixer_settings*
     return -1;
    break;
-   case ROAR_VIO_CTL_GET_DELAY:
+  case ROAR_VIO_CTL_GET_DELAY:
     // get delay of this stream, data is uint_least32_t*, in bytes
     // there is more about delay. please ask.

roard/driver_oss.c

@@ -38 +38 @@
  vio->write    = driver_oss_write;
  vio->read     = driver_oss_read;
- vio->nonblock = driver_oss_nonblock;
  vio->sync     = driver_oss_sync;
  vio->ctl      = driver_oss_ctl;
@@ -448 +447 @@
 }
 
-int     driver_oss_nonblock(struct roar_vio_calls * vio, int state) {
- ROAR_DBG("driver_oss_nonblock(vio=%p, state=%i) = ?", vio, state);
-
- if ( roar_socket_nonblock(_get(vio,fh), state) == -1 ) {
-  ROAR_DBG("driver_oss_nonblock(vio=%p, state=%i) = -1", vio, state);
-  return -1;
- }
-
- if ( state == ROAR_SOCKET_NONBLOCK ) {
-  ROAR_DBG("driver_oss_nonblock(vio=%p, state=%i) = 0", vio, state);
-  return 0;
- }
-
- roar_vio_sync(vio);
-
- ROAR_DBG("driver_oss_nonblock(vio=%p, state=%i) = 0", vio, state);
-
- return 0;
-}
-
 int driver_oss_sync(struct roar_vio_calls * vio) {
 #ifdef SNDCTL_DSP_SYNC
@@ -558 +537 @@
    break;
 #endif
+  case ROAR_VIO_CTL_NONBLOCK:
+    if ( roar_socket_nonblock(_get(vio,fh), *(int*)data) == -1 ) {
+     return -1;
+    }
+
+    if ( *(int*)data == ROAR_SOCKET_NONBLOCK ) {
+     return 0;
+    }
+
+    roar_vio_sync(vio);
+   break;
   default:
    return -1;

roard/driver_portaudio.c

@@ -124 +124 @@
  inst->close = driver_portaudio_close;
  inst->write = driver_portaudio_write;
- inst->nonblock = driver_dummy_nonblock;
+ inst->ctl   = driver_dummy_ctl;
 
  Pa_Initialize();

roard/driver_pulsesimple.c

@@ -127 +127 @@
  inst->sync     = driver_pulsesimple_sync;
  inst->ctl      = driver_pulsesimple_ctl;
- inst->nonblock = driver_dummy_nonblock;
 
  return 0;
@@ -167 +166 @@
  ROAR_DBG("driver_pulsesimple_ctl(vio=%p) = ?", vio);
 
+ switch (cmd) {
+  case ROAR_VIO_CTL_NONBLOCK:
+    if ( *(int*)data == ROAR_SOCKET_BLOCK )
+     return 0;
+    roar_err_set(ROAR_ERROR_NOTSUP);
+    return -1;
+   break;
+ }
+
+ roar_err_set(ROAR_ERROR_NOSYS);
  return -1;
 }

roard/driver_pwmled.c

@@ -62 +62 @@
  inst->write    = driver_pwmled_write;
  inst->lseek    = NULL;
- inst->nonblock = NULL;
  inst->sync     = NULL;
  inst->ctl      = driver_pwmled_ctl;

roard/driver_rsound.c

@@ -171 +171 @@
  inst->close    = driver_rsound_close;
  inst->write    = driver_rsound_write;
- inst->nonblock = driver_dummy_nonblock;
+ inst->ctl      = driver_dummy_ctl;
 
  return 0;

roard/driver_shout.c

@@ -202 +202 @@
  inst->write    = driver_shout_write;
  inst->close    = driver_shout_close;
- inst->nonblock = driver_dummy_nonblock;
+ inst->ctl      = driver_dummy_ctl;
 
  return 0;

roard/driver_sndio.c

@@ -265 +265 @@
     return sio_setvol(self->shandle, d) == 0 ? -1 : 0;
    break;
+  case ROAR_VIO_CTL_NONBLOCK:
+    if ( *(int*)data == ROAR_SOCKET_BLOCK )
+     return 0;
+    roar_err_set(ROAR_ERROR_NOTSUP);
+    return -1;
+   break;
   default:
     return -1;

roard/driver_sysclock.c

@@ -42 +42 @@
  inst->inst     = self;
  inst->close    = driver_sysclock_close;
- inst->nonblock = driver_dummy_nonblock;
  inst->write    = driver_sysclock_write;
+ inst->ctl      = driver_dummy_ctl;
 
  self->bps      = roar_info2bitspersec(info)/8;

roard/driver_wmm.c

@@ -191 +191 @@
  inst->close    = driver_wmm_close_vio;
  inst->write    = driver_wmm_write;
- inst->nonblock = driver_dummy_nonblock;
+ inst->ctl      = driver_dummy_ctl;
 
  info->codec = ROAR_CODEC_PCM_S_LE;

roard/include/driver.h

@@ -159 +159 @@
 #endif
 
-int  driver_dummy_nonblock(struct roar_vio_calls * vio, int state);
+int  driver_dummy_ctl(struct roar_vio_calls * vio, int cmd, void * data);
 
 #endif

roard/include/driver_oss.h

@@ -46 +46 @@
 ssize_t driver_oss_write    (struct roar_vio_calls * vio, void *buf, size_t count);
 ssize_t driver_oss_read     (struct roar_vio_calls * vio, void *buf, size_t count);
-int     driver_oss_nonblock (struct roar_vio_calls * vio, int state);
 int     driver_oss_close_vio(struct roar_vio_calls * vio);
 int     driver_oss_reopen_device(struct driver_oss * self);

roard/include/midi.h

@@ -174 +174 @@
 // dummys:
 int     midi_vio_set_dummy(int stream);
+int     midi_vio_ctl(struct roar_vio_calls * vio, int cmd, void * data);
 int     midi_vio_ok(struct roar_vio_calls * vio, ...);
 

roard/midi.c

@@ -1058 +1058 @@
  ss->vio.write    = NULL;
  ss->vio.lseek    = NULL;
- ss->vio.nonblock = (int (*)(struct roar_vio_calls * vio, int state))midi_vio_ok;
  ss->vio.sync     = (int (*)(struct roar_vio_calls * vio))midi_vio_ok;
- ss->vio.ctl      = NULL;
+ ss->vio.ctl      = midi_vio_ctl;
  ss->vio.close    = (int (*)(struct roar_vio_calls * vio))midi_vio_ok;
 
@@ -1066 +1065 @@
 }
 
+int midi_vio_ctl(struct roar_vio_calls * vio, int cmd, void * data) {
+ if ( cmd == ROAR_VIO_CTL_NONBLOCK )
+  return 0;
+ return -1;
+}
+
 int     midi_vio_ok(struct roar_vio_calls * vio, ...) {
  return 0;

roard/sources.c

@@ -418 +418 @@
 }
 
+static int  sources_radionoise_ctl(struct roar_vio_calls * vio, int cmd, void * data) {
+ if ( cmd == ROAR_VIO_CTL_NONBLOCK )
+  return 0;
+
+ roar_err_set(ROAR_ERROR_BADRQC);
+ return -1;
+}
+
 int sources_add_radionoise (int stream, const char * device, int fh, const char * driver) {
  struct roar_stream_server * ss;
@@ -437 +445 @@
  ss->vio.close    = sources_radionoise_return_zero;
  ss->vio.sync     = sources_radionoise_return_zero;
- ss->vio.nonblock = (int (*)(struct roar_vio_calls * vio, int state))sources_radionoise_return_zero;
+ ss->vio.ctl      = sources_radionoise_ctl;
 
  return streams_set_fh(stream, -2);