예제 #1
0
static void
snd_epg_array (int sock, EpgArray * rv)
{
  uint32_t i;
  ipcSndS (sock, rv->num_pgm);
  debugMsg ("num_pgm: %d\n", rv->num_pgm);
  for (i = 0; i < rv->num_pgm; i++)
  {
    ipcSndS (sock, rv->pgm_nrs[i]);
  }
  for (i = 0; i < rv->num_pgm; i++)
  {
    uint32_t j;
    debugMsg ("num_events: %d\n", rv->sched[i].num_events);
    ipcSndS (sock, rv->sched[i].num_events);
    for (j = 0; j < rv->sched[i].num_events; j++)
    {
      uint16_t sz;
      sz = evtGetSize (rv->sched[i].events[j]);
      debugMsg ("event size: %" PRIu16 "\n", sz);
      ipcSndS (sock, sz);
      ioBlkWr (sock, rv->sched[i].events[j], sz);
    }
  }
}
예제 #2
0
//***********************************************************************
void ICACHE_FLASH_ATTR easyMesh::handleTimeSync( meshConnectionType *conn, JsonObject& root ) {
    
    String timeStamp = root["msg"];
    debugMsg( SYNC, "handleTimeSync(): with %d in timestamp=%s\n", conn->chipId, timeStamp.c_str());
    
    conn->time.processTimeStamp( timeStamp );  //varifies timeStamp and updates it with a new one.

    debugMsg( SYNC, "handleTimeSync(): with %d out timestamp=%s\n", conn->chipId, timeStamp.c_str());

    
    if ( conn->time.num < TIME_SYNC_CYCLES ) {
        staticThis->sendMessage( conn, _chipId, TIME_SYNC, timeStamp );
    }
    
    uint8_t odd = conn->time.num % 2;
    
    if ( (conn->time.num + odd) >= TIME_SYNC_CYCLES ) {   // timeSync completed
        if ( conn->time.adopt ) {
            conn->time.calcAdjustment( odd );
            
            // flag all connections for re-timeSync
            SimpleList<meshConnectionType>::iterator connection = _connections.begin();
            while ( connection != _connections.end() ) {
                if ( connection != conn ) {  // exclude this connection
                    connection->timeSyncStatus = NEEDED;
                }
                connection++;
            }
        }
        conn->lastTimeSync = getNodeTime();
        conn->timeSyncStatus = COMPLETE;
    }
}
예제 #3
0
파일: svt.c 프로젝트: klammerj/dvb-vulture
/**
 *\brief finds or creates a new Trk object
 *
 *if a new one is created, refcount will be at 1 on return.
 *if one already exists and is found, refcount will be incremented by 1 on return.
 *selector is not locked
 */
