Example #1
0
void *connect_new(t_symbol *s, long argc, t_atom *argv)
{
	t_connect *x = NULL;

	x = (t_connect *)object_alloc((t_class *)connect_class);
	if (x)
	{	
		x->f_harmonics = 4;
		x->f_output = 4;
		if(atom_gettype(argv) == A_LONG)
			x->f_harmonics	= atom_getlong(argv) * 2 +1;
		if(atom_gettype(argv+1) == A_LONG)
			x->f_output	= atom_getlong(argv+1);
		else 
			x->f_output = x->f_harmonics;
		
		// colors setup
		x->f_colorPositiv.red = x->f_colorPositiv.alpha = 1.;
		x->f_colorPositiv.green = x->f_colorPositiv.blue = 0.;
		x->f_colorNegativ.blue = x->f_colorNegativ.alpha = 1.;
		x->f_colorNegativ.green = x->f_colorNegativ.red = 0.;
		x->f_colorPlane.red = x->f_colorPlane.green = x->f_colorPlane.blue = x->f_colorPlane.alpha = 1.;
		
		//object_obex_lookup(x, gensym("#P"), &x->f_patcher); // passé dans la fonction connect_attach
		defer_low(x, (method)connect_attach, NULL, 0, NULL);
		
		//attr_args_process(x, argc, argv);
		x->f_nbSelected = 0;
	}
	
	return x;
}	
Example #2
0
void *f0ext_new(t_symbol *s, long argc, t_atom *argv) {
	t_f0ext *x= (t_f0ext *)object_alloc(f0ext_class);
	if(x) {
        x->valLeft= 0.0;
        x->valOut= 0.0;
        x->valMiddle= 120.0;
        x->valRight= 20.0;
        t_atom *ap;
        ap= argv;
        ap++;
        if(argc>2) {post("warning: f0.beats_to_frames %d extra argument(s)", argc-2);}
        switch(MIN(argc, 2)) {
            case 2:
                if(atom_gettype(ap)==A_FLOAT) {
                    x->valRight= (double)atom_getfloat(ap);
                } else if(atom_gettype(ap)==A_LONG) {
                    x->valRight= (double)atom_getlong(ap);
                }
            case 1:
                ap--;
                if(atom_gettype(ap)==A_FLOAT) {
                    x->valMiddle= (double)atom_getfloat(ap);
                } else if(atom_gettype(ap)==A_LONG) {
                    x->valMiddle= (double)atom_getlong(ap);
                }
        }
        floatin(x, 2);
        floatin(x, 1);
        x->out= floatout(x);
    }
	return (x);
}
Example #3
0
	void send(long inlet, t_symbol *s, long ac, t_atom *av) {
		if(ac==1)
		{
			//post("inlet %ld int %ld", inlet, ac);
			unsigned char value = atom_getlong(av);
			//post("value is %ld", value);
			message.push_back(value);
			if(is_valid_message(&message))
			{
				if(midiout && midiout->isPortOpen()) {
					midiout->sendMessage( &message );
				}
				message.clear();
			}

		}
		else
		{
			message.clear();
			for (int i=0; i<ac; i++) {
				unsigned char value = atom_getlong(av+i);
				message.push_back(value);
			}
			
			if(midiout && midiout->isPortOpen()) {
				midiout->sendMessage( &message );
				
			}
			message.clear();
		}
    }
