diff options
Diffstat (limited to 'pdp_frei0r/pdp_frei0r.c')
| -rw-r--r-- | pdp_frei0r/pdp_frei0r.c | 637 |
1 files changed, 637 insertions, 0 deletions
diff --git a/pdp_frei0r/pdp_frei0r.c b/pdp_frei0r/pdp_frei0r.c new file mode 100644 index 0000000..3a66147 --- /dev/null +++ b/pdp_frei0r/pdp_frei0r.c @@ -0,0 +1,637 @@ +/* + * Pure Data Packet module. + * Copyright (c) by Tom Schouten <pdp@zzz.kotnet.org> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <dirent.h> +#include <limits.h> +#include <dlfcn.h> + +#include "pdp.h" +#include "frei0r.h" + +#define FREI0R_PNAME_LENGTH 128 + +typedef struct +{ + char name[FREI0R_PNAME_LENGTH+1]; + unsigned numparameters; + int plugin_type; + f0r_instance_t instance; + f0r_plugin_info_t plugin_info; + int (*f0r_init)(void); + void (*f0r_get_plugin_info)(f0r_plugin_info_t* pluginInfo); + void (*f0r_get_param_info)(f0r_param_info_t* info, int param_index); + f0r_instance_t (*f0r_construct)(unsigned int width, unsigned int height); + void (*f0r_destruct)(f0r_instance_t instance); + void (*f0r_set_param_value)(f0r_instance_t instance, f0r_param_t param, int param_index); + void (*f0r_get_param_value)(f0r_instance_t instance, f0r_param_t param, int param_index); + void (*f0r_update)(f0r_instance_t instance, double time, const uint32_t* inframe, uint32_t* outframe); + void (*f0r_update2)(f0r_instance_t instance, double time, + const uint32_t* inframe1, const uint32_t* inframe2, const uint32_t* inframe3, uint32_t* outframe); + int (*f0r_deinit)(void); +} PLUGIN; + +typedef struct pdp_frei0r_struct +{ + t_object x_obj; + t_float x_f; + + t_outlet *x_outlet0; + t_outlet *x_pname; + t_outlet *x_nparams; + t_outlet *x_parname; + t_outlet *x_partype; + int x_packet0; + int x_packet1; + int x_packet2; + int x_packet3; + + // middle input packets + int x_packetm0; + int x_packetm1; + + // right input packets + int x_packetr0; + int x_packetr1; + + int x_dropped; + int x_queue_id; + + int x_width; + int x_height; + int x_size; + + int x_plugin_count; + struct dirent **x_filename_list; + int x_filename_count; + + int x_plugin; + int x_infosok; + + PLUGIN *plugins; + +} t_pdp_frei0r; + +void panic(const char *panicstr, ...) +{ + post("pdp_frei0r :: PANIC!! %s\n", panicstr); + exit(1); +} + +static int selector(const struct dirent *dp) +{ + return (strstr(dp->d_name, ".so") != NULL); +} + +static void scan_plugins(t_pdp_frei0r *x, char *plugindir) +{ + x->x_filename_count = scandir(plugindir, &x->x_filename_list, selector, alphasort); + if (x->x_filename_count < 0) + { + x->x_filename_count = 0; + } +} + +void fr_loadplugins(t_pdp_frei0r *x, char *plugindir) +{ + char libname[PATH_MAX]; + unsigned instance, numparameters; + int i; + char *pluginname; + void *plugin_handle; + + scan_plugins(x, plugindir); + + x->x_plugin_count = 0; + x->plugins = (PLUGIN *)getbytes(x->x_filename_count*sizeof(PLUGIN)); + if (x->plugins == NULL) + { + panic("no memory for loading plugins\n"); + } + else + { + post( "allocated plugins : %x", x->plugins ); + } + + for (i=0; i<x->x_filename_count; i++) + { + pluginname = x->x_filename_list[i]->d_name; + + snprintf(libname, PATH_MAX, "%s/%s", plugindir, pluginname); + + post( "pdp_frei0r : opening : %s", pluginname ); + + plugin_handle = dlopen(libname, RTLD_NOW); + dlerror(); + + // get functions pointers + *(void**) (&x->plugins[x->x_plugin_count].f0r_init) = dlsym(plugin_handle, "f0r_init"); + *(void**) (&x->plugins[x->x_plugin_count].f0r_get_plugin_info) = dlsym(plugin_handle, "f0r_get_plugin_info"); + *(void**) (&x->plugins[x->x_plugin_count].f0r_get_param_info) = dlsym(plugin_handle, "f0r_get_param_info"); + *(void**) (&x->plugins[x->x_plugin_count].f0r_construct) = dlsym(plugin_handle, "f0r_construct"); + *(void**) (&x->plugins[x->x_plugin_count].f0r_destruct) = dlsym(plugin_handle, "f0r_destruct"); + *(void**) (&x->plugins[x->x_plugin_count].f0r_set_param_value) = dlsym(plugin_handle, "f0r_set_param_value"); + *(void**) (&x->plugins[x->x_plugin_count].f0r_get_param_value) = dlsym(plugin_handle, "f0r_get_param_value"); + *(void**) (&x->plugins[x->x_plugin_count].f0r_update) = dlsym(plugin_handle, "f0r_update"); + dlerror(); + + // check for special function update2 + *(void**) (&x->plugins[x->x_plugin_count].f0r_update2) = dlsym(plugin_handle, "f0r_update2"); + if (!dlerror()) + { + // continue; + } + + // init plugin + (*x->plugins[x->x_plugin_count].f0r_init)(); + + // instantiate + x->plugins[x->x_plugin_count].instance = (*x->plugins[x->x_plugin_count].f0r_construct)(x->x_width, x->x_height); + + // get plugin infos + (*x->plugins[x->x_plugin_count].f0r_get_plugin_info)(&x->plugins[x->x_plugin_count].plugin_info); + strcpy( x->plugins[x->x_plugin_count].name, x->plugins[x->x_plugin_count].plugin_info.name ); + x->plugins[x->x_plugin_count].numparameters=x->plugins[x->x_plugin_count].plugin_info.num_params; + x->plugins[x->x_plugin_count].plugin_type=x->plugins[x->x_plugin_count].plugin_info.plugin_type; + + if ( ( x->plugins[x->x_plugin_count].plugin_info.color_model != F0R_COLOR_MODEL_RGBA8888 ) && + ( x->plugins[x->x_plugin_count].plugin_info.color_model != F0R_COLOR_MODEL_BGRA8888 ) && + ( x->plugins[x->x_plugin_count].plugin_info.color_model != F0R_COLOR_MODEL_PACKED32 ) ) + { + post( "pdp_frei0r : warning : plugin : %s use unsupported color model (%d) : ignored ...", + pluginname, x->plugins[x->x_plugin_count].plugin_info.color_model ); + continue; + } + + x->x_plugin_count++; + } +} + +void fr_processframe(t_pdp_frei0r *x, int plugin, void *ibuffer, void *imbuffer, void *irbuffer, void *obuffer) +{ + double time = 0.0; + + if ( x->x_plugin_count <= 0 ) + { + return; + } + + if ( ( x->plugins[x->x_plugin].plugin_type == F0R_PLUGIN_TYPE_FILTER ) || + ( x->plugins[x->x_plugin].plugin_type == F0R_PLUGIN_TYPE_SOURCE ) ) + { + // process frame + (*x->plugins[x->x_plugin].f0r_update)(x->plugins[x->x_plugin].instance, time, ibuffer, obuffer); + } + if ( x->plugins[x->x_plugin].plugin_type == F0R_PLUGIN_TYPE_MIXER2 ) + { + if ( ( x->x_packet1 != -1 ) && ( x->x_packet2 != -1 ) && ( x->x_packetm1 != -1 ) ) + { + // process frame + (*x->plugins[x->x_plugin].f0r_update2)(x->plugins[x->x_plugin].instance, time, ibuffer, imbuffer, irbuffer, obuffer); + } + } + if ( x->plugins[x->x_plugin].plugin_type == F0R_PLUGIN_TYPE_MIXER3 ) + { + if ( ( x->x_packet1 != -1 ) && ( x->x_packet2 != -1 ) && ( x->x_packetm1 != -1 ) && ( x->x_packetr1 != -1 ) ) + { + // process frame + (*x->plugins[x->x_plugin].f0r_update2)(x->plugins[x->x_plugin].instance, time, ibuffer, imbuffer, irbuffer, obuffer); + } + } +} + +void fr_freeplugins(t_pdp_frei0r *x) +{ + t_int i; + + for (i=0; i<x->x_plugin_count; i++) + { + // destroy plugin + (*x->plugins[i].f0r_destruct)(x->plugins[i].instance); + } + post("freeing plugin resources : %x", x->plugins); + freebytes( x->plugins, x->x_filename_count*sizeof(PLUGIN) ); + x->plugins = NULL; +} + +static void pdp_frei0r_process_rgba(t_pdp_frei0r *x) +{ + t_pdp *newheader = pdp_packet_header(x->x_packet2); + char *newdata = (char *)pdp_packet_data(x->x_packet2); + t_pdp *lheader = pdp_packet_header(x->x_packet1); + char *ldata = (char *)pdp_packet_data(x->x_packet1); + t_pdp *mheader = pdp_packet_header(x->x_packetm1); + char *mdata = (char *)pdp_packet_data(x->x_packetm1); + t_pdp *rheader = pdp_packet_header(x->x_packetr1); + char *rdata = (char *)pdp_packet_data(x->x_packetr1); + + if ((x->x_width != (t_int)lheader->info.image.width) || + (x->x_height != (t_int)lheader->info.image.height)) + { + + post("pdp_frei0r :: resizing plugins"); + + fr_freeplugins(x); + + x->x_width = lheader->info.image.width; + x->x_height = lheader->info.image.height; + x->x_size = x->x_width*x->x_height; + + //load the plugins + fr_loadplugins(x, FR_PLUGIN_DIR); + } + + newheader->info.image.encoding = lheader->info.image.encoding; + newheader->info.image.width = x->x_width; + newheader->info.image.height = x->x_height; + + memcpy( newdata, ldata, x->x_size*sizeof(uint32_t) ); + + fr_processframe(x, x->x_plugin, ldata, mdata, rdata, newdata); + + +} + +static void pdp_frei0r_param(t_pdp_frei0r *x, t_symbol *s, int argc, t_atom *argv) +{ + int pnumber; + f0r_param_info_t param_infos; + + if ( x->x_plugin_count <= 0 ) + { + post( "frei0r : set parameter : no plugins loaded, check your plugin directory setup" ); + return; + } + + if ( argc < 2 ) + { + post("pdp_frei0r : set parameter : insufficient parameters (%d)", argc ); + return; + } + + if ( argv[0].a_type != A_FLOAT ) + { + post("pdp_frei0r : set parameter : wrong parameter number" ); + return; + } + pnumber = (int)argv[0].a_w.w_float; + // post("pdp_frei0r : setting parameter : %d", pnumber ); + + if ( (pnumber<0) || (pnumber>=(int)x->plugins[x->x_plugin].numparameters) ) + { + post("pdp_frei0r : set parameter : wrong parameter number : %d : max : %d", pnumber, x->plugins[x->x_plugin].numparameters ); + return; + } + + (*x->plugins[x->x_plugin].f0r_get_param_info)(¶m_infos, pnumber); + + // set parameter + switch (param_infos.type) + { + case F0R_PARAM_BOOL: + { + f0r_param_bool fvalue; + + if ( argc != 2 ) + { + post("pdp_frei0r : wrong parameter arguments (%d) for boolean", argc ); + return; + } + if ( argv[1].a_type != A_FLOAT ) + { + post("pdp_frei0r : wrong parameter value" ); + return; + } + if ( argv[1].a_w.w_float != 0. && argv[1].a_w.w_float != 1. ) + { + // post("pdp_frei0r : wrong parameter value for boolean" ); + return; + } + fvalue=argv[1].a_w.w_float; + (*x->plugins[x->x_plugin].f0r_set_param_value)(x->plugins[x->x_plugin].instance, &fvalue, pnumber); + } + break; + case F0R_PARAM_DOUBLE: + { + f0r_param_double fvalue; + + if ( argc != 2 ) + { + post("pdp_frei0r : wrong parameter arguments (%d) for double", argc ); + return; + } + if ( argv[1].a_type != A_FLOAT ) + { + post("pdp_frei0r : wrong parameter value" ); + return; + } + fvalue=argv[1].a_w.w_float; + (*x->plugins[x->x_plugin].f0r_set_param_value)(x->plugins[x->x_plugin].instance, &fvalue, pnumber); + } + break; + case F0R_PARAM_COLOR: + { + struct f0r_param_color color; + + if ( argc != 4 ) + { + post("pdp_frei0r : wrong parameter arguments (%d) for color", argc ); + return; + } + if ( argv[1].a_type != A_FLOAT || + argv[2].a_type != A_FLOAT || + argv[3].a_type != A_FLOAT ) + { + post("pdp_frei0r : wrong parameter value" ); + return; + } + color.r = argv[1].a_w.w_float; + color.g = argv[2].a_w.w_float; + color.b = argv[3].a_w.w_float; + (*x->plugins[x->x_plugin].f0r_set_param_value)(x->plugins[x->x_plugin].instance, &color, pnumber); + } + break; + case F0R_PARAM_POSITION: + { + struct f0r_param_position position; + + if ( argc != 3 ) + { + post("pdp_frei0r : wrong parameter arguments (%d) for position", argc ); + return; + } + if ( argv[1].a_type != A_FLOAT || + argv[2].a_type != A_FLOAT ) + { + post("pdp_frei0r : wrong parameter value" ); + return; + } + position.x = argv[1].a_w.w_float; + position.y = argv[2].a_w.w_float; + (*x->plugins[x->x_plugin].f0r_set_param_value)(x->plugins[x->x_plugin].instance, &position, pnumber); + } + break; + default: + post("pdp_frei0r : unsupported parameter type (%d)", param_infos.type ); + return; + } +} + +static void pdp_frei0r_plugin(t_pdp_frei0r *x, t_floatarg f) +{ + unsigned pi; + char *parname; + int partype; + t_atom plist[2]; + t_atom tlist[2]; + t_atom vlist[2]; + f0r_param_info_t param_infos; + + if ( x->x_plugin_count <= 0 ) + { + post( "frei0r : no plugins loaded, check your plugin directory setup" ); + return; + } + if((f<x->x_plugin_count)&&(f>-1)) + { + x->x_plugin = f; + } + else + { + post( "frei0r : plugin out of range : %d", (t_int)f ); + return; + } + post ("pdp_freeframe :: %s selected, %d parameters", x->plugins[x->x_plugin].name, x->plugins[x->x_plugin].numparameters); + outlet_symbol(x->x_pname, gensym( x->plugins[x->x_plugin].name ) ); + outlet_float(x->x_nparams, (float)x->plugins[x->x_plugin].numparameters); + for ( pi=0; pi<x->plugins[x->x_plugin].numparameters; pi++ ) + { + (*x->plugins[x->x_plugin].f0r_get_param_info)(¶m_infos, pi); + SETFLOAT(&plist[0], pi); + SETSYMBOL(&plist[1], gensym(param_infos.name) ); + outlet_list( x->x_parname, &s_list, 2, &plist[0] ); + SETFLOAT(&tlist[0], pi); + SETFLOAT(&tlist[1], param_infos.type ); + outlet_list( x->x_partype, &s_list, 2, &tlist[0] ); + } +} + +static void pdp_frei0r_sendpacket(t_pdp_frei0r *x) +{ + /* release the incoming packets */ + pdp_packet_mark_unused(x->x_packet0); + x->x_packet0 = -1; + pdp_packet_mark_unused(x->x_packet1); + x->x_packet1 = -1; + pdp_packet_mark_unused(x->x_packetr0); + x->x_packetr0 = -1; + pdp_packet_mark_unused(x->x_packetr1); + x->x_packetr1 = -1; + pdp_packet_mark_unused(x->x_packetm0); + x->x_packetm0 = -1; + pdp_packet_mark_unused(x->x_packetm1); + x->x_packetm1 = -1; + + x->x_packet3=-1; + x->x_dropped = pdp_packet_convert_ro_or_drop(&x->x_packet3, x->x_packet2, pdp_gensym("bitmap/rgb/*") ); + pdp_packet_mark_unused(x->x_packet2); + x->x_packet2 = -1; + + /* unregister and propagate if valid dest packet */ + pdp_packet_pass_if_valid(x->x_outlet0, &x->x_packet3); +} + +static void pdp_frei0r_process(t_pdp_frei0r *x) +{ + int encoding; + t_pdp *header = 0; + char *parname; + unsigned pi; + int partype; + t_atom plist[2]; + t_atom tlist[2]; + t_atom vlist[2]; + f0r_param_info_t param_infos; + + /* check if image data packets are compatible */ + if ( (header = pdp_packet_header(x->x_packet1)) + && (PDP_BITMAP == header->type)){ + + /* pdp_frei0r_process inputs and write into active inlet */ + switch(pdp_packet_header(x->x_packet1)->info.image.encoding){ + + case PDP_BITMAP_RGBA: + x->x_packet2 = pdp_packet_clone_rw(x->x_packet1); + pdp_queue_add(x, pdp_frei0r_process_rgba, pdp_frei0r_sendpacket, &x->x_queue_id); + break; + + default: + /* don't know the type, so dont pdp_frei0r_process */ + break; + + } + } + + // hack to display infos of first loaded plugin + if ( ( x->x_plugin_count>0 ) && ( !x->x_infosok ) ) + { + outlet_symbol(x->x_pname, gensym( x->plugins[x->x_plugin].name ) ); + outlet_float(x->x_nparams, (float)x->plugins[x->x_plugin].numparameters); + for ( pi=0; pi<x->plugins[x->x_plugin].numparameters; pi++ ) + { + (*x->plugins[x->x_plugin].f0r_get_param_info)(¶m_infos, pi); + SETFLOAT(&plist[0], pi); + SETSYMBOL(&plist[1], gensym(param_infos.name) ); + outlet_list( x->x_parname, &s_list, 2, &plist[0] ); + SETFLOAT(&tlist[0], pi); + SETFLOAT(&tlist[1], param_infos.type ); + outlet_list( x->x_partype, &s_list, 2, &tlist[0] ); + } + x->x_infosok = 1; + } +} + +static void pdp_frei0r_input_0(t_pdp_frei0r *x, t_symbol *s, t_floatarg f) +{ + if (s == gensym("register_rw")) + { + x->x_packet0=-1; + x->x_dropped = pdp_packet_convert_ro_or_drop(&x->x_packet0, (int)f, pdp_gensym("bitmap/rgb/*") ); + // post("pdp_freiOr : drop 1 : %d", x->x_dropped ); + x->x_packet1=-1; + x->x_dropped = pdp_packet_convert_ro_or_drop(&x->x_packet1, x->x_packet0, pdp_gensym("bitmap/rgba/*") ); + // post("pdp_freiOr : drop 2 : %d", x->x_dropped ); + } + + if ((s == gensym("process")) && (-1 != x->x_packet1) && (!x->x_dropped)) + { + /* add the process method and callback to the process queue */ + pdp_frei0r_process(x); + } +} + +static void pdp_frei0r_input_1(t_pdp_frei0r *x, t_symbol *s, t_floatarg f) +{ + char *ddata; + char *sdata; + + if ( x->x_packetm0 != -1 ) + { + return; + } + x->x_dropped = pdp_packet_convert_rw_or_drop(&x->x_packetm0, (int)f, pdp_gensym("bitmap/rgb/*") ); + // post("pdp_freiOr : middle drop 1 : %d", x->x_dropped ); + x->x_dropped = pdp_packet_convert_rw_or_drop(&x->x_packetm1, x->x_packetm0, pdp_gensym("bitmap/rgba/*") ); + // post("pdp_freiOr : middle drop 2 : %d", x->x_dropped ); +} + +static void pdp_frei0r_input_2(t_pdp_frei0r *x, t_symbol *s, t_floatarg f) +{ + char *ddata; + char *sdata; + + if ( x->x_packetr0 != -1 ) + { + return; + } + x->x_dropped = pdp_packet_convert_rw_or_drop(&x->x_packetr0, (int)f, pdp_gensym("bitmap/rgb/*") ); + // post("pdp_freiOr : right drop 1 : %d", x->x_dropped ); + x->x_dropped = pdp_packet_convert_rw_or_drop(&x->x_packetr1, x->x_packetr0, pdp_gensym("bitmap/rgba/*") ); + // post("pdp_freiOr : right drop 2 : %d", x->x_dropped ); +} + +static void pdp_frei0r_free(t_pdp_frei0r *x) +{ + int i; + + pdp_queue_finish(x->x_queue_id); + pdp_packet_mark_unused(x->x_packet0); + fr_freeplugins(x); +} + +t_class *pdp_frei0r_class; + +void *pdp_frei0r_new(t_floatarg f) +{ + int i; + + t_pdp_frei0r *x = (t_pdp_frei0r *)pd_new(pdp_frei0r_class); + inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("pdp"), gensym("pdp1") ); + inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("pdp"), gensym("pdp2") ); + inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("plugin")); + + x->x_outlet0 = outlet_new(&x->x_obj, &s_anything); + x->x_pname = outlet_new(&x->x_obj, &s_anything); + x->x_nparams = outlet_new(&x->x_obj, &s_anything); + x->x_parname = outlet_new(&x->x_obj, &s_anything); + x->x_partype = outlet_new(&x->x_obj, &s_anything); + + x->x_packet0 = -1; + x->x_packet1 = -1; + x->x_packet2 = -1; + x->x_packet3 = -1; + x->x_packetm0 = -1; + x->x_packetm1 = -1; + x->x_packetr0 = -1; + x->x_packetr1 = -1; + x->x_queue_id = -1; + + x->x_width = 320; + x->x_height = 240; + x->x_size = x->x_width * x->x_height; + + //load the plugins + x->x_plugin_count = 0; + x->x_infosok = 0; + fr_loadplugins(x, FR_PLUGIN_DIR); + + //select plugin + pdp_frei0r_plugin(x, f); + + return (void *)x; +} + + +#ifdef __cplusplus +extern "C" +{ +#endif + + +void pdp_frei0r_setup(void) +{ + + post( "pdp_frei0r :: frei0r host for Pure Data Packet version 0.1\n by Lluis Gomez i Bigorda (lluis@artefacte.org) \n & Yves Degoyon (ydegoyon@free.fr)\n using frei0r specification 1.1 by Georg Seidel,\n Phillip Promesberger and Martin Bayer\n made at piksel yearly gathering : http://www.piksel.no" ); + pdp_frei0r_class = class_new(gensym("pdp_frei0r"), (t_newmethod)pdp_frei0r_new, + (t_method)pdp_frei0r_free, sizeof(t_pdp_frei0r), 0, A_DEFFLOAT, A_NULL); + + class_addmethod(pdp_frei0r_class, (t_method)pdp_frei0r_input_0, gensym("pdp"), A_SYMBOL, A_DEFFLOAT, A_NULL); + class_addmethod(pdp_frei0r_class, (t_method)pdp_frei0r_input_1, gensym("pdp1"), A_SYMBOL, A_DEFFLOAT, A_NULL); + class_addmethod(pdp_frei0r_class, (t_method)pdp_frei0r_input_2, gensym("pdp2"), A_SYMBOL, A_DEFFLOAT, A_NULL); + class_addmethod(pdp_frei0r_class, (t_method)pdp_frei0r_plugin, gensym("plugin"), A_FLOAT, A_NULL); + class_addmethod(pdp_frei0r_class, (t_method)pdp_frei0r_param, gensym("param"), A_GIMME, A_NULL); + +} + +#ifdef __cplusplus +} +#endif |