static SvcTrk *
find_or_new_svt (SwDmx * d, uint16_t pnr)
{
  SvcTrk *t;
  uint16_t pat_pid = 0;
  debugMsg ("looking up tracker for pnr: %" PRIu16 "\n", pnr);
  t = find_svt (d, pnr);
  debugMsg ("found tracker %p\n", t);
  if (t == NULL)
  {
    t = rcptrMalloc (sizeof (*t));
    debugMsg ("creating new tracker %p\n", t);
    memset (t, 0, sizeof (*t));
    t->pnr = pnr;
    t->pid = 0x1fff;
    t->input = selectorAddPortSync (&d->s, svt_packet_put, t);
    pidbufDump ("find_or_new_svt", &pat_pid, 1);
    selectorModPort (t->input, 1, &pat_pid);
    t->pmt[0] = NULL;           //those start out empty... also will have to dump pms_cache
    t->pmt[1] = NULL;
    t->n_out = 0;
    t->output = NULL;
    secExInit (&t->ex, t->input, svt_release_pk);       //svt_release_pk assumes selector is not locked...
    debugMsg ("tracker created\n");
  }
  else
    rcptrAcquire (t);           //so it has +1 refcount in both cases..
  debugMsg ("returning tracker: %p\n", t);
  return t;
}
예제 #4
0
int
srvListTp (Connection * c)
{
  int num_tp, i;
  TransponderInfo *t;
  uint32_t pos;
  debugMsg ("list_tp start\n");
  ipcRcvS (c->sockfd, pos);
  t = pgmdbListTransp (&c->p->program_database, pos, &num_tp);
  if (!t)
  {
    debugMsg ("pgmdb_list_tp error\n");
    ipcSndS (c->sockfd, SRV_ERR);
    return 1;
  }

  ipcSndS (c->sockfd, SRV_NOERR);
  debugMsg ("success: got %d transponders\n", num_tp);
  ipcSndS (c->sockfd, num_tp);
  for (i = 0; i < num_tp; i++)
  {
    tpiSnd (c->sockfd, &t[i]);
  }
  debugMsg ("freeing transponder array\n");
  utlFAN (t);
  return 0;
}
예제 #5
0
int
srvListPg (Connection * c)
{
  int num_pg, i;
  ProgramInfo *pi;
  uint32_t freq;
  uint8_t pol;
  uint32_t pos;

  ipcRcvS (c->sockfd, pos);
  ipcRcvS (c->sockfd, freq);
  ipcRcvS (c->sockfd, pol);
  debugMsg ("pgmdbListPgm\n");
  pi = pgmdbListPgm (&c->p->program_database, pos, freq, pol, &num_pg);
  if (!pi)
  {
    debugMsg ("pgmdbListPgm error\n");
    ipcSndS (c->sockfd, SRV_ERR);
    return 1;
  }

  ipcSndS (c->sockfd, SRV_NOERR);
  ipcSndS (c->sockfd, num_pg);
  if (num_pg > 0)
  {
    for (i = 0; i < num_pg; i++)
    {
      programInfoSnd (c->sockfd, &pi[i]);
      programInfoClear (&pi[i]);
    }
    utlFAN (pi);
  }
  return 0;
}
예제 #6
0
int
srvSetFcorr (Connection * c)
{
  int32_t fcorr;
  TransponderInfo t;
  debugMsg ("set_fcorr start\n");

  ipcRcvS (c->sockfd, fcorr);

  if (!(c->super && c->active))
  {
    ipcSndS (c->sockfd, SRV_ERR);
    return 0;
  }

  if (dvbSetFCorr (&c->p->dvb, fcorr))
  {
    ipcSndS (c->sockfd, SRV_ERR);
    return 0;
  }
  else
  {
    //this works because I was lazy and didn't clear the frontend data on tuning failure
    //TODO: find a sane way of getting at some valid tuning parms
    if (pgmdbFindTransp
        (&c->p->program_database, &t, c->p->dvb.pos, c->p->dvb.freq,
         c->p->dvb.pol))
    {
      ipcSndS (c->sockfd, SRV_NOERR);
      return 0;
    }
    if (!recTaskActive (&c->p->recorder_task))
    {
      debugMsg ("pgmRmvAllPnrs\n");
      pgmRmvAllPnrs ((PgmState *) c->p);        //iterate over all connections stopping their pnrs/recordings.
      if (!srvTuneTpi (c->p, c->p->dvb.pos, &t))
      {
        debugMsg ("done\n");
      }
      else
      {
        errMsg ("tuning error\n");
        ipcSndS (c->sockfd, SRV_ERR);
        return 1;
      }
    }
    else
    {
      errMsg ("error\n");
      ipcSndS (c->sockfd, SRV_NOACTIVE);
      return 1;
    }
    ipcSndS (c->sockfd, SRV_NOERR);
  }
  return 0;
}
예제 #7
0
int
srvTpFt (Connection * c)
{
  debugMsg ("ft_tp\n");
  uint32_t freq;
  uint8_t pol;
  uint32_t pos;
  int32_t ft;
  TransponderInfo t;

  ipcRcvS (c->sockfd, pos);
  ipcRcvS (c->sockfd, freq);
  ipcRcvS (c->sockfd, pol);
  ipcRcvS (c->sockfd, ft);
  if (!(c->super && c->active))
  {
    ipcSndS (c->sockfd, SRV_NOACTIVE);
    return 0;
  }
  if (pgmdbFt (&c->p->program_database, pos, freq, pol, ft))
    ipcSndS (c->sockfd, SRV_ERR);
  else
  {
    if (pgmdbFindTransp (&c->p->program_database, &t, pos, freq, pol))
    {
      ipcSndS (c->sockfd, SRV_NOERR);
      return 0;
    }
    if (!recTaskActive (&c->p->recorder_task))
    {
      debugMsg ("pgmRmvAllPnrs\n");
      pgmRmvAllPnrs ((PgmState *) c->p);        //iterate over all connections stopping their pnrs/recordings.
      if (!srvTuneTpi (c->p, pos, &t))
      {
        debugMsg ("done\n");
      }
      else
      {
        errMsg ("tuning error\n");
        ipcSndS (c->sockfd, SRV_ERR);
        return 1;
      }
    }
    else
    {
      errMsg ("error\n");
      ipcSndS (c->sockfd, SRV_NOACTIVE);
      return 1;
    }
    ipcSndS (c->sockfd, SRV_NOERR);
  }
  return 0;
}
예제 #8
0
int
cuStackPop (CUStack * st)
{
  if (!st->Index)
  {
    return 1;
  }
  st->Index--;
  debugMsg ("popping func addr: %p\n", (void *) st->Stack[st->Index].ff);
  debugMsg ("          Handle: %p\n", st->Stack[st->Index].Handle);
  st->Stack[st->Index].ff (st->Stack[st->Index].Handle);
  return 0;
}
예제 #9
0
/*
 * GC Mark function
 */
