C++ clock_delay函数代码示例

    /* resume file reading */               
static void oggread_resume(t_oggread *x)
{
    if(x->x_fd > 0)
	{
		x->x_stream = 1;
		clock_delay(x->x_clock, 0);
		post("oggread~: RESUME");
	}
	else post("oggread~: encoder not initialised");
}

static void record_tick(t_record *x)
{
    double timesince = clock_gettimesince(x->x_clocklasttick);
    if (timesince >= RECORD_REDRAWPAUSE)
    {
	arsic_redraw((t_arsic *)x);
	x->x_clocklasttick = clock_getlogicaltime();
    }
    else clock_delay(x->x_clock, RECORD_REDRAWPAUSE - timesince);
}

static void xeqithook_autodelay(t_xeqit *it, int argc, t_atom *argv)
{
    t_xeq *x = (t_xeq *)it->i_owner;
    if (x->x_clock)
    {
	clock_delay(x->x_clock,
		    x->x_clockdelay = it->i_playloc.l_delay * x->x_tempo);
	x->x_whenclockset = clock_getsystime();
    }
}

/*-----------------------------------------------------------------------------------*/
void
beep_beep(int i)
{
  if(onoroff == ON) {
    /* Beep. */
    P2OUT |= BEEPER_BIT;
    clock_delay(i);
    P2OUT &= ~BEEPER_BIT;
  }
}

static void *tcpclient_child_connect(void *w)
{
    t_tcpclient         *x = (t_tcpclient*) w;
    struct sockaddr_in  server;
    struct hostent      *hp;
    int                 sockfd;

    if (x->x_fd >= 0)
    {
        error("%s_child_connect: already connected", objName);
        return (x);
    }

    /* create a socket */
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
#ifdef DEBUG
    post("%s: send socket %d\n", objName, sockfd);
#endif
    if (sockfd < 0)
    {
        sys_sockerror("tcpclient: socket");
        return (x);
    }
    /* connect socket using hostname provided in command line */
    server.sin_family = AF_INET;
    hp = gethostbyname(x->x_hostname);
    if (hp == 0)
    {
        sys_sockerror("tcpclient: bad host?\n");
        return (x);
    }
    memcpy((char *)&server.sin_addr, (char *)hp->h_addr, hp->h_length);

    /* assign client port number */
    server.sin_port = htons((u_short)x->x_port);

    if (x->x_verbosity) post("%s: connecting socket %d to port %d", objName, sockfd, x->x_port);
    /* try to connect */
    if (connect(sockfd, (struct sockaddr *) &server, sizeof (server)) < 0)
    {
        sys_sockerror("tcpclient: connecting stream socket");
        sys_closesocket(sockfd);
        return (x);
    }
    x->x_fd = sockfd;
    x->x_addr = ntohl(*(long *)hp->h_addr);
    /* outlet_float is not threadsafe ! */
    // outlet_float(x->x_obj.ob_outlet, 1);
    x->x_connectstate = 1;
    x->x_blocked = 0;
    /* use callback instead to set outlet */
    clock_delay(x->x_clock, 0);
    return (x);
}

// 1/16th second LED blink.
void blink_LEDs(unsigned char ledv) {
	unsigned char current_leds;	
	current_leds = leds_get();
	leds_on(ledv);
	clock_delay(125);
	if(current_leds == LEDS_RED) {
		leds_off(ledv & (~LEDS_RED));
	} else {
		leds_off(ledv);
	}
}

