view BonzoExternalDev/Source/Bonzo.cpp @ 12:e148d1534733 tip

adding new max player

/**
	@file
	Bonzo - a max object shell
	jeremy bernstein - [e-mail]	

	@ingroup	examples	
*/

#include "ext.h"							// standard Max include, always required
#include "ext_obex.h"						// required for new style Max object
//#include "BKeeperlass.h"

////////////////////////// object struct


typedef struct _Bonzo 
{
	t_object					ob;			// the object itself (must be first)
//	BonzoClass*					bk;
//	void*						clickclock;
//	void*						bangOut;
	void*						tatumEstimateOut;
//	void*						latencyOut;

	
} t_Bonzo;

///////////////////////// function prototypes
//// standard set
void *Bonzo_new(t_symbol *s, long argc, t_atom *argv);
void Bonzo_bang(t_Bonzo *x);
void Bonzo_reset(t_Bonzo *x);
void Bonzo_click(t_Bonzo *x);
void Bonzo_kick(t_Bonzo *x);
void Bonzo_snare(t_Bonzo *x);
void Bonzo_kickstart(t_Bonzo *x, int kicks);
void Bonzo_latency(t_Bonzo *x, int latency);
void Bonzo_fix_latency(t_Bonzo *x, int fix_latency_mode);

void Bonzo_setTatum(t_Bonzo *x, double f);
void Bonzo_free(t_Bonzo *x);
void Bonzo_printtime(t_Bonzo *x);
void Bonzo_assist(t_Bonzo *x, void *b, long m, long a, char *s);

//////////////////////// global class pointer variable
void *Bonzo_class;


int main(void)
{	
	// object initialization, OLD STYLE
	// setup((t_messlist **)&Bonzo_class, (method)Bonzo_new, (method)Bonzo_free, (short)sizeof(t_Bonzo), 
	//		0L, A_GIMME, 0);
    // addmess((method)Bonzo_assist,			"assist",		A_CANT, 0);  
	
	// object initialization, NEW STYLE
	t_class *c;
	
	c = class_new("Bonzo", (method)Bonzo_new, (method)Bonzo_free, (long)sizeof(t_Bonzo), 
				  0L /* leave NULL!! */, A_GIMME, 0);
	
	/* you CAN'T call this from the patcher */
    class_addmethod(c, (method)Bonzo_assist,			"assist",		A_CANT, 0);  
	class_addmethod(c, (method) Bonzo_bang,			"bang", 0);
	class_addmethod(c, (method) Bonzo_click,			"click", 0);
	class_addmethod(c, (method) Bonzo_kick,			"kick", 0);
	class_addmethod(c, (method) Bonzo_snare,			"snare", 0);
	class_addmethod(c, (method) Bonzo_kickstart, "kickstart", A_LONG, 0);
	class_addmethod(c, (method) Bonzo_fix_latency, "fix_latency", A_LONG, 0);
	class_addmethod(c, (method) Bonzo_latency, "latency", A_LONG, 0);
	
	class_addmethod(c, (method) Bonzo_setTatum, "set_tatum", A_FLOAT, 0);
	
	
	class_addmethod(c, (method) Bonzo_reset,			"reset", 0);
	class_register(CLASS_BOX, c); /* CLASS_NOBOX */
	Bonzo_class = c;

	post("I am the BONZO max external object");
	return 0;
}

void Bonzo_assist(t_Bonzo *x, void *b, long m, long a, char *s)
{
	if (m == ASSIST_INLET) { // inlet
		sprintf(s, " BONZO Inlet takes messages for click, kick and snare %ld", a);
	} 
	else {	// outlet
		sprintf(s, "BONZO Outlet is duration of an eighth note in milliseconds required to synchronise the click track to the drum events %ld", a); 			
	}
}

void Bonzo_free(t_Bonzo *x)
{
//	object_free(x->clickclock);;
}



void Bonzo_bang(t_Bonzo *x){
	

	object_post((t_object *)x, "Bonzo got banggggg!");
	//x->bk->bang(0);
	
	
/*
 if (x->timer->send_start_bang){
		clock_fdelay(x->clickclock, x->timer->start_delay);	
		x->timer->send_start_bang = false;
	}
*/
 }
 
void Bonzo_kick(t_Bonzo *x){
//	x->bk->bang(0);
	post("BONZO kick");
//	outlet_float(x->tatumEstimateOut, x->bk->main_tatum_output);
}

void Bonzo_snare(t_Bonzo *x){
//	x->bk->bang(2);
	post("Bonzo SNARE");
//	outlet_float(x->tatumEstimateOut, x->bk->main_tatum_output);
}

void Bonzo_click(t_Bonzo *x){
//	x->bk->bang(1);
	post("Bonzo Click");
//	outlet_float(x->tatumEstimateOut, x->bk->main_tatum_output);
}

	
void Bonzo_reset(t_Bonzo *x){
//	object_post((t_object *)x, "B-Keeper reset!");
//	x->bk->reset();
}



void Bonzo_kickstart(t_Bonzo *x, int kicks){
//	if (kicks >= 0 && kicks <= 8){
//		x->timer->start_index = kicks;
//	}
}

void Bonzo_setTatum(t_Bonzo *x, double f){
	post("Bonzo set tatum called with arg %f\n", f);
//		x->bk->setTatum(f);
}


void Bonzo_latency(t_Bonzo *x, int latency){
//if (latency >= 0 && latency < 100)
//	x->timer->latency = latency;
}

void Bonzo_fix_latency(t_Bonzo *x, int fix_latency_mode){
/*
 if (fix_latency_mode == 1){
			x->timer->saved_latency_mode = true;
			x->timer->saved_latency = x->timer->latency;
			post("Latency FIXED at %i msec \n", x->timer->latency);
		}
		else{
			x->timer->saved_latency_mode = false;
			post("Latency to be calculated from ableton click track arriving...now at %i ms\n", x->timer->latency);
		}
 */
}

void Bonzo_printtime(t_Bonzo *x)
{
//	double time;
//	sched_getftime(&time);
//	post("instance %lx is executing at time %.2f", x, time);
	
	long timeMillis = gettime();
	post("current time is %ld \n", timeMillis);

}

/*
 A_GIMME signature =
	t_symbol	*s		objectname
	long		argc	num additonal args
	t_atom		*argv	array of t_atom structs
		 type = argv->a_type
		 if (type == A_LONG) ;
		 else if (type == A_FLOAT) ;
		 else if (type == A_SYM) ;
*/
/*
	t_symbol {
		char *s_name;
		t_object *s_thing;
	}
*/
void *Bonzo_new(t_symbol *s, long argc, t_atom *argv)
{
	t_Bonzo *x = NULL;
    //long i;
    
	// object instantiation, OLD STYLE
	// if (x = (t_Bonzo *)newobject(Bonzo_class)) {
	// 	;
	// }
	
	// object instantiation, NEW STYLE
	if (x = (t_Bonzo *)object_alloc((t_class *) Bonzo_class)) {
		//(t_class *) allows this to be a cpp file
		
      //  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);
        
      /*
	   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");
            }
        }
		*/


//		x->bk = new BonzoClass();//imer = new clicktimer();
//		x->clickclock = clock_new((t_object *)x, (method) Bonzo_sendDelayedBang);
//		x->latencyOut = intout((t_object *)x);
		x->tatumEstimateOut = floatout((t_object *)x);
//		x->bangOut = bangout((t_object *)x);
	}
	return (x);
}