\nPartendo dall modello matematico di un filtro passa basso, ho definito la formulazione pi\u00f9 semplice che permettesse di isolare una banda di frequenze abbastanza stretta e con un taglio abbastanza netto: si tratta di un filtro passa basso con un'importante resonance sulla frequenza di taglio, che otterr\u00f2 tramite la seguente formula:<\/p>\n\n\n\n
![\"\"\/](\"https:\/\/nicolafiorello.it\/articles\/creazione-oggetto-max-sdk\/eq1.png\")
<\/figure>\n\n\nwhere s<\/em>, a1<\/em> and a2<\/em> are coefficients to be calculated each time, based on even at the required cut-off frequency.<\/p>\n\n\n The object will be called notefilter~<\/em>, and the advice to start writing its behavior in C is to clone the folder of one of the audio object examples (Max\/Packages\/max-sdk\/source\/audio<\/em>) and clear the .c<\/em> file, renaming appropriately all files it contains. In this way you quickly obtain a project already structured with libraries in their place. Personally I worked with Max 8, using Visual Studio in its free version. If you are using (as it is likely to be) 64-bit Max, I remind you to select that mode in the Visual Studio drop-down menu! I have included the libraries necessary for the functioning of an audio object, and I have defined the object class, calling it notefilter_class<\/em><\/p>\n\n\n\n then specifying the parameters, the first of which (t_pxobject l_obj) is indispensable for the correct definition of the object<\/p>\n\n\n\n Finally I have declared all the headers of the functions that I am going to implement, whether they are actually methods of the object class or not.<\/p>\n\n\n\n At this point the implementation of the actual functions begins, the first of which is called ext_main<\/em> and takes care of physically creating the object through class_new<\/em>, specifying the name, the methods of construction and destruction and the size (and other parameters that do not come used because unnecessary or obsolete). The same function also takes care of adding the methods to the class: the functions that until now are independent become methods via class_addmethod<\/em>, which also requires you to pass a name to recognize that method within the function. The next function, notefilter_dsp64 <\/em>, allows you to store the previous coefficients in special variables, and to store the input value provided at that instant; this step is added to the dsp chain <\/em>, the list that specifies the signal processing functions defined by the object for its signals.<\/p>\n\n\n\n The core of the program lies in the next function, notefilter_perform64<\/em>, which requires perhaps a slightly more detailed analysis. The software now goes through all the available samples, processing the quantized value according to the mathematical formulation I have chosen. <\/p>\n\n\n\n In Max’s objects there can be different inputs, which accept data of different types. In this case, the first input will be reserved for the signal to be filtered (noise, if you want use notefilter<\/em> as a synthesizer), while the second will receive an integer relative to the note midi around whose frequency you want to filter. The cutoff frequency is calculated starting from the midi-note, following the simple formula<\/p>\n\n\n\n and its data is stored in the cut_freq<\/em> parameter. The coefficients a1<\/em> and a2<\/em> are fundamental for a correct filtering operation: they characterize the intensity of the resonance and report the cutoff frequency; their calculation takes place in the function notefilter_calc<\/em> according to the following expressions:<\/p>\n\n\n\n and the code with which I implement it is very simple:<\/p>\n\n\n\n The last function of the software, which concludes the realization of the object, is notefilter_new <\/em>, what is called when creating the object. The software works, and once compiled it has successfully generated the notefilter~<\/em> object, which appears now among Max’s objects, complete with auto-fill when you start typing its name. The result is a metallic sound and definitely not suitable for real use, but I am satisfied with how much I got because, after all, that’s what I expected. This is what the spectroscope shows during notefilter operation.<\/p>\n\n\n\n The Cycling Software Development Kit is a library that allows, once added among the packages, to program a new object for Max. I have read the official documentation and have done some tests; this article is the summary of what I concluded. The idea is to create an object in C language that filters a …<\/p>","protected":false},"author":2,"featured_media":58,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[6,7],"tags":[],"_links":{"self":[{"href":"https:\/\/atled.it\/atled\/it\/wp-json\/wp\/v2\/posts\/43"}],"collection":[{"href":"https:\/\/atled.it\/atled\/it\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/atled.it\/atled\/it\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/atled.it\/atled\/it\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/atled.it\/atled\/it\/wp-json\/wp\/v2\/comments?post=43"}],"version-history":[{"count":10,"href":"https:\/\/atled.it\/atled\/it\/wp-json\/wp\/v2\/posts\/43\/revisions"}],"predecessor-version":[{"id":213,"href":"https:\/\/atled.it\/atled\/it\/wp-json\/wp\/v2\/posts\/43\/revisions\/213"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/atled.it\/atled\/it\/wp-json\/wp\/v2\/media\/58"}],"wp:attachment":[{"href":"https:\/\/atled.it\/atled\/it\/wp-json\/wp\/v2\/media?parent=43"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/atled.it\/atled\/it\/wp-json\/wp\/v2\/categories?post=43"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/atled.it\/atled\/it\/wp-json\/wp\/v2\/tags?post=43"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
Here’s how I wrote the notefilter.c <\/em>file, step by step.<\/p>\n\n\n#include \"ext.h\"\n#include \"ext_obex.h\"\n#include \"z_dsp.h\"\n#include <math.h>\n\nvoid *notefilter_class;<\/code><\/pre>\n\n\ntypedef struct _notefilter\n{\n t_pxobject l_obj;\n double freq_cut; \/\/ cutoff frequency\n double l_a1; \/\/ coefficient 1\n double l_a2; \/\/ coefficient 2\n double l_a1p; \/\/ previous coefficient 1\n double l_a2p; \/\/ previous coefficient 2\n double l_ym1; \/\/ previous output sample\n double l_ym2; \/\/ previous output sample\n double l_fqterm; \/\/ frequency coefficient\n double l_resterm; \/\/ coefficient of resonance\n double l_2pidsr; \/\/ 2 pi\n short l_fcon; \/\/ signal related to the frequency input\n} t_notefilter;<\/code><\/pre>\n\n\nvoid notefilter_dsp64(t_notefilter *x, t_object *dsp64, short *count, double samplerate, long maxvectorsize, long flags);\nvoid notefilter_perform64(t_notefilter *x, t_object *dsp64, double **ins, long numins, double **outs, long numouts, long sampleframes, long flags, void *userparam);\nvoid notefilter_int(t_notefilter *x, int f);\nvoid notefilter_calc(t_notefilter *x);\nvoid *notefilter_new(double freq, double reso);<\/code><\/pre>\n\n\n
class_register<\/em> finally allows you to register the class defined in the ClassBox<\/em> of Max.<\/p>\n\n\n\nvoid ext_main(void *r)\n{\n t_class *c;\n c = class_new(\"notefilter~\",(method)notefilter_new, (method)dsp_free,\n sizeof(t_notefilter), 0L, A_DEFFLOAT, A_DEFFLOAT, 0);\n class_addmethod(c, (method)notefilter_dsp64, \"dsp64\", A_CANT, 0);\n class_addmethod(c, (method)notefilter_int, \"int\", A_LONG, 0);\n class_dspinit(c);\n class_register(CLASS_BOX, c);\n notefilter_class = c;\n return 0;\n}<\/code><\/pre>\n\n\nvoid notefilter_dsp64(t_notefilter *x, t_object *dsp64, short *count, double samplerate, long maxvectorsize, long flags)\n{\n x->l_2pidsr = (2.0 * PI) \/ samplerate;\n notefilter_calc(x);\n x->l_a1p = x->l_a1;\n x->l_a2p = x->l_a2;\n x->l_fcon = count[1];\n\n dsp_add64(dsp64, (t_object *)x, (t_perfroutine64)notefilter_perform64, 0, NULL);\n}<\/code><\/pre>\n\n\n
After the definition of the temporary variables that are needed in the execution of the function, values ar loaded (in these newly created spaces) from the parameter set of the object, and a value called scale<\/em>, given by the sum of the two coefficients increased of one is defined.<\/p>\n\n\n\nvoid notefilter_perform64(t_notefilter *x, t_object *dsp64, double **ins, long numins, double **outs, long numouts, long sampleframes, long flags, void *userparam) {\n t_double *in = ins[0];\n t_double *out = outs[0];\n t_double freq = x->freq_taglio;\n double a1 = x->l_a1;\n double a2 = x->l_a2;\n double ym1 = x->l_ym1;\n double ym2 = x->l_ym2;\n double val, scale, temp, resterm;\n\n scale = 1.0 + a1 + a2;\n}<\/code><\/pre>\n\n\n
To implement its operation, I used the temporary variables defined at the beginning of the function, and I structured a while <\/em>loop to loop through the samples.
To make this key step easier to understand, I have summarized the operation in a diagram.<\/p>\n\n\n![\"\"\/](\"https:\/\/nicolafiorello.it\/articles\/creazione-oggetto-max-sdk\/schema_bis.png\")
<\/figure>\n\n\n\nwhile (sampleframes--) {\n val = *in++;\n temp = ym1;\n ym1 = scale * val - a1 * ym1 - a2 * ym2;\n ym2 = temp;\n *out++ = ym1;\n}\nx->l_ym1 = ym1;\nx->l_ym2 = ym2;\n<\/code><\/pre>\n\n\n
The notefilter_int<\/em> function is in charge of defining the behavior of the object upon receiving that integer.<\/p>\n\n\n![\"\"\/](\"https:\/\/nicolafiorello.it\/articles\/creazione-oggetto-max-sdk\/eq2.png\")
<\/figure>\n\n\n
A post<\/em> function (syntax analogous to the common printf<\/em> function of C) allows you to print in the max console a message containing the note and frequency information in question. The function finally calls notefilter_calc<\/em>, a method that performs the calculation of the coefficients, which I will discuss shortly.<\/p>\n\n\n\nvoid notefilter_int(t_notefilter *x, int f)\n{\n x->freq_taglio = (440.0 \/ 32.0) * pow(2.0,((f - 9.0) \/ 12.0));\n post(\"nota n. %i - frequenza: %f\",f, x->freq_taglio);\n notefilter_calc(x);\n}<\/code><\/pre>\n\n\n![\"\"\/](\"https:\/\/nicolafiorello.it\/articles\/creazione-oggetto-max-sdk\/eq3.png\")
<\/figure>\n\n\nvoid notefilter_calc(t_notefilter *x)\n{\n double resterm;\n resterm = exp(0.125) * 0.882497;\n x->l_fqterm = cos(x->l_2pidsr * x->freq_taglio);\n x->l_a1 = -2. * resterm * x->l_fqterm;\n x->l_a2 = resterm * resterm;\n x->l_resterm = resterm;\n}<\/code><\/pre>\n\n\n
Some routine operations are performed, in order to allocate the memory necessary for the operation of the object, and the inlets (in our case 2) and the outlets are defined (in our case 1).
Some parametric values (such as 2pidsr<\/em>) can be calculated here, since their value does not have to be recalculated during the execution: these operations, in fact, come performed only when the object is created.<\/p>\n\n\n\nvoid *notefilter_new(double val, double reso)\n{\n t_notefilter *x = object_alloc(notefilter_class);\n dsp_setup((t_pxobject *)x,2);\n\n x->freq_taglio = val;\n x->l_2pidsr = (2. * PI) \/ sys_getsr();\n notefilter_calc(x);\n\n x->l_a1p = x->l_a1;\n x->l_a2p = x->l_a2;\n\n outlet_new((t_object *)x, \"signal\");\n return (x);\n}<\/code><\/pre>\n\n\n
To test this, I made a simple patch where the noise produced by a noise~<\/em> object is filtered from notefilter~<\/em>, which receives from a kslider<\/em> the note around which to filter the signal. The output is viewed via the spectroscope<\/em> and reproduced via the sound card via the object ezdac<\/em>.<\/p>\n\n\n\n![\"\"\/](\"https:\/\/nicolafiorello.it\/articles\/creazione-oggetto-max-sdk\/patch.jpg\")
<\/figure>\n\n\n![\"\"](\"https:\/\/nicolafiorello.it\/articles\/creazione-oggetto-max-sdk\/filtrato.jpg\")
<\/figure>","protected":false},"excerpt":{"rendered":"