C++ clock_new函数代码示例

t_mouse *mouse_new(void)
{
	t_mouse *mouse  = (t_mouse *)malloc(sizeof(t_mouse));

	mouse->button_left=button_released;
	mouse->button_right=button_released;
	mouse->button_middle=button_released;
	mouse->wheel=wheel_idle;

	mouse->x=0;
	mouse->y=0;
	mouse->delta_x=0;
	mouse->delta_y=0;
	mouse->last_x=0;
	mouse->last_y=0;
	mouse->dx=0;
	mouse->dy=0;
	mouse->is_moving=0;
	mouse->button_left_is_ready=1;
	mouse->sign_x=0;
	mouse->sign_y=0;
	mouse->clic_clock=clock_new();
	mouse->release_clock=clock_new();
	mouse->dbclic=0;
	mouse->lgclic=0;

	return mouse;
}

 PIMPL(GemWindow*gc) : parent(gc),
                       mycontext(0),
                       infoOut(0), rejectOut(0),
                       dispatchClock(0),
                       dispatchTime(10.),
                       qClock(0)
 {
   qClock=clock_new(this, reinterpret_cast<t_method>(qCallBack));
   dispatchClock=clock_new(this, reinterpret_cast<t_method>(dispatchCallBack));
 }

void *simpleNeuron_new(t_symbol *s, long argc, t_atom *argv)
{
	t_simpleNeuron *x = NULL;
    long i;

	// object instantiation
	if (x = (t_simpleNeuron *)object_alloc(simpleNeuron_class)) {
        object_post((t_object *)x, "a new %s object was instantiated: 0x%X", s->s_name, x);
        object_post((t_object *)x, "it has %ld arguments", argc);
		x = (t_simpleNeuron *)object_alloc(simpleNeuron_class);
		x->m_outlet1 = bangout((t_simpleNeuron *)x);
		x->m_clock1 = clock_new((t_simpleNeuron *)x, (method)delayedReset);
		x->m_clock2 = clock_new((t_simpleNeuron *)x, (method)leak);
		x->m_clock3 = clock_new((t_simpleNeuron *)x, (method)delayedBang);
        
        for (i = 0; i < argc; i++) {
            if ((argv + i)->a_type == A_LONG) {
                object_post((t_object *)x, "arg %ld: long (%ld)", i, atom_getlong(argv+i));
            } else if ((argv + i)->a_type == A_FLOAT) {
                object_post((t_object *)x, "arg %ld: float (%f)", i, atom_getfloat(argv+i));
            } else if ((argv + i)->a_type == A_SYM) {
                object_post((t_object *)x, "arg %ld: symbol (%s)", i, atom_getsym(argv+i)->s_name);
            } else {
                object_error((t_object *)x, "forbidden argument");
            }
        }
	}
	
	// default settings
	
	x->d_V = 0;
	x->d_Vth = 5;
	x->d_C = 1;
	x->d_R = 100;
	
	// Fitzhugh
	x->d_W = 0;
	x->d_Wth = 1.5;
	x->d_Wr  = 1.3;
	x->d_a = -0.7;  // http://www.scholarpedia.org/article/FitzHugh-Nagumo_model
	x->d_b = 0.8;
	x->d_tao = 12.5;
	x->d_stepSize = 0.3; // this needs to be
	x->l_bangFlag = 0;
	
	x->l_mode = 0;
	x->l_ref = 0;
	
	x->d_absRef = 100;
	x->d_leakPer = 100;
	x->d_bangD = 10;
	
	return (x);
}

/* \param qu determines whether timed messages should be queued (low priority - only when supported by the system).
*/
flext::Timer::Timer(bool qu):
    queued(qu),
    clss(NULL),userdata(NULL),
    period(0)
{
#if FLEXT_SYS == FLEXT_SYS_PD
    clk = (t_clock *)clock_new(this,(t_method)callback);
#elif FLEXT_SYS == FLEXT_SYS_MAX
    clk = (t_clock *)clock_new(this,(t_method)callback);
    if(queued) qelem = (t_qelem *)qelem_new(this,(method)queuefun);
#else
    #error Not implemented
#endif
}

void *breakpoints_new(t_symbol *s, int argc, t_atom *argv)
{
    t_binbuf* d = binbuf_via_atoms(argc,argv);
	t_breakpoints *x = (t_breakpoints *)eobj_new(breakpoints_class);
    if(x && d)
    {
        x->f_outline_mode = 0;
        long flags = 0
        | EBOX_GROWINDI
        ;
        ebox_new((t_ebox *)x, flags);
        
        x->f_out_float = (t_outlet *)floatout(x);
        x->f_out_list = (t_outlet *)listout(x);
        x->f_out_function = (t_outlet *)listout(x);
        
        x->f_number_of_points = 0;
        x->f_point_hover    = -1;
        x->f_point_selected = -1;
        x->f_output_inc     = -1;
        x->f_output_nextprev = 0;
        x->f_point_last_created = -1;
        x->f_mouse.x = -666666;
        x->f_mouse.y = -666666;
        
        x->f_clock = clock_new(x, (t_method)breakpoints_inc);
        
        ebox_attrprocess_viabinbuf(x, d);
        breakpoints_init(x, d);
        ebox_ready((t_ebox *)x);
    }
    
    return (x);
}