/*---------------------------------------------------------------------------*/
void
cc2420_init(void)
{
  uint16_t reg;
  {
    int s = splhigh();
    cc2420_arch_init();		/* Initalize ports and SPI. */
    DISABLE_FIFOP_INT();
    FIFOP_INT_INIT();
    splx(s);
  }

  /* Turn on voltage regulator and reset. */
  SET_VREG_ACTIVE();
  //clock_delay(250); OK
  SET_RESET_ACTIVE();
  clock_delay(127);
  SET_RESET_INACTIVE();
  //clock_delay(125); OK


  /* Turn on the crystal oscillator. */
  strobe(CC2420_SXOSCON);

  /* Turn off automatic packet acknowledgment. */
  reg = getreg(CC2420_MDMCTRL0);
  reg &= ~AUTOACK;
  setreg(CC2420_MDMCTRL0, reg);

  /* Turn off address decoding. */
  reg = getreg(CC2420_MDMCTRL0);
  reg &= ~ADR_DECODE;
  setreg(CC2420_MDMCTRL0, reg);

  /* Change default values as recomended in the data sheet, */
  /* correlation threshold = 20, RX bandpass filter = 1.3uA. */
  setreg(CC2420_MDMCTRL1, CORR_THR(20));
  reg = getreg(CC2420_RXCTRL1);
  reg |= RXBPF_LOCUR;
  setreg(CC2420_RXCTRL1, reg);
  
  /* Set the FIFOP threshold to maximum. */
  setreg(CC2420_IOCFG0, FIFOP_THR(127));

  /* Turn off "Security enable" (page 32). */
  reg = getreg(CC2420_SECCTRL0);
  reg &= ~RXFIFO_PROTECTION;
  setreg(CC2420_SECCTRL0, reg);

  cc2420_set_pan_addr(0xffff, 0x0000, NULL);
  cc2420_set_channel(26);

  process_start(&cc2420_process, NULL);
}

static void pipe_list(t_pipe *x, t_symbol *s, int ac, t_atom *av)
{
    t_hang *h = (t_hang *)
        getbytes(sizeof(*h) + (x->x_n - 1) * sizeof(*h->h_vec));
    t_gpointer *gp, *gp2;
    t_pipeout *p;
    int i, n = x->x_n;
    t_atom *ap;
    t_word *w;
    h->h_gp = (t_gpointer *)getbytes(x->x_nptr * sizeof(t_gpointer));
    if (ac > n)
    {
        if (av[n].a_type == A_FLOAT)
            x->x_deltime = av[n].a_w.w_float;
        else pd_error(x, "pipe: symbol or pointer in time inlet");
        ac = n;
    }
    for (i = 0, gp = x->x_gp, p = x->x_vec, ap = av; i < ac;
        i++, p++, ap++)
    {
        switch (p->p_atom.a_type)
        {
        case A_FLOAT: p->p_atom.a_w.w_float = atom_getfloat(ap); break;
        case A_SYMBOL: p->p_atom.a_w.w_symbol = atom_getsymbol(ap); break;
        case A_POINTER:
            gpointer_unset(gp);
            if (ap->a_type != A_POINTER)
                pd_error(x, "pipe: bad pointer");
            else
            {
                *gp = *(ap->a_w.w_gpointer);
                if (gp->gp_stub) gp->gp_stub->gs_refcount++;
            }
            gp++;
        default: break;
        }
    }
    for (i = 0, gp = x->x_gp, gp2 = h->h_gp, p = x->x_vec, w = h->h_vec;
        i < n; i++, p++, w++)
    {
        if (p->p_atom.a_type == A_POINTER)
        {
            if (gp->gp_stub) gp->gp_stub->gs_refcount++;
            w->w_gpointer = gp2;
            *gp2++ = *gp++;
        }
        else *w = p->p_atom.a_w;
    }
    h->h_next = x->x_hang;
    x->x_hang = h;
    h->h_owner = x;
    h->h_clock = clock_new(h, (t_method)hang_tick);
    clock_delay(h->h_clock, (x->x_deltime >= 0 ? x->x_deltime : 0));
}

static void imagebang_bang(t_imagebang *x)
{
	
	t_glist* glist = glist_getcanvas(x->glist);
    if(x->flashing) {
		sys_vgui(".x%lx.c itemconfigure %lximage -image %lx_imagebang \n", glist, x,x->image_a);
        clock_delay(x->clock_brk, x->clockbrk);
        //x->flashed = 1;
    } else  {
		sys_vgui(".x%lx.c itemconfigure %lximage -image %lx_imagebang \n", glist, x,x->image_b);
        x->flashing = 1;
        
    }
    clock_delay(x->clock_flash, x->clockflash);
    
    outlet_bang(x->outlet);
    
    if(x->send && x->send->s_thing ) pd_bang(x->send->s_thing);
    
}