Example #4
0
File: lorenz.c Project: mzed/lorenz
void *lorenz_new(t_symbol *s, long argc, t_atom *argv)
{
    t_lorenz *x;
    x = (t_lorenz *)object_alloc(lorenz_class);
    x->l_xyz[0]= x->l_xyz[1] = x->l_xyz[2] = 0.6;
    x->l_h = 0.01;
    if (argc) {
        for (int i = 0; i < argc; ++i) {
            if (i < 3) {
                if ((argv+i)->a_type == A_FLOAT) {
                    x->l_xyz[i] = (double)atom_getfloat(argv+i);
                } else if ((argv+i)->a_type == A_LONG) {
                    x->l_xyz[i] = (double)atom_getlong(argv+i);
                }
            }
        }
        if (argc > 3){
            if (argv[3].a_type == A_FLOAT) {
                x->l_h = atom_getfloat(argv+3);
            } else if (argv[3].a_type == A_LONG) {
                x->l_h = (float)atom_getlong(argv+3);
            }
        }
    }
    
    floatin(x,3);
	floatin(x,2);
	floatin(x,1);
	
	x->l_out2 = floatout(x);
	x->l_out1 = floatout(x);
	x->l_out0 = floatout(x);
	
    return (x);
}
t_pd_err vectors_set(t_hoa_meter *x, void *attr, long argc, t_atom *argv)
{
    if(argc && argv)
    {
        if(atom_gettype(argv) == A_SYM)
        {
            if(atom_getsym(argv) == hoa_sym_energy)
                x->f_vector_type = hoa_sym_energy;
            else if(atom_getsym(argv) == hoa_sym_velocity)
                x->f_vector_type = hoa_sym_velocity;
            else if(atom_getsym(argv) == hoa_sym_both)
                x->f_vector_type = hoa_sym_both;
            else
                x->f_vector_type = hoa_sym_none;
        }
        else if(atom_gettype(argv) == A_FLOAT)
        {
            if(atom_getlong(argv) == 1)
                x->f_vector_type = hoa_sym_energy;
            else if(atom_getlong(argv) == 2)
                x->f_vector_type = hoa_sym_velocity;
            else if(atom_getlong(argv) == 3)
                x->f_vector_type = hoa_sym_both;
            else
                x->f_vector_type = hoa_sym_none;
        }
        ebox_invalidate_layer((t_ebox *)x, hoa_sym_vector_layer);
    }
    return 0;
}
Example #6
0
t_max_err coefficients_set(t_space *x, void *attr, long ac, t_atom *av)
{
    if (ac >= 1 && atom_getfloat(av) == 666.)
    {
        for (int i = 0; i < x->f_number_of_microphones; i++)
		{
                x->f_microphonesValues[i] = 0.;
        }
        
    }
    else if (ac && av)
    {
        if(atom_gettype(av) == A_FLOAT)
        {
            if(x->f_mode == 0)
            {
                for (int i = 0; i < ac && i < MAX_MICS; i++)
                {
                    if(atom_gettype(av+i) == A_FLOAT)
                        x->f_microphonesValues[i] = Tools::clip((double)atom_getfloat(av + i), 0., 1.);
                }
                
            }
            else if(x->f_mode == 2)
            {
                double max = 1.;
                double min = 0.;
                for (int i = 0; i < ac && i < MAX_MICS; i++)
                {
                    if(atom_getfloat(av + i) > max)
                        max = atom_getfloat(av + i);
                    if(atom_getfloat(av + i) < min)
                        min = atom_getfloat(av + i);
                }
                for (int i = 0; i < ac && i < MAX_MICS; i++)
                {
                    if(atom_gettype(av+i) == A_FLOAT)
                        x->f_microphonesValues[i] = atom_getfloat(av + i) - (max - 1.) - min;
                }
            }
            else
            {
                for (int i = 0; i < ac && i < MAX_MICS; i++)
                {   
                    x->f_microphonesValues[i] = atom_getfloat(av + i);
                }
            }
            
        }
        else if (atom_gettype(av) == A_LONG && ac >= 2)
        {
            if(atom_gettype(av+1) == A_FLOAT && atom_getlong(av) < x->f_number_of_microphones)
                x->f_microphonesValues[atom_getlong(av)] = Tools::clip((double)atom_getfloat(av+1), 0., 1.);
        }
    }
   
    if (x->f_number_of_microphones_initialized ==  true)
        space_compute(x);
    return 0;
}
Example #7
0
void *HoaStereo_new(t_symbol *s, long argc, t_atom *argv)
{
	t_HoaStereo *x = NULL;
	int order = 4;
	double anAngle1 = 60.;
	if (x = (t_HoaStereo *)object_alloc((t_class*)HoaStereo_class)) 
	{
		if(atom_gettype(argv) == A_LONG)
			order	= atom_getlong(argv);
		
		if(atom_gettype(argv+1) == A_LONG)
			anAngle1	= atom_getlong(argv+1);
		else if(atom_gettype(argv+1) == A_FLOAT)
			anAngle1	= atom_getfloat(argv+1);
		
		x->f_AmbisonicStereo	= new AmbisonicStereo(order, anAngle1, sys_getblksize());
		
		dsp_setup((t_pxobject *)x, x->f_AmbisonicStereo->getNumberOfInputs());
		for (int i = 0; i < x->f_AmbisonicStereo->getNumberOfOutputs(); i++) 
			outlet_new(x, "signal");
		
		x->f_ob.z_misc = Z_NO_INPLACE;
	}
	return (x);
}
Example #8
0
void hoa_map_3D_tilde_list(t_hoa_map_3D_tilde *x, t_symbol* s, long argc, t_atom* argv)
{
    if(argc > 2 && argv && atom_gettype(argv) == A_LONG && atom_gettype(argv+1) == A_SYM)
    {
        int index = atom_getlong(argv);
        if(index < 1 || index > x->f_map->getNumberOfSources())
            return;
        
        if(argc > 4 && (atom_getsym(argv+1) == hoa_sym_polar || atom_getsym(argv+1) == hoa_sym_pol))
        {
            x->f_lines->setRadius(index-1, atom_getfloat(argv+2));
            x->f_lines->setAzimuth(index-1, atom_getfloat(argv+3));
            x->f_lines->setElevation(index-1, atom_getfloat(argv+4));
        }
        else if(argc > 4 && (atom_getsym(argv+1) == hoa_sym_cartesian || atom_getsym(argv+1) == hoa_sym_car))
        {
            x->f_lines->setRadius(index-1, radius(atom_getfloat(argv+2), atom_getfloat(argv+3), atom_getfloat(argv+4)));
            x->f_lines->setAzimuth(index-1, azimuth(atom_getfloat(argv+2), atom_getfloat(argv+3), atom_getfloat(argv+4)));
            x->f_lines->setElevation(index-1, elevation(atom_getfloat(argv+2), atom_getfloat(argv+3), atom_getfloat(argv+4)));
        }
        else if(argc > 2 && atom_getsym(argv+1) == hoa_sym_mute)
        {
            x->f_map->setMute(index-1, atom_getlong(argv+2));
        }
    }
}
Example #9
0
void *HoaSevenDotOne_new(t_symbol *s, long argc, t_atom *argv)
{
	t_HoaSevenDotOne *x = NULL;
	int order = 4;
	double anAngle1 = 30.;
	double anAngle2 = 110.;
	if (x = (t_HoaSevenDotOne *)object_alloc((t_class*)HoaSevenDotOne_class)) 
	{
		if(atom_gettype(argv) == A_LONG)
			order	= atom_getlong(argv);
		if(atom_gettype(argv+1) == A_LONG)
			anAngle1	= atom_getlong(argv+1);
		else if(atom_gettype(argv+1) == A_FLOAT)
			anAngle1	= atom_getfloat(argv+1);
		if(atom_gettype(argv+2) == A_LONG)
			anAngle2	= atom_getlong(argv+2);
		else if(atom_gettype(argv+2) == A_FLOAT)
			anAngle2	= atom_getfloat(argv+2);

		x->f_AmbisonicSixDotOne	= new AmbisonicSixDotOne(order, anAngle1, anAngle2, sys_getblksize());
		
		dsp_setup((t_pxobject *)x, x->f_AmbisonicSixDotOne->getNumberOfInputs());
		for (int i = 0; i < x->f_AmbisonicSixDotOne->getNumberOfOutputs(); i++) 
			outlet_new(x, "signal");
		
	
	}
	return (x);
}
Example #10
0
void CLASSMETHOD(ClipMode)(IMPORT_T, t_symbol *s, long argc, t_atom *argv)
{
  if (argc != 3) {
    post("Clip Led messages must have 3 parts: column - row - mode");
    return;
  }

  int row, column;
  CLIP_LED cl = CL_INVALID;

  if (atom_gettype(argv) == A_LONG) {
    column = (int)atom_getlong(argv);
  }
  else {
    post("First argument is not an integer.");
    return;
  }

  if (atom_gettype(argv + 1) == A_LONG) {
    row = (int)atom_getlong(argv + 1);
  }
  else {
    post("Second argument is not an integer.");
    return;
  }

  if (row < 1 || row > CLIPROWS || column < 1 || column > CLIPCOLUMNS) {
    post("Element is not in range.");
    return;
  }

  // set array offset
  row--; column--;

  if (atom_gettype(argv + 2) == A_LONG) {
    int mode = (int)atom_getlong(argv + 2);
    switch (mode) {
      case 0: T->memory.setClipMode(column, row, CM_OFF); break;
      case 1: T->memory.setClipMode(column, row, CM_SINGLE_ORANGE_GREEN); break;
      case 2: T->memory.setClipMode(column, row, CM_SINGLE_ORANGE_RED); break;
      case 3: T->memory.setClipMode(column, row, CM_TOGGLE_ORANGE_GREEN); break;
      case 4: T->memory.setClipMode(column, row, CM_TOGGLE_ORANGE_RED); break;
      case 5: T->memory.setClipMode(column, row, CM_CUSTOM); break;
      default: {
        post("Third argument is not a valid integer");
        return;
      }
    }

  }
  else {
    post("Third argument is not an integer");
    return;
  }

  // send led color to apc
  {
    CLASSMETHOD(SendNoteOn)(T, column + 1, row + 53, (int)T->memory.getClipLed(column, row));
  }
}
Example #11
0
t_max_err number_of_microphones_set(t_space *x, t_object *attr, long argc, t_atom *argv)
{
    if(atom_gettype(argv) == A_LONG)
	{
		if(atom_getlong(argv) != x->f_number_of_microphones)
		{
			delete x->f_viewer;
            delete x->f_recomposer;
            
            x->f_number_of_microphones = Tools::clip(atom_getlong(argv), (long)3, (long)MAX_MICS);
            if(x->f_number_of_microphones % 2 == 0)
                x->f_order              = (x->f_number_of_microphones - 2) / 2;
            else
                 x->f_order             = (x->f_number_of_microphones - 1) / 2;
            x->f_number_of_harmonics    = x->f_order * 2 + 1;
            
			x->f_viewer         = new AmbisonicViewer(x->f_order);
            x->f_recomposer		= new ambisonicRecomposer(x->f_order, x->f_number_of_microphones);
            

            jbox_invalidate_layer((t_object*)x, NULL, gensym("background_layer"));
            space_compute(x);
		}
	}
	return 0;
}
Example #12
0
void *hoa_map_new(t_symbol *s, long argc, t_atom *argv)
{
	t_hoa_map *x = NULL;
	int	order = 1;
    int numberOfSources = 1;
    x = (t_hoa_map *)object_alloc(hoa_map_class);
	if (x)
	{		
		if(atom_gettype(argv) == A_LONG)
			order = atom_getlong(argv);
        if(argc > 1 && atom_gettype(argv+1) == A_LONG)
            numberOfSources = atom_getlong(argv+1);

		x->f_map = new Hoa3D::Map(order, numberOfSources);
		if(x->f_map->getNumberOfSources() == 1)
            dsp_setup((t_pxobject *)x, 4);
        else
            dsp_setup((t_pxobject *)x, x->f_map->getNumberOfSources());
		
		for (int i = 0; i < x->f_map->getNumberOfHarmonics(); i++)
			outlet_new(x, "signal");
        
        if(x->f_map->getNumberOfSources() == 1)
            x->f_sig_ins    =  new double[4 * SYS_MAXBLKSIZE];
        else
            x->f_sig_ins    =  new double[x->f_map->getNumberOfSources() * SYS_MAXBLKSIZE];
        x->f_sig_outs   =  new double[x->f_map->getNumberOfHarmonics() * SYS_MAXBLKSIZE];
	}
    
	return (x);
}
Example #13
0
void tralala_mouseHitZone(t_tll *x)
{
    long argc, k = TLL_SELECTED;
    t_atom *argv = NULL;
    long position = TLL_X_TO_POSITION(x->cursor.x);
    long pitch = TLL_Y_TO_PITCH(x->cursor.y);
    
    TLL_DATA_LOCK
    
    if (!(dictionary_getatoms(x->current, TLL_SYM_ZONE, &argc, &argv))) {
        if (position < atom_getlong(argv + 1)) { 
            k = TLL_SELECTED_START;
        } else if (position > atom_getlong(argv + 2)) { 
            k = TLL_SELECTED_END;
        } else if (pitch < atom_getlong(argv + 3)) { 
            k = TLL_SELECTED_DOWN;
        } else if (pitch > atom_getlong(argv + 4)) { 
            k = TLL_SELECTED_UP;
        } 
    }
    
    dictionary_appendlong(x->status, TLL_SYM_ZONE, k);
    
    TLL_DATA_UNLOCK
}
Example #14
0
void *HoaRecomposer_new(t_symbol *s, long argc, t_atom *argv)
{
	t_HoaRecomposer *x = NULL;
    t_dictionary *d;
	int order = 4, inputs = 10;
    x = (t_HoaRecomposer *)object_alloc((t_class*)HoaRecomposer_class);
	if (x)
	{
		if(atom_gettype(argv) == A_LONG)
			order	= atom_getlong(argv);
		if(atom_gettype(argv+1) == A_LONG)
			inputs	= atom_getlong(argv+1);
        
        /* Base Attributes */
        
		x->f_ambiRecomposer	= new AmbisonicRecomposer(order, inputs, Hoa_Fixe, sys_getblksize(), sys_getsr());
        x->f_ambiRecomposer->setRampInMs(20.);
        
        x->f_ramp_time = x->f_ambiRecomposer->getRampInMs();
        x->f_mode = gensym("fixe");
        
		dsp_setup((t_pxobject *)x, x->f_ambiRecomposer->getNumberOfInputs());
		for (int i = 0; i < x->f_ambiRecomposer->getNumberOfOutputs(); i++)
			outlet_new(x, "signal");
        
		x->f_ob.z_misc = Z_NO_INPLACE;
        
        attr_args_process(x, argc, argv);
        d = (t_dictionary *)gensym("#D")->s_thing;
        if (d) attr_dictionary_process(x, d);
        object_attr_setdisabled((t_object *)x, gensym("ramp"), (x->f_mode == gensym("fixe")) ? 1 : 0);
	}
	return (x);
}
void *hoa_projector_new(t_symbol *s, long argc, t_atom *argv)
{
	// @arg 0 @name ambisonic-order @optional 0 @type int @digest The ambisonic order of decomposition
	// @description First argument is the ambisonic order of decomposition.
	
	// @arg 1 @name number-of-channels @optional 0 @type int @digest The number of channels
	// @description Second argument sets the number of channels.
	
	t_hoa_projector *x = NULL;
	int	order = 1;
    int numberOfLoudspeakers = 4;
    x = (t_hoa_projector *)object_alloc(hoa_projector_class);
	if (x)
	{		
		if(atom_gettype(argv) == A_LONG)
			order = atom_getlong(argv);
		if(order < 1)
            order = 1;
        if(atom_gettype(argv+1) == A_LONG)
			numberOfLoudspeakers = atom_getlong(argv+1);
        if(numberOfLoudspeakers < order * 2 + 1)
            numberOfLoudspeakers = order * 2 + 1;
		
		x->f_projector = new Hoa2D::Projector(order, numberOfLoudspeakers);
		
		dsp_setup((t_pxobject *)x, x->f_projector->getNumberOfHarmonics());
		for (int i = 0; i < x->f_projector->getNumberOfChannels(); i++)
			outlet_new(x, "signal");
        
		x->f_ins = new double[x->f_projector->getNumberOfHarmonics() * SYS_MAXBLKSIZE];
        x->f_outs = new double[x->f_projector->getNumberOfChannels() * SYS_MAXBLKSIZE];
	}

	return (x);
}
Example #16
0
t_max_err number_of_microphones_set(t_space *x, t_object *attr, long argc, t_atom *argv)
{
    if(atom_gettype(argv) == A_LONG)
	{
		if(atom_getlong(argv) != x->f_number_of_microphones || x->f_number_of_microphones_initialized == false)
		{
			delete x->f_viewer;
            delete x->f_recomposer;
            
            x->f_number_of_microphones = atom_getlong(argv);

            x->f_number_of_microphones = Tools::clip_min(x->f_number_of_microphones, (long)3);
            if(x->f_number_of_microphones % 2 == 0)
                x->f_order              = (x->f_number_of_microphones - 2) / 2;
            else
                 x->f_order             = (x->f_number_of_microphones - 1) / 2;
            x->f_number_of_harmonics    = x->f_order * 2 + 1;
            			
			x->f_viewer         = new AmbisonicViewer(x->f_order);
            x->f_recomposer		= new ambisonicRecomposer(x->f_order, x->f_number_of_microphones);
            
            if(x->f_number_of_microphones_initialized == false)
                x->f_number_of_microphones_initialized = true;
            jbox_invalidate_layer((t_object*)x, NULL, gensym("background_layer"));
            object_method(x, gensym("coeffs"), 0, NULL);
		}
	}
	return 0;
}
Example #17
0
void minimum_compare(t_big_atom *min, t_atom *newone, long *i, long *minIndex)
{
	double a, b;

	if (min->a_type ==A_NOTHING) {
		min->a_type = atom_gettype(newone);
		if (atom_gettype(newone) == A_LONG)
			min->w_long = atom_getlong(newone);
		else if (atom_gettype(newone) == A_FLOAT)
			min->w_float = atom_getfloat(newone);
		else {
			min->a_type = A_LONG;
			min->w_long = 0L;
		}
		return;
	}
	if (min->a_type ==A_FLOAT)
		a = min->w_float;
	else
		a = (double)min->w_long;
	if (atom_gettype(newone) == A_FLOAT)
		b = atom_getfloat(newone);
	else
		b = (double)atom_getlong(newone);

	if (a <= b) {
		min->a_type = A_FLOAT;
		min->w_float = a;
	} else {
		*minIndex = *i;
		min->a_type = A_FLOAT;
		min->w_float = b;
	}
}
void *hoa_projector_new(t_symbol *s, long argc, t_atom *argv)
{
	// @arg 0 @name ambisonic-order @optional 0 @type int @digest The ambisonic order of decomposition
	// @description First argument is the ambisonic order of decomposition.
	
	// @arg 1 @name number-of-channels @optional 0 @type int @digest The number of channels
	// @description Second argument sets the number of channels.
    
	t_hoa_projector *x = NULL;
    x = (t_hoa_projector *)object_alloc(hoa_projector_class);
	if (x)
	{
        ulong order = 1;
        ulong numberOfPlanewaves = 4;
        
		if(argc && atom_gettype(argv) == A_LONG)
			order = max<long>(atom_getlong(argv), 1);
        
        if(argc > 1 && atom_gettype(argv+1) == A_LONG)
			numberOfPlanewaves = max<long>(atom_getlong(argv+1), order * 2 + 1);
		
		x->f_projector = new Projector<Hoa2d, t_sample>(order, numberOfPlanewaves);
		
		dsp_setup((t_pxobject *)x, x->f_projector->getNumberOfHarmonics());
		for (int i = 0; i < x->f_projector->getNumberOfPlanewaves(); i++)
			outlet_new(x, "signal");
        
        x->f_ins = new t_sample[x->f_projector->getNumberOfHarmonics() * HOA_MAXBLKSIZE];
        x->f_outs = new t_sample[x->f_projector->getNumberOfPlanewaves() * HOA_MAXBLKSIZE];
	}

	return (x);
}
//----------------------------------------------------------------------------------------------------------------
// object creation
void *udmx_new(t_symbol *s, long argc, t_atom *argv)	{
    

    t_atom *ap;
    t_int16 n;
    n = 0;
    
 
    // n = int argument typed into object box (A_DEFLONG) -- defaults to 0 if no args are typed
    
    t_udmx *x = (t_udmx *)object_alloc(udmx_class);
    intin(x,1);					// create a second int inlet (leftmost inlet is automatic - all objects have one inlet by default)
    x->m_clock = clock_new(x,(method)udmx_tick); 	// make new clock for polling and attach tick function to it
    x->m_qelem = qelem_new((t_object *)x, (method)find_device);
    
    x->msgOutlet = outlet_new(x,0L);	//create right outlet
    x->statusOutlet = outlet_new(x,0L);	//create an outlet for connected flag
    
    x->correct_adressing = 1;
    
    if (argc) {
        ap = argv;
        switch (atom_gettype(ap)) {
            case A_LONG:
                n = atom_getlong(ap);
                break;
            default:
                break;
        }
        ap = &argv[argc-1];
        
        switch (atom_gettype(ap)) {
            case A_LONG:
                if (atom_getlong(ap) == 0 ) {
                    x->correct_adressing = 0;
                }
                break;
            default:
                break;
        }
     }
    if(x->correct_adressing) {n = n - 1;}
    if (n < 0) n = 0;
    if (n > 511) n = 511;

    x->channel = n;
    x->debug_flag = 0;
    x->channel_changed_min = 512;
    x->channel_changed_max = -1;
    x->clock_running = 0;
    x->dev_handle = NULL;
    x->speedlim = SPEED_LIMIT;
    x->usb_devices_seen = -1;

    
    clock_fdelay(x->m_clock,100);
    usb_init();
    
    return(x);					// return a reference to the object instance
}
Example #20
0
void HoaTool_list(t_HoaTool *x, t_symbol *s, long argc, t_atom *argv)
{
    if(atom_getsym(argv+1) == gensym("car") || atom_getsym(argv+1) == gensym("cartesian"))
        x->f_AmbisonicPolyEase->setCartesianCoordinates(atom_getlong(argv), atom_getfloat(argv+2), atom_getfloat(argv+3));
    else if(atom_getsym(argv+1) == gensym("pol") || atom_getsym(argv+1) == gensym("polar"))
        x->f_AmbisonicPolyEase->setPolarCoordinates(atom_getlong(argv), atom_getfloat(argv+2), atom_getfloat(argv+3));
    else if (atom_getsym(argv+1) == gensym("mute"))
        x->f_AmbisonicPolyEase->setMuted(atom_getlong(argv), atom_getlong(argv+2));
}
Example #21
0
void *hoa_map_3D_tilde_new(t_symbol *s, long argc, t_atom *argv)
{
    t_hoa_map_3D_tilde *x = NULL;
    t_binbuf *d;
    int	order = 1;
    int numberOfSources = 1;
    
    if (!(d = binbuf_via_atoms(argc,argv)))
		return NULL;
    
    x = (t_hoa_map_3D_tilde *)eobj_new(hoa_map_3D_tilde_class);
    
	if (x)
	{
		if(atom_gettype(argv) == A_LONG)
			order = clip_min(atom_getlong(argv), 0);
        if(argc > 1 && atom_gettype(argv+1) == A_LONG)
            numberOfSources = clip_minmax(atom_getlong(argv+1), 1, 255);
        if(argc > 2 && atom_gettype(argv+2) == A_SYM)
        {
            if(atom_getsym(argv+2) == gensym("car") || atom_getsym(argv+2) == gensym("cartesian"))
                x->f_mode = 1;
            else
                x->f_mode = 0;
        }
        else
            x->f_mode = 0;
        
        x->f_ramp       = 100;
		x->f_map        = new Hoa3D::Map(order, numberOfSources);
		x->f_lines      = new MapPolarLines3D(x->f_map->getNumberOfSources());
        x->f_lines->setRamp(0.1 * sys_getsr());
        for (int i = 0; i < x->f_map->getNumberOfSources(); i++)
        {
            x->f_lines->setRadiusDirect(i, 1);
            x->f_lines->setAzimuthDirect(i, 0.);
            x->f_lines->setElevationDirect(i, 0.);
        }
        
		if(x->f_map->getNumberOfSources() == 1)
            eobj_dspsetup(x, 4, x->f_map->getNumberOfHarmonics());
        else
            eobj_dspsetup(x, x->f_map->getNumberOfSources(), x->f_map->getNumberOfHarmonics());
        
        if(x->f_map->getNumberOfSources() == 1)
            x->f_sig_ins    = new t_float[4 * SYS_MAXBLKSIZE];
        else
            x->f_sig_ins    = new t_float[x->f_map->getNumberOfSources() * SYS_MAXBLKSIZE];
		
        x->f_sig_outs       = new t_float[x->f_map->getNumberOfHarmonics() * SYS_MAXBLKSIZE];
        x->f_lines_vector   = new float[x->f_map->getNumberOfSources() * 3];
        
        ebox_attrprocess_viabinbuf(x, d);
	}
    
	return (x);
}
ObjectPtr wrappedClass_new(SymbolPtr name, AtomCount argc, AtomPtr argv)
{	
	WrappedClass*		wrappedMaxClass = NULL;
    WrappedInstancePtr	self = NULL;
	TTValue				v;
	TTErr				err = kTTErrNone;
	TTUInt8				numInputs = 1;
	TTUInt8				numOutputs = 1;
 	long				attrstart = attr_args_offset(argc, argv);		// support normal arguments
	
	// Find the WrappedClass
	hashtab_lookup(wrappedMaxClasses, name, (ObjectPtr*)&wrappedMaxClass);
	
	// If the WrappedClass has a validity check defined, then call the validity check function.
	// If it returns an error, then we won't instantiate the object.
	if (wrappedMaxClass) {
		if (wrappedMaxClass->validityCheck)
			err = wrappedMaxClass->validityCheck(wrappedMaxClass->validityCheckArgument);
		else
			err = kTTErrNone;
	}
	else
		err = kTTErrGeneric;
	
	if (!err)
		self = (WrappedInstancePtr)object_alloc(wrappedMaxClass->maxClass);
    if (self){

		if (wrappedMaxClass->options && !wrappedMaxClass->options->lookup(TT("argumentDefinesNumInlets"), v)) {
			long argumentOffsetToDefineTheNumberOfInlets = v;
			if ((attrstart-argumentOffsetToDefineTheNumberOfInlets > 0) && argv+argumentOffsetToDefineTheNumberOfInlets)
				numInputs = atom_getlong(argv+argumentOffsetToDefineTheNumberOfInlets);
		}
		for (TTUInt16 i=numInputs-1; i>0; i--)
			self->inlets[i-1] = proxy_new(self, i, NULL);
		
    	object_obex_store((void*)self, _sym_dumpout, (object*)outlet_new(self, NULL));	// dumpout
		if (wrappedMaxClass->options && !wrappedMaxClass->options->lookup(TT("argumentDefinesNumOutlets"), v)) {
			long argumentOffsetToDefineTheNumberOfOutlets = v;
			if ((attrstart-argumentOffsetToDefineTheNumberOfOutlets > 0) && argv+argumentOffsetToDefineTheNumberOfOutlets)
				numOutputs = atom_getlong(argv+argumentOffsetToDefineTheNumberOfOutlets);
		}
		for (TTInt16 i=numOutputs-1; i>=0; i--)
			self->audioGraphOutlets[i] = outlet_new(self, "audio.connect");

		self->wrappedClassDefinition = wrappedMaxClass;
		v.setSize(3);
		v.set(0, wrappedMaxClass->ttClassName);
		v.set(1, numInputs);
		v.set(2, numOutputs);
		err = TTObjectInstantiate(TT("audio.object"), (TTObjectPtr*)&self->audioGraphObject, v);
				
		attr_args_process(self, argc, argv);
	}
	return ObjectPtr(self);
}
Example #23
0
void CLASSMETHOD(ClipLed)(IMPORT_T, t_symbol *s, long argc, t_atom *argv)
{
  if (argc != 3) {
    post("Clip Led messages must have 3 integers: column - row - mode");
    return;
  }

  int row, column;
  CLIP_LED cl = CL_INVALID;

  if (atom_gettype(argv) == A_LONG) {
    column = (int)atom_getlong(argv);
  }
  else {
    post("First argument is not an integer.");
    return;
  }

  if (atom_gettype(argv + 1) == A_LONG) {
    row = (int)atom_getlong(argv + 1);
  }
  else {
    post("Second argument is not an integer.");
    return;
  }

  if (row < 1 || row > CLIPROWS || column < 1 || column > CLIPCOLUMNS) {
    post("Element is not in range.");
    return;
  }

  // set array offset
  row--; column--;

  if (atom_gettype(argv + 2) == A_SYM) {
    std::string s; 
    s = atom_getsym(argv + 2)->s_name;
    if (s == "green") T->memory.setClipLed(column, row, CL_GREEN);
    else if (s == "orange") T->memory.setClipLed(column, row, CL_ORANGE);
    else if (s == "red") T->memory.setClipLed(column, row, CL_RED);
    else {
      post("Third argument is not a valid symbol");
      return;
    }
  }
  else {
    post("Third argument is not a symbol");
    return;
  }

  // send led color to apc
  {
    CLASSMETHOD(SendNoteOn)(T, column + 1, row + 53, (int)T->memory.getClipLed(column, row));
  }
}
Example #24
0
/****************************************************************
*  Constructor
*/
void *strstr_new(t_symbol *sym, long argc, t_atom *argv)
{
  t_strstr *x = NULL;

  x = (t_strstr *)object_alloc(strstr_class);

  if (x == NULL) {
    error("strstr:  Allocation failed.");
    return NULL;
  }

  // Set inlets, outlets, and proxy
  x->inl_proxy_ind = 0;
  x->inl_proxy = proxy_new((t_object *)x, 1, &x->inl_proxy_ind);
  x->outl_int = intout((t_object *)x);

  // Set the left string buffer
  x->i_dstr1 = dstr_new();

  // First argument:  right string buffer
  x->i_dstr2 = dstr_new();
  if ((argc >= 1) && (attr_args_offset((short)argc, argv) >= 1)) {
    x->i_dstr2 = str_cat_atom(x, x->i_dstr2, argv);
  }

  // Test the string buffers
  if (DSTR_IS_NULL(x->i_dstr1) || DSTR_IS_NULL(x->i_dstr2)) {
    object_error((t_object *)x, "Allocation error.");
    strstr_free(x);
    return NULL;
  }

  // Second argument:  mode
  long mode = 0;
  if ((argc >= 2) && (attr_args_offset((short)argc, argv) >= 2)) {
    if ((atom_gettype(argv + 1) == A_LONG) && (atom_getlong(argv + 1) >= 0) && (atom_getlong(argv + 1) <= 1)) {
      mode = (long)atom_getlong(argv + 1);
    } else {
      object_error((t_object *)x, "Arg 2:  Mode:  0 or 1 expected");
    }
  }
  object_attr_setlong(x, gensym("mode"), mode);

  // Set the float precision
  object_attr_setlong(x, gensym("fprecision"), 6);

  // Set the remaining variables
  x->o_pos = -1;

  // Process the attributes
  attr_args_process(x, (short)argc, argv);

  return x;
}
void dynamicdsp_loadpatch(t_dynamicdsp *x, t_symbol *s, long argc, t_atom *argv)
{
    t_symbol *patch_name = NULL;
    t_atom_long index = -1;
	t_atom_long thread_request = -1;
	
	// Get requested patch index if there is one
	
	if (argc && atom_gettype(argv) == A_LONG)
	{
		index = atom_getlong(argv) - 1;
		if (index < 0)
		{
			object_error((t_object *) x, "patch index out of range");
			return;
		}
		argc--; argv++;
	}
	
	// Get thread request if there is one
	
	if (argc && atom_gettype(argv) == A_LONG)
	{
		thread_request = atom_getlong(argv) - 1;
		argc--; argv++;
	}
	
	// If there is a patch name then try to load the patch
	
	if (argc && atom_gettype(argv) == A_SYM)			
	{
		patch_name = atom_getsym(argv);
		argc--; argv++;
        
        index = x->slots->load(index, patch_name, argc, argv, x->last_vec_size, x->last_samp_rate);
        
        // FIX - threading...
        // FIX - review
        
        if (thread_request && index >= 0)
        {
            if (thread_request > 0)
                x->slots->requestThread(index, thread_request);
            else
                x->slots->requestThread(index, index);
            
            x->update_thread_map = 1;
        }
	} 
	else 
		object_error((t_object *) x, "no patch specified");
}
Example #26
0
void tralala_paintStrncatNote(char *dst, long argc, t_atom *argv)
{
    char a[5];
    char temp[32];
    long p = atom_getlong(argv + 1);
    long v = atom_getlong(argv + 3);
    long d = atom_getlong(argv + 4);
    long c = atom_getlong(argv + 5);
    
    tralala_paintPitchAsString(a, atom_getlong(argv + 2), 5);
    snprintf_zero(temp, 32, "%ld %s %ld %ld %ld\n", p, a, v, d, c);
    strncat_zero(dst, temp, TLL_STRING_SIZE);
}
Example #27
0
void ovalidate_anything(t_ovalidate *x, t_symbol *msg, int argc, t_atom *argv)
{
	if(msg == gensym("xosc-msgsize-bug")){
		// DON'T DO SHIT LIKE THIS---THIS ISN'T THE WILD F*****G WEST
		long len = atom_getlong(argv + 1);
		char *ptr = (char *)atom_getlong(argv + 2);
		char *size = ptr + OSC_HEADER_SIZE;
		*((int32_t *)size) = hton32(100);
		ovalidate_fullPacket(x, atom_getsym(argv), argc - 1, argv + 1);
	}else{
		object_error((t_object *)x, "doesn't understand message %s", msg->s_name);
	}
}
Example #28
0
void hoa_optim_deprecated(t_hoa_optim* x, t_symbol *s, long ac, t_atom* av)
{
    t_atom* argv;
    long argc;
    if(s && s == gensym("mode") && ac && av)
    {
        if(atom_gettype(av) == A_SYM)
        {
            if(atom_getsym(av) == gensym("maxRe"))
                x->f_optim->setMode(Hoa2D::Optim::MaxRe);
            else if(atom_getsym(av) == gensym("basic"))
                x->f_optim->setMode(Hoa2D::Optim::Basic);
            else
                x->f_optim->setMode(Hoa2D::Optim::InPhase);
        }
        else
        {
            if(atom_getlong(av) == 1)
                x->f_optim->setMode(Hoa2D::Optim::MaxRe);
            else if(atom_getlong(av) == 0)
                x->f_optim->setMode(Hoa2D::Optim::Basic);
            else
                x->f_optim->setMode(Hoa2D::Optim::InPhase);
        }
        object_error(x, "%s attribute @mode is deprecated, please use it as an argument.", eobj_getclassname(x)->s_name);
    }
    atoms_get_attribute(ac, av, gensym("@mode"), &argc, &argv);
    if(argc && argv)
    {
        if(atom_gettype(argv) == A_SYM)
        {
            if(atom_getsym(argv) == gensym("maxRe"))
                x->f_optim->setMode(Hoa2D::Optim::MaxRe);
            else if(atom_getsym(argv) == gensym("basic"))
                x->f_optim->setMode(Hoa2D::Optim::Basic);
            else
                x->f_optim->setMode(Hoa2D::Optim::InPhase);
        }
        else
        {
            if(atom_getlong(argv) == 1)
                x->f_optim->setMode(Hoa2D::Optim::MaxRe);
            else if(atom_getlong(argv) == 0)
                x->f_optim->setMode(Hoa2D::Optim::Basic);
            else
                x->f_optim->setMode(Hoa2D::Optim::InPhase);
        }
        object_error(x, "%s attribute @mode is deprecated, please use it as an argument.", eobj_getclassname(x)->s_name);
        argc = 0;free(argv);argv = NULL;
    }
}
Example #29
0
short past_compare(t_past *x, t_atom *a, long index)
{
	t_atom *b;
	float temp1;
	
	b = x->p_vector + index;
	if (atom_gettype(a) == A_LONG) {
		if (atom_gettype(b) == A_LONG) {
			if (atom_getlong(a) > atom_getlong(b))
				return 1;
			else if (atom_getlong(a) == atom_getlong(b))
				return 0;
			else
				return -1;
		} else if (atom_gettype(b) == A_FLOAT) {
			temp1 = (float)atom_getlong(a);
			if (temp1 > atom_getfloat(b))
				return 1;
			else if (temp1 == atom_getfloat(b))
				return 0;
			else
				return -1;
		} else {
			if (atom_getlong(a) > 0)
				return 1;
			else if (atom_getlong(a) == 0)
				return 0;
			else
				return -1;
		}
	} else if (atom_gettype(a) == A_FLOAT) {
		if (atom_gettype(b) == A_LONG) {
			temp1 = (float)atom_getlong(b);
			if (atom_getfloat(a) > temp1)
				return 1;
			else if (atom_getfloat(a) == temp1)
				return 0;
			else
				return -1;
		} else if (atom_gettype(b) == A_FLOAT) {
			if (atom_getfloat(a) > atom_getfloat(b))
				return 1;
			else if (atom_getfloat(a) == atom_getfloat(b))
				return 0;
			else
				return -1;
		} else {
			if (atom_getfloat(a) > 0.)
				return 1;
			else if (atom_getfloat(a) == 0.)
				return 0;
			else
				return -1;
		}
	}
	return -1;
	// uh, yeah, I guess. return -1 when in doubt. makes as much sense as anything else.
	// if someone's trying to compare a t_symbol you just say it's less than whatever you're comparing it with.
	// in theory this should never happen with the past object.
}
Example #30
0
// messages received from jcom.hub for the algorithm
void out_algorithm_message(t_out *x, t_symbol *msg, long argc, t_atom *argv)
{
	if(argc < 2)
		return;
		
	if(argv->a_type == A_SYM){
// jamoma 0.4
//		if((argv->a_w.w_sym == jps_slash_audio_gain_midi) || (argv->a_w.w_sym == jps_audio_gain_midi)){
// jamoma 0.5
		if((argv->a_w.w_sym == gensym("/audio/gain")) || (argv->a_w.w_sym == gensym("audio/gain")) || (argv->a_w.w_sym == gensym("gain")) || (argv->a_w.w_sym == gensym("/gain"))){
			// Do gain control here...
			// Should be that the gain change triggers a short tt_ramp to the new value
			x->attr_gain = atom_getfloat(argv+1);	// store as midi values
#ifdef JCOM_OUT_TILDE
			x->gain->setAttributeValue(TT("midiGain"), x->attr_gain);
#endif
		}
		else if((argv->a_w.w_sym == jps_audio_mute) || (argv->a_w.w_sym == jps_slash_audio_mute) || (argv->a_w.w_sym == gensym("mute")) || (argv->a_w.w_sym == gensym("/mute"))){
			x->attr_mute = atom_getlong(argv+1);
#ifdef JCOM_OUT_TILDE
			if(x->attr_mute)
				x->gain->setAttributeValue(TT("linearGain"), 0.0);
			else 
				x->gain->setAttributeValue(TT("midiGain"), x->attr_gain);			
#endif
		}
		else if((argv->a_w.w_sym == jps_audio_bypass) || (argv->a_w.w_sym == jps_slash_audio_bypass) || (argv->a_w.w_sym == gensym("bypass")) || (argv->a_w.w_sym == gensym("/bypass"))){
			x->attr_bypass = atom_getlong(argv+1);
#ifdef JCOM_OUT_TILDE
			if(x->attr_bypass == 0)
				x->xfade->setAttributeValue(TT("position"), x->attr_mix * 0.01);
			else
				x->xfade->setAttributeValue(TT("position"), 0.0);
#endif
		}
		else if((argv->a_w.w_sym == jps_audio_mix) || (argv->a_w.w_sym == jps_slash_audio_mix) || (argv->a_w.w_sym == gensym("mix")) || (argv->a_w.w_sym == gensym("/mix"))){
			x->attr_mix = atom_getfloat(argv+1);
#ifdef JCOM_OUT_TILDE
			if(x->attr_bypass == 0)
				x->xfade->setAttributeValue(TT("position"), x->attr_mix * 0.01);		
#endif
		}
		else if((argv->a_w.w_sym == jps_audio_meters_freeze) || (argv->a_w.w_sym == jps_slash_audio_meters_freeze) || (argv->a_w.w_sym == gensym("freeze")) || (argv->a_w.w_sym == gensym("/freeze"))){
			x->attr_defeat_meters = atom_getlong(argv+1);
		}
		else if((argv->a_w.w_sym == jps_video_preview) || (argv->a_w.w_sym == jps_slash_video_preview) || (argv->a_w.w_sym == gensym("preview")) || (argv->a_w.w_sym == gensym("/preview")))
			x->attr_preview = atom_getlong(argv+1);
	}
}