void *phasorshot_new(t_symbol *s,int argc,t_atom* argv)
{
    t_phasorshot *x = (t_phasorshot *)pd_new(phasorshot_class);
    
    x->x_f = 0;
    if (argc) x->x_f = atom_getfloat(argv++),argc--;
    
    inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("ft1"));
    
    x->x_phase = 0;
    x->x_conv = 0;
   
    outlet_new(&x->x_obj, gensym("signal"));
    
    inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("loop"));
    x->loop = 0;
    
    if (argc) x->loop = atom_getfloat(argv++),argc--;
     
     x->state = 0;
    
    x->x_outlet1 = outlet_new(&x->x_obj, &s_bang);
    x->x_outlet2 = outlet_new(&x->x_obj, &s_bang);
    
    x->x_clock = clock_new(x, (t_method)phasorshot_tick);

    
    return (x);
}

static void *env_tilde_new(t_floatarg fnpoints, t_floatarg fperiod)
{
    int npoints = fnpoints;
    int period = fperiod;
    t_sigenv *x;
    t_sample *buf;
    int i;

    if (npoints < 1) npoints = 1024;
    if (period < 1) period = npoints/2;
    if (period < npoints / MAXOVERLAP + 1)
        period = npoints / MAXOVERLAP + 1;
    if (!(buf = getbytes(sizeof(t_sample) * (npoints + INITVSTAKEN))))
    {
        error("env: couldn't allocate buffer");
        return (0);
    }
    x = (t_sigenv *)pd_new(env_tilde_class);
    x->x_buf = buf;
    x->x_npoints = npoints;
    x->x_phase = 0;
    x->x_period = period;
    for (i = 0; i < MAXOVERLAP; i++) x->x_sumbuf[i] = 0;
    for (i = 0; i < npoints; i++)
        buf[i] = (1. - cos((2 * 3.14159 * i) / npoints))/npoints;
    for (; i < npoints+INITVSTAKEN; i++) buf[i] = 0;
    x->x_clock = clock_new(x, (t_method)env_tilde_tick);
    x->x_outlet = outlet_new(&x->x_obj, gensym("float"));
    x->x_f = 0;
    x->x_allocforvs = INITVSTAKEN;
    return (x);
}

static void *pvu_tilde_new(t_floatarg metro_time, t_floatarg release_time, t_floatarg threshold)
{
  t_pvu_tilde *x;
  t_float t;
  
  x = (t_pvu_tilde *)pd_new(pvu_tilde_class);
  if(metro_time <= 0.0f)
    metro_time = 300.0f;
  if(metro_time <= 5.0f)
    metro_time = 5.0f;
  if(release_time <= 0.0f)
    release_time = 300.0f;
  if(release_time <= 5.0f)
    release_time = 5.0f;
  if(threshold == 0.0f)
    threshold = -0.01f;
  x->x_threshold_over = threshold;
  x->x_overflow_counter = 0;
  x->x_metro_time = metro_time;
  x->x_release_time = release_time;
  x->x_c1 = exp(-metro_time/release_time);
  x->x_cur_peak = 0.0f;
  x->x_old_peak = 0.0f;
  x->x_clock = clock_new(x, (t_method)pvu_tilde_tick);
  x->x_outlet_meter = outlet_new(&x->x_obj, &s_float);/* left */
  x->x_outlet_over = outlet_new(&x->x_obj, &s_float); /* right */
  x->x_started = 1;
  x->x_float_sig_in = 0.0f;
  return(x);
}

void *meter_new(t_symbol *s, int argc, t_atom *argv)
{
	t_meter *x =  NULL;
	t_binbuf* d;
    long flags;
	if (!(d = binbuf_via_atoms(argc,argv)))
		return NULL;
    
	x = (t_meter *)eobj_new(meter_class);
    
    flags = 0
    | EBOX_GROWINDI
    | EBOX_IGNORELOCKCLICK
    ;
    
	ebox_new((t_ebox *)x, flags);
    eobj_dspsetup((t_ebox *)x, 1, 0);
    
    x->f_direction      = 0;
    x->f_peaks_outlet   = floatout(x);
    x->f_peak_value     = -90.;
    x->f_clock          = clock_new(x,(t_method)meter_tick);
	x->f_startclock     = 0;
    x->f_over_led_preserved = 0;
    ebox_attrprocess_viabinbuf(x, d);
	ebox_ready((t_ebox *)x);
    
	return (x);
}