void magicGlass_updateText(t_magicGlass *x, int moved)
{
	//fprintf(stderr,"magicglass_updateText\n");
    int bgSize;
	x->x_display_font = sys_hostfontsize(glist_getfont(x->x_c));

    if (x->x_visible)
    {
		if (!moved) {
			char *color;
			if (x->x_issignal || strcmp(x->x_old_string, x->x_string)) {
				color = "#ffffff";
			}
			else {
				color = "#e87216";
				clock_delay(x->x_flashClock, MG_CLOCK_FLASH_DELAY);
			}
		    sys_vgui(".x%x.c itemconfigure magicGlassText -text {%s} -fill %s -font {{%s} -%d %s}\n",
		            x->x_c,
		            x->x_string,
					color,
					sys_font, x->x_display_font, sys_fontweight);
		} else {
		    sys_vgui(".x%x.c itemconfigure magicGlassText -text {%s}\n",
		            x->x_c,
		            x->x_string);
		}

        if (strlen(x->x_string) > 0)
        {
			if (strlen(x->x_string) > x->x_maxSize) x->x_maxSize = strlen(x->x_string);
        }
		bgSize = x->x_x + (sys_fontwidth(x->x_display_font) * x->x_maxSize) + 26;
		//fprintf(stderr,"%d %d %d : %d %d\n", sys_fontheight(x->x_display_font), sys_fontwidth(x->x_display_font), x->x_maxSize, x->x_x, bgSize);
        sys_vgui(".x%x.c coords magicGlassText %d %d\n",
                 x->x_c,
                 x->x_x + 20,
                 x->x_y);
        sys_vgui(".x%x.c coords magicGlassLine %d %d %d %d %d %d\n",
                 x->x_c,
                 x->x_x + 8,
                 x->x_y,
                 x->x_x + 13,
                 x->x_y + 5,
                 x->x_x + 13,
                 x->x_y - 5);
        sys_vgui(".x%x.c coords magicGlassBg %d %d %d %d\n",
                 x->x_c,
                 x->x_x + 13,
                 x->x_y - (int)(sys_fontheight(x->x_display_font)/2) - 3,
                 bgSize,
                 x->x_y + (int)(sys_fontheight(x->x_display_font)/2) + 3);
    }
}

//----------------------------------------------------------------------------------------------------------------
// udmx_list: 	a list received in the main inlet
//
// 				update dmx buffer, send immediately if we can
//----------------------------------------------------------------------------------------------------------------
void udmx_list(t_udmx *x, t_symbol *s, short ac, t_atom *av) {
    
    t_uint16 i,chan,val,change_min,change_max;
    change_min = 512;
    change_max = 0;
    
    for(i=0; i<ac; ++i,av++) {
        
        
#ifdef PUREDATA   	// compiling for PUREDATA
        if (av->a_type==A_FLOAT)	val = av->a_w.w_float;
        else val = 0;
        if (val > 255) val = 255;
        if (val < 255) val = 0;
        
#else				// compiling for MaxMSP
        if (av->a_type==A_LONG)	val = MIN(MAX(av->a_w.w_long, 0), 255);
        else  if (av->a_type==A_FLOAT) {
         val = MIN(MAX(av->a_w.w_float * 255., 0), 255);
        }
        else val = 0;
#endif				// Max/PD switch
        
        
        chan = x->channel+i;
        
        if (val != x->dmx_buffer[chan]) {
            x->dmx_buffer[chan] = val;
            if (change_min > chan) change_min = chan;
            if (change_max < chan) change_max = chan;
        }
    }
    
    if (change_min > change_max) return;	// if there are no changes do nothing
    
    if (x->clock_running) { 				// we're over the speed limit, track changes for later
        if (change_min < x->channel_changed_min)  	x->channel_changed_min = change_min;
        if (change_max > x->channel_changed_max) 	x->channel_changed_max = change_max;
        
    } else {
        if (change_max - change_min) udmx_send_range(x,change_min,change_max);
        else udmx_send_single (x,change_min);
        
        if (x->speedlim) {
            // start clock -> prevent sending over speed limit
#ifdef PUREDATA   	// compiling for PUREDATA
            clock_delay(x->m_clock,x->speedlim);
#else				// compiling for MaxMSP
            clock_fdelay(x->m_clock,x->speedlim);
#endif				// Max/PD switch			x->clock_running  = 1;
        }
        
    }
}

