Changeset 5075:fd02b8a97aea in roaraudio


Ignore:
Timestamp:
06/20/11 01:00:56 (10 years ago)
Author:
phi
Branch:
default
Phase:
public
Message:

added support ROAR_VS_ASYNC to roar_vs_latency2()

Location:
libroar
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • libroar/time.c

    r5068 r5075  
    161161 switch (clock) { 
    162162  case ROAR_CLOCK_REALTIME: 
    163     ROAR_DBG("roar_clock_gettime(rt=%p, clock=(%i)ROAR_CLOCK_REALTIME) = -1", rt, clock); 
     163    ROAR_DBG("roar_clock_gettime(rt=%p, clock=(%i)ROAR_CLOCK_REALTIME) = ?", rt, clock); 
    164164#ifdef ROAR_HAVE_GETTIMEOFDAY 
    165165    if ( gettimeofday(&tv, NULL) == -1 ) { 
    166166     roar_err_from_errno(); 
     167     ROAR_DBG("roar_clock_gettime(rt=%p, clock=(%i)ROAR_CLOCK_REALTIME) = -1 //error=%i", rt, clock, roar_error); 
    167168     return -1; 
    168169    } 
     
    175176    rt->c_freq = 1000000000LLU; 
    176177#else 
     178    ROAR_DBG("roar_clock_gettime(rt=%p, clock=(%i)ROAR_CLOCK_REALTIME) = -1 // error=NOTSUP", rt, clock); 
    177179    roar_err_set(ROAR_ERROR_NOTSUP); 
    178180    return -1; 
    179181#endif 
     182    ROAR_DBG("roar_clock_gettime(rt=%p, clock=(%i)ROAR_CLOCK_REALTIME) = 0", rt, clock); 
    180183    return 0; 
    181184   break; 
  • libroar/vs.c

    r5073 r5075  
    5050#define FLAG_FREE_VOL  0x0010 
    5151#define FLAG_DEF_PAUSE 0x0020 
    52 #define FLAG_ASYNC     0x0040 
    5352#define FLAG_DIR_IN    0x1000 
    5453#define FLAG_DIR_OUT   0x2000 
     
    5958#define _seterrse() do { roar_err_from_errno(); _seterr(roar_error); } while(0) 
    6059#define _ckvss(ret) do { if ( vss == NULL ) { _seterr(ROAR_ERROR_INVAL); return (ret); } } while(0) 
    61 #define _ckasync(ret) do { if ( _handle_async(vss, error) == -1 ) { return (ret); } } while(0); 
     60#define _ckasync(ret) do { if ( _handle_async(vss, error) == -1 ) { return (ret); } } while(0) 
    6261 
    6362struct roar_vs { 
     
    8988 } latmes; 
    9089 struct { 
     90  int    level; 
    9191  size_t lock; 
    9292  size_t qlen; 
     
    9797 
    9898static int _roar_vs_find_first_prim(roar_vs_t * vss); 
     99 
     100static int _send_async_req(roar_vs_t * vss, int cmd, int subcmd, int * error) { 
     101 struct roar_message mes; 
     102 uint16_t * data = (uint16_t *) mes.data; 
     103 
     104 if ( !vss->async.level ) { 
     105  _seterr(ROAR_ERROR_INVAL); 
     106  return -1; 
     107 } 
     108 
     109 if ( vss->async.lock ) { 
     110  _seterr(ROAR_ERROR_BUSY); 
     111  return -1; 
     112 } 
     113 
     114 if ( vss->async.qlen == ASYNC_QLEN ) { 
     115  _seterr(ROAR_ERROR_NOSPC); 
     116  return -1; 
     117 } 
     118 
     119 memset(&mes, 0, sizeof(mes)); 
     120 
     121 mes.cmd    = cmd; 
     122 mes.stream = roar_stream_get_id(&(vss->stream)); 
     123 mes.pos    = 0; 
     124 
     125 if ( cmd == ROAR_CMD_GET_STREAM_PARA && subcmd == ROAR_STREAM_PARA_INFO ) { 
     126  mes.datalen = 4; 
     127  data[0] = ROAR_HOST2NET16(0); // Version and reserved 
     128  data[1] = ROAR_HOST2NET16(ROAR_STREAM_PARA_INFO); // stream 
     129 } else if ( cmd == ROAR_CMD_GET_STREAM ) { 
     130  mes.datalen = 1; 
     131  mes.data[0] = mes.stream; 
     132 } else { 
     133  _seterr(ROAR_ERROR_NOSYS); 
     134  return -1; 
     135 } 
     136 
     137 if ( roar_send_message(vss->con, &mes, NULL) == -1 ) { 
     138  _seterrre(); 
     139  return -1; 
     140 } 
     141 
     142 vss->async.qcmd[vss->async.qlen] = cmd; 
     143 vss->async.qsubcmd[vss->async.qlen] = subcmd; 
     144 vss->async.qlen++; 
     145 
     146 return 0; 
     147} 
    99148 
    100149static int _handle_async_req(roar_vs_t * vss, int * error) { 
     
    118167  vss->async.qsubcmd[i-1] = vss->async.qsubcmd[i]; 
    119168 } 
     169 
     170 //printf("mes.cmd=%i, cmd=%i, subcmd=%i\n", (int)mes.cmd, cmd, subcmd); 
    120171 
    121172 if ( mes.cmd == ROAR_CMD_OK ) { 
     
    140191    break; 
    141192   case ROAR_CMD_GET_STREAM: 
    142      vss->latmes.last_offset = mes.pos; // ha, this is a easy one ;) 
     193     if ( roar_clock_gettime(&(vss->latmes.last_time), LOCAL_CLOCK) == -1 ) { 
     194      vss->latmes.last_pos = -1; 
     195     } else { 
     196      vss->latmes.last_pos = mes.pos; 
     197     } 
     198     //printf("vss->latmes.last_pos=%li, mes.pos=%li\n", (long int)vss->latmes.last_pos, (long int)mes.pos); 
    143199    break; 
    144200   default: 
    145201     ROAR_WARN("_handle_async_req(vss=%p, error=%p): Got unexpected reply for command %i", vss, error, cmd); 
     202     _seterr(ROAR_ERROR_NOSYS); 
    146203    break; 
    147204  } 
     
    151208  free(data); 
    152209 
    153  _seterr(ROAR_ERROR_NOSYS); 
    154  return -1; 
     210 return 0; 
    155211} 
    156212 
     
    163219 
    164220 return 0; 
     221} 
     222 
     223static void _check_async(roar_vs_t * vss) { 
     224 struct roar_vio_select vios; 
     225 struct roar_vio_selecttv tv = {0, 0}; 
     226 
     227 if ( !vss->async.qlen ) 
     228  return; 
     229 
     230 ROAR_VIO_SELECT_SETVIO(&vios, roar_get_connection_vio2(vss->con), ROAR_VIO_SELECT_READ); 
     231 
     232 if ( roar_vio_select(&vios, 1, &tv, NULL) < 1 ) 
     233  return; 
     234 
     235 if ( !(vios.eventsa & ROAR_VIO_SELECT_READ) ) 
     236  return; 
     237 
     238 _handle_async_req(vss, NULL); 
    165239} 
    166240 
     
    869943 } 
    870944 
     945 _check_async(vss); 
     946 
    871947 if ( wait == ROAR_VS_WAIT ) { 
    872948  return roar_vs_latency(vss, backend, error); 
     
    922998 
    923999  return lag; 
     1000 } else if ( wait == ROAR_VS_ASYNC ) { 
     1001  if ( _send_async_req(vss, ROAR_CMD_GET_STREAM, -1, error) == -1 ) 
     1002   return 0; 
     1003/* 
     1004  if ( _send_async_req(vss, ROAR_CMD_GET_STREAM_PARA, ROAR_STREAM_PARA_INFO, error) == -1 ) 
     1005   return 0; 
     1006*/ 
     1007  _seterr(ROAR_ERROR_NODATA); 
     1008  return 0; 
    9241009 } 
    9251010 
     
    16051690    *(int*)argp = vss->flags & FLAG_DEF_PAUSE ? ROAR_VS_TRUE : ROAR_VS_FALSE; 
    16061691   break; 
     1692  case ROAR_VS_CMD_SET_ASYNC: 
     1693    vss->async.level = *(int*)argp; 
     1694   break; 
     1695  case ROAR_VS_CMD_GET_ASYNC: 
     1696    *(int*)argp = vss->async.level; 
     1697   break; 
     1698  case ROAR_VS_CMD_LOCK_ASYNC: 
     1699    _ckasync(-1); 
     1700    if ( argp == NULL ) { 
     1701     vss->async.lock++; 
     1702    } else { 
     1703     vss->async.lock -= *(int*)argp; 
     1704    } 
     1705   break; 
     1706  case ROAR_VS_CMD_UNLOCK_ASYNC: 
     1707    if ( argp == NULL ) { 
     1708     if ( !vss->async.lock ) { 
     1709      _seterr(ROAR_ERROR_LOSTSYNC); 
     1710      return -1; 
     1711     } else { 
     1712      vss->async.lock--; 
     1713     } 
     1714    } else { 
     1715     if ( vss->async.lock < (size_t)*(int*)argp ) { 
     1716      _seterr(ROAR_ERROR_LOSTSYNC); 
     1717      return -1; 
     1718     } else { 
     1719      vss->async.lock -= *(int*)argp; 
     1720     } 
     1721    } 
     1722   break; 
    16071723// use ifndef here so warnings of unhandled enum values will be shown in DEBUG mode. 
    16081724#ifndef DEBUG 
Note: See TracChangeset for help on using the changeset viewer.