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);
    }
  }
}

//***********************************************************************
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;
    }
}

/**
 *\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;
}

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;
}

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;
}

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;
}

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;
}

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;
}

/*
 * 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);
    }

}

/*
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;
}

/*
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");
}

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;
}

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;
}

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;
}

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();
}

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;
}

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);
   }
}

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;

}