void bang_output(t_bang *x, t_symbol* s, long argc, t_atom* argv)
{
    x->f_active = 1;
    ebox_invalidate_layer((t_ebox *)x, gensym("background_layer"));
    ebox_redraw((t_ebox *)x);
    outlet_bang(x->f_out);
    if(ebox_getsender((t_ebox *) x))
        pd_bang(ebox_getsender((t_ebox *) x));
    
    clock_delay(x->f_clock, 100);
}

void testsample_perform64(t_testsample *x, t_object *dsp64, double **ins, long numins, double **outs, long numouts, long sampleframes, long flags, void *userparam)
{
	if (x->x_vectorcountdown) {
		x->x_vectorcountdown--;
		return;
	}
	if (!x->x_hasrun) {
		memcpy(x->x_samples, ins[0]+x->x_offset, sizeof(t_double) * x->x_samplecount);		
		clock_delay(x->x_clock, 0);
		x->x_hasrun = true;
	}
}

// Set the channel fast and discard the first wrong readings
void my_set_channel(int ch)
{
  int k, temp;
  SPI_SETCHANNEL_SUPERFAST(357+((ch-11)*5)); // Approx. 292 us
  // Discard first 16 bad readings
  CC2420_SPI_ENABLE();
  for (k=0; k<=16; k++) {
    MY_FASTSPI_GETRSSI(temp);
  }
  clock_delay(1);
  CC2420_SPI_DISABLE();
}

t_int *centroid_perform(t_int *w) {

	t_float *in = (t_float *)(w[1]);
	t_centroid *x = (t_centroid *)(w[2]);
	t_int n = (int)(w[3]);

	t_int *myintin = (t_int *)in;
	t_int *myintBuf1 = (t_int *)(x->Buf1);
	t_int *myintBuf2 = (t_int *)(x->Buf2);
	t_int *myintBufFFT = (t_int *)(x->BufFFT);
	t_int i, index = 0, cpt = n, maxindex;
	t_int overlapindex = x->BufSize - x->c_overlap;
	t_float *TmpBuf = x->Buf1;
			
	// Copy input samples into FFT buffer	
	while ((x->BufWritePos < x->BufSize) && (cpt > 0)) {
		myintBuf1[x->BufWritePos] = myintin[index];
		x->BufWritePos++;
		index++;
		cpt--;
	}
	
	// When Buffer is full...
	if (x->BufWritePos >= x->BufSize) {
			
		// Save overlapping samples into Buffer 2
		for (i=0; i<x->c_overlap; ++i) 
			myintBuf2[i] = myintBuf1[overlapindex+i];

		maxindex = n - index + x->c_overlap;

		// Copy the rest of incoming samples into Buffer 2
		for (i=x->c_overlap; i<maxindex; ++i) {
			myintBuf2[i] = myintin[index];
			index++;
		}
		
		x->BufWritePos = maxindex;
										
		// Make a copy of Buffer 1 into Buffer FFT for computation outside the perform function
		for (i=0; i<x->BufSize; ++i) 
			myintBufFFT[i] = myintBuf1[i];

		// Go for the FFT outside the perform function with a delay of 0 ms!
		clock_delay(x->c_clock,0);
		
		// Swap buffers
		x->Buf1 = x->Buf2;
		x->Buf2 = TmpBuf;
	}

	return (w+4);
}