Changeset 5276:0eb24ca6810e in roaraudio for roard


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:
roard
Files:
20 edited

Legend:

Unmodified
Added
Removed

  • roard/container_framework.c

    r4957 r5276  
    198198 
    199199off_t   cont_fw_lseek   (struct roar_vio_calls * vio, off_t offset, int whence); 
    200 int     cont_fw_nonblock(struct roar_vio_calls * vio, int state); 
    201200 
    202201int     cont_fw_sync    (struct roar_vio_calls * vio) { 
    … …  
    245244 vio->write    = cont_pvio_write; 
    246245 vio->lseek    = cont_pvio_lseek; 
    247  vio->nonblock = cont_pvio_nonblock; 
    248246 vio->sync     = cont_pvio_sync; 
    249247 vio->ctl      = cont_pvio_ctl; 
    … …  
    264262off_t   cont_pvio_lseek   (struct roar_vio_calls * vio, off_t offset, int whence) { 
    265263 return roar_vio_lseek(&(((struct cont_fw_parent_inst*)(vio->inst))->stream.stream->vio), offset, whence); 
    266 } 
    267  
    268 int     cont_pvio_nonblock(struct roar_vio_calls * vio, int state) { 
    269  return roar_vio_nonblock(&(((struct cont_fw_parent_inst*)(vio->inst))->stream.stream->vio), state); 
    270264} 
    271265 

  • roard/driver.c

    r5274 r5276  
    317317#endif 
    318318 
    319 int  driver_dummy_nonblock(struct roar_vio_calls * vio, int state) { 
    320  if ( state == ROAR_SOCKET_BLOCK ) 
    321   return 0; 
    322  
    323  roar_err_set(ROAR_ERROR_NOTSUP); 
    324  return -1; 
     319int  driver_dummy_ctl(struct roar_vio_calls * vio, int cmd, void * data) { 
     320 switch (cmd) { 
     321  case ROAR_VIO_CTL_NONBLOCK: 
     322    if ( *(const int*)data == ROAR_SOCKET_BLOCK ) 
     323     return 0; 
     324 
     325    roar_err_set(ROAR_ERROR_NOTSUP); 
     326    return -1; 
     327   break; 
     328  default: 
     329    roar_err_set(ROAR_ERROR_BADRQC); 
     330    return -1; 
     331   break; 
     332 } 
    325333} 
    326334 

  • roard/driver_alsa.c

    r5012 r5276  
    231231 inst->sync     = driver_alsa_sync; 
    232232 inst->ctl      = driver_alsa_ctl; 
    233  inst->nonblock = driver_dummy_nonblock; 
    234233 
    235234 ROAR_DBG("driver_alsa_open_vio(inst=%p, device='%s', info=%p, fh=%i, sstream=%p) = 0", inst, device, info, fh, sstream); 
    … …  
    333332 switch (cmd) { 
    334333  case ROAR_VIO_CTL_GET_DELAY: 
    335    if ( snd_pcm_delay(device->handle, &alsa_delay) < 0 ) 
     334    if ( snd_pcm_delay(device->handle, &alsa_delay) < 0 ) 
     335     return -1; 
     336    else { 
     337     *(uint_least32_t *)data = snd_pcm_frames_to_bytes(device->handle, alsa_delay); 
     338     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)); 
     339    } 
     340   break; 
     341 
     342  case ROAR_VIO_CTL_SET_SSTREAMID: 
     343    device->ssid = *(int *)data; 
     344    ROAR_DBG("driver_alsa_ctl(vio=%p, cmd=ROAR_VIO_CTL_SET_SSTREAMID(0x%.8x), data=%p): ssid=%i", vio, cmd, data, device->ssid); 
     345   break; 
     346 
     347  case ROAR_VIO_CTL_SET_SSTREAM: 
     348    device->sstream = data; 
     349    ROAR_DBG("driver_alsa_ctl(vio=%p, cmd=ROAR_VIO_CTL_SET_SSTREAM(0x%.8x), data=%p): sstream=%p", vio, cmd, data, device->sstream); 
     350   break; 
     351 
     352  case ROAR_VIO_CTL_GET_AUINFO: 
     353    ROAR_DBG("driver_alsa_ctl(vio=%p, cmd=ROAR_VIO_CTL_GET_AUINFO(0x%.8x), data=%p) = ?", vio, cmd, data); 
     354    memcpy(data, &(device->info), sizeof(struct roar_audio_info)); 
     355   break; 
     356 
     357  case ROAR_VIO_CTL_SET_AUINFO: 
     358    ROAR_DBG("driver_alsa_ctl(vio=%p, cmd=ROAR_VIO_CTL_SET_AUINFO(0x%.8x), data=%p) = ?", vio, cmd, data); 
     359    memcpy(&(device->info), data, sizeof(struct roar_audio_info)); 
     360    return driver_alsa_reopen_device(device); 
     361   break; 
     362 
     363  case ROAR_VIO_CTL_NONBLOCK: 
     364    if ( *(int*)data == ROAR_SOCKET_BLOCK ) 
     365     return 0; 
     366    roar_err_set(ROAR_ERROR_NOTSUP); 
    336367    return -1; 
    337    else { 
    338     *(uint_least32_t *)data = snd_pcm_frames_to_bytes(device->handle, alsa_delay); 
    339     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)); 
    340    } 
    341    break; 
    342  
    343   case ROAR_VIO_CTL_SET_SSTREAMID: 
    344    device->ssid = *(int *)data; 
    345    ROAR_DBG("driver_alsa_ctl(vio=%p, cmd=ROAR_VIO_CTL_SET_SSTREAMID(0x%.8x), data=%p): ssid=%i", vio, cmd, data, device->ssid); 
    346    break; 
    347  
    348   case ROAR_VIO_CTL_SET_SSTREAM: 
    349    device->sstream = data; 
    350    ROAR_DBG("driver_alsa_ctl(vio=%p, cmd=ROAR_VIO_CTL_SET_SSTREAM(0x%.8x), data=%p): sstream=%p", vio, cmd, data, device->sstream); 
    351    break; 
    352  
    353   case ROAR_VIO_CTL_GET_AUINFO: 
    354    ROAR_DBG("driver_alsa_ctl(vio=%p, cmd=ROAR_VIO_CTL_GET_AUINFO(0x%.8x), data=%p) = ?", vio, cmd, data); 
    355    memcpy(data, &(device->info), sizeof(struct roar_audio_info)); 
    356    break; 
    357  
    358   case ROAR_VIO_CTL_SET_AUINFO: 
    359    ROAR_DBG("driver_alsa_ctl(vio=%p, cmd=ROAR_VIO_CTL_SET_AUINFO(0x%.8x), data=%p) = ?", vio, cmd, data); 
    360    memcpy(&(device->info), data, sizeof(struct roar_audio_info)); 
    361    return driver_alsa_reopen_device(device); 
     368   break; 
    362369 
    363370  default: 

  • roard/driver_ao.c

    r5056 r5276  
    134134 inst->write    = driver_ao_write; 
    135135 inst->close    = driver_ao_close; 
    136  inst->nonblock = driver_dummy_nonblock; 
     136 inst->ctl      = driver_dummy_ctl; 
    137137 
    138138 return 0; 

  • roard/driver_artsc.c

    r5108 r5276  
    124124 inst->close    = driver_artsc_close; 
    125125 inst->ctl      = driver_artsc_ctl; 
    126  inst->nonblock = driver_artsc_nonblock; 
    127126 
    128127 ROAR_DBG("driver_artsc_open_vio(*) = 0"); 
    … …  
    155154 
    156155 return driver_artsc_init_shutdown(SHUTDOWN); 
    157 } 
    158  
    159 int     driver_artsc_nonblock(struct roar_vio_calls * vio, int state) { 
    160  struct roar_artsc * self = vio->inst; 
    161  int ret; 
    162  
    163  switch (state) { 
    164   case ROAR_SOCKET_NONBLOCK: 
    165     ret = arts_stream_set(self->stream, ARTS_P_BLOCKING, 0); 
    166     if ( ret == 0 ) 
    167      return 0; 
    168    break; 
    169   case ROAR_SOCKET_BLOCK: 
    170     ret = arts_stream_set(self->stream, ARTS_P_BLOCKING, 1); 
    171     if ( ret == 1 ) 
    172      return 0; 
    173    break; 
    174  } 
    175  
    176  return -1; 
    177156} 
    178157 
    … …  
    206185 
    207186    return 0; 
     187  case ROAR_VIO_CTL_NONBLOCK: 
     188    switch (*(int*)data) { 
     189     case ROAR_SOCKET_NONBLOCK: 
     190       ret = arts_stream_set(self->stream, ARTS_P_BLOCKING, 0); 
     191       if ( ret == 0 ) 
     192        return 0; 
     193       return -1; 
     194      break; 
     195     case ROAR_SOCKET_BLOCK: 
     196       ret = arts_stream_set(self->stream, ARTS_P_BLOCKING, 1); 
     197       if ( ret == 1 ) 
     198        return 0; 
     199       return -1; 
     200      break; 
     201    } 
     202   break; 
    208203  default: 
    209204    return -1; 

  • roard/driver_jack.c

    r5259 r5276  
    6565 inst->write    = driver_jack_write; 
    6666 inst->lseek    = NULL; // no seeking on this device 
    67  inst->nonblock = driver_jack_nonblock; 
    6867 inst->sync     = driver_jack_sync; 
    6968 inst->ctl      = driver_jack_ctl; 
    … …  
    157156} 
    158157 
    159 int     driver_jack_nonblock(struct roar_vio_calls * vio, int state) { 
    160  struct driver_jack * self = vio->inst; 
    161  // control if read and write calls should block untill all data is read or written. 
    162  // state could be: 
    163  //  ROAR_SOCKET_BLOCK    - Block untill the data is read or written 
    164  //  ROAR_SOCKET_NONBLOCK - Return as soon as possible 
    165  return -1; 
    166 } 
    167  
    168158int     driver_jack_sync    (struct roar_vio_calls * vio) { 
    169159 struct driver_jack * self = vio->inst; 
    … …  
    200190    return 0; 
    201191   break; 
    202    case ROAR_VIO_CTL_GET_AUINFO: 
    203    case ROAR_VIO_CTL_SET_AUINFO: 
     192  case ROAR_VIO_CTL_NONBLOCK: 
     193 // control if read and write calls should block untill all data is read or written. 
     194 // state is in *(int*)data and could be: 
     195 //  ROAR_SOCKET_BLOCK    - Block untill the data is read or written 
     196 //  ROAR_SOCKET_NONBLOCK - Return as soon as possible 
     197   break; 
     198  case ROAR_VIO_CTL_GET_AUINFO: 
     199  case ROAR_VIO_CTL_SET_AUINFO: 
    204200    // get or set audio info, data is a struct roar_audio_info*. 
    205201    return -1; 
    206202   break; 
    207    case ROAR_VIO_CTL_GET_DBLKSIZE: 
    208    case ROAR_VIO_CTL_SET_DBLKSIZE: 
     203  case ROAR_VIO_CTL_GET_DBLKSIZE: 
     204  case ROAR_VIO_CTL_SET_DBLKSIZE: 
    209205     // get or set block size used, data is uint_least32_t*, number of bytes. 
    210206    return -1; 
    211207   break; 
    212    case ROAR_VIO_CTL_GET_DBLOCKS: 
    213    case ROAR_VIO_CTL_SET_DBLOCKS: 
     208  case ROAR_VIO_CTL_GET_DBLOCKS: 
     209  case ROAR_VIO_CTL_SET_DBLOCKS: 
    214210     // get or set number of blocks used, data is uint_least32_t*. 
    215211    return -1; 
    216212   break; 
    217    case ROAR_VIO_CTL_SET_SSTREAM: 
     213  case ROAR_VIO_CTL_SET_SSTREAM: 
    218214    // set server stream object for this stream, data is struct roar_stream_server* 
    219215    return -1; 
    220216   break; 
    221    case ROAR_VIO_CTL_SET_SSTREAMID: 
     217  case ROAR_VIO_CTL_SET_SSTREAMID: 
    222218    // set stream ID for this stream, data is int* 
    223219    return -1; 
    224220   break; 
    225    case ROAR_VIO_CTL_SET_VOLUME: 
     221  case ROAR_VIO_CTL_SET_VOLUME: 
    226222    // set volume for this device, data is struct roar_mixer_settings* 
    227223    return -1; 
    228224   break; 
    229    case ROAR_VIO_CTL_GET_DELAY: 
     225  case ROAR_VIO_CTL_GET_DELAY: 
    230226    // get delay of this stream, data is uint_least32_t*, in bytes 
    231227    // there is more about delay. please ask. 

  • roard/driver_oss.c

    r5055 r5276  
    3838 vio->write    = driver_oss_write; 
    3939 vio->read     = driver_oss_read; 
    40  vio->nonblock = driver_oss_nonblock; 
    4140 vio->sync     = driver_oss_sync; 
    4241 vio->ctl      = driver_oss_ctl; 
    … …  
    448447} 
    449448 
    450 int     driver_oss_nonblock(struct roar_vio_calls * vio, int state) { 
    451  ROAR_DBG("driver_oss_nonblock(vio=%p, state=%i) = ?", vio, state); 
    452  
    453  if ( roar_socket_nonblock(_get(vio,fh), state) == -1 ) { 
    454   ROAR_DBG("driver_oss_nonblock(vio=%p, state=%i) = -1", vio, state); 
    455   return -1; 
    456  } 
    457  
    458  if ( state == ROAR_SOCKET_NONBLOCK ) { 
    459   ROAR_DBG("driver_oss_nonblock(vio=%p, state=%i) = 0", vio, state); 
    460   return 0; 
    461  } 
    462  
    463  roar_vio_sync(vio); 
    464  
    465  ROAR_DBG("driver_oss_nonblock(vio=%p, state=%i) = 0", vio, state); 
    466  
    467  return 0; 
    468 } 
    469  
    470449int driver_oss_sync(struct roar_vio_calls * vio) { 
    471450#ifdef SNDCTL_DSP_SYNC 
    … …  
    558537   break; 
    559538#endif 
     539  case ROAR_VIO_CTL_NONBLOCK: 
     540    if ( roar_socket_nonblock(_get(vio,fh), *(int*)data) == -1 ) { 
     541     return -1; 
     542    } 
     543 
     544    if ( *(int*)data == ROAR_SOCKET_NONBLOCK ) { 
     545     return 0; 
     546    } 
     547 
     548    roar_vio_sync(vio); 
     549   break; 
    560550  default: 
    561551   return -1; 

  • roard/driver_portaudio.c

    r5134 r5276  
    124124 inst->close = driver_portaudio_close; 
    125125 inst->write = driver_portaudio_write; 
    126  inst->nonblock = driver_dummy_nonblock; 
     126 inst->ctl   = driver_dummy_ctl; 
    127127 
    128128 Pa_Initialize(); 

  • roard/driver_pulsesimple.c

    r5056 r5276  
    127127 inst->sync     = driver_pulsesimple_sync; 
    128128 inst->ctl      = driver_pulsesimple_ctl; 
    129  inst->nonblock = driver_dummy_nonblock; 
    130129 
    131130 return 0; 
    … …  
    167166 ROAR_DBG("driver_pulsesimple_ctl(vio=%p) = ?", vio); 
    168167 
     168 switch (cmd) { 
     169  case ROAR_VIO_CTL_NONBLOCK: 
     170    if ( *(int*)data == ROAR_SOCKET_BLOCK ) 
     171     return 0; 
     172    roar_err_set(ROAR_ERROR_NOTSUP); 
     173    return -1; 
     174   break; 
     175 } 
     176 
     177 roar_err_set(ROAR_ERROR_NOSYS); 
    169178 return -1; 
    170179} 

  • roard/driver_pwmled.c

    r4957 r5276  
    6262 inst->write    = driver_pwmled_write; 
    6363 inst->lseek    = NULL; 
    64  inst->nonblock = NULL; 
    6564 inst->sync     = NULL; 
    6665 inst->ctl      = driver_pwmled_ctl; 

  • roard/driver_rsound.c

    r5107 r5276  
    171171 inst->close    = driver_rsound_close; 
    172172 inst->write    = driver_rsound_write; 
    173  inst->nonblock = driver_dummy_nonblock; 
     173 inst->ctl      = driver_dummy_ctl; 
    174174 
    175175 return 0; 

  • roard/driver_shout.c

    r5012 r5276  
    202202 inst->write    = driver_shout_write; 
    203203 inst->close    = driver_shout_close; 
    204  inst->nonblock = driver_dummy_nonblock; 
     204 inst->ctl      = driver_dummy_ctl; 
    205205 
    206206 return 0; 

  • roard/driver_sndio.c

    r5105 r5276  
    265265    return sio_setvol(self->shandle, d) == 0 ? -1 : 0; 
    266266   break; 
     267  case ROAR_VIO_CTL_NONBLOCK: 
     268    if ( *(int*)data == ROAR_SOCKET_BLOCK ) 
     269     return 0; 
     270    roar_err_set(ROAR_ERROR_NOTSUP); 
     271    return -1; 
     272   break; 
    267273  default: 
    268274    return -1; 

  • roard/driver_sysclock.c

    r5012 r5276  
    4242 inst->inst     = self; 
    4343 inst->close    = driver_sysclock_close; 
    44  inst->nonblock = driver_dummy_nonblock; 
    4544 inst->write    = driver_sysclock_write; 
     45 inst->ctl      = driver_dummy_ctl; 
    4646 
    4747 self->bps      = roar_info2bitspersec(info)/8; 

  • roard/driver_wmm.c

    r5062 r5276  
    191191 inst->close    = driver_wmm_close_vio; 
    192192 inst->write    = driver_wmm_write; 
    193  inst->nonblock = driver_dummy_nonblock; 
     193 inst->ctl      = driver_dummy_ctl; 
    194194 
    195195 info->codec = ROAR_CODEC_PCM_S_LE; 

  • roard/include/driver.h

    r5245 r5276  
    159159#endif 
    160160 
    161 int  driver_dummy_nonblock(struct roar_vio_calls * vio, int state); 
     161int  driver_dummy_ctl(struct roar_vio_calls * vio, int cmd, void * data); 
    162162 
    163163#endif 

  • roard/include/driver_oss.h

    r4815 r5276  
    4646ssize_t driver_oss_write    (struct roar_vio_calls * vio, void *buf, size_t count); 
    4747ssize_t driver_oss_read     (struct roar_vio_calls * vio, void *buf, size_t count); 
    48 int     driver_oss_nonblock (struct roar_vio_calls * vio, int state); 
    4948int     driver_oss_close_vio(struct roar_vio_calls * vio); 
    5049int     driver_oss_reopen_device(struct driver_oss * self); 

  • roard/include/midi.h

    r5194 r5276  
    174174// dummys: 
    175175int     midi_vio_set_dummy(int stream); 
     176int     midi_vio_ctl(struct roar_vio_calls * vio, int cmd, void * data); 
    176177int     midi_vio_ok(struct roar_vio_calls * vio, ...); 
    177178 

  • roard/midi.c

    r5210 r5276  
    10581058 ss->vio.write    = NULL; 
    10591059 ss->vio.lseek    = NULL; 
    1060  ss->vio.nonblock = (int (*)(struct roar_vio_calls * vio, int state))midi_vio_ok; 
    10611060 ss->vio.sync     = (int (*)(struct roar_vio_calls * vio))midi_vio_ok; 
    1062  ss->vio.ctl      = NULL; 
     1061 ss->vio.ctl      = midi_vio_ctl; 
    10631062 ss->vio.close    = (int (*)(struct roar_vio_calls * vio))midi_vio_ok; 
    10641063 
    … …  
    10661065} 
    10671066 
     1067int midi_vio_ctl(struct roar_vio_calls * vio, int cmd, void * data) { 
     1068 if ( cmd == ROAR_VIO_CTL_NONBLOCK ) 
     1069  return 0; 
     1070 return -1; 
     1071} 
     1072 
    10681073int     midi_vio_ok(struct roar_vio_calls * vio, ...) { 
    10691074 return 0; 

  • roard/sources.c

    r5246 r5276  
    418418} 
    419419 
     420static int  sources_radionoise_ctl(struct roar_vio_calls * vio, int cmd, void * data) { 
     421 if ( cmd == ROAR_VIO_CTL_NONBLOCK ) 
     422  return 0; 
     423 
     424 roar_err_set(ROAR_ERROR_BADRQC); 
     425 return -1; 
     426} 
     427 
    420428int sources_add_radionoise (int stream, const char * device, int fh, const char * driver) { 
    421429 struct roar_stream_server * ss; 
    … …  
    437445 ss->vio.close    = sources_radionoise_return_zero; 
    438446 ss->vio.sync     = sources_radionoise_return_zero; 
    439  ss->vio.nonblock = (int (*)(struct roar_vio_calls * vio, int state))sources_radionoise_return_zero; 
     447 ss->vio.ctl      = sources_radionoise_ctl; 
    440448 
    441449 return streams_set_fh(stream, -2); 
Note: See TracChangeset for help on using the changeset viewer.