static void
rlink_sentence_gc_mark( struct rlink_sentence *ptr ) {
	debugMsg(( "Marking LinkParser::Sentence %p", ptr ));

	if ( ptr ) {
		rb_gc_mark( ptr->dictionary );
		rb_gc_mark( ptr->options );
	}

	else {
		debugMsg(( "Not marking uninitialized rlink_sentence struct" ));
	}
}
void LeftbagdetectorPlugin::onStringParamChanged(const QString& varName, const QString& val){
    if(varName == "input_file"){
        input_file = val;
        blobPositionReader.openFile(input_file);
        debugMsg("input_file set to "  + val);
    }
    else if(varName == "output_file"){
        output_file = val;
        blobPositionReader.openFile(output_file);
        debugMsg("output_file set to "  + val);
    }

}
예제 #11
0
파일: svt.c 프로젝트: klammerj/dvb-vulture
/*
add indicated functions to svc tracker
may have to associate tracker if it's empty...
selector is not locked
*/
void
add_func (SvcOut * o, uint16_t pnr, uint16_t func)
{
  unsigned i;
  debugMsg ("add_func o=%p pnr=%hu func=0x%hx\n", o, pnr, func);
  /*
     tracker may be new, pids unknown, what to do?
     will have to defer
   */
  for (i = 0; i < o->n_funcs; i++)
  {
    if (o->r[i].pnr == pnr)
    {
      break;
    }
  }
  if (i >= o->n_funcs)
  {
    FuncRec r;
    unsigned s = o->n_funcs;
    r.pnr = pnr;
    r.func = func;
    /*
       svt may already exist, but is not associated with this svcOut
       may have to create new svt
       if new, will not know any pids. starts out empty
       listening to pat or perhaps grabbing one from pgmdb
       (rather not as it is blocking operation...)
     */
    debugMsg ("looking for tracker\n");
    r.trk = find_or_new_svt (o->dmx, pnr);      //refcount gets incremented here
    //append an element
    utlAppend1 ((uint8_t **) & o->r, &o->n_funcs, &s, (uint8_t *) & r,
                sizeof (r));
    //associate the other way around
    s = r.trk->n_out;
    utlAppend1 ((uint8_t **) & r.trk->output, &r.trk->n_out, &s,
                (uint8_t *) & o, sizeof (o));
    debugMsg ("add_func done\n");
    return;
  }
  /*
     here, svt already exists
     and is associated 
     it may already know all pids,
     and may be able to supply us with them later ..
   */
  o->r[i].func = func;
  debugMsg ("add_func done2\n");
  return;
}
예제 #12
0
파일: svt.c 프로젝트: klammerj/dvb-vulture
/*
selector must not be locked
*/
static void
svt_clear (SvcTrk * t)
{
  debugMsg ("svt_clear \n");
  assert (t->n_out == 0);
  selectorRemovePort (t->input);
  t->input = NULL;
  utlFAN (t->output);
  clear_tbl (t->pmt[0]);
  utlFAN (t->pmt[0]);
  clear_tbl (t->pmt[1]);
  utlFAN (t->pmt[1]);
  debugMsg ("svt_clear done\n");
}
예제 #13
0
int
cuStackGrow (CUStack * st)
{
  unsigned int size = st->Size + GROW_CU_SIZE;
  CUStackElem *sp;
  debugMsg ("Growing Stack\n");
  sp = realloc (st->Stack, sizeof (CUStackElem) * size);
  if (!sp)
    return 1;
  debugMsg ("Success\n");
  st->Stack = sp;
  st->Size = size;
  return 0;
}
예제 #14
0
int
cuStackPush (void *handle, void (*ff) (void *handle), CUStack * st)
{
  if (st->Index == (st->Size))
  {
    if (cuStackGrow (st))
      return 1;
  }
  st->Stack[st->Index].ff = ff;
  st->Stack[st->Index].Handle = handle;
  st->Index++;
  debugMsg ("pushed func addr: %p\n", ff);
  debugMsg ("          Handle: %p\n", handle);
  return 0;
}
예제 #15
0
int
offline_task_vt (OfflineTask * rt)
{
  int num_tp;
  if (rt->current_tp >= rt->num_tp)
  {
    debugMsg ("rt->current_tp>=rt->num_tp\n");

    if (rt->current_pos >= rt->num_pos)
    {
      debugMsg ("rt->current_pos>=rt->num_pos\n");
      utlFAN (rt->tpi);
      rt->tpi = NULL;
      rt->current_tp = 0;
      rt->num_tp = 0;
      rt->num_pos = 0;
      rt->current_pos = 0;
      return 1;
    }
    else
    {
      debugMsg ("else\n");
      utlFAN (rt->tpi);
      rt->tpi = NULL;
      do
      {
        rt->current_pos++;
        if (rt->current_pos >= rt->num_pos)
        {
          debugMsg ("rt->current_pos>=rt->num_pos\n");
          rt->current_tp = 0;
          rt->num_tp = 0;
          rt->num_pos = 0;
          rt->current_pos = 0;
          return 1;
        }
        rt->tpi =
          pgmdbListTransp (&rt->p->program_database, rt->current_pos,
                           &num_tp);
        rt->num_tp = num_tp;
        rt->current_tp = 0;
      }
      while (NULL == rt->tpi);
    }
  }
  debugMsg ("ok\n");
  return 0;
}
예제 #16
0
파일: analyzer.c 프로젝트: Fedjmike/fcc
void analyzerNode (analyzerCtx* ctx, ast* Node) {
    debugEnter(astTagGetStr(Node->tag));

    if (Node->tag == astEmpty)
        debugMsg("Empty");

    else if (Node->tag == astInvalid)
        debugMsg("Invalid");

    else if (Node->tag == astModule)
        analyzerModule(ctx, Node);

    else if (Node->tag == astUsing)
        analyzerUsing(ctx, Node);

    else if (Node->tag == astFnImpl)
        analyzerFnImpl(ctx, Node);

    else if (Node->tag == astDecl)
        analyzerDecl(ctx, Node, false);

    else if (Node->tag == astCode)
        analyzerCode(ctx, Node);

    else if (Node->tag == astBranch)
        analyzerBranch(ctx, Node);

    else if (Node->tag == astLoop)
        analyzerLoop(ctx, Node);

    else if (Node->tag == astIter)
        analyzerIter(ctx, Node);

    else if (Node->tag == astReturn)
        analyzerReturn(ctx, Node);

    else if (Node->tag == astBreak || Node->tag == astContinue)
        ; /*Nothing to check (inside loop is a parsing issue)*/

    else if (astIsValueTag(Node->tag))
        /*TODO: Check not throwing away value*/
        analyzerValue(ctx, Node);

    else
        debugErrorUnhandled("analyzerNode", "AST tag", astTagGetStr(Node->tag));

    debugLeave();
}
예제 #17
0
static int
io_udp_socket6 (char *bcast_addr, uint16_t port, int loop,
                struct sockaddr_in6 *dest_addr)
{
    int sockfd;
    debugMsg ("initialising dest_addr\n");
    memset ((void *) dest_addr, 0, sizeof (*dest_addr));
    if (!inet_pton (AF_INET6, bcast_addr, &dest_addr->sin6_addr))
    {
        errMsg ("failed\n");
        return -1;
    }
    dest_addr->sin6_port = htons (port);
    dest_addr->sin6_family = AF_INET6;

