OMax.render.c

Go to the documentation of this file.

/*--------------------------------------
 * OMax.render - OMax.render.c
 * Created on 20/03/09 by BenCello
 *--------------------------------------*/




#ifndef __OMax_render_MAX_API_
#define __OMax_render_MAX_API_

#include <stdlib.h>
#include <list>
using namespace std;
#include "Oracle_data.hpp"

extern "C"
{
        
#include "ext.h"                                // standard Max include, always required
#include "ext_obex.h"                   // required for new style Max object
#include "jpatcher_api.h"               // required for the color
#include "jgraphics.h"                  // required for the color
        
#include "OMax.data.h"
        
        typedef struct _OMax_render 
        {
                t_object        ob;                     
                t_symbol*       oname;          
                t_symbol*       dataname;       
                bool            obound;         
                O_DataType      datatype;       
                int                     nbcoeffs;       
                O_data*         data;           
                t_atom*         twout;          
                t_atom*         coefout;        
                list<float>*coeflist;   
                float*          coeftab;        
                void*           out_statenb;
                void*           out_buf;        
                void*           out_sectphr;
                void*           out_data;       
                void*           out_bang;       
        } t_OMax_render;
        
        
        // Prototypes //
        
        // Standard Max5 methodes
        void *OMax_render_new(t_symbol *s, long argc, t_atom *argv);
        void OMax_render_free(t_OMax_render *x);
        void OMax_render_assist(t_OMax_render *x, void *b, long io, long index, char *s);
        
        // Input/ouput routines
        void OMax_render_read(t_OMax_render *x, long statnb);
        void OMax_render_setname(t_OMax_render *x, t_symbol *newname);
        
        // Internal routines
        t_symbol * OMax_render_name(t_symbol * oname);
        bool OMax_render_bind(t_OMax_render *x);
        
        // Global class pointer variable
        t_class *OMax_render_class;
        
        // Functions //
        
        int main(void)
        {       
                t_class *c;
                
                c = class_new("OMax.render", (method)OMax_render_new, (method)OMax_render_free, (long)sizeof(t_OMax_render), 
                                          0L /* leave NULL!! */, A_GIMME, 0);
                
                // assistance
                class_addmethod(c, (method)OMax_render_assist,"assist",A_CANT, 0); 
                
                // input methods
                class_addmethod(c, (method)OMax_render_read,"int", A_LONG, 0);
                class_addmethod(c, (method)OMax_render_setname, "set", A_DEFSYM, 0);
                
                class_register(CLASS_BOX, c); /* CLASS_NOBOX */
                OMax_render_class = c;
                
                return 0;
        }
        

        
        void *OMax_render_new(t_symbol *s, long argc, t_atom *argv)
        {
                t_OMax_render *x = NULL;
                
                if (x = (t_OMax_render *)object_alloc(OMax_render_class))
                {
                        // allocation
                        char err;
                        long i = 0;
                        atom_alloc_array(2, &i, &x->twout, &err);
                        if (!err || i!=2)
                                object_error((t_object*)x, "Allocation error");
                        
                        // outlet init
                        x->out_statenb = intout(x); // rightmost
                        x->out_buf = listout(x);
                        x->out_sectphr = listout(x);
                        x->out_data = outlet_new(x,NULL);
                        x->out_bang= bangout(x);
                        
                        x->obound = FALSE;
                        if (argc == 0)
                                object_error((t_object *)x,"Missing name of the Oracle data to read");
                        else
                        {
                                if (argv->a_type != A_SYM)
                                        object_error((t_object *)x,"First argument must be a symbol (name of an existing Oracle)");
                                else
                                        x->oname = atom_getsym(argv);
                        }
                        
                        // color
                        t_object *box;
                        t_jrgba colorvals;
                        jrgba_set(&colorvals, 0.30, 1.0, 0.15, 1.0);
                        object_obex_lookup((t_object *)x, gensym("#B"), &box);
                        jbox_set_color(box, &colorvals);
                }
                return (x);
        }
        
        void OMax_render_free(t_OMax_render *x)
        {
                ;
        }
        
        void OMax_render_assist(t_OMax_render *x, void *b, long io, long index, char *s)
        {
                switch (io)
                {
            case 1: // inlets
                                switch (index)
                        {
                                case 0: // leftmost
                                        sprintf(s, "state to read, set [symbol] changes sequence to read");
                                        break;
                        }
                break;
            case 2: // outlets
                                switch (index)
                        {
                                case 0:
                                        sprintf(s, "bang when done");
                                        break;
                                case 1: // leftmost
                                        sprintf(s, "data");
                                        break;
                                case 2:
                                        sprintf(s, "section & phrase");
                                        break;
                                case 3:
                                        sprintf(s, "buffer date & duration");
                                        break;
                                case 4:
                                        sprintf(s, "state number");
                                        break;
                        }
                                break;
                }
        }
        
        

        
        t_symbol * OMax_render_name(t_symbol * oname)
        {
                char dataname[128];
                strcpy(dataname,oname->s_name);
                strcat(dataname,"_data");
                return gensym(dataname);
        }
        
        bool OMax_render_bind(t_OMax_render *x)
        {
                if (x->obound == FALSE)
                {
                        x->dataname = OMax_render_name(x->oname);
                        if ((x->dataname->s_thing) && (ob_sym(x->dataname->s_thing) == gensym("OMax.data")))
                        {
                                x->data = &(((t_OMax_data*)(x->dataname->s_thing))->data);
                                // If binding is ok, then don't do it next time.
                                x->obound = TRUE;
                                x->datatype = ((t_OMax_data*)(x->dataname->s_thing))->datatype;
                                if (x->datatype == SPECTRAL)
                                {
                                        x->nbcoeffs = ((t_OMax_data*)(x->dataname->s_thing))->nbcoeffs;
                                        // allocation for coeff output
                                        x->coeflist = new list<float>(x->nbcoeffs);
                                        x->coeftab = (float*)malloc((x->nbcoeffs)*sizeof(float));
                                        char err;
                                        long i = 0;
                                        atom_alloc_array(x->nbcoeffs, &i, &x->coefout, &err);
                                        if (!err || i!=x->nbcoeffs)
                                                object_error((t_object*)x, "Allocation error");
                                }
                        }
                        else
                        {
                                object_error((t_object *)x,"No data for Oracle %s declared", x->oname->s_name);
                        }
                }
                return x->obound;
        }
        
        

        
        void OMax_render_setname(t_OMax_render *x, t_symbol *s)
        {
                x->oname = s;
                x->obound = FALSE;
                OMax_render_bind(x);
        }
        
        void OMax_render_read(t_OMax_render *x, long statnb)
        {
                if (OMax_render_bind(x))
                {
                        ATOMIC_INCREMENT(&(((t_OMax_data *)(x->dataname->s_thing))->readcount));
                        if(!(((t_OMax_data *)(x->dataname->s_thing))->wflag))
                        {
                                if ((statnb>=0) && (statnb<(long)(x->data->get_size())))
                                {
                                        O_label * labL = (*x->data)[statnb];
                                        
                                        // state number
                                        outlet_int(x->out_statenb, labL->get_statenb()); // output
                                        
                                        // date & duration
                                        atom_setlong(x->twout, labL->get_bufferef());
                                        atom_setlong(x->twout+1, labL->get_duration());
                                        outlet_list(x->out_buf, NULL, 2, x->twout); // output
                                        
                                        // section & phrase
                                        atom_setlong(x->twout, labL->get_section());
                                        atom_setlong(x->twout+1, labL->get_phrase());
                                        outlet_list(x->out_sectphr, NULL, 2, x->twout); // output
                                        
                                        // data
                                        switch(x->datatype)
                                        {
                                                case LETTERS:
                                                {
                                                        t_symbol * symout;
                                                        char carout[2];
                                                        *carout = ((O_char*)labL)->get_letter();
                                                        *(carout+1) = '\0';
                                                        symout = gensym(carout);
                                                        outlet_anything(x->out_data, symout,0,NULL); // output
                                                        break;
                                                }
                                                case MIDI_MONO:
                                                {
                                                        atom_setlong(x->twout, ((O_MIDI_mono*)labL)->get_pitch());
                                                        atom_setlong(x->twout+1, ((O_MIDI_mono*)labL)->get_velocity());
                                                        outlet_list(x->out_data, NULL, 2, x->twout); // output
                                                        break;
                                                }
                                                case SPECTRAL:
                                                {
                                                        outlet_int(x->out_data, ((O_spectral*)labL)->get_pitch()); // output pitch first
                                                        *x->coeflist = ((O_spectral*)labL)->get_coeffs();
                                                        list<float>::iterator it = x->coeflist->begin();
                                                        int coefi;
                                                        for (coefi = 0; coefi< x->nbcoeffs; coefi++)
                                                        {
                                                                x->coeftab[coefi] = (*it);
                                                                it ++;
                                                        }
                                                        atom_setfloat_array(x->nbcoeffs, x->coefout, x->nbcoeffs, x->coeftab);
                                                        outlet_list(x->out_data, NULL,x->nbcoeffs, x->coefout); // then output coeffs
                                                        break;
                                                }

                                        }
                                        
                                        outlet_bang(x->out_bang);
                                        
                                }
                                //else
                                //object_post((t_object *)x,"State %ld outside Oracles bounds", statnb, x->oname->s_name);
                        }
                        else
                                object_error((t_object *)x,"Data of Oracle %s busy",x->oname->s_name);
                        ATOMIC_DECREMENT(&(((t_OMax_data *)(x->dataname->s_thing))->readcount));
                }
        }
        
}

#endif