Changeset 5276:0eb24ca6810e in roaraudio for libroar


Ignore:
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)

Location:
libroar
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • libroar/vio.c

    r5270 r5276  
    6565 calls->write    = roar_vio_basic_write; 
    6666 calls->lseek    = roar_vio_basic_lseek; 
    67  calls->nonblock = roar_vio_basic_nonblock; 
    6867 calls->sync     = roar_vio_basic_sync; 
    6968 calls->ctl      = roar_vio_basic_ctl; 
    … …  
    179178 
    180179int     roar_vio_nonblock(struct roar_vio_calls * vio, int state) { 
    181  int ret; 
    182  
    183180 ROAR_DBG("roar_vio_nonblock(vio=%p, state=%i) = ?", vio, state); 
    184181 
    … …  
    188185 } 
    189186 
    190  if ( vio->nonblock == NULL ) { 
    191   roar_err_set(ROAR_ERROR_NOSYS); 
    192   return -1; 
    193  } 
    194  
    195  roar_err_clear_all(); 
    196  ret = vio->nonblock(vio, state); 
    197  roar_err_update(); 
    198  
    199  return ret; 
     187 return roar_vio_ctl(vio, ROAR_VIO_CTL_NONBLOCK, &state); 
    200188} 
    201189 
    … …  
    346334 calls->read     = roar_vio_winsock_read; 
    347335 calls->write    = roar_vio_winsock_write; 
    348  calls->nonblock = roar_vio_winsock_nonblock; 
    349336 calls->sync     = roar_vio_winsock_sync; 
    350337 calls->ctl      = roar_vio_winsock_ctl; 
    … …  
    414401 return -1; 
    415402#endif 
    416 } 
    417  
    418 int     roar_vio_basic_nonblock(struct roar_vio_calls * vio, int state) { 
    419  if ( roar_socket_nonblock(roar_vio_get_fh(vio), state) == -1 ) 
    420   return -1; 
    421  
    422  if ( state == ROAR_SOCKET_NONBLOCK ) 
    423   return 0; 
    424  
    425  roar_vio_sync(vio); 
    426  
    427  return 0; 
    428403} 
    429404 
    … …  
    666641   break; 
    667642#endif 
     643  case ROAR_VIO_CTL_NONBLOCK: 
     644    if ( roar_socket_nonblock(roar_vio_get_fh(vio), *(int*)data) == -1 ) 
     645     return -1; 
     646 
     647    if ( *(int*)data == ROAR_SOCKET_NONBLOCK ) 
     648     return 0; 
     649 
     650    roar_vio_sync(vio); 
     651    return 0; 
     652   break; 
    668653 } 
    669654 
    … …  
    713698 calls->write    = roar_vio_pass_write; 
    714699 calls->lseek    = roar_vio_pass_lseek; 
    715  calls->nonblock = roar_vio_pass_nonblock; 
    716700 calls->sync     = roar_vio_pass_sync; 
    717701 calls->ctl      = roar_vio_pass_ctl; 
    … …  
    733717off_t   roar_vio_pass_lseek(struct roar_vio_calls * vio, off_t offset, int whence) { 
    734718 return roar_vio_lseek((struct roar_vio_calls *) vio->inst, offset, whence); 
    735 } 
    736  
    737 int     roar_vio_pass_nonblock(struct roar_vio_calls * vio, int state) { 
    738  return roar_vio_nonblock((struct roar_vio_calls *) vio->inst, state); 
    739719} 
    740720 

  • libroar/vio_buffer.c

    r4708 r5276  
    6363 calls->close    = roar_vio_buffer_close; 
    6464 calls->write    = roar_vio_buffer_write; 
    65  calls->nonblock = roar_vio_buffer_nonblock; 
    6665 calls->ctl      = roar_vio_buffer_ctl; 
    6766 calls->sync     = roar_vio_buffer_sync; 
    … …  
    327326    return 0; 
    328327   break; 
     328  case ROAR_VIO_CTL_NONBLOCK: 
     329    if ( self->use_re ) { 
     330     return roar_vio_ctl(&(self->re_vio), ROAR_VIO_CTL_NONBLOCK, data); 
     331    } else { 
     332     return roar_vio_ctl(self->backend, ROAR_VIO_CTL_NONBLOCK, data); 
     333    } 
     334   break; 
    329335 } 
    330336 
    … …  
    342348} 
    343349 
    344 int     roar_vio_buffer_nonblock(struct roar_vio_calls * vio, int state) { 
    345  struct roar_vio_buffer * self = vio->inst; 
    346  
    347  if ( self->use_re ) { 
    348   return roar_vio_nonblock(&(self->re_vio), state); 
    349  } else { 
    350   return roar_vio_nonblock(self->backend, state); 
    351  } 
    352 } 
    353  
    354350//ll 

  • libroar/vio_buffer_store.c

    r4708 r5276  
    5656 calls->inst     = self; 
    5757 calls->close    = roar_vio_buffer_store_close; 
    58  calls->nonblock = roar_vio_buffer_store_nonblock; 
    5958 calls->sync     = roar_vio_buffer_store_sync; 
    6059 calls->ctl      = roar_vio_buffer_store_ctl; 
    … …  
    138137} 
    139138 
    140 int     roar_vio_buffer_store_nonblock(struct roar_vio_calls * vio, int state) { 
    141  return 0; // if we are in nonblock or not is the same for us. 
    142 } 
    143  
    144139int     roar_vio_buffer_store_sync    (struct roar_vio_calls * vio) { 
    145140 return 0; // we are always sync. 
    … …  
    160155    return 0; 
    161156   break; 
     157  case ROAR_VIO_CTL_NONBLOCK: 
     158    return 0; // if we are in nonblock or not is the same for us. 
     159   break; 
    162160 } 
    163161 

  • libroar/vio_cmd.c

    r5111 r5276  
    8080 calls->read     = roar_vio_cmd_read; 
    8181 calls->write    = roar_vio_cmd_write; 
    82  calls->nonblock = roar_vio_cmd_nonblock; 
    8382 calls->sync     = roar_vio_cmd_sync; 
    8483 calls->ctl      = roar_vio_cmd_ctl; 
    … …  
    514513} 
    515514 
    516 int     roar_vio_cmd_nonblock(struct roar_vio_calls * vio, int state) { 
    517  struct roar_vio_cmd_state * self = (struct roar_vio_cmd_state *)vio->inst; 
    518  
    519  self->options |= ROAR_VIO_CMD_OPTS_NONBLOCK; 
    520  
    521  if ( state == ROAR_SOCKET_BLOCK ) 
    522   self->options -= ROAR_VIO_CMD_OPTS_NONBLOCK; 
    523  
    524  _LIBROAR_IGNORE_RET(roar_vio_nonblock(self->next, state)); // this should help, but may not nessessery. 
    525  
    526  return 0; 
    527 } 
    528  
    529515int     roar_vio_cmd_sync    (struct roar_vio_calls * vio) { 
    530516 struct roar_vio_cmd_state * state = (struct roar_vio_cmd_state *)vio->inst; 
     517 int newblock = ROAR_SOCKET_BLOCK; 
    531518 int oldblock; 
    532519 int ret = 0; 
    … …  
    534521 oldblock = state->options & ROAR_VIO_CMD_OPTS_NONBLOCK ? ROAR_SOCKET_NONBLOCK : ROAR_SOCKET_BLOCK; 
    535522 
    536  if ( roar_vio_cmd_nonblock(vio, ROAR_SOCKET_BLOCK) == -1 ) 
     523 if ( roar_vio_cmd_ctl(vio, ROAR_VIO_CTL_NONBLOCK, &newblock) == -1 ) 
    537524  return -1; 
    538525 
    … …  
    543530  ret = -1; 
    544531 
    545  if ( roar_vio_cmd_nonblock(vio, oldblock) == -1 ) 
     532 if ( roar_vio_cmd_ctl(vio, ROAR_VIO_CTL_NONBLOCK, &oldblock) == -1 ) 
    546533  return -1; 
    547534 
    … …  
    586573    return -1; 
    587574   break; 
     575  case ROAR_VIO_CTL_NONBLOCK: 
     576    state->options |= ROAR_VIO_CMD_OPTS_NONBLOCK; 
     577 
     578    if ( *(int*)data == ROAR_SOCKET_BLOCK ) 
     579     state->options -= ROAR_VIO_CMD_OPTS_NONBLOCK; 
     580 
     581    _LIBROAR_IGNORE_RET(roar_vio_ctl(state->next, cmd, data)); // this should help, but may not necessarily. 
     582   break; 
    588583  default: 
    589584    return -1; 

  • libroar/vio_jumbo.c

    r5270 r5276  
    5858 calls->write    = roar_vio_jumbo_write; 
    5959 calls->lseek    = roar_vio_jumbo_lseek; 
    60  calls->nonblock = roar_vio_jumbo_nonblock; 
    6160 calls->sync     = roar_vio_jumbo_sync; 
    6261 calls->ctl      = roar_vio_jumbo_ctl; 
    … …  
    130129} 
    131130 
    132 int     roar_vio_jumbo_nonblock(struct roar_vio_calls * vio, int state) { 
    133  struct roar_vio_jumbo * self = vio->inst; 
    134  
    135  return roar_vio_nonblock(self->backend, state); 
    136 } 
    137  
    138131int     roar_vio_jumbo_sync    (struct roar_vio_calls * vio) { 
    139132 struct roar_vio_jumbo * self = vio->inst; 
    … …  
    156149 
    157150int     roar_vio_jumbo_ctl     (struct roar_vio_calls * vio, int cmd, void * data) { 
     151 struct roar_vio_jumbo * self = vio->inst; 
     152 
     153 switch (cmd) { 
     154  case ROAR_VIO_CTL_NONBLOCK: 
     155    return roar_vio_ctl(self->backend, cmd, data); 
     156   break; 
     157 } 
     158 
     159 roar_err_set(ROAR_ERROR_BADRQC); 
    158160 return -1; 
    159161} 

  • libroar/vio_misc.c

    r5270 r5276  
    5959} 
    6060 
    61 static int     roar_vio_misc_nonblock(struct roar_vio_calls * vio, int state) { 
    62  struct roar_vio_misc * self = vio->inst; 
    63  
    64  if ( self->support_nonblocking ) 
    65   return 0; 
    66  
    67  if ( state == ROAR_SOCKET_BLOCK ) 
    68   return 0; 
    69  
    70  return -1; 
    71 } 
    72  
    7361static int     roar_vio_misc_sync    (struct roar_vio_calls * vio) { 
    7462 (void)vio; 
    … …  
    9482    return 0; 
    9583   break; 
     84  case ROAR_VIO_CTL_NONBLOCK: 
     85    if ( self->support_nonblocking ) 
     86     return 0; 
     87 
     88    if ( *(int*)data == ROAR_SOCKET_BLOCK ) 
     89     return 0; 
     90 
     91    return -1; 
     92   break;  
    9693 } 
    9794 
    … …  
    112109 calls->write    = roar_vio_misc_write; 
    113110 calls->lseek    = roar_vio_misc_lseek; 
    114  calls->nonblock = roar_vio_misc_nonblock; 
    115111 calls->sync     = roar_vio_misc_sync; 
    116112 calls->ctl      = roar_vio_misc_ctl; 

  • libroar/vio_pipe.c

    r5270 r5276  
    119119#ifndef ROAR_WITHOUT_VIO_PIPE 
    120120int roar_vio_pipe_init (struct roar_vio_calls * s,  struct roar_vio_pipe * self, int flags) { 
     121 int nonblock = ROAR_SOCKET_NONBLOCK; 
     122 
    121123 if ( s == NULL || self == NULL ) 
    122124  return -1; 
    … …  
    127129 s->read     = roar_vio_pipe_read; 
    128130 s->write    = roar_vio_pipe_write; 
    129  s->nonblock = roar_vio_pipe_nonblock; 
    130131 s->sync     = roar_vio_pipe_sync; 
    131132 
    … …  
    133134 
    134135 if ( flags & O_NONBLOCK ) { 
    135   roar_vio_pipe_nonblock(s, ROAR_SOCKET_NONBLOCK); 
     136  roar_vio_pipe_ctl(s, ROAR_VIO_CTL_NONBLOCK, &nonblock); 
    136137 } 
    137138 
    … …  
    187188} 
    188189 
    189 int     roar_vio_pipe_nonblock(struct roar_vio_calls * vio, int state) { 
    190  struct roar_vio_pipe * self; 
    191  
    192  if ( vio == NULL ) 
    193   return -1; 
    194  
    195  if ( (self = (struct roar_vio_pipe *)vio->inst) == NULL ) 
    196   return -1; 
    197  
    198  switch (self->type) { 
    199   case ROAR_VIO_PIPE_TYPE_PIPE: 
    200     if ( roar_socket_nonblock(self->b.p[ROAR_VIO_PIPE_S(self,vio)*2], state) == -1 ) 
    201      return -1; 
    202     return roar_socket_nonblock(self->b.p[(ROAR_VIO_PIPE_SR(self,vio)*2)+1], state); 
    203    break; 
    204 #ifdef ROAR_HAVE_UNIX 
    205   case ROAR_VIO_PIPE_TYPE_SOCKET: 
    206     return roar_socket_nonblock(self->b.p[ROAR_VIO_PIPE_S(self,vio)], state); 
    207    break; 
    208 #endif 
    209  } 
    210  
    211  return -1; 
    212 } 
    213  
    214190int     roar_vio_pipe_sync    (struct roar_vio_calls * vio) { 
    215191 // we may add fdatasync() calls here depending on the type 
    … …  
    276252       return 0; 
    277253      break; 
     254    } 
     255   break; 
     256  case ROAR_VIO_CTL_NONBLOCK: 
     257    switch (self->type) { 
     258     case ROAR_VIO_PIPE_TYPE_PIPE: 
     259       if ( roar_socket_nonblock(self->b.p[ROAR_VIO_PIPE_S(self,vio)*2], *(int*)data) == -1 ) 
     260        return -1; 
     261       return roar_socket_nonblock(self->b.p[(ROAR_VIO_PIPE_SR(self,vio)*2)+1], *(int*)data); 
     262      break; 
     263#ifdef ROAR_HAVE_UNIX 
     264     case ROAR_VIO_PIPE_TYPE_SOCKET: 
     265       return roar_socket_nonblock(self->b.p[ROAR_VIO_PIPE_S(self,vio)], *(int*)data); 
     266      break; 
     267#endif 
    278268    } 
    279269   break; 

  • libroar/vio_proto.c

    r5254 r5276  
    121121 calls->write    = roar_vio_proto_write; 
    122122// calls->lseek    = roar_vio_proto_lseek; // TODO: this is currently not supported 
    123  calls->nonblock = roar_vio_proto_nonblock; 
    124123 calls->sync     = roar_vio_proto_sync; 
    125124 calls->ctl      = roar_vio_proto_ctl; 
    … …  
    232231// TODO: this is currently not implemented as this is hard to implement with buffers: 
    233232off_t   roar_vio_proto_lseek   (struct roar_vio_calls * vio, off_t offset, int whence); 
    234  
    235 int     roar_vio_proto_nonblock(struct roar_vio_calls * vio, int state) { 
    236  struct roar_vio_proto * self = vio->inst; 
    237  
    238  /* we can simply use the next layer's nonblock as all we do in addtion * 
    239   * to call there functions are our buffers which do not block normaly  */ 
    240  
    241  return roar_vio_nonblock(self->next, state); 
    242 } 
    243233 
    244234int     roar_vio_proto_sync    (struct roar_vio_calls * vio) { 

  • libroar/vio_rtp.c

    r5111 r5276  
    115115 calls->write              = roar_vio_rtp_write; 
    116116// calls->lseek              = roar_vio_rtp_lseek; 
    117  calls->nonblock           = roar_vio_rtp_nonblock; 
    118117 calls->sync               = roar_vio_rtp_sync; 
    119118 calls->ctl                = roar_vio_rtp_ctl; 
    … …  
    316315off_t   roar_vio_rtp_lseek   (struct roar_vio_calls * vio, off_t offset, int whence); 
    317316 
    318 int     roar_vio_rtp_nonblock(struct roar_vio_calls * vio, int state) { 
    319  struct roar_rtp_inst * self = vio->inst; 
    320  
    321  ROAR_DBG("roar_vio_rtp_nonblock(vio=%p, state=%i) = ?", vio, state); 
    322  
    323  return roar_vio_nonblock(self->vio, state); 
    324 } 
    325  
    326317int     roar_vio_rtp_sync    (struct roar_vio_calls * vio) { 
    327318 struct roar_rtp_inst * self = vio->inst; 

  • libroar/vio_stack.c

    r4975 r5276  
    6565 calls->write    = roar_vio_stack_write; 
    6666 calls->lseek    = roar_vio_stack_lseek; 
    67  calls->nonblock = roar_vio_stack_nonblock; 
    6867 calls->sync     = roar_vio_stack_sync; 
    6968 
    … …  
    184183} 
    185184 
    186 int     roar_vio_stack_nonblock(struct roar_vio_calls * vio, int state) { 
    187  if ( vio == NULL ) 
    188   return -1; 
    189  
    190  if ( vio->inst == NULL ) 
    191   return -1; 
    192  
    193  if ( ((struct roar_vio_stack*)(vio->inst))->cur == NULL ) 
    194   return -1; 
    195  
    196  return roar_vio_nonblock(((struct roar_vio_stack*)(vio->inst))->cur, state); 
    197 } 
    198  
    199185int     roar_vio_stack_sync    (struct roar_vio_calls * vio) { 
    200186 if ( vio == NULL ) 

  • libroar/vio_stdvios.c

    r4708 r5276  
    4343   .write    = roar_vio_basic_write, 
    4444   .lseek    = roar_vio_basic_lseek, 
    45    .nonblock = roar_vio_basic_nonblock, 
    4645   .sync     = roar_vio_basic_sync, 
    4746   .ctl      = roar_vio_basic_ctl, 
    … …  
    5453   .write    = roar_vio_basic_write, 
    5554   .lseek    = roar_vio_basic_lseek, 
    56    .nonblock = roar_vio_basic_nonblock, 
    5755   .sync     = roar_vio_basic_sync, 
    5856   .ctl      = roar_vio_basic_ctl, 
    … …  
    6563   .write    = roar_vio_basic_write, 
    6664   .lseek    = roar_vio_basic_lseek, 
    67    .nonblock = roar_vio_basic_nonblock, 
    6865   .sync     = roar_vio_basic_sync, 
    6966   .ctl      = roar_vio_basic_ctl, 

  • libroar/vio_stream.c

    r5238 r5276  
    4747 return roar_vio_lseek(roar_get_connection_vio2(vio->inst), offset, whence); 
    4848} 
    49 static int     _vio_stream_nonblock(struct roar_vio_calls * vio, int state) { 
    50  return roar_vio_nonblock(roar_get_connection_vio2(vio->inst), state); 
    51 } 
    5249static int     _vio_stream_sync    (struct roar_vio_calls * vio) { 
    5350 return roar_vio_sync(roar_get_connection_vio2(vio->inst)); 
    … …  
    8178    roar_err_set(ROAR_ERROR_NOTSUP); 
    8279    return -1; 
     80   break; 
     81  case ROAR_VIO_CTL_NONBLOCK: 
     82    return roar_vio_ctl(roar_get_connection_vio2(vio->inst), ROAR_VIO_CTL_NONBLOCK, data); 
    8383   break; 
    8484 } 
    … …  
    143143 calls->write      = _vio_stream_write; 
    144144 calls->lseek      = _vio_stream_lseek; 
    145  calls->nonblock   = _vio_stream_nonblock; 
    146145 calls->sync       = _vio_stream_sync; 
    147146 calls->ctl        = _vio_stream_ctl; 

  • libroar/vio_winsock.c

    r4708 r5276  
    4545} 
    4646 
    47 int     roar_vio_winsock_nonblock(struct roar_vio_calls * vio, int state) { 
    48  return -1; 
    49 } 
    5047int     roar_vio_winsock_sync    (struct roar_vio_calls * vio) { 
    5148 return 0; 
    … …  
    123120 } 
    124121 
     122 roar_err_set(ROAR_ERROR_BADRQC); 
    125123 return -1; 
    126124} 

  • libroar/vio_zlib.c

    r5270 r5276  
    435435} 
    436436 
    437 static int     roar_vio_zlib_nonblock(struct roar_vio_calls * vio, int state) { 
    438  struct roar_vio_gzip * self = vio->inst; 
    439  return roar_vio_nonblock(self->next, state); 
    440 } 
    441  
    442437static int     roar_vio_zlib_sync    (struct roar_vio_calls * vio) { 
    443438 struct roar_vio_gzip * self = vio->inst; 
    … …  
    483478    return -1; 
    484479   break; 
     480  case ROAR_VIO_CTL_NONBLOCK: 
     481    return roar_vio_ctl(self->next, cmd, data); 
     482   break; 
    485483  default: 
    486484    roar_err_set(ROAR_ERROR_BADRQC); 
    … …  
    545543 calls->write      = roar_vio_zlib_write; 
    546544 calls->lseek      = roar_vio_zlib_lseek; 
    547  calls->nonblock   = roar_vio_zlib_nonblock; 
    548545 calls->sync       = roar_vio_zlib_sync; 
    549546 calls->ctl        = roar_vio_zlib_ctl; 
Note: See TracChangeset for help on using the changeset viewer.