void *hoa_scope_3D_new(t_symbol *s, int argc, t_atom *argv)
{
	t_hoa_scope_3D *x =  NULL;
	t_binbuf *d;
	long flags;
	
	if (!(d = binbuf_via_atoms(argc, argv)))
		return NULL;

	x = (t_hoa_scope_3D *)eobj_new(hoa_scope_3D_class);
    
    x->f_order      = 1;
	x->f_startclock = 0;
	x->f_scope      = new Hoa3D::Scope(x->f_order, NUMBEROFCIRCLEPOINTS_UI2 * 0.5, NUMBEROFCIRCLEPOINTS_UI2);
    x->f_order      = x->f_scope->getDecompositionOrder();
    x->f_signals    = new t_float[x->f_scope->getNumberOfHarmonics() * SYS_MAXBLKSIZE];
    x->f_index      = 0;
    
    eobj_dspsetup(x, x->f_scope->getNumberOfHarmonics(), 0);
    
	flags = 0
    | EBOX_IGNORELOCKCLICK
    | EBOX_GROWLINK
    ;
	ebox_new((t_ebox *)x, flags);
    
    x->f_clock = clock_new(x,(t_method)hoa_scope_3D_tick);
	x->f_startclock = 0;
    
    ebox_attrprocess_viabinbuf(x, d);
	ebox_ready((t_ebox *)x);
	
	return (x);
}

static void *bang_tilde_new(t_symbol *s)
{
    t_bang *x = (t_bang *)pd_new(bang_tilde_class);
    x->x_clock = clock_new(x, (t_method)bang_tilde_tick);
    outlet_new(&x->x_obj, &s_bang);
    return (x);
}

void GemMan :: createContext(char* disp)
{
  // can we only have one context?

  t_atom*a=GemSettings::get("window.singlecontext"); // find a better name!
  if(a) {
    int i=atom_getint(a);
    if(1==i)
      s_singleContext = 1;
      /*
      m_width = 640;
      m_height = 480;
      */
  }

  s_windowClock = clock_new(NULL, reinterpret_cast<t_method>(GemMan::dispatchWinmessCallback));
  if (!m_windowContext && !createConstWindow(disp))
    {
      error("GEM: A serious error occured creating const Context");
      error("GEM: Continue at your own risk!");
      m_windowContext = 0;
    } else 
    m_windowContext = 1;
  setResizeCallback(GemMan::resizeCallback, NULL);
}

static void *abl_link_tilde_new(t_symbol *s, int argc, t_atom *argv) {
    t_abl_link_tilde *x = (t_abl_link_tilde *)pd_new(abl_link_tilde_class);
    x->clock = clock_new(x, (t_method)abl_link_tilde_tick);
    x->step_out = outlet_new(&x->obj, &s_float);
    x->phase_out = outlet_new(&x->obj, &s_float);
    x->beat_out = outlet_new(&x->obj, &s_float);
    x->steps_per_beat = 1;
    x->prev_beat_time = 0;
    x->quantum = ABLLinkGetQuantum(libpdLinkRef);
    x->tempo = 0;
    switch (argc) {
        default:
            post("abl_link~: Unexpected number of creation args: %d", argc);
        case 4:
            if (ABLLinkIsConnected(libpdLinkRef)) {
                post("abl_link~: Ignoring tempo parameter because Link is connected.");
            } else {
                x->tempo = atom_getfloat(argv + 3);
            }
        case 3:
            x->quantum = atom_getfloat(argv + 2);
        case 2:
            x->prev_beat_time = atom_getfloat(argv + 1);
        case 1:
            x->steps_per_beat = atom_getfloat(argv);
        case 0:
            break;
    }
    return x;
}

static void *rawin_new(t_symbol *spipe, t_symbol *type)
{
    t_rawin *x;

    pdp_post("%s %s", spipe->s_name, type->s_name);

    /* allocate & init */
    x = (t_rawin *)pd_new(rawin_class);
    x->x_outlet = outlet_new(&x->x_obj, &s_anything);
    x->x_sync_outlet = outlet_new(&x->x_obj, &s_anything);
    x->x_clock = clock_new(x, (t_method)rawin_tick);
    x->x_queue = pdp_list_new(0);
    x->x_active = 0;
    x->x_giveup = 0;
    x->x_mode = 0;
    x->x_type = pdp_gensym("image/YCrCb/320x240"); //default
    x->x_pipe = gensym("/tmp/pdpraw"); // default
    pthread_attr_init(&x->x_attr);
    pthread_mutex_init(&x->x_mut, NULL);
    clock_delay(x->x_clock, PERIOD);

    /* args */
    rawin_type(x, type);
    if (spipe->s_name[0]) x->x_pipe = spipe; 

    return (void *)x;

}

void *LJ_IOIn_new(t_symbol *s, int argc, t_atom *argv)
{
	t_LJ_IOIn *x;	
	x = (t_LJ_IOIn *)pd_new(LJ_IOIn_class);
	int i;
	
	// outlets
	x->nb_ports = argc;
	for (i = 0; (i < argc) && (i < 4); i++) {
		x->io[i] = outlet_new(&x->p_ob, &s_float);
		x->ports[i] = atom_getfloat(argv+i);
	}

	x->err = outlet_new(&x->p_ob, &s_bang);

	// a clock to update outputs 
  	x->x_clock = clock_new(x, (t_method) LJ_IOIn_update);

	// setting up thread and semaphores
	sem_init (&x->busy, 0, 1);
	sem_init (&x->go, 0, 0);
	sem_init (&x->acquired, 0, 1);

	LJ_IOIn_thread_start(x);

	return x; 
}