    sockfd = socket (AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
    if (sockfd < 0)
    {
        errMsg ("Failed to create bcast socket: %s\n", strerror (errno));
        return -1;
    }
    setsockopt (sockfd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &loop,
                sizeof (loop));
    return sockfd;
}
예제 #18
0
void
videoRTPSession_t::receivedData (RTPPacket_t * packet)
{
    debugMsg(dbg_App_Normal,
             "videoRTPSession_t",
             "receivedData 1 SSRC=%d\n", 
             packet->getSSRC()
            ); 

    channel_t * channel = NULL;
    if ((channel = channelList->lookUp(packet->getSSRC())) != NULL)        
    {
        if(channel->getKind() == PLAY_CHANNEL)
        {
            playChannel_t * playChannel = static_cast<playChannel_t *>(channel);
            playChannel->addFragment(packet);
        }
        else
        {
            delete packet;
        }
	
   }
   else if(*SetAutoChannel)
   {
       NOTIFY("Receiving new flow SSRC = %d. Building playChannel_t...\n",
              packet->getSSRC()
             );
       char name[20]="";
       sprintf(name,"Remote %d",packet->getSSRC());
       playChannel_t * playChannel = new playChannel_t(packet->getSSRC(),name);
   }
}
예제 #19
0
파일: tagscanner.cpp 프로젝트: gt945/gede
void TagScanner::init()
{

    // Check if ctags exists?
    QStringList argList;
    argList.push_back("--version");
    QByteArray stdoutContent;
    int n = execProgram(ETAGS_CMD, argList, &stdoutContent, NULL);
    QStringList outputList = QString(stdoutContent).split('\n');
    for(int u = 0;u < outputList.size();u++)
    {
        debugMsg("ETAGS: %s", stringToCStr(outputList[u]));
    }
    if(n)
    {
        QString msg;

        msg.sprintf("Failed to start program '%s'\n", ETAGS_CMD);
        msg += "ctags can be installed on ubuntu/debian using command:\n";
        msg +  "\n";
        msg += " apt-get install exuberant-ctags";

        QMessageBox::warning(NULL,
                    "Failed to start ctags",
                    msg);
        m_ctagsExist = false;
    }
    else
        m_ctagsExist = true;
}
void Faceanomaly1Plugin::inputData(const QStringList& strList, QList<QImage> imageList){

    int i;

    frameNum=strList.at(1);

    if (!strList.at(0).isEmpty())
        i= strList.at(0).split(" ")[0].toInt();

    if(!imageList.isEmpty()){

        imageList.at(0);
        updateFrameViewer("Output",imageList.at(0).copy());


    }

    if( i>=threasholdFaceCount){

        debugMsg(QString("<FONT COLOR='#ff0000'>%1 faces detected on frame %2 ").arg(threasholdFaceCount).arg(frameNum));
        generateAlert("Output","Too many people",nooba::RedAlert);
    }
    i=0;

}
예제 #21
0
파일: svt.c 프로젝트: klammerj/dvb-vulture
/*
selector must not be locked

*/
static void
svt_release (SwDmx * d, SvcTrk * t)
{
  debugMsg ("svt_release d=%p t=%p\n", d, t);
  if (1 == rcptrRefcount (t))
  {
    debugMsg ("removing tracker\n");
    selectorLock (&d->s);
    secExClear (&t->ex);        //selector has to be locked here
    selectorUnlock (&d->s);
    btreeNodeRemove (&d->svt_root, &t->n);
    svt_clear (t);
  }
  rcptrRelease (t);
  debugMsg ("svt_release done\n");
}
예제 #22
0
파일: svt.c 프로젝트: klammerj/dvb-vulture
/*
remove indicated functions from port
does not remove corresponding pids from output port
has to be done later.
may have to modify tracker and dissociate it, if 
it's not used anymore by this port

selector is not locked
*/
void
rmv_func (SvcOut * o, uint16_t pnr, uint16_t func)
{
  unsigned i;
  /*
     remove func from out port
     iterate over SvcOut s FuncRec array
   */
  debugMsg ("rmv_func o=%p pnr=%hu func=0x%hx\n", o, pnr, func);
  for (i = 0; i < o->n_funcs; i++)
  {
    if (o->r[i].pnr == pnr)
    {
      break;
    }
  }
  if (i >= o->n_funcs)
  {
    errMsg ("pnr not found: 0x%" PRIx16 ",0x%" PRIx16 "\nin SvcOut:%p\n", pnr,
            func, o);
    return;
  }
  /*
     clear func bits in svcout
     if it gets zero, remove tracker
   */
  o->r[i].func &= ~func;        //clear func
  if (o->r[i].func == 0)
  {
    remove_tracker (o, i);
  }

}
예제 #23
0
type* analyzerParamList (analyzerCtx* ctx, ast* Node, type* returnType) {
    debugEnter("ParamList");

    bool variadic = false;
    type** paramTypes = calloc(Node->children, sizeof(type*));
    int paramNo = 0;

    for (ast* param = Node->firstChild;
         param;
         param = param->nextSibling) {
        /*Ellipsis to indicate variadic function. The grammar has already
          ensured there is only one and that it is the final parameter.*/
        if (param->tag == astEllipsis) {
            variadic = true;
            debugMsg("Ellipsis");

        } else if (param->tag == astParam) {
            const type* BasicDT = analyzerDeclBasic(ctx, param->l);
            const type* paramType = analyzerDeclNode(ctx, param->r, typeDeepDuplicate(BasicDT), false, storageUndefined);

            paramTypes[paramNo++] = typeDeepDuplicate(paramType);

            if (!typeIsComplete(paramType))
                errorIncompleteParamDecl(ctx, param, Node, paramNo, paramType);

        } else
            debugErrorUnhandled("analyzerParamList", "AST tag", astTagGetStr(param->tag));
    }

    type* DT = typeCreateFunction(returnType, paramTypes, paramNo, variadic);

    debugLeave();

    return DT;
}
예제 #24
0
void fatal(const char *fmt, ...) {
  va_list ap;
  va_start(ap, fmt);
  debugMsg(MSG_QUIET, fmt, ap);
  va_end(ap);
  _exit(1);
}
예제 #25
0
void NoobaPlugin::initSignalSlots()
{
    connect(_api, SIGNAL(debugMsgRequest(QString)), this, SIGNAL(debugMsg(QString)));
    connect(_api, SIGNAL(debugMsgRequest(QString)), this, SLOT(onDebugMsg(QString)));
    connect(_api, SIGNAL(createIntParamRequest(QString,int,int,int)), this, SLOT(onCreateIntParam(QString,int, int, int)));
    connect(_api, SIGNAL(createDoubleParamRequest(QString,double, double, double)), this, SLOT(onCreateDoubleParam(QString,double, double, double)));
    connect(_api, SIGNAL(createStringParamRequest(QString,QString, bool)), this, SLOT(onCreateStringParam(QString,QString, bool)));
    connect(_api, SIGNAL(createMultiValParamRequest(QString,QStringList)), this, SLOT(onCreateMultiValParam(QString,QStringList)));
//    connect(_api, SIGNAL(createPointParamRequest(QString,QPointF)), this, SLOT(onCreatePointParam(QString,QPointF)));
//    connect(_api, SIGNAL(createRectParamRequest(QString,QRectF)), this, SLOT(onCreateRectParam(QString,QRectF)));
    connect(_api, SIGNAL(createFrameViewerRequest(QString,bool)), this, SLOT(onCreateFrameViewer(QString,bool)));
    connect(_api, SIGNAL(createFilePathParamRequest(QString,QString,nooba::PathType,QString)),
            this, SLOT(onCreateFilePathParam(QString,QString,nooba::PathType,QString)));

    connect(_api, SIGNAL(createLineParamRequest(QString,QString,QColor)), this, SLOT(onCreateLineParam(QString,QString,QColor))); // after version 0.10

    qRegisterMetaType<PluginPassData>("PluginPassData");
    connect(_api, SIGNAL(outputDataRequest(PluginPassData)), this, SIGNAL(outputData(PluginPassData)));
    qRegisterMetaType< QList<QImage> >("QList<QImage>");
    connect(_api, SIGNAL(outputDataRequest(QStringList,QList<QImage>)), this, SIGNAL(outputData(QStringList,QList<QImage>)));
    connect(_api, SIGNAL(updateFrameViewerRequest(QString,QImage)), this, SLOT(onUpdateFrameViewerRequest(QString,QImage)));
    connect(_api, SIGNAL(updateFrameViewerVisibilityRequest(QString,bool)), this, SLOT(onSetFrameViewerVisibility(QString, bool)));
    connect(this, SIGNAL(intParamUpdate(QString,int)), _api, SLOT(onIntParamChanged(QString,int)));
    connect(this, SIGNAL(doubleParamUpdate(QString,double)), _api, SLOT(onDoubleParamChanged(QString,double)));
    connect(this, SIGNAL(stringParamUpdate(QString,QString)), _api, SLOT(onStringParamChanged(QString,QString)));
    connect(this, SIGNAL(filePathParamUpdate(QString,QString)), _api, SLOT(onFilePathParamChanged(QString,QString)));
    connect(this, SIGNAL(multiValParamUpdate(QString,QString)), _api, SLOT(onMultiValParamChanged(QString,QString)));
//    connect(this, SIGNAL(pointParamUpdate(QString,QPointF)), _api, SLOT(onPointParamChanged(QString,QPointF)));
//    connect(this, SIGNAL(rectParamUpdate(QString,QRectF)), _api, SLOT(onRectParamChanged(QString,QRectF)));
    connect(this, SIGNAL(lineParamUpdate(QString,QString,QLine)), _api, SLOT(onLineParamUpdated(QString,QString,QLine)));
    qRegisterMetaType<nooba::AlertType>("nooba::AlertType");
    connect(_api, SIGNAL(generateAlertRequest(QString,QString,nooba::AlertType)), this, SLOT(onGenerateAlert(QString,QString,nooba::AlertType)));
}
예제 #26
0
// timeSync Functions
//***********************************************************************
uint32_t ICACHE_FLASH_ATTR easyMesh::getNodeTime( void ) {
    uint32_t ret = system_get_time() + timeAdjuster;

    debugMsg( GENERAL, "getNodeTime(): time=%d\n", ret);
    
    return ret;
}
예제 #27
0
/**
 *\brief get a timestamp truncated to the past hour
 */
time_t
epg_get_buf_time (void)
{
  time_t a;
  long d, m, y;
  uint32_t mjd;
  struct tm result;
//  pthread_mutex_lock (&tzmutex);
  a = time (NULL);
#ifdef __WATCOMC__
  _gmtime (&a, &result);
#else
  gmtime_r (&a, &result);
#endif
  result.tm_min = 0;
  result.tm_sec = 0;
  /*
     b) To find MJD from Y, M, D
     If M = 1 or M = 2, then L = 1; else L = 0
     MJD = 14 956 + D + int [ (Y - L) × 365,25] + int [ (M + 1 + L × 12) × 30,6001 ]
   */
  d = result.tm_mday;
  m = result.tm_mon + 1;
  y = result.tm_year;
  mjd = get_mjd (d, m, y);
  debugMsg ("BUF_MJD: %" PRIu32 "\n", mjd);
//  pthread_mutex_unlock (&tzmutex);
  return (mjd - MJD_EPOCH) * 86400 + get_time_hms (result.tm_hour, 0, 0);
//      b=mktime(&result);
//      return b;
}
예제 #28
0
/*
 *  call-seq:
 *     sentence.parse( options={} )   -> fixnum
 *
 *  Attach a parse set to this sentence and return the number of linkages
 *  found. If any +options+ are specified, they override those set in the 
 *  sentence's dictionary.
 * 
 */
static VALUE
rlink_sentence_parse( int argc, VALUE *argv, VALUE self ) {
	struct rlink_sentence *ptr = get_sentence( self );
	Parse_Options opts;
	VALUE defopts = Qnil;
	VALUE options = Qnil;
	int link_count = 0;

	/*
	if ( RTEST(ptr->parsed_p) )
		rb_raise( rlink_eLpError, "Can't reparse a sentence." );
	*/
	debugMsg(( "Parsing sentence <%p>", ptr ));

	/* Merge the hash from this call with the one from the dict and build
	   Parse_Options from it. */
	rb_scan_args( argc, argv, "01", &options );
	defopts = rb_funcall( ptr->dictionary, rb_intern("options"), 0 );

	/* Turn the option hash into a ParseOptions object, then extract the
	   Parse_Options struct from that  */
	options = rlink_make_parse_options( defopts, options );
	opts = rlink_get_parseopts( options );

	/* Parse the sentence */
	if ( (link_count = sentence_parse( ptr->sentence, opts )) < 0 )
		rlink_raise_lp_error();

	ptr->options = options;
	ptr->parsed_p = Qtrue;

	return INT2FIX( link_count );
}
예제 #29
0
static int
io_udp_socket4 (char *bcast_addr, uint16_t port, int bcast_ttl, int loop,
                struct sockaddr_in *dest_addr)
{
    int sockfd;
    debugMsg ("initialising dest_addr\n");
    memset ((void *) dest_addr, 0, sizeof (*dest_addr));
#ifdef __WIN32__
    dest_addr->sin_addr.S_un.S_addr = inet_addr (bcast_addr);
#else
    if (!inet_pton (AF_INET, bcast_addr, &dest_addr->sin_addr))
    {
        errMsg ("failed\n");
        return -1;
    }
#endif
    dest_addr->sin_port = htons (port);
    dest_addr->sin_family = AF_INET;

    sockfd = socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    if (sockfd < 0)
    {
        errMsg ("Failed to create bcast socket: %s\n", strerror (errno));
        return -1;
    }
#ifndef __WIN32__
    setsockopt (sockfd, SOL_IP, IP_MULTICAST_TTL, &bcast_ttl,
                sizeof (bcast_ttl));
    setsockopt (sockfd, SOL_IP, IP_MULTICAST_LOOP, &loop, sizeof (loop));
#endif
    return sockfd;
}
예제 #30
0
파일: opt.c 프로젝트: klammerj/dvb-vulture
int
find_opt (int argc, char *argv[], char *key)
{
  int i = 0;
  debugMsg ("looking for cmdline argument %s\n", key);
  for (i = 1; i < argc; i++)
  {
    debugMsg ("seen %s\n", argv[i]);
    if (!strcmp (argv[i], key))
    {
      debugMsg ("matches\n");
      return 1;
    }
  }
  debugMsg ("not found\n");
  return 0;
}