checking in pdp 0.12.4 from http://zwizwa.fartit.com/pd/pdp/pdp-0.12.4.tar.gz

svn path=/trunk/externals/pdp/; revision=4232

37 files changed, 3664 insertions, 0 deletions

diff --git a/include/Makefile b/include/Makefile
new file mode 100644
index 0000000..1aba02c
--- /dev/null
+++ b/include/Makefile
@@ -0,0 +1,6 @@
+current:
+
+
+clean:
+	rm -f *~
+
diff --git a/include/pdp.h b/include/pdp.h
new file mode 100644
index 0000000..ed57b24
--- /dev/null
+++ b/include/pdp.h
@@ -0,0 +1,158 @@
+/*
+ *   Pure Data Packet header file.
+ *   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.
+ *
+ */
+
+
+
+#ifndef PDP_H
+#define PDP_H
+
+
+/* header and subheader size in bytes */
+
+#include <string.h>
+#include <stdlib.h>
+
+#include "pdp_pd.h"
+
+/* config stuff */
+#include "pdp_config.h"
+
+/* debug stuff */
+#include "pdp_debug.h"
+
+/* some typedefs */
+#include "pdp_types.h"
+
+/* pdp's symbol handling */
+#include "pdp_symbol.h"
+
+/* the list object */
+#include "pdp_list.h"
+
+/* memory management */
+#include "pdp_mem.h"
+
+/* console messages */
+#include "pdp_post.h"
+
+
+/* PDP_IMAGE COMPONENTS */
+
+/* header and methods for the built in image packet type */
+#include "pdp_image.h"
+
+/* low level image processing and high level dispatching routines */
+#include "pdp_imageproc.h"
+
+/* low level image conversion routines */
+#include "pdp_llconv.h"
+
+/* low level image resampling routines */
+#include "pdp_resample.h"
+
+
+
+/* PDP_BITMAP COMPONENTS */
+
+/* header and methods for the built in bitmap packet type */
+#include "pdp_bitmap.h"
+
+
+
+/* PDP_MATRIX COMPONENTS */
+#include "pdp_matrix.h"
+
+
+
+
+/* PDP SYSTEM COMPONENTS */
+
+/* packet pool stuff */
+#include "pdp_packet.h"
+
+/* processing queue object */
+#include "pdp_queue.h"
+
+/* several communication helper methods (pd specific) */
+#include "pdp_comm.h"
+
+/* type handling subsystem */
+#include "pdp_type.h"
+
+/* dpd command stuff */
+#include "pdp_dpd_command.h"
+
+
+/* BACKWARDS COMPAT STUFF */
+#include "pdp_compat.h"
+
+
+
+
+#endif 
+
+/*
+
+   PDP CORE API OVERVIEW
+
+   pdp_packet_* : packet methods, first argument is packet id
+
+      new:                construct a raw packet (depreciated)
+      new_*:              construct packet of specific type/subtype/...
+      mark_unused:        release
+      mark_passing:       conditional release (release on first copy ro/rw)
+      copy_ro:            readonly (shared) copy
+      copy_rw:            private copy
+      clone_rw:           private copy (copies only meta data, not the content)
+      header:             get the raw header (t_pdp *)
+      data:               get the raw data (void *)
+      pass_if_valid:      send a packet to pd outlet, if it is valid
+      replace_if_valid    delete packet and replace with new one, if new is valid
+      copy_ro_or_drop:    copy readonly, or don't copy if dest slot is full + send drop notify
+      copy_rw_or_drop:    same, but private copy
+      get_description:    retrieve type info
+      convert_ro:         same as copy_ro, but with an automatic conversion matching a type template
+      convert_rw:         same as convert_ro, but producing a private copy
+
+   pdp_pool_* : packet pool methods
+
+      collect_garbage:    manually free all unused resources in packet pool
+
+   pdp_queue_* : processing queue methods
+
+      add:                add a process method + callback
+      finish:             wait until a specific task is done
+      wait:               wait until processing queue is done
+
+   pdp_control_* : central pdp control hub methods
+
+      notify_drop:        notify that a packet has been dropped
+
+   pdp_type_* : packet type mediator methods
+
+      description_match:   check if two type templates match
+      register_conversion: register a type conversion program
+
+
+
+   NOTE: it is advised to derive your module from the pdp base class defined in pdp_base.h
+         instead of communicating directly with the pdp core
+
+*/
diff --git a/include/pdp_ascii.h b/include/pdp_ascii.h
new file mode 100644
index 0000000..1fde9b4
--- /dev/null
+++ b/include/pdp_ascii.h
@@ -0,0 +1,39 @@
+/*
+ *   Pure Data Packet header file. ascii packet type.
+ *   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.
+ *
+ */
+
+
+#ifndef PDP_H
+#define PDP_H
+
+/* ascii data packet */   
+typedef struct
+{
+    unsigned int encoding;  /* image encoding (data format) */
+    unsigned int width;     /* image width in pixels */
+    unsigned int height;    /* image height in pixels */
+} t_ascii;
+
+
+/* ascii encodings */
+#define PDP_ASCII_BW     1  /* 8 bit per character black and white.*/
+#define PDP_ASCII_IBM    2  /* 16 bit per character colour (8 bit character, 8 bit colour, like good old text framebuffers.*/
+#define PDP_ASCII_RGB    3  /* 64 bit per character colour (8 bit character, 3x8 bit RGB */
+
+#endif
diff --git a/include/pdp_base.h b/include/pdp_base.h
new file mode 100644
index 0000000..2839f37
--- /dev/null
+++ b/include/pdp_base.h
@@ -0,0 +1,136 @@
+/*
+ *   Pure Data Packet base class header file.
+ *   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.
+ *
+ */
+
+
+/*
+  This file contains the specification of the pdp base class. It is derived
+  from t_object, the basic pd object (like any other pd extern). Have a look
+  at pdp_add, pdp_gain and pdp_noise to see how to use this.
+
+*/
+
+
+#define MAX_NB_PDP_BASE_INLETS 4
+#define MAX_NB_PDP_BASE_OUTLETS 4
+
+#include "pdp_pd.h"
+#include "pdp_symbol.h"
+#include "pdp_types.h"
+#include "pdp_queue.h"
+#include "pdp_comm.h"
+#include "pdp_compat.h"
+#include "pdp_packet.h"
+
+typedef void (*t_pdp_method)(void *);
+typedef void* (*t_pdp_newmethod)(void *);
+
+
+typedef struct
+{
+    t_object x_obj;
+
+    int b_inlets;           // the number of pdp inlets
+    int b_outlets;          // the number of pdp outlets
+
+                            // registers to store incoming packets
+    int b_packet[MAX_NB_PDP_BASE_INLETS];
+    int b_packet_next[MAX_NB_PDP_BASE_INLETS];
+    t_pdp_symbol *b_type_template[MAX_NB_PDP_BASE_INLETS];
+
+    int b_queue_id;         // task id in process queue (for callback cancelling)
+    //int b_dropped;          // indicate if a packet was dropped during register_rw cycle
+
+                            // wil the default (left) active inlet accept pdp messages ?
+    int b_active_inlet_enabled;
+    int b_active_inlet_readonly;
+    
+                            // the process callbacks
+    t_pdp_method b_process_method; // called in pdp thread
+    t_pdp_method b_preproc_method; // called before thread (for packet alloc and checking)
+    t_pdp_method b_postproc_method; // called after thread (for outlet stuff other than default active packet->out0)
+	                     
+                            // packet outlets
+    t_outlet *b_outlet[MAX_NB_PDP_BASE_OUTLETS];
+
+    u32 b_channel_mask;     // channel mask
+
+    int b_thread_enabled;   // thread enable switch
+
+    t_pdp_procqueue *b_q;   // queue object
+
+} t_pdp_base;
+
+
+
+/* setup base class. call this in your derived class setup method */
+void pdp_base_setup(t_class *c);
+
+
+/* base class constructor/destructor. call this in your base class constructor/destructor */
+void pdp_base_init(void *x);
+void pdp_base_free(void *x);
+
+
+/* register processing callbacks */
+void pdp_base_set_process_method(void *x, t_pdp_method m); //process callback (called from pdp thread)
+void pdp_base_set_preproc_method(void *x, t_pdp_method m); //pre-process callback (called before process from pd thread)
+void pdp_base_set_postproc_method(void *x, t_pdp_method m); //post-process callback (called after process from pd thread)
+
+
+/* configure inlets/outlets */
+void pdp_base_add_pdp_inlet(void *x);
+t_outlet *pdp_base_add_pdp_outlet(void *x);
+void pdp_base_disable_active_inlet(void *x); //use this for pdp generators
+void pdp_base_readonly_active_inlet(void *x); //use this for pdp converters ("out of place" processing)
+void pdp_base_add_gen_inlet(void *x, t_symbol *from, t_symbol *to); // generic inlet
+
+
+/* bang method */
+void pdp_base_bang(void *x);
+
+
+/* move delayed passive packets in place */
+void pdp_base_movepassive(void *x);
+
+
+
+/* packet manipulation methods 
+   0   active inlet (left) if enabled
+   >0  additional pdp inlets created with pdp_base_add_pdp_inlet */
+int pdp_base_get_packet(void *x, int inlet);  // get the packet from an inlet
+int pdp_base_move_packet(void *x, int inlet); // same as get, but it removes the reference in the base class
+void pdp_base_set_packet(void *x, int inlet, int packet); // set (replace) the active packet (will be sent to outlet)
+
+
+/* getters for base class data */
+u32 pdp_base_get_chanmask(void *x);
+t_object *pdp_base_get_object(void *x);
+
+
+/* thread control */
+void pdp_base_disable_thread(void *x);
+
+/* type control */
+void pdp_base_set_type_template(void *x, int inlet, t_pdp_symbol *type_template);
+
+/* queue control */
+void pdp_base_queue_wait(void *x);
+void pdp_base_set_queue(void *x, t_pdp_procqueue *q);
+t_pdp_procqueue *pdp_base_get_queue(void *x);
diff --git a/include/pdp_bitmap.h b/include/pdp_bitmap.h
new file mode 100644
index 0000000..3fddc25
--- /dev/null
+++ b/include/pdp_bitmap.h
@@ -0,0 +1,96 @@
+/*
+ *   Pure Data Packet system implementation. 8 bit image packet interface
+ *   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.
+ *
+ */
+
+
+/*
+  This file contains methods for the image packets
+  pdp_packet_new_* methods are several image packet constructors
+
+  It also contains some pdp_type_ methods, for type checking
+  and conversion.
+
+*/
+
+#ifndef PDP_BITMAP_H
+#define PDP_BITMAP_H
+
+
+
+/* bitmap  data packet */   
+typedef struct _bitmap
+{
+    /* standard images */
+    unsigned int encoding;    /* image encoding (fourcc data format) */
+    unsigned int width;       /* image width in pixels */
+    unsigned int height;      /* image height in pixels */
+    unsigned int bpp;         /* bits per pixel (0 == standard) */
+
+} t_bitmap;
+
+
+
+/* supported encodings (fourcc) */
+
+/* special */
+#define PDP_BITMAP_RGB  0x32424752
+#define PDP_BITMAP_RGBA 0x41424752
+#define PDP_BITMAP_GREY 0x59455247
+
+/* packet yuv */
+#define PDP_BITMAP_YUY2 0x32595559
+#define PDP_BITMAP_UYVY 0x59565955
+
+/* planar yuv */
+#define PDP_BITMAP_I420 0x30323449
+#define PDP_BITMAP_YV12 0x32315659
+
+
+/* all symbols are C style */
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+
+/* bitmap constructors*/
+int pdp_packet_new_bitmap_yv12(u32 width, u32 height);
+int pdp_packet_new_bitmap_grey(u32 width, u32 height);
+int pdp_packet_new_bitmap_rgb(u32 width, u32 height);
+int pdp_packet_new_bitmap_rgba(u32 width, u32 height);
+int pdp_packet_new_bitmap(int type, u32 width, u32 height);
+
+/* utility methids */
+void pdp_packet_bitmap_flip_top_bottom(int packet);
+
+
+/* get description */
+t_pdp_symbol *pdp_packet_bitmap_get_description(int packet);
+
+/* get subheader */
+t_bitmap *pdp_packet_bitmap_info(int packet);
+
+bool pdp_packet_bitmap_isvalid(int packet);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/include/pdp_comm.h b/include/pdp_comm.h
new file mode 100644
index 0000000..bd6cab8
--- /dev/null
+++ b/include/pdp_comm.h
@@ -0,0 +1,120 @@
+/*
+ *   Pure Data Packet system implementation.
+ *   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.
+ *
+ */
+
+/* this file contains misc communication methods */
+
+#ifndef PDP_COMM_H
+#define PDP_COMM_H
+
+#include "pdp_symbol.h"
+#include "pdp_list.h"
+
+/* all symbols are C style */
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+
+/* pdp's pd symbols for communication 
+   don't use these directly!!
+   use the macros instead, in case
+   this is proven to be too much of a hack.. */
+
+extern t_symbol s_pdp;
+extern t_symbol s_register_ro;
+extern t_symbol s_register_rw;
+extern t_symbol s_process;
+extern t_symbol s_dpd;
+extern t_symbol s_inspect;
+extern t_symbol s_accumulate;
+extern t_symbol s_chanmask;
+
+
+#define S_PDP         &s_pdp
+#define S_REGISTER_RO &s_register_ro
+#define S_REGISTER_RW &s_register_rw
+#define S_PROCESS     &s_process
+#define S_DPD         &s_dpd
+#define S_INSPECT     &s_inspect
+#define S_ACCUMULATE  &s_accumulate
+#define S_CHANMASK    &s_chanmask
+
+
+/* utility methods */
+
+
+
+/* if packet is valid, mark it unused and send it to an outlet */
+void pdp_packet_pass_if_valid(t_outlet *outlet, int *packet);
+
+/* if source packet is valid, release dest packet and move src->dest */
+void pdp_packet_replace_if_valid(int *dpacket, int *spacket);
+
+/* copy_ro if dest packet if invalid, else drop source 
+   (don't copy) + send drop notif to pdp system 
+   returns 1 if dropped, 0 if copied */
+int pdp_packet_copy_ro_or_drop(int *dpacket, int spacket);
+int pdp_packet_convert_ro_or_drop(int *dpacket, int spacket, t_pdp_symbol *type_template);
+
+/* copy_rw if dest packit is invalid, else drop source 
+   (don't copy) + send drop notif to pdp system 
+   returns 1 if dropped, zero if copied */
+int pdp_packet_copy_rw_or_drop(int *dpacket, int spacket);
+int pdp_packet_convert_rw_or_drop(int *dpacket, int spacket, t_pdp_symbol *type_template);
+
+
+/* pd and pdp conversion stuff */
+void pd_atom_to_pdp_atom(t_atom *pdatom, t_pdp_atom *pdpatom);
+
+
+/* send pdp lists and atoms */
+void outlet_pdp_atom(t_outlet *out, struct _pdp_atom *a);
+void outlet_pdp_list(t_outlet *out, struct _pdp_list *l);
+
+
+
+/* send a packet to an outlet: it is only legal to call this on a "passing packet"
+   or a "read only packet".
+   this means it is illegal to change a packet after you have passed it to others,
+   since this would mess up all read only references to the packet.
+*/
+
+/* this seems like a nice place to hide a comment on the notion of read/write in pdp
+   which packets are writable? all packets with exactly 1 user. this includes all packets 
+   aquired with pdp_packet_*_rw or a constructor, and all packets that are not registered
+   after being sent out by outlet_pdp.
+   which packets are readable? all packets */
+
+void outlet_pdp(t_outlet *out, int packetid);
+
+/* send an accumulation (context) packet to an outlet. this is for usage in the dpd
+   base class. */
+void outlet_dpd(t_outlet *out, int packetid);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#endif
diff --git a/include/pdp_compat.h b/include/pdp_compat.h
new file mode 100644
index 0000000..2bc948f
--- /dev/null
+++ b/include/pdp_compat.h
@@ -0,0 +1,17 @@
+
+/*
+   please don't use any of these. for backwards compatibility only
+*/
+
+
+#ifndef PDP_COMPAT_H
+#define PDP_COMPAT_H
+
+
+
+
+void pdp_pass_if_valid(t_outlet *outlet, int *packet);
+void pdp_replace_if_valid(int *dpacket, int *spacket);
+
+
+#endif
diff --git a/include/pdp_config.h b/include/pdp_config.h
new file mode 100644
index 0000000..74274e2
--- /dev/null
+++ b/include/pdp_config.h
@@ -0,0 +1,89 @@
+/* include/pdp_config.h.  Generated by configure.  */
+/* include/pdp_config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#define HAVE_INTTYPES_H 1
+
+/* Define to 1 if you have the `gslcblas' library (-lgslcblas). */
+#define HAVE_LIBGSLCBLAS 1
+
+/* Define to 1 if you have the `m' library (-lm). */
+#define HAVE_LIBM 1
+
+/* Define to 1 if you have the <memory.h> header file. */
+#define HAVE_MEMORY_H 1
+
+/* build pdp_glx */
+#define HAVE_PDP_GLX 1
+
+/* gsl support */
+#define HAVE_PDP_GSL 1
+
+/* build png support */
+#define HAVE_PDP_PNG 1
+
+/* build pdp_qt */
+#define HAVE_PDP_QT 1
+
+/* readline needed for console support */
+/* #undef HAVE_PDP_READLINE */
+
+/* build pdp_sdl */
+/* #undef HAVE_PDP_SDL */
+
+/* build pdp_v4l */
+/* #undef HAVE_PDP_V4L */
+
+/* experimental vforth dsp engine */
+/* #undef HAVE_PDP_VFORTH */
+
+/* build X11 support */
+#define HAVE_PDP_X 1
+
+/* build pdp_xv */
+#define HAVE_PDP_XV 1
+
+/* enable forced pwc v4l support */
+/* #undef HAVE_PWCV4L */
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#define HAVE_STDINT_H 1
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
+
+/* Define to 1 if you have the <strings.h> header file. */
+#define HAVE_STRINGS_H 1
+
+/* Define to 1 if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#define HAVE_SYS_STAT_H 1
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#define HAVE_SYS_TYPES_H 1
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#define HAVE_UNISTD_H 1
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT ""
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME ""
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING ""
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME ""
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION ""
+
+/* "disable debugging support" */
+#define PDP_DEBUG 0
+
+/* Define to 1 if you have the ANSI C header files. */
+#define STDC_HEADERS 1
diff --git a/include/pdp_config.h.in b/include/pdp_config.h.in
new file mode 100644
index 0000000..1ecfb3a
--- /dev/null
+++ b/include/pdp_config.h.in
@@ -0,0 +1,88 @@
+/* include/pdp_config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#undef HAVE_INTTYPES_H
+
+/* Define to 1 if you have the `gslcblas' library (-lgslcblas). */
+#undef HAVE_LIBGSLCBLAS
+
+/* Define to 1 if you have the `m' library (-lm). */
+#undef HAVE_LIBM
+
+/* Define to 1 if you have the <memory.h> header file. */
+#undef HAVE_MEMORY_H
+
+/* build pdp_glx */
+#undef HAVE_PDP_GLX
+
+/* gsl support */
+#undef HAVE_PDP_GSL
+
+/* build png support */
+#undef HAVE_PDP_PNG
+
+/* build pdp_qt */
+#undef HAVE_PDP_QT
+
+/* readline needed for console support */
+#undef HAVE_PDP_READLINE
+
+/* build pdp_sdl */
+#undef HAVE_PDP_SDL
+
+/* build pdp_v4l */
+#undef HAVE_PDP_V4L
+
+/* experimental vforth dsp engine */
+#undef HAVE_PDP_VFORTH
+
+/* build X11 support */
+#undef HAVE_PDP_X
+
+/* build pdp_xv */
+#undef HAVE_PDP_XV
+
+/* enable forced pwc v4l support */
+#undef HAVE_PWCV4L
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#undef HAVE_STDINT_H
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#undef HAVE_STDLIB_H
+
+/* Define to 1 if you have the <strings.h> header file. */
+#undef HAVE_STRINGS_H
+
+/* Define to 1 if you have the <string.h> header file. */
+#undef HAVE_STRING_H
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#undef HAVE_SYS_STAT_H
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#undef HAVE_SYS_TYPES_H
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#undef HAVE_UNISTD_H
+
+/* Define to the address where bug reports for this package should be sent. */
+#undef PACKAGE_BUGREPORT
+
+/* Define to the full name of this package. */
+#undef PACKAGE_NAME
+
+/* Define to the full name and version of this package. */
+#undef PACKAGE_STRING
+
+/* Define to the one symbol short name of this package. */
+#undef PACKAGE_TARNAME
+
+/* Define to the version of this package. */
+#undef PACKAGE_VERSION
+
+/* "disable debugging support" */
+#undef PDP_DEBUG
+
+/* Define to 1 if you have the ANSI C header files. */
+#undef STDC_HEADERS
diff --git a/include/pdp_control.h b/include/pdp_control.h
new file mode 100644
index 0000000..c23dc1f
--- /dev/null
+++ b/include/pdp_control.h
@@ -0,0 +1,12 @@
+#ifndef __PDP_CONTROL_H__
+#define __PDP_CONTROL_H__
+
+#include "pdp_pd.h"
+
+struct _pdp_control;
+typedef void (t_pdp_control_method_notify)(struct _pdp_control *x);
+
+void pdp_control_notify_broadcast(t_pdp_control_method_notify *notify);
+void pdp_control_addmethod(t_method m, t_symbol *s);
+
+#endif
diff --git a/include/pdp_debug.h b/include/pdp_debug.h
new file mode 100644
index 0000000..a5e48fc
--- /dev/null
+++ b/include/pdp_debug.h
@@ -0,0 +1,16 @@
+#ifndef __PDP_DEBUG_H_
+#define __PDP_DEBUG_H_
+
+#include "pdp_config.h" // needed for PDP_DEBUG define
+
+void pdp_assert_hook (char *condition, char *file, int line);
+
+
+
+#if PDP_DEBUG
+#define PDP_ASSERT(x) if (!(x)) {pdp_assert_hook(#x, __FILE__, __LINE__);}
+#else
+#define PDP_ASSERT(x)
+#endif
+
+#endif //__PDP_DEBUG_H_
diff --git a/include/pdp_dpd_base.h b/include/pdp_dpd_base.h
new file mode 100644
index 0000000..0d20e29
--- /dev/null
+++ b/include/pdp_dpd_base.h
@@ -0,0 +1,141 @@
+/*
+ *   Pure Data Packet header file. DPD base class
+ *   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.
+ *
+ */
+
+
+/* dpd base class for context based processors (for pd-fying standard stack based serial languages)
+   not all of pdp is used here, but the class is derived from the pdp base class to enable mixing
+   standard pdp (data flow packet processing) and dpd (context based serial languages)
+   
+   dpd is short for "upside down pdp". the name stems from the observation
+   of opengl code in pd (like in gem) having an upside down feel when looking
+   through dataflow eyes. i.e.: the target (window context) is on top, while
+   the objects (geos) are at the bottom connected by a chain of geometric transforms
+
+   the principles of dpd are simple:
+
+   * there is only one main packet, received on the left inlet.
+   * this packet is called the "context" and is produced by and returned to a top context source/sink
+   * additional pd messages and pdp packets can be received on the cold inlets
+   * as opposed to pdp, no copies are made of this context packet, all operations on it are accumulative.
+   * the protocol is different because fanout is prohibited (so no ro/rw registering)
+   * the only exception for fanout are inspectors, which have precedence over normal processors
+   * all processors and inspectors for a single context type must use the pdp thread, to preserve execution order
+   
+
+*/
+
+
+
+#include "pdp_base.h"
+
+#define PDP_DPD_MAX_CONTEXT_OUTLETS 4
+
+typedef struct pdp_dpd_base_struct
+{
+    t_pdp_base b_base; /* pdp base class */
+
+    int b_nb_context_outlets;
+    t_outlet *b_context_outlet[PDP_DPD_MAX_CONTEXT_OUTLETS];  /* dpd outlets */
+    int b_outlet_enable[PDP_DPD_MAX_CONTEXT_OUTLETS];  /* dpd outlets */
+    t_pdp_method b_accum_method[PDP_DPD_MAX_CONTEXT_OUTLETS]; /* accumulation methods for each outlet */
+    t_pdp_method b_accum_callback[PDP_DPD_MAX_CONTEXT_OUTLETS]; /* pd callback methods for each outlet */
+    //int b_accum_queue_id[PDP_DPD_MAX_CONTEXT_OUTLETS];        /* accumulator queue id's */
+
+    t_pdp_method b_inspector_method;         /* pdp thread inspector callback */
+    t_pdp_method b_inspector_callback;       /* main thread inspector callback */
+    //int b_inspector_queue_id;
+    
+    t_pdp_method b_cleanup_method;         /* queued after propagation is done  */
+    t_pdp_method b_cleanup_callback;       /* queued after propagation is done  */
+    //int b_cleanup_queue_id;
+
+    t_pdp_method b_complete_notify;         /* method called after packet output is done */
+    t_pdp_newmethod b_command_factory_method;      /* command factory method */
+
+
+    int b_context_packet; /* the current context packet */
+
+    int b_dpd_active_inlet_disabled;
+
+
+} t_pdp_dpd_base;
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/* bang method (propagate context to outlets & register callbacks)
+   mainly for context source/sinks
+   it is not registered as a pd message by default ! */
+void pdp_dpd_base_bang(void *x);
+
+/* get/set the context packet */
+int pdp_dpd_base_get_context_packet(void *x);
+void pdp_dpd_base_set_context_packet(void *x, int p);
+int pdp_dpd_base_move_context_packet(void *x);
+
+/* add a context outlet and it's corresponding accumulation (process) and callback method */
+t_outlet *pdp_dpd_base_add_outlet(void *x, t_pdp_method accum_method, t_pdp_method accum_callback);
+
+/* add a cleanup callback (called after all propagation is finished) for sources/sinks */
+void pdp_dpd_base_add_cleanup(void *x, t_pdp_method cleanup_method, t_pdp_method accum_callback);
+
+/* add an inspector callback */
+void pdp_dpd_base_add_inspector(void *x, t_pdp_method inspector_method);
+
+
+/* destructor */
+void pdp_dpd_base_free(void *x);
+
+/* init method */
+void pdp_dpd_base_init(void *x);
+
+/* disable dpd active inlet */
+void pdp_dpd_base_disable_active_inlet(void *x);
+
+/* enable/disable outlet */
+void pdp_dpd_base_enable_outlet(void *x, int outlet, int toggle);
+
+/* register notify method (called from the end of pdp_dpd_base_bang) */
+void pdp_dpd_base_register_complete_notify(void *x, t_pdp_method method);
+
+/* register a command init (factory) method 
+   this method should return a command object to place in the queue */
+void pdp_dpd_base_register_command_factory_method(void *x, t_pdp_newmethod command_factory_method);
+
+/* class setup method */
+void pdp_dpd_base_setup(t_class *class);
+
+/* add a command to the process queue */
+void pdp_dpd_base_queue_command(void *x, void *c, t_pdp_method process, 
+				t_pdp_method callback, int *id);
+
+
+/* get/set the queue instance (thread) used for scheduling */
+#define pdp_dpd_base_set_queue   pdp_base_set_queue
+#define pdp_dpd_base_get_queue   pdp_base_get_queue
+#define pdp_dpd_base_queue_wait  pdp_base_queue_wait
+
+
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/include/pdp_dpd_command.h b/include/pdp_dpd_command.h
new file mode 100644
index 0000000..1cfcf8a
--- /dev/null
+++ b/include/pdp_dpd_command.h
@@ -0,0 +1,79 @@
+
+/*
+ *   Pure Data Packet header file. DPD command class
+ *   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.
+ *
+ */
+
+/* this object implements a dpd command 'factory and recycling center' */
+
+/* a small note on commands & dpd
+
+   dpd uses a different synchronization model than pdp.
+
+   in pdp, objects only pass once the process method in the process thread
+   has finished.
+
+   in dpd a context packet propagates a context trough an tree of objects, 
+   depth first, following the pd messages. it is possible to send a list of
+   contexts trough a tree before the actual processing starts. therefore,
+   each time a context passes trough an object, a new command object (or memento)
+   needs to be created that saves the state of the rendering context. the command
+   factory class can be used to create these commands.
+
+   the dpd base class queues a command object and calls the registered method
+   on the object instead of the dpd object. so a command object is in fact
+   a delegate of the dpd object in question.
+
+*/
+
+
+#ifndef PDP_DPD_COMMAND
+#define PDP_DPD_COMMAND
+
+#include "pdp_types.h"
+
+
+/* COMMAND BASE CLASS */
+typedef struct _pdp_dpd_command
+{
+    struct _pdp_dpd_command *next;
+    u32 used;
+
+} t_pdp_dpd_command;
+
+
+/* COMMAND LIST (COMMAND FACTORY) CLASS */
+typedef struct _pdp_dpd_commandfactory
+{
+    u32 nb_commands;
+    u32 command_size;
+    t_pdp_dpd_command *command;
+} t_pdp_dpd_commandfactory;
+
+
+/* COMMAND LIST METHODS */
+void pdp_dpd_commandfactory_init(t_pdp_dpd_commandfactory *x, u32 size);
+void pdp_dpd_commandfactory_free(t_pdp_dpd_commandfactory *x);
+t_pdp_dpd_command *pdp_dpd_commandfactory_get_new_command(t_pdp_dpd_commandfactory *x);
+
+
+/* COMMAND METHODS */
+void pdp_dpd_command_suicide(void *);
+
+
+#endif
diff --git a/include/pdp_image.h b/include/pdp_image.h
new file mode 100644
index 0000000..3dabfb1
--- /dev/null
+++ b/include/pdp_image.h
@@ -0,0 +1,95 @@
+/*
+ *   Pure Data Packet system implementation. Image packet interface
+ *   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.
+ *
+ */
+
+
+/*
+  This file contains methods for the image packets
+  pdp_packet_new_* methods are several image packet constructors
+
+  It also contains some pdp_type_ methods, for type checking
+  and conversion.
+
+*/
+
+#ifndef PDP_IMAGE_H
+#define PDP_IMAGE_H
+
+#include "pdp_symbol.h"
+#include "pdp_types.h"
+
+/* image subheader */   
+typedef struct _image
+{
+    /* standard images */
+    unsigned int encoding;    /* image encoding (data format) */
+    unsigned int width;       /* image width in pixels */
+    unsigned int height;      /* image height in pixels */
+    unsigned int depth;       /* number of colour planes if PDP_IMAGE_MCHP */
+    unsigned int chanmask;    /* channel bitmask to mask out inactive channels (0 == not used) */
+
+} t_image;
+
+
+/* image encodings */
+#define PDP_IMAGE_YV12   1  /* 24bbp: 16 bit Y plane followed by 16 bit 2x2 subsampled V and U planes.*/
+#define PDP_IMAGE_GREY   2  /* 16bbp: 16 bit Y plane */
+#define PDP_IMAGE_MCHP   4  /* generic 16bit multi channel planar (16 bit 3D tensor) */
+
+/* slice synchro information */
+#define PDP_IMAGE_SLICE_FIRST (1<<0)
+#define PDP_IMAGE_SLICE_LAST  (1<<1)
+#define PDP_IMAGE_SLICE_BODY  (1<<2)
+
+
+
+/* all symbols are C style */
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+
+
+/* validate and compat check */
+bool pdp_packet_image_isvalid(int packet);
+bool pdp_packet_image_compat(int packet0, int packet1);
+
+/* short cuts to create specific packets */
+int pdp_packet_new_image(u32 encoding, u32 width, u32 height);
+int pdp_packet_new_image_YCrCb(u32 width, u32 height);
+int pdp_packet_new_image_grey(u32 width, u32 height);
+int pdp_packet_new_image_mchp(u32 width, u32 height, u32 depth);
+
+#define pdp_packet_new_image_multi pdp_packet_new_image_mchp
+
+/* get info */
+t_pdp_symbol *pdp_packet_image_get_description(int packet);
+t_image *pdp_packet_image_info(int packet);
+
+/* set props */
+void pdp_packet_image_set_chanmask(int packet, unsigned int chanmask);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/include/pdp_imagebase.h b/include/pdp_imagebase.h
new file mode 100644
index 0000000..6d6b902
--- /dev/null
+++ b/include/pdp_imagebase.h
@@ -0,0 +1,51 @@
+/*
+ *   Pure Data Packet image processor base class header file.
+ *   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.
+ *
+ */
+
+
+/*
+  This file contains the specification of the pdp base class. It is derived
+  from t_object, the basic pd object (like any other pd extern). Have a look
+  at pdp_add, pdp_gain and pdp_noise to see how to use this.
+
+*/
+
+
+#include "pdp_base.h"
+
+
+typedef struct
+{
+    t_pdp_base x_obj;
+    u32 b_channel_mask;     // channel mask
+
+} t_pdp_imagebase;
+
+
+
+/* setup base class. call this in your derived class setup method */
+void pdp_imagebase_setup(t_class *c);
+
+
+/* base class constructor/destructor. call this in your base class constructor/destructor */
+void pdp_imagebase_init(void *x);
+void pdp_imagebase_free(void *x);
+
+/* getters for image base class data */
+u32 pdp_imagebase_get_chanmask(void *x);
diff --git a/include/pdp_imageproc.h b/include/pdp_imageproc.h
new file mode 100644
index 0000000..8cc0baa
--- /dev/null
+++ b/include/pdp_imageproc.h
@@ -0,0 +1,226 @@
+
+/*
+ *   Pure Data Packet. Header file for image processing routines (used in modules).
+ *   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.
+ *
+ */
+
+/* this is a c wrapper around platform specific (mmx) code */
+
+#include "pdp_types.h"
+
+#ifndef PDP_IMAGEPROC_H
+#define PDP_IMAGEPROC_H
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/* the basic allocation unit, for stack alignment */
+typedef long long t_pdp_imageproc_stackword;
+
+/* convert byte size to nb of stack words */
+#define PDP_IMAGEPROC_NB_STACKWORDS(x) (((x-1)/sizeof(t_pdp_imageproc_stackword))+1)
+
+
+/* the packet types should be the same for the dispatchers. packet0 is the dominant packet */
+
+/* image processing dispatchers */
+void pdp_imageproc_dispatch_1buf(void (*process_routine)(void*, u32, u32, s16*), void *x, u32 chanmask, int packet0);
+void pdp_imageproc_dispatch_2buf(void (*process_routine)(void*, u32, u32, s16*, s16 *), void *x, u32 chanmask, int packet0, int packet1);
+void pdp_imageproc_dispatch_3buf(void (*process_routine)(void*, u32, u32, s16*, s16 *, s16*), void *x, u32 chanmask, int packet0, int packet1, int packet2);
+
+
+
+
+/* get legal image dimensions */
+/* this is a fix for the dimension problem */
+/* some imageproc implementations require the dims to be a multiple of some square */
+u32 pdp_imageproc_legalwidth(int i);
+u32 pdp_imageproc_legalheight(int i);
+u32 pdp_imageproc_legalwidth_round_down(int i);
+u32 pdp_imageproc_legalheight_round_down(int i);
+
+
+
+/****************************** 16 bit signed (pixel) routines ***************************************/
+
+
+// mix 2 images
+void *pdp_imageproc_mix_new(void);
+int  pdp_imageproc_mix_nb_stackwords(void);
+void pdp_imageproc_mix_delete(void *x);
+void pdp_imageproc_mix_setleftgain(void *x, float gain);
+void pdp_imageproc_mix_setrightgain(void *x, float gain);
+void pdp_imageproc_mix_process(void *x, u32 width, u32 height, s16 *image, s16 *image2);
+
+// random mix 2 images
+// note: random number generator can be platform specific
+// however, it should be seeded. (same seed produces the same result)
+// threshold = 0 -> left image
+// threshold = 1 -> right image
+
+void *pdp_imageproc_randmix_new(void);
+int  pdp_imageproc_randmix_nb_stackwords(void);
+void pdp_imageproc_randmix_delete(void *x);
+void pdp_imageproc_randmix_setthreshold(void *x, float threshold);
+void pdp_imageproc_randmix_setseed(void *x, float seed);
+void pdp_imageproc_randmix_process(void *x, u32 width, u32 height, s16 *image, s16 *image2);
+
+
+// produce a random image
+// note: random number generator can be platform specific
+// however, it should be seeded. (same seed produces the same result)
+void *pdp_imageproc_random_new(void);
+void pdp_imageproc_random_delete(void *x);
+void pdp_imageproc_random_setseed(void *x, float seed);
+void pdp_imageproc_random_process(void *x, u32 width, u32 height, s16 *image);
+
+
+// produce a plasma image
+// note: random number generator can be platform specific
+// however, it should be seeded. (same seed produces the same result)
+void *pdp_imageproc_plasma_new(void);
+void pdp_imageproc_plasma_delete(void *x);
+void pdp_imageproc_plasma_setseed(void *x, float seed);
+void pdp_imageproc_plasma_setturbulence(void *x, float seed);
+void pdp_imageproc_plasma_process(void *x, u32 width, u32 height, s16 *image);
+
+
+// apply a gain to an image
+void *pdp_imageproc_gain_new(void);
+void pdp_imageproc_gain_delete(void *x);
+void pdp_imageproc_gain_setgain(void *x, float gain);
+void pdp_imageproc_gain_process(void *x, u32 width, u32 height, s16 *image);
+
+
+
+// add two images
+void pdp_imageproc_add_process(void *x, u32 width, u32 height, s16 *image, s16 *image2);
+
+// mul two images
+void pdp_imageproc_mul_process(void *x, u32 width, u32 height, s16 *image, s16 *image2);
+
+
+// 3x1 or 1x3 in place convolution
+// orientation
+#define PDP_IMAGEPROC_CONV_HORIZONTAL 0
+#define PDP_IMAGEPROC_CONV_VERTICAL   1
+void *pdp_imageproc_conv_new(void);
+void pdp_imageproc_conv_delete(void *x);
+void pdp_imageproc_conv_setmin1(void *x, float val);
+void pdp_imageproc_conv_setzero(void *x, float val);
+void pdp_imageproc_conv_setplus1(void *x, float val);
+void pdp_imageproc_conv_setbordercolor(void *x, float intensity);
+void pdp_imageproc_conv_setorientation(void *x, u32 val);
+void pdp_imageproc_conv_setnbpasses(void *x, u32 val);
+void pdp_imageproc_conv_process(void *x, u32 width, u32 height, s16 *image);
+
+
+// colour rotation for 2 colour planes ($$$TODO: change interface)
+// matrix is column encoded
+void *pdp_imageproc_crot2d_new(void);
+void pdp_imageproc_crot2d_delete(void *x);
+void pdp_imageproc_crot2d_setmatrix(void *x, float *matrix);
+void pdp_imageproc_crot2d_process(void *x, s16 *image, u32 width, u32 height);
+
+// colour rotation for 3 colour planes ($$$TODO: change interface)
+void *pdp_imageproc_crot3d_new(void);
+void pdp_imageproc_crot3d_delete(void *x);
+void pdp_imageproc_crot3d_setmatrix(void *x, float *matrix);
+void pdp_imageproc_crot3d_process(void *x, s16 *image, u32 width, u32 height);
+
+
+
+
+// biquad space
+
+// directions
+#define PDP_IMAGEPROC_BIQUAD_TOP2BOTTOM (1<<0)
+#define PDP_IMAGEPROC_BIQUAD_BOTTOM2TOP (1<<1)
+#define PDP_IMAGEPROC_BIQUAD_LEFT2RIGHT (1<<2)
+#define PDP_IMAGEPROC_BIQUAD_RIGHT2LEFT (1<<3)
+void *pdp_imageproc_bq_new(void);
+void pdp_imageproc_bq_delete(void *x);
+void pdp_imageproc_bq_setcoef(void *x, float *coef); // a0,a1,a2,b0,b1,b2
+void pdp_imageproc_bq_setnbpasses(void *x, u32 nbpasses);
+void pdp_imageproc_bq_setdirection(void *x, u32 direction);
+void pdp_imageproc_bq_process(void *x, u32 width, u32 height, s16* image);
+
+
+// biquad time
+//void *pdp_imageproc_bqt_new(void);
+//void pdp_imageproc_bqt_delete(void *x);
+//void pdp_imageproc_bqt_setcoef(void *x, float *coef); // a0,a1,a2,b0,b1,b2
+void pdp_imageproc_bqt_process(void *x, u32 width, u32 height, s16 *image, s16 *state0, s16 *state1);
+
+
+
+// zoom object
+void *pdp_imageproc_resample_affinemap_new(void);
+void pdp_imageproc_resample_affinemap_delete(void *x);
+void pdp_imageproc_resample_affinemap_setcenterx(void *x, float f);
+void pdp_imageproc_resample_affinemap_setcentery(void *x, float f);
+void pdp_imageproc_resample_affinemap_setzoomx(void *x, float f);
+void pdp_imageproc_resample_affinemap_setzoomy(void *x, float f);
+void pdp_imageproc_resample_affinemap_setangle(void *x, float f);
+void pdp_imageproc_resample_affinemap_process(void *x, u32 width, u32 height, s16 *srcimage, s16 *dstimage);
+
+
+
+//chebyshev poly
+void *pdp_imageproc_cheby_new(int order);
+void pdp_imageproc_cheby_delete(void *x);
+void pdp_imageproc_cheby_setcoef(void *x, u32 n, float f);
+void pdp_imageproc_cheby_setnbpasses(void *x, u32 n);
+void pdp_imageproc_cheby_process(void *x, u32 width, u32 height, s16 *image);
+
+
+//logic ops
+void pdp_imageproc_xor_process(void *x, u32 width, u32 height, s16 *image, s16 *image2);
+void pdp_imageproc_or_process(void *x, u32 width, u32 height, s16 *image, s16 *image2);
+void pdp_imageproc_and_process(void *x, u32 width, u32 height, s16 *image, s16 *image2);
+void pdp_imageproc_mask_process(void *x, u32 width, u32 height, s16 *image);
+void pdp_imageproc_not_process(void *x, u32 width, u32 height, s16 *image);
+void pdp_imageproc_hardthresh_process(void *x, u32 width, u32 height, s16 *image);
+void pdp_imageproc_softthresh_process(void *x, u32 width, u32 height, s16 *image);
+
+
+//other stateles operators
+void pdp_imageproc_abs_process(void *x, u32 width, u32 height, s16 *image);
+void pdp_imageproc_zthresh_process(void *x, u32 width, u32 height, s16 *image);
+void pdp_imageproc_plasma_process(void *x, u32 width, u32 height, s16 *image);
+void pdp_imageproc_ispositive_process(void *x, u32 width, u32 height, s16 *image);
+void pdp_imageproc_sign_process(void *x, u32 width, u32 height, s16 *image);
+void pdp_imageproc_flip_lr_process(void *dummy, u32 width, u32 height, s16 *image);
+void pdp_imageproc_flip_tb_process(void *dummy, u32 width, u32 height, s16 *image);
+
+//set to zero
+void pdp_imageproc_zero_process(void *x, u32 width, u32 height, s16 *image);
+void pdp_imageproc_constant_process(void *x, u32 width, u32 height, s16 *image);
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#endif //PDP_IMAGEPROC_H
diff --git a/include/pdp_internals.h b/include/pdp_internals.h
new file mode 100644
index 0000000..924d5eb
--- /dev/null
+++ b/include/pdp_internals.h
@@ -0,0 +1,59 @@
+
+/*
+ *   Pure Data Packet internal header file.
+ *   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.
+ *
+ */
+
+
+/* this file contains prototypes for "private" pdp methods.
+   DON'T CALL THESE FROM OUTSIDE OF PDP! unless you really
+   know what you are doing.
+ */
+
+
+
+#ifndef PDP_INTERNALS_H
+#define PDP_INTERNALS_H
+
+#ifdef __cplusplus
+extern "C" 
+{
+#endif
+
+/* INTERNAL SYSTEM METHODS */
+
+/* set/unset main pdp thread usage */
+void pdp_queue_use_thread(int t);
+
+
+/* INTERNAL PACKET METHODS */
+
+/* create a new packet, reuse if possible.
+   ONLY USE THIS IN A TYPE SPECIFIC CONSTRUCTOR! */
+int pdp_packet_new(unsigned int datatype, unsigned int datasize); 
+
+
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif 
diff --git a/include/pdp_list.h b/include/pdp_list.h
new file mode 100644
index 0000000..2f7b8f5
--- /dev/null
+++ b/include/pdp_list.h
@@ -0,0 +1,240 @@
+
+/*
+ *   Pure Data Packet header file. List class
+ *   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.
+ *
+ */
+
+/* the pdp list is composed of atoms. 
+   the default atom is a pointer.
+   lists can be recursed into trees.
+
+   note: all functions that return t_pdp_word and don't take a type argument
+   obviously don't perform any type checking. if you have heterogenous lists,
+   you should use atom iterators or direct access.
+
+   functions starting with "pdp_tree" recurse through sublists.
+   functions starting with "pdp_list" stay at the top level.
+
+*/
+
+
+
+#ifndef PDP_LIST_H
+#define PDP_LIST_H
+
+struct _pdp_list;
+struct _pdp_atom;
+
+/* THE LIST OBJECT */
+
+typedef enum {
+    /* generic atoms */
+    a_undef = 0,
+    a_pointer,
+    a_float,
+    a_int,
+    a_symbol,
+    a_packet,
+    a_list,
+    a_atom_pointer,
+
+    /* forth atoms */
+    a_forthword,         /* forth word operating on a stack */
+    a_vmword,            /* forth word operating on a virtual machine */
+    a_vmmacro            /* forth word operating on vm, manipilating current def */
+} t_pdp_word_type;
+
+typedef union _pdp_word
+{
+    void*                   w_pointer;
+    float                   w_float;
+    int                     w_int;
+    struct _pdp_symbol*     w_symbol;
+    int                     w_packet;
+    struct _pdp_list*       w_list;
+    struct _pdp_atom*       w_atom_pointer;
+
+} t_pdp_word;
+
+/* a list element */
+typedef struct _pdp_atom
+{
+    struct _pdp_atom *next;
+    t_pdp_word w;
+    t_pdp_word_type t;
+} t_pdp_atom;
+
+/* a list container */
+typedef struct _pdp_list
+{
+    int elements;
+    t_pdp_atom *first;
+    t_pdp_atom *last;
+    
+} t_pdp_list;
+
+
+/* CONVENTION: trees stacks and lists.
+
+   * all operations with "list" in them operate on flat lists. all the
+     items contained in the list are either pure atoms (floats, ints, or symbols) 
+     or references (packets, pointers, lists)
+
+   * all operations with "tree" in them, operate on recursive lists (trees)
+     all sublists of the list (tree) are owned by the parent list, so you can't
+     build trees from references to other lists.
+ 
+   * stacks are trees (the forth can have tree's on a stack, or have recursive stacks)
+     (WAS: stacks are by definition flat lists, so they can not contains sublists)
+
+*/
+     
+typedef void (*t_pdp_atom_method)(t_pdp_atom *);
+typedef void (*t_pdp_word_method)(t_pdp_word);
+typedef void (*t_pdp_pword_method)(t_pdp_word *);
+typedef void (*t_pdp_free_method)(void *);
+
+/* creation / destruction */
+t_pdp_atom*        pdp_atom_new           (void);
+void               pdp_atom_free          (t_pdp_atom *);
+t_pdp_list*        pdp_list_new           (int elements);
+void               pdp_list_free          (t_pdp_list *l);
+void               pdp_list_clear         (t_pdp_list *l);
+void               pdp_tree_free          (t_pdp_list *l);
+void               pdp_tree_clear         (t_pdp_list *l);
+
+
+
+/* call a free method on all pointers in a tree */
+void               pdp_tree_strip_pointers (t_pdp_list *l, t_pdp_free_method f);
+
+/* strip all packets from a tree. i.e. call pdp_packet_mark_unused on them */
+void               pdp_tree_strip_packets  (t_pdp_list *l);
+
+/* copy a tree, and copy all packets readonly */
+t_pdp_list        *pdp_tree_copy_ro(t_pdp_list *l);
+
+t_pdp_list*        pdp_tree_from_cstring(char *chardef, char **nextchar);
+
+/* check type syntax of list */
+int pdp_tree_check_syntax(t_pdp_list *list, t_pdp_list *syntax);
+t_pdp_atom *pdp_atom_from_cstring(char *chardef, char **nextchar);
+//void pdp_atom_from_cstring(t_pdp_atom *a, char *string);
+
+
+/* traversal routines (map functions) */
+/* use these in conjunction with gcc local functions
+   if there's ever a portability problem: add a void* data argument to implement closures */
+void pdp_list_apply       (t_pdp_list *l, t_pdp_atom_method am);
+void pdp_tree_apply       (t_pdp_list *l, t_pdp_atom_method am);
+void pdp_list_apply_word_method  (t_pdp_list *l, t_pdp_word_type t, t_pdp_word_method wm);
+void pdp_tree_apply_word_method  (t_pdp_list *l, t_pdp_word_type t, t_pdp_word_method wm);
+void pdp_list_apply_pword_method (t_pdp_list *l, t_pdp_word_type t, t_pdp_pword_method pwm);
+void pdp_tree_apply_pword_method (t_pdp_list *l, t_pdp_word_type t, t_pdp_pword_method pwm);
+
+
+/* copy: (reverse) copies a list. */ 
+/* list copy is flat. pointers and packets are copied. so you need to
+   ensure reference consistency yourself. */
+
+t_pdp_list*        pdp_list_copy          (t_pdp_list *l);
+t_pdp_list*        pdp_list_copy_reverse  (t_pdp_list *l);
+t_pdp_list*        pdp_tree_copy          (t_pdp_list *l);
+t_pdp_list*        pdp_tree_copy_reverse  (t_pdp_list *l);
+
+
+/* cat: this makes a copy of the second list and adds it at the end of the first one */
+void               pdp_list_cat           (t_pdp_list *l, t_pdp_list *tail);
+
+/* information */
+int     pdp_list_contains                 (t_pdp_list *l, t_pdp_word_type t, t_pdp_word w);
+int     pdp_list_size                     (t_pdp_list *l);
+void    pdp_list_print                    (t_pdp_list *l);
+void    pdp_atom_print                    (t_pdp_atom *a);
+
+/* access */
+void          pdp_list_add           (t_pdp_list *l, t_pdp_word_type t, t_pdp_word w);
+void          pdp_list_add_back      (t_pdp_list *l, t_pdp_word_type t, t_pdp_word w);
+void          pdp_list_add_to_set    (t_pdp_list *l, t_pdp_word_type t, t_pdp_word w);
+void          pdp_list_remove        (t_pdp_list *l, t_pdp_word_type t, t_pdp_word w);
+
+void pdp_list_add_atom(t_pdp_list *l, t_pdp_atom *a);
+void pdp_list_add_back_atom(t_pdp_list *l, t_pdp_atom *a);
+
+/* these don't do error checking. out of bound == error */
+t_pdp_atom   *pdp_list_pop_atom      (t_pdp_list *l);
+t_pdp_word    pdp_list_pop           (t_pdp_list *l);
+t_pdp_word    pdp_list_index         (t_pdp_list *l, int index);
+void          pdp_list_pop_push      (t_pdp_list *source, t_pdp_list *dest);
+
+/* some aliases */
+#define pdp_list_add_front pdp_list_add
+#define pdp_list_push      pdp_list_add
+#define pdp_list_queue     pdp_list_add_end
+#define pdp_list_unqueue   pdp_list_pop
+
+/* util */
+void pdp_list_reverse(t_pdp_list *l);
+
+/* generic atom iterator */
+#define PDP_ATOM_IN(list,atom)              for (atom = list->first ; atom ; atom = atom->next)
+
+/* fast single type iterators */
+
+/* generic */
+#define PDP_WORD_IN(list, atom, word, type) for (atom=list->first ;atom && ((word = atom -> w . type) || 1); atom=atom->next)
+
+/* type specific */
+#define PDP_POINTER_IN(list, atom, x) PDP_WORD_IN(list, atom, x, w_pointer)
+#define PDP_INT_IN(list, atom, x)     PDP_WORD_IN(list, atom, x, w_int)
+#define PDP_FLOAT_IN(list, atom, x)   PDP_WORD_IN(list, atom, x, w_float)
+#define PDP_SYMBOL_IN(list, atom, x)  PDP_WORD_IN(list, atom, x, w_symbol)
+#define PDP_PACKET_IN(list, atom, x)  PDP_WORD_IN(list, atom, x, w_packet)
+#define PDP_LIST_IN(list, atom, x)    PDP_WORD_IN(list, atom, x, w_list)
+
+
+/* some macros for the pointer type */
+
+#define pdp_list_add_pointer(l,p)          pdp_list_add(l, a_pointer, ((t_pdp_word)((void *)(p))))
+#define pdp_list_add_back_pointer(l,p)     pdp_list_add_back(l, a_pointer, ((t_pdp_word)((void *)(p))))
+#define pdp_list_add_pointer_to_set(l,p)   pdp_list_add_to_set(l, a_pointer, ((t_pdp_word)((void *)(p))))
+#define pdp_list_remove_pointer(l,p)       pdp_list_remove(l, a_pointer, ((t_pdp_word)((void *)(p))))
+#define pdp_list_contains_pointer(l,p)     pdp_list_contains(l, a_pointer, ((t_pdp_word)((void *)(p))))
+
+/* atom access */
+#define PDP_LIST_ATOM_0(x) ((x)->first)
+#define PDP_LIST_ATOM_1(x) ((x)->first->next)
+#define PDP_LIST_ATOM_2(x) ((x)->first->next->next)
+#define PDP_LIST_ATOM_3(x) ((x)->first->next->next->next)
+#define PDP_LIST_ATOM_4(x) ((x)->first->next->next->next->next)
+
+/* array like setters */
+static inline void pdp_atom_set(t_pdp_atom *a, t_pdp_word_type t, t_pdp_word w) {a->t = t; a->w = w;}
+static inline void pdp_list_set_0(t_pdp_list *l, t_pdp_word_type t, t_pdp_word w) {pdp_atom_set(l->first, t, w);}
+static inline void pdp_list_set_1(t_pdp_list *l, t_pdp_word_type t, t_pdp_word w) {pdp_atom_set(l->first->next, t, w);}
+static inline void pdp_list_set_2(t_pdp_list *l, t_pdp_word_type t, t_pdp_word w) {pdp_atom_set(l->first->next->next, t, w);}
+  
+
+/* evaluator (tiny lisp) */
+
+
+
+typedef t_pdp_list* (*t_pdp_list_evaluator_function)(t_pdp_list *);
+
+
+#endif
diff --git a/include/pdp_list_macros.h b/include/pdp_list_macros.h
new file mode 100644
index 0000000..cb1f49f
--- /dev/null
+++ b/include/pdp_list_macros.h
@@ -0,0 +1,27 @@
+#ifndef __PDP_LIST_MACROS__
+#define __PDP_LIST_MACROS__
+
+/* some additional (short named) list macros mainly for manipulationg
+   argument lists. needs to be included locally. */
+
+/* reading a list */
+#define FIRST(l)  ((l)->first)
+#define SIZE(l)   ((l)->elements)
+
+#define NEXT(a)   ((a)->next)
+#define N(a)      (a = a->next)
+
+#define FLOAT(a)  ((a)->t == a_float ? (a)->w.w_float : 0.0f)
+#define PACKET(a) ((a)->t == a_packet ? (a)->w.w_packet : -1)
+#define INT(a)    ((a)->t == a_int ? (a)->w.w_packet : 0)
+
+
+/* creating a list, and adding stuff to the end (queueing) */
+#define LIST(n)       pdp_list_new(n)
+#define LFREE(l)      pdp_list_free(l)
+#define QFLOAT(l, x)  pdp_list_add_back(l, a_float, ((t_pdp_word)(float)(x)))
+#define QINT(l, x)    pdp_list_add_back(l, a_int,   ((t_pdp_word)(int)(x)))
+#define QPACKET(l, x) pdp_list_add_back(l, a_packet,((t_pdp_word)(int)(x)))
+
+
+#endif
diff --git a/include/pdp_llconv.h b/include/pdp_llconv.h
new file mode 100644
index 0000000..5e22d3a
--- /dev/null
+++ b/include/pdp_llconv.h
@@ -0,0 +1,81 @@
+/*
+ *   Pure Data Packet system implementation. : low level format conversion code
+ *   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.
+ *
+ */
+
+/* this file contains low level conversion code
+   it is a wrapper around some machine code routines padded
+   with some extra c code */
+
+/* don't rely too much on the calling conventions here
+   this is mainly to tuck away "ugly" parts of the code
+   that come up in several places */
+
+#ifndef PDP_LLCONV_H
+#define PDP_LLCONV_H
+
+
+/* all symbols are C style */
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+
+/* raw image formats (RIF) descriptions used for low level conversion routines
+   format: RIF_[component names and order]_[data arganization]_[data type] 
+
+   component names: R(red), G(green), B(blue), Y(chroma), V(chroma red), U(chroma blue)
+   component type: [S/U][nb bits] ex: S16, U8
+   data organization: [P/P[samplefrequency]] ex: P(packed) P411(planar, 2nd and 3rd 2x2 subsampled) 
+
+
+*/
+
+enum RIF {
+	RIF_YVU__P411_U8,
+	RIF_YUV__P411_U8,
+	RIF_YVU__P411_S16,
+	RIF_YVU__P444_S16,
+	RIF_YUYV_P____U8,
+        RIF_RGB__P____U8,
+	RIF_RGBA_P____U8,
+	RIF_RGB__P444_S16,
+	RIF_GREY______S16,
+	RIF_GREY______U8,
+        RIF_BGR__P____U8,
+        RIF_BGRA_P____U8
+	
+};	
+
+/*  pdp_llconv is NOT thread safe !*/
+/* gain = 1.0 means maximal */
+/* low level convert 2 images */
+void pdp_llconv(void *src, int stype, void *dest, int dtype, int w, int h);
+
+
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif
diff --git a/include/pdp_matrix.h b/include/pdp_matrix.h
new file mode 100644
index 0000000..22a33bb
--- /dev/null
+++ b/include/pdp_matrix.h
@@ -0,0 +1,94 @@
+/*
+ *   Pure Data Packet system implementation. matrix packet interface
+ *   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.
+ *
+ */
+
+#ifndef PDP_MATRIX_H
+#define PDP_MATRIX_H
+
+#include <stdio.h>
+#include <gsl/gsl_block.h>
+#include <gsl/gsl_vector.h>
+#include <gsl/gsl_matrix.h>
+#include <gsl/gsl_blas.h>
+#include <gsl/gsl_linalg.h> 
+
+#include "pdp_types.h"
+
+#define gsl_rows size1
+#define gsl_columns size2
+
+typedef struct _matrix
+{
+    /* meta data */
+    u32 type;                 /* float/double real/complex */
+    u32 rows;
+    u32 columns;
+
+    /* gsl structures: these will be cast to the correct type on use */
+    gsl_block  block;     /* gsl block meta data */
+    gsl_vector vector;    /* gsl vector meta data */
+    gsl_matrix matrix;    /* gsl matrix meta data */
+    gsl_permutation perm; /* permutation data for storing an LU decomposition */
+    int signum;           /* sign of permutation matrix */
+
+
+} t_matrix;
+
+#define PDP_MATRIX 7
+
+#define PDP_MATRIX_TYPE_RFLOAT 1
+#define PDP_MATRIX_TYPE_CFLOAT 2
+#define PDP_MATRIX_TYPE_RDOUBLE 3
+#define PDP_MATRIX_TYPE_CDOUBLE 4
+
+int pdp_packet_matrix_isvalid(int p);
+int pdp_packet_matrix_isvector(int p);
+int pdp_packet_matrix_ismatrix(int p);
+
+int pdp_packet_new_matrix(u32 rows, u32 columns, u32 type);
+int pdp_packet_new_matrix_product_result(CBLAS_TRANSPOSE_t TransA, CBLAS_TRANSPOSE_t TransB, int pA, int pB);
+void pdp_packet_matrix_setzero(int p);
+
+
+/* getters: returns 0 if type is incorrect */
+void *pdp_packet_matrix_get_gsl_matrix(int p, u32 type);
+void *pdp_packet_matrix_get_gsl_vector(int p, u32 type);
+int pdp_packet_matrix_get_type(int p);
+
+
+/* type transparent matrix operations */
+
+/* blas wrappers */
+
+/* C += scale op(A) op(B) */
+int pdp_packet_matrix_blas_mm(CBLAS_TRANSPOSE_t TransA, CBLAS_TRANSPOSE_t TransB, 
+			      int pA, int pB, int pC,
+			      float scale_r, float scale_i);
+/* c += scale op(A) b */
+int pdp_packet_matrix_blas_mv(CBLAS_TRANSPOSE_t TransA,
+			      int pA, int pb, int pc, 
+			      float scale_r, float scale_i);
+
+/* other gsl wrappers */
+int pdp_packet_matrix_LU(int p_matrix);
+int pdp_packet_matrix_LU_to_inverse(int p_matrix);
+int pdp_packet_matrix_LU_solve(int p_matrix, int p_vector);
+
+
+#endif
diff --git a/include/pdp_mem.h b/include/pdp_mem.h
new file mode 100644
index 0000000..3301655
--- /dev/null
+++ b/include/pdp_mem.h
@@ -0,0 +1,46 @@
+/*
+ *   Pure Data Packet header file: memory allocation
+ *   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.
+ *
+ */
+
+#ifndef _PDP_MEM_H_
+#define _PDP_MEM_H_
+
+#include <pthread.h>
+
+/* a wrapper around malloc and free to keep track of pdp's memory usage */
+void *pdp_alloc(int size);
+void pdp_dealloc(void *stuff);
+
+
+/* fast allocator object (for lists and atoms) */
+#define PDP_FASTALLOC_BLOCK_ELEMENTS 4096
+typedef struct _pdp_fastalloc
+{
+  unsigned int atom_size;
+  unsigned int block_elements;
+  pthread_mutex_t mut;
+  struct _fastalloc *freelist;
+  
+} t_pdp_fastalloc;
+
+void *pdp_fastalloc_new_atom(t_pdp_fastalloc *x);
+void pdp_fastalloc_save_atom(t_pdp_fastalloc *x, void *atom);
+t_pdp_fastalloc *pdp_fastalloc_new(unsigned int size);
+
+#endif
diff --git a/include/pdp_mmx.h b/include/pdp_mmx.h
new file mode 100644
index 0000000..8181ff0
--- /dev/null
+++ b/include/pdp_mmx.h
@@ -0,0 +1,171 @@
+
+/*
+ *   Pure Data Packet. Header file for mmx routines.
+ *   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.
+ *
+ */
+
+
+#ifndef PDP_MMX_H
+#define PDP_MMX_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/****************************** 16 bit signed (pixel) routines ***************************************/
+
+/* pack: gain is 8.8 fixed point */
+void pixel_pack_s16u8_y(short int *input_pixels, 
+			unsigned char *output_pixels, 
+			int nb_pixels_div_8);
+
+void pixel_pack_s16u8_uv(short int *input_pixels, 
+			 unsigned char *output_pixels, 
+			 int nb_pixels_div_8);
+
+
+/* unpack: gain is not used -> full scale unpack */
+void pixel_unpack_u8s16_y(unsigned char *input_pixels, 
+			  short int *output_pixels, 
+			  int nb_pixels_div_8);
+
+void pixel_unpack_u8s16_uv(unsigned char *input_pixels, 
+			   short int *output_pixels, 
+			   int nb_pixels_div_8);
+
+
+/* gain */
+/* gain = integer */
+/* shift is down shift count */
+void pixel_gain_s16(short int *image, 
+		    int nb_4pixel_vectors, 
+		    short int gain[4], 
+		    unsigned long long *shift);
+
+
+/* mix: left = gain_left * left + gain_right * right / gains are s.15 fixed point */
+void pixel_mix_s16(short int *left, 
+		   short int *right, 
+		   int nb_4pixel_vectors,
+		   short int gain_left[4], 
+		   short int gain_right[4]);
+
+void pixel_randmix_s16(short int *left, 
+		       short int *right, 
+		       int nb_4pixel_vectors, 
+		       short int random_seed[4], 
+		       short int threshold[4]);
+
+void pixel_rand_s16(short int *image, 
+		    int nb_4pixel_vectors, 
+		    short int random_seed[4]);
+
+void pixel_add_s16(short int *left, 
+		   short int *right, 
+		   int nb_4pixel_vectors);
+
+void pixel_mul_s16(short int *left, 
+		   short int *right, 
+		   int nb_4pixel_vectors);
+
+
+/* affine transfo */
+void pixel_affine_s16(short int *buf, 
+		      int nb_4pixel_vectors, 
+		      short int gain[4], 
+		      short int offset[4]);
+
+/* conv */
+void pixel_conv_hor_s16(short int *pixel_array, 
+			int nb_4_pixel_vectors, 
+			short int border[4],
+			short int mask[12]);
+
+void pixel_conv_ver_s16(short int *pixel_array, 
+			int nb_4_pixel_vectors, 
+			int row_byte_size, 
+			short int border[4],
+			short int mask[12]);
+
+/* biquad */
+
+void pixel_biquad_vertb_s16(short int *pixel_array, 
+			    int nb_4x4_pixblocks, 
+			    int linewidth, 
+			    short int coef[20], 
+			    short int state[8]);
+
+void pixel_biquad_verbt_s16(short int *pixel_array, 
+			    int nb_4x4_pixblocks, 
+			    int linewidth, 
+			    short int coef[20], 
+			    short int state[8]);
+
+
+void pixel_biquad_horlr_s16(short int *pixel_array, 
+			    int nb_4x4_pixblocks, 
+			    int linewidth, 
+			    short int coef[20], 
+			    short int state[8]);
+
+void pixel_biquad_horrl_s16(short int *pixel_array, 
+			    int nb_4x4_pixblocks, 
+			    int linewidth, 
+			    short int coef[20], 
+			    short int state[8]);
+
+void pixel_biquad_time_s16(short int *pixel_array, 
+			   short int *state_array1, 
+			   short int *state_array2, 
+			   short int *coefs, 
+			   int nb_4_pix_vectors);
+
+/********************************** PLANAR COLOUR OPERATIONS ***************************************/
+
+/* color rotation for 3 colour planes */
+void pixel_crot3d_s16(short int *pixel_array, 
+		      int nb_4pixel_vectors_per_plane, 
+		      short int *row_encoded_vector_matrix);
+
+
+/* color rotation for 2 colour planes */
+void pixel_crot2d_s16(short int *pixel_array, 
+		      int nb_4pixel_vectors_per_plane, 
+		      short int *row_encoded_vector_matrix);
+
+
+/********************************** RESAMPLE OPERATIONS *******************************************/
+
+// affine transformation (called linear map, but that's flou terminology)
+void pixel_resample_linmap_s16(void *x);
+
+
+
+/********************************** POLYNOMIAL OPERATIONS *****************************************/
+// chebychev polynomial
+void pixel_cheby_s16_3plus(short int *buf, int nb_8pixel_vectors, int orderplusone, short int *coefs);
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif //PDP_MMX_H
diff --git a/include/pdp_net.h b/include/pdp_net.h
new file mode 100644
index 0000000..ddc3f7f
--- /dev/null
+++ b/include/pdp_net.h
@@ -0,0 +1,197 @@
+#ifndef __PDP_UDP_H_
+#define __PDP_UDP_H_
+
+/*
+ *   Pure Data Packet header: UDP protocol for raw packets
+ *   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.
+ *
+ */
+
+/*
+
+     This file contains the specification of the pdp UDP transport protocol.
+     It is a very basic binary protocol, not very fool proof.
+
+     The protocol:
+
+     A header packet is transmitted first. This contains mime type information,
+     and the size of and number of packets to be received.
+
+     The connection id:
+
+     Currently it is just a random number from the libc rand() function
+     this should be accurate enough.
+
+
+*/
+
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <netdb.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+/* some defs */
+#define MAX_UDP_PACKET 1472
+#define RESEND_MAX_CHUNKS ((MAX_UDP_PACKET - sizeof(t_pdp_udp_header))/sizeof(unsigned int))
+
+#define PDP_UDP_VERSION 1
+
+/* a pdp udp packet is prepended with this header */
+
+typedef struct _pdp_udp_header
+{
+    char signature[4];                  /* must be "PDP" */;
+    unsigned int version;               /* protocol version */
+    unsigned int connection_id;         /* the 'connection' id */ 
+    unsigned int sequence_number;       /* sequence number. negative: control packet: body contains meta info */
+
+} t_pdp_udp_header;
+
+/* the data part for a new connection */
+
+#define PDP_UDP_NEW -1 /* start a new transmission */
+typedef struct _pdp_udp_new
+{
+    unsigned int data_size;             /* the size of the packets */
+    unsigned int nb_chunks;             /* number of chunks in pdp to be transmitted */
+    unsigned int chunk_size;            /* the maximum chunk size */
+    char type[0];                       /* the packet type */
+
+    // the tail part is the mime type, for creation and reassembly
+} t_pdp_udp_newpacket;
+
+#define PDP_UDP_DONE   -2 /* transmission is done */
+
+#define PDP_UDP_RESEND -3 /* request retransmission of certain chunks. empty: transmission ok */
+#define PDP_UDP_ACKNEW -4 /* acknowledge reception of new packet header */
+
+
+/* receiver and sender classes (transport layer) */
+
+#define PDP_UDP_BUFSIZE 0xF000
+
+/* RECEIVER */
+typedef struct _pdp_udp_receiver
+{
+
+    // buffer for receiving
+    t_pdp_udp_header x_header;  //pdp over udp header
+    char x_buf[PDP_UDP_BUFSIZE];        //send buffer
+    unsigned int x_zero_terminator; // to prevent runaway strings
+    unsigned int x_buf_size;    //size of the received data in the buffer (excluding the header)
+
+    // buffer for sending
+    t_pdp_udp_header x_resend_header;                   // header of the resend packet
+    unsigned int x_resend_chunks[RESEND_MAX_CHUNKS];    // body contains the chunks to resend
+    unsigned int x_resend_udp_packet_size;
+
+    // transmission info
+    unsigned int x_connection_id;
+    unsigned int x_nb_chunks;
+    unsigned int x_chunk_size;
+    unsigned int *x_chunk_list;
+    char *x_data_type;
+    unsigned int x_data_size;
+    void *x_data;
+    struct sockaddr_in x_source_socket;
+    int x_sslen;
+    int x_receive_finished;
+    int x_packet_transferred;
+
+    int x_socket;             //socket used for sending
+    struct sockaddr_in x_sa;  //address struct
+    
+} t_pdp_udp_receiver;
+
+/* setup */
+t_pdp_udp_receiver *pdp_udp_receiver_new(int port);
+void pdp_udp_receiver_free(t_pdp_udp_receiver *x);
+
+/* reset connection (wait for new packet) */
+void pdp_udp_receiver_reset(t_pdp_udp_receiver *x);
+
+/* receive, returns 1 on success, 0 on timeout, -1 on error */
+int pdp_udp_receiver_receive(t_pdp_udp_receiver *x, unsigned int timeout_ms);
+
+/* get meta & data */
+char *pdp_udp_receiver_type(t_pdp_udp_receiver *x);
+unsigned int pdp_udp_receiver_size(t_pdp_udp_receiver *x);
+void *pdp_udp_receiver_data(t_pdp_udp_receiver *x);
+
+
+
+/* SENDER */
+typedef struct _pdp_udp_sender
+{
+    // desired udp packet size
+    unsigned int x_udp_payload_size;
+
+    // current packet && communication info
+    unsigned int x_connection_id;
+    char *x_data_type;
+    void *x_data;
+    unsigned int x_data_size;
+    unsigned int x_chunk_size;
+    unsigned int *x_chunk_list;
+    unsigned int x_nb_chunks;
+    unsigned int x_chunk_list_size;
+
+    // connection data
+    int x_socket;             //socket used for sending
+    struct sockaddr_in x_sa;  //address struct
+    unsigned int x_sleepgrain_us;      //pause between sends (the poor man's flow control) (0 == no sleep)
+    unsigned int x_sleep_count;
+    unsigned int x_sleep_period;
+    unsigned int x_timeout_us;
+
+    // temp buffer for sending
+    t_pdp_udp_header x_header;                          
+    char x_buf[PDP_UDP_BUFSIZE];                                
+    unsigned int x_buf_size;
+
+    // temp buffer for receiving
+    t_pdp_udp_header x_resend_header;                   
+    unsigned int x_resend_chunks[RESEND_MAX_CHUNKS];
+    unsigned int x_resend_items;
+
+
+} t_pdp_udp_sender;
+
+/* some flow control variables */
+void pdp_udp_sender_timeout_us(t_pdp_udp_sender *x, unsigned int timeout_us);
+void pdp_udp_sender_sleepgrain_us(t_pdp_udp_sender *x, unsigned int sleepgrain_us);
+void pdp_udp_sender_sleepperiod(t_pdp_udp_sender *x, unsigned int sleepperiod);
+void pdp_udp_sender_udp_packet_size(t_pdp_udp_sender *x, unsigned int udp_packet_size);
+
+/* setup */
+t_pdp_udp_sender *pdp_udp_sender_new(void);
+void pdp_udp_sender_free(t_pdp_udp_sender *x);
+
+/* connect */
+void pdp_udp_sender_connect(t_pdp_udp_sender *x, char *host, unsigned int port);
+
+/* send, returns 1 on success, 0 on error */
+int pdp_udp_sender_send(t_pdp_udp_sender *x, char* type, unsigned int size, void *data);
+
+
+
+#endif
diff --git a/include/pdp_packet.h b/include/pdp_packet.h
new file mode 100644
index 0000000..f944095
--- /dev/null
+++ b/include/pdp_packet.h
@@ -0,0 +1,214 @@
+/*
+ *   Pure Data Packet system implementation: Packet Manager Interface
+ *   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.
+ *
+ */
+
+/*
+
+    This file contains the pdp packet manager interface specification.
+
+    It is an implementation of the "Object Pool" pattern with lazy instantiation
+    and lazy destruction.
+
+    The pool is a growable array. It can only grow larger. Packets are represented
+    by an integer, which is an index in this array.
+
+    The standard "pure" packets (the ones which use a flat memory buffer) have recovery
+    for resource depletion (main memory). If an out of memory condition is met
+    on allocation of a new package, the garbage collector kicks in and frees unused
+    packets until the out of memory condition is solved. Since an out of memory
+    condition can be fatal for other parts of the program, pdp also supports a
+    memory limit, to ensure some kind of safety margin.
+
+    The "not so pure" packets should resolve resource conflicts in their own factory method,
+    since the constructor is responsible for allocating external resources. The standard
+    way to do this is to allocate a packet, free it's resources and allocate a new packet
+    until the resource allocation succeeds. Especially for these kinds of packets, the
+    pdp pool supports an explicit reuse method. This returns a valid packet if it can reuse 
+    one (based on the high level type description).
+
+    Packets that don't have memory managing methods defined in the packet class
+    (Standard packets) are treated as a header concatenated with a flat memory buffer, and
+    can be copied and cloned without problems. So, if a packet contains pointers to other
+    data or code, it can't be a pure packet.
+
+    The interface to the packet manager contains the following managing methods:
+
+    * pdp_packet_new: create a new packet or reuse a previous one
+    * pdp_packet_mark_unused: release a packet
+    * pdp_packet_copy_ro: register a packet for read only use
+    * pdp_packet_copy_rw: register a packet for read/write use (this creates a copy if necessary)
+    * pdp_packet_clone_rw: create a new packet using a template, but don't copy the data
+
+    And two methods for raw data access
+
+    * pdp_packet_header: retreive the header of the packet
+    * pdp_packet_data: retreive the data buffer of the packet (only for static packets)
+
+    All the methods declared in this header are supposed to be thread safe, so you
+    can call them from the pd and pdp thread.
+
+*/
+
+#ifndef PDP_PACKET_H
+#define PDP_PACKET_H
+
+#include "pdp_symbol.h"
+#include "pdp_types.h"
+
+// this is legacy stuff: images are basic types
+#include "pdp_image.h"
+#include "pdp_bitmap.h"
+
+
+#define PDP_HEADER_SIZE 256
+
+
+
+/* all symbols are C-style */
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+
+typedef int (*t_pdp_factory_method)(t_pdp_symbol *); //returns bool success
+
+/* packet class header */
+typedef struct _pdp_class
+{
+    /* packet manips: non-pure data packets (using external resources) must define these */
+    t_pdp_packet_method1 wakeup;     /* called before returning a reused packet (rc:0->1) */
+    t_pdp_packet_method2 copy;       /* copy data from source packet to destination packet */
+    t_pdp_packet_method1 cleanup;    /* free packet's resources (destructor) */
+    t_pdp_packet_method1 sleep;      /* mark_unused notify: called when refcount reaches zero */
+    t_pdp_symbol *type;              /* type template for packet class */
+    t_pdp_factory_method create;     /* the constructor: create a packet with uninitialized data */
+}t_pdp_class;
+
+
+/* TODO:
+   implement garbage collection for fobs. 
+   (fobs are forth object dictionaries, but for the gc these count as lists)
+*/
+
+#define PDP_GC_COLOUR_GREY  0      /* 0 == default: object is reachable */
+#define PDP_GC_COLOUR_WHITE 1
+#define PDP_GC_COLOUR_BLACK 2
+
+
+/* packet object header */
+struct _pdp
+{
+    /* meta info */
+    unsigned int type;             /* main datatype of this object */
+    t_pdp_symbol *desc;            /* high level type description (sort of a mime type) */
+    unsigned int size;             /* datasize including header */
+    unsigned int flags;            /* packet flags */
+
+    /* reference count */
+    unsigned int users;            /* nb users of this object, readonly if > 1 */
+
+    /* class object */
+    t_pdp_class *theclass;         /* if zero, the packet is a pure packet (just data, no member functions) */
+
+    u32 pad[10];                   /* LATER: reserve bytes to provide compatibility with future extensions */
+
+    union                          /* each packet type has a unique subheader */
+    {
+	t_raw    raw;              /* raw subheader (for extensions unkown to pdp core system) */
+	struct _image  image;      /* (nonstandard internal) 16 bit signed planar bitmap image format */
+	struct _bitmap bitmap;     /* (standard) bitmap image (fourcc coded) */
+	//t_ca     ca;             /* cellular automaton state data */
+	//t_ascii  ascii;          /* ascii packet */
+    } info;
+
+};
+
+
+/* pdp data packet type id */
+#define PDP_IMAGE                 1  /* 16bit signed planar scanline encoded image packet */
+//RESERVED: #define PDP_CA        2  /* 1bit toroidial shifted scanline encoded cellular automaton */
+//RESERVED: #define PDP_ASCII     3  /* ascii packet */
+//RESERVED: #define PDP_TEXTURE   4  /* opengl texture object */
+//RESERVED: #define PDP_3DCONTEXT 5  /* opengl render context */
+#define PDP_BITMAP                6  /* 8bit image packet (fourcc coded??) */
+//RESERVED: #define PDP_MATRIX    7  /* floating point/double matrix/vector packet (from gsl) */
+#define PDP_FOB                   8  /* small c->forth object wrapper */
+
+/* PACKET FLAGS */
+#define PDP_FLAG_DONOTCOPY (1<<0)   /* don't copy the packet on register_rw, instead return an invalid packet */
+
+
+
+/* class methods */
+t_pdp_class *pdp_class_new(t_pdp_symbol *type, t_pdp_factory_method create);
+
+#if 0
+void pdp_class_addmethod(t_pdp_class *c, t_pdp_symbol *name, t_pdp_attribute_method method,
+			 struct _pdp_list *in_spec, struct _pdp_list *out_spec);
+#endif
+
+/* packet factory method + registration */
+int pdp_factory_newpacket(t_pdp_symbol *type);
+
+#if 0
+/* send a message to a packet (packet polymorphy) 
+   this returns NULL on failure, or a return list
+   the return list should be freed by the caller */
+
+int pdp_packet_op(t_pdp_symbol *operation, struct _pdp_list *stack);
+#endif
+
+/* debug */
+void pdp_packet_print_debug(int packet);
+
+
+/* hard coded packet methods */
+int pdp_packet_copy_ro(int handle); /* get a read only copy */
+int pdp_packet_copy_rw(int handle); /* get a read/write copy */
+int pdp_packet_clone_rw(int handle); /* get an empty read/write packet of the same type (only copy header) */
+void pdp_packet_mark_unused(int handle); /* indicate that you're done with the packet */
+void pdp_packet_delete(int packet); /* like mark_unused, but really delete when refcount == 0 */
+
+t_pdp* pdp_packet_header(int handle);    /* get packet header */
+void*  pdp_packet_subheader(int handle); /* get packet subheader */
+void*  pdp_packet_data(int handle);      /* get packet raw data */
+int    pdp_packet_data_size(int handle); /* get packet raw data size */
+
+int pdp_packet_compat(int packet0, int packet1);
+int pdp_packet_reuse(t_pdp_symbol *description);
+int pdp_packet_create(unsigned int datatype, unsigned int datasize); /* create a new packet, don't reuse */
+
+int pdp_packet_writable(int packet); /* returns true if packet is writable */
+void pdp_packet_replace_with_writable(int *packet); /* replaces a packet with a writable copy */
+//void pdp_packet_mark_unused_atomic(int *handle); /* mark unused + set reference to -1 (for thread synchro) */
+
+
+/* pool stuff */
+int pdp_pool_collect_garbage(void); /* free all unused packets */
+void pdp_pool_set_max_mem_usage(int max); /* set max mem usage */
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif 
diff --git a/include/pdp_pd.h b/include/pdp_pd.h
new file mode 100644
index 0000000..e200c1e
--- /dev/null
+++ b/include/pdp_pd.h
@@ -0,0 +1,7 @@
+/* pdp_pd.h wrapper */
+
+#ifndef _M_PD_H_
+#define _M_PD_H_
+#include "m_pd.h"
+#endif
+
diff --git a/include/pdp_png.h b/include/pdp_png.h
new file mode 100644
index 0000000..5aae4c7
--- /dev/null
+++ b/include/pdp_png.h
@@ -0,0 +1,28 @@
+/*
+ *   Pure Data Packet header file. png glue code.
+ *   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.
+ *
+ */
+
+#ifndef __PDP_PNG_H__
+#define __PDP_PNG_H__
+
+int pdp_packet_bitmap_save_png_file(int packet, char *filename);
+int pdp_packet_bitmap_from_png_file(char *filename);
+
+
+#endif
diff --git a/include/pdp_post.h b/include/pdp_post.h
new file mode 100644
index 0000000..05b5143
--- /dev/null
+++ b/include/pdp_post.h
@@ -0,0 +1,29 @@
+
+/*
+ *   Pure Data Packet header file. pdp logging.
+ *   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.
+ *
+ */
+
+#ifndef _PDP_POST_H_
+#define _PDP_POST_H_
+
+/* write a message to log (console) */
+void pdp_post_n(char *fmt, ...);
+void pdp_post(char *fmt, ...);
+
+#endif
diff --git a/include/pdp_queue.h b/include/pdp_queue.h
new file mode 100644
index 0000000..eeffd2e
--- /dev/null
+++ b/include/pdp_queue.h
@@ -0,0 +1,123 @@
+/*
+ *   Pure Data Packet - processor queue interface
+ *   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.
+ *
+ */
+
+
+#ifndef PDP_QUEUE_H
+#define PDP_QUEUE_H
+
+#include "pdp_pd.h"
+#include <pthread.h>
+
+/********************* general purpose pd process queue class *********************/
+
+typedef void (*t_pdpmethod)(void *client);
+
+/* the process queue data record */
+typedef struct process_queue_struct
+{
+  void *x_owner;             /* the object we are dealing with */
+  t_pdpmethod x_process;     /* the process method */
+  t_pdpmethod x_callback;    /* the function to be called when finished */
+  int *x_queue_id;           /* place to store the queue id for task */
+} t_process_queue_item;
+
+
+/* a pd process queue object */
+typedef struct _pd_queue
+{
+    /* clock members */
+    t_clock *pdp_clock;
+    double deltime;
+
+    /* some bookkeeping vars */
+    long long ticks;
+    long long packets;
+
+    /* queue members */
+    t_process_queue_item *q;    /* queue */
+    int mask;
+    int head;              /* last entry in queue + 1 */
+    int tail;              /* first entry in queque */
+    int curr;              /* the object currently processed in other thread */
+
+    /* pthread vars */
+    pthread_mutex_t mut;
+    pthread_cond_t cond_dataready;
+    pthread_cond_t cond_processingdone;
+    pthread_t thread_id;
+    
+    /* toggle for thread usage */
+    int use_thread;
+
+} t_pdp_procqueue;
+
+
+/* all symbols are C-style */
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+/* returns 1 if full, 0 if there's space available */
+int pdp_procqueue_full(t_pdp_procqueue *q);
+
+
+void pdp_procqueue_flush(t_pdp_procqueue *q);
+void pdp_procqueue_wait(t_pdp_procqueue *q);
+void pdp_procqueue_finish(t_pdp_procqueue *q, int index);
+void pdp_procqueue_add(t_pdp_procqueue *q, void *owner, void *process, void *callback, int *queue_id);
+void pdp_procqueue_use_thread(t_pdp_procqueue* q, int t);
+void pdp_procqueue_init(t_pdp_procqueue *q, double milliseconds, int logsize);
+
+/********************* interface to pdp process queue singleton *********************/
+
+/* processor queue methods, callable from main pd thread */
+
+/* get the default queue */
+t_pdp_procqueue *pdp_queue_get_queue(void);
+
+
+
+#if 1 
+
+/* add a method to the processing queue */
+void  pdp_queue_add(void *owner, void *process, void *callback, int *queue_id);
+
+/* halt main tread until processing is done */
+void pdp_queue_wait(void);
+
+/* halt main tread until processing is done and remove 
+   callback from queue(for destructors) */
+void pdp_queue_finish(int queue_id);
+
+#endif
+
+
+/* misc signals to pdp */
+void pdp_control_notify_drop(int packet);
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif 
diff --git a/include/pdp_resample.h b/include/pdp_resample.h
new file mode 100644
index 0000000..8876bfa
--- /dev/null
+++ b/include/pdp_resample.h
@@ -0,0 +1,50 @@
+/*
+ *   Pure Data Packet header file. - image resampling prototypes
+ *   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.
+ *
+ */
+
+#ifndef PDP_RESAMPLE_H
+#define PDP_RESAMPLE_H
+
+#include "pdp_types.h"
+
+
+/* image resampling methods */
+void pdp_resample_scale_bilin(s16 *src_image, s16 *dst_image, s32 src_w, s32 src_h, s32 dst_w, s32 dst_h);
+void pdp_resample_scale_nn(s16 *src_image, s16 *dst_image, s32 src_w, s32 src_h, s32 dst_w, s32 dst_h);
+
+/* USE pdp_imageproc_resample_affinemap
+void pdp_resample_zoom_tiled_bilin(s16 *src_image, s16 *dst_image, s32 w, s32 h, 
+				   float zoom_x, float zoom_y, float center_x_relative, float center_y_relative);
+*/
+
+//void pdp_resample_zoom_tiled_nn(s16 *src_image, s16 *dst_image, s32 w, s32 h, float zoom_x, float zoom_y);
+
+
+
+/* power of 2 resamplers */
+void pdp_resample_halve(s16 *src_image, s16 *dst_image, s32 src_w, s32 src_h);
+void pdp_resample_double(s16 *src_image, s16 *dst_image, s32 src_w, s32 src_h);
+
+
+
+/* core routines */
+//s32 pdp_resample_bilin(s16 *image, s32 width, s32 height, s32 virt_x, s32 virt_y);
+
+
+#endif
diff --git a/include/pdp_symbol.h b/include/pdp_symbol.h
new file mode 100644
index 0000000..fe3137a
--- /dev/null
+++ b/include/pdp_symbol.h
@@ -0,0 +1,136 @@
+/*
+ *   Pure Data Packet system implementation. : symbol and namespace stuff
+ *   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.
+ *
+ */
+
+#ifndef _PDP_SYMBOL_
+#define _PDP_SYMBOL_
+
+
+/* pdp's symbols are derived from pd's symbols
+   there is one symbol hash. each symbol has
+   a meaning in several name spaces.
+
+   * forth words
+   * type description lists (for accelerating type matching)
+
+
+*/
+
+#include "pdp_list.h"
+
+
+
+
+/* the pdp symbol type */
+typedef struct _pdp_symbol
+{
+    /* next */
+    struct _pdp_symbol *s_next;
+
+    /* the symbol name */
+    char *s_name;
+
+    /* forth symbol->atom */
+    struct _pdp_atom s_forth;
+
+    /* packet handling cache */
+    struct _pdp_list *s_type;                // a parsed type description: a/b/c -> (a,b,c)
+    struct _pdp_list *s_reusefifo;           // packet pool fifo for this type
+
+
+} t_pdp_symbol;
+
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/* namespace stuff */
+int pdp_symbol_set_typelist(t_pdp_symbol *s, struct _pdp_list *typelist);
+
+/* get symbol from char */
+t_pdp_symbol *pdp_gensym(char *s);
+
+/* iterate over all symbols */
+typedef void (*t_pdp_symbol_iterator)(t_pdp_symbol *s);
+void pdp_symbol_apply_all(t_pdp_symbol_iterator ir);
+
+// don't use these directly, use the macros
+extern t_pdp_symbol _pdp_sym_wildcard;
+extern t_pdp_symbol _pdp_sym_float;
+extern t_pdp_symbol _pdp_sym_int;
+extern t_pdp_symbol _pdp_sym_symbol;
+extern t_pdp_symbol _pdp_sym_packet;
+extern t_pdp_symbol _pdp_sym_pointer;
+extern t_pdp_symbol _pdp_sym_list;
+extern t_pdp_symbol _pdp_sym_invalid;
+extern t_pdp_symbol _pdp_sym_question_mark;
+extern t_pdp_symbol _pdp_sym_atom;
+extern t_pdp_symbol _pdp_sym_null;
+extern t_pdp_symbol _pdp_sym_quote_start;
+extern t_pdp_symbol _pdp_sym_quote_end;
+extern t_pdp_symbol _pdp_sym_return;
+extern t_pdp_symbol _pdp_sym_nreturn;
+extern t_pdp_symbol _pdp_sym_defstart;
+extern t_pdp_symbol _pdp_sym_defend;
+extern t_pdp_symbol _pdp_sym_if;
+extern t_pdp_symbol _pdp_sym_then;
+extern t_pdp_symbol _pdp_sym_local;
+extern t_pdp_symbol _pdp_sym_forth;
+extern t_pdp_symbol _pdp_sym_call;
+extern t_pdp_symbol _pdp_sym_push;
+extern t_pdp_symbol _pdp_sym_pop;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+// these symbols are used a lot in critical parts
+// optimize later
+
+#define PDP_SYM_WILDCARD       &_pdp_sym_wildcard
+#define PDP_SYM_FLOAT          &_pdp_sym_float
+#define PDP_SYM_INT            &_pdp_sym_int
+#define PDP_SYM_SYMBOL         &_pdp_sym_symbol
+#define PDP_SYM_PACKET         &_pdp_sym_packet
+#define PDP_SYM_POINTER        &_pdp_sym_pointer
+#define PDP_SYM_LIST           &_pdp_sym_list
+#define PDP_SYM_INVALID        &_pdp_sym_invalid
+#define PDP_SYM_QUESTION_MARK  &_pdp_sym_question_mark
+#define PDP_SYM_ATOM           &_pdp_sym_atom
+#define PDP_SYM_NULL           &_pdp_sym_null
+#define PDP_SYM_QUOTE_START    &_pdp_sym_quote_start
+#define PDP_SYM_QUOTE_END      &_pdp_sym_quote_end
+#define PDP_SYM_RETURN         &_pdp_sym_return
+#define PDP_SYM_NRETURN        &_pdp_sym_nreturn
+#define PDP_SYM_DEF_START      &_pdp_sym_defstart
+#define PDP_SYM_DEF_END        &_pdp_sym_defend
+#define PDP_SYM_IF             &_pdp_sym_if
+#define PDP_SYM_THEN           &_pdp_sym_then
+#define PDP_SYM_LOCAL          &_pdp_sym_local
+#define PDP_SYM_FORTH          &_pdp_sym_forth
+#define PDP_SYM_CALL           &_pdp_sym_call
+#define PDP_SYM_PUSH           &_pdp_sym_push
+#define PDP_SYM_POP            &_pdp_sym_pop
+
+#endif
+
diff --git a/include/pdp_type.h b/include/pdp_type.h
new file mode 100644
index 0000000..85d6ea7
--- /dev/null
+++ b/include/pdp_type.h
@@ -0,0 +1,180 @@
+/*
+ *   Pure Data Packet system implementation. Type handling interface
+ *   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.
+ *
+ */
+
+
+/* COMMENTS
+
+Since version 0.11 all packets have an (optional) high level type description.
+This can be thought of as their mime type. It has several uses:
+
+* automatic type conversion
+* better reuse strategy for non pure packets
+* debugging
+
+The description is text-encoded, in the following form:
+
+type/subtype/subsubtype/..
+
+This is implemented using t_pdp_symbol.
+
+Type descriptors can have wildcards. This is to give some freedom to a desired
+type conversion. The following are all compatible:
+
+*/
+
+// image/grey/320x240
+// image/*/320x240
+// image/*/*
+
+/*
+
+From a user pov, the type conversion is centralized. A single object (pdp_convert)
+can do most of the conversions.
+
+Type conversion implementation has to be done decentralized. It is subdivided into
+two steps: inter-type and intra-type conversions.
+
+Intra-type is the full responsability of each type implementation and can be handled
+in a decentralized way (at linkage the type central intra-converter is registered
+at the pdp framework.
+
+Inter-type conversion is harder to do decentralized, therefore each new type should
+provide some conversions to the basic built in types. (internal image, bitmap or matrix
+types.
+
+The point of this whole business is to
+
+* enable automatic conversion from anything to a desired type for operators that combine objects.
+  i.e. pdp_add but receive incompatible objects.
+* enable manual anything to anything conversion using a pdp_convert object, i.e. have a consistent
+  packet conversion api for users.
+
+
+The solution is type conversion programs. A program's behaviour is specified as follows:
+
+* the program is registered with a source and destination (result) template
+* it is passed a packet and a destination template
+* it can assume the source packet complies to the program's registerd source template
+* it should convert the packet to a packet that will comply to it's registered destination template
+* if for some reason a conversion fails, an invalid packet (handle == -1) should be returned
+
+about type templates:
+
+* they are hierarchical, with subtypes separated by a '/' character
+* they can contain a wildcard '*', meaning that a certain level in the type hierarchy is:
+  - a don't care value, when the wildcard is used
+    -> as a destination template in a requested conversion
+    -> as a source template in a conversion program's specification
+  - uspecified, when the wildcard is used
+    -> as a destination template in a conversion program's specification
+
+
+
+NOTE: 
+
+  a wildcard can't be used in a source template for a conversion request
+  this assymetry requires there be 2 kinds of template matching mechanisms:
+
+  - source type description (without wildcards) to conversion program source template matching
+  - destination type description (with wildcards) to conversion program destination template matching
+
+  since a packet's type description cannot have wildcards, a symmetric matching (both sides have
+  wildcards) can be used for matching.
+
+*/
+
+
+
+/*
+
+implementation:
+
+there are 2 lists with conversion progams:
+* the global list, containing all registered programs.
+* the cached list, containing all recently used registered programs, or combinations thereof
+
+if there is no cached, perfectly matching rule, a new one will be created, and added to
+the head of the conversion list.
+
+all conversion methods should keep their hands off the source packet. it is treated as readonly.
+this is to ensure a more flexible operation (i.e. be able to put the conversion at the register_ro
+level)
+
+
+TODO: add a breadth first search algorithm to do multiple stage conversion.
+
+*/
+
+#ifndef PDP_TYPE_H
+#define PDP_TYPE_H
+
+#include "pdp_symbol.h"
+#include "pdp_list.h"
+
+/* the conversion method accepts a packet (which is freed) and a destination wildcard 
+   and produces a new packet, or the invalid packet if the conversion failed */
+typedef int (*t_pdp_conversion_method)(int, t_pdp_symbol *);
+
+/* a conversion program is alist of conversion methods */
+typedef t_pdp_list t_pdp_conversion_program;
+
+/* a conversion has source and dest wildcards, and a conversion program */
+typedef struct _pdp_conversion
+{
+    t_pdp_symbol *src_pattern;                   // source type pattern
+    t_pdp_symbol *dst_pattern;                   // destination type pattern 
+    t_pdp_conversion_program *program;       // the conversion program for this conversion
+} t_pdp_conversion;
+
+/* all symbols are C style */
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/* pdp_packet methods */
+t_pdp_symbol *pdp_packet_get_description(int packet);
+int pdp_packet_convert_ro(int packet, t_pdp_symbol *dest_pattern);
+int pdp_packet_convert_rw(int packet, t_pdp_symbol *dest_pattern);
+
+
+/* pdp_conversion_program methods */
+void pdp_conversion_program_free(t_pdp_conversion_program *program);
+t_pdp_conversion_program *pdp_conversion_program_new(t_pdp_conversion_method method, ...);
+t_pdp_conversion_program *pdp_conversion_program_copy(t_pdp_conversion_program *program);
+void pdp_conversion_program_add(t_pdp_conversion_program *program, t_pdp_conversion_program *tail);
+
+/* pdp_type (central type object) methods */
+int pdp_type_description_match(t_pdp_symbol *description, t_pdp_symbol *pattern);
+void pdp_type_register_conversion (t_pdp_symbol *src_pattern, t_pdp_symbol *dst_pattern, t_pdp_conversion_program *program);
+void pdp_type_register_cached_conversion (t_pdp_symbol *src_pattern, t_pdp_symbol *dst_pattern, t_pdp_conversion_program *program);
+
+    //t_pdp_symbol *pdp_type_gendesc(char *desc); //generate a type description (with description list attached)
+t_pdp_list *pdp_type_to_list(t_pdp_symbol *type);
+
+/* pdp's (threadsafe) symbol */
+t_pdp_symbol *pdp_gensym(char *s);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/include/pdp_type.h_old b/include/pdp_type.h_old
new file mode 100644
index 0000000..d588e7f
--- /dev/null
+++ b/include/pdp_type.h_old
@@ -0,0 +1,180 @@
+/*
+ *   Pure Data Packet system implementation. Type handling interface
+ *   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.
+ *
+ */
+
+
+/* COMMENTS
+
+Since version 0.11 all packets have an (optional) high level type description.
+This can be thought of as their mime type. It has several uses:
+
+* automatic type conversion
+* better reuse strategy for non pure packets
+* debugging
+
+The description is text-encoded, in the following form:
+
+type/subtype/subsubtype/..
+
+This is implemented using t_pdp_symbol.
+
+Type descriptors can have wildcards. This is to give some freedom to a desired
+type conversion. The following are all compatible:
+
+*/
+
+// image/grey/320x240
+// image/*/320x240
+// image/*/*
+
+/*
+
+From a user pov, the type conversion is centralized. A single object (pdp_convert)
+can do most of the conversions.
+
+Type conversion implementation has to be done decentralized. It is subdivided into
+two steps: inter-type and intra-type conversions.
+
+Intra-type is the full responsability of each type implementation and can be handled
+in a decentralized way (at linkage the type central intra-converter is registered
+at the pdp framework.
+
+Inter-type conversion is harder to do decentralized, therefore each new type should
+provide some conversions to the basic built in types. (internal image, bitmap or matrix
+types.
+
+The point of this whole business is to
+
+* enable automatic conversion from anything to a desired type for operators that combine objects.
+  i.e. pdp_add but receive incompatible objects.
+* enable manual anything to anything conversion using a pdp_convert object, i.e. have a consistent
+  package conversion api for users.
+
+
+The solution is type conversion programs. A program's behaviour is specified as follows:
+
+* the program is registered with a source and destination (result) template
+* it is passed a packet and a destination template
+* it can assume the source packet complies to the program's registerd source template
+* it should convert the packet to a packet that will comply to it's registered destination template
+* if for some reason a conversion fails, an invalid packet (handle == -1) should be returned
+
+about type templates:
+
+* they are hierarchical, with subtypes separated by a '/' character
+* they can contain a wildcard '*', meaning that a certain level in the type hierarchy is:
+  - a don't care value, when the wildcard is used
+    -> as a destination template in a requested conversion
+    -> as a source template in a conversion program's specification
+  - uspecified, when the wildcard is used
+    -> as a destination template in a conversion program's specification
+
+
+
+NOTE: 
+
+  a wildcard can't be used in a source template for a conversion request
+  this assymetry requires there be 2 kinds of template matching mechanisms:
+
+  - source type description (without wildcards) to conversion program source template matching
+  - destination type description (with wildcards) to conversion program destination template matching
+
+  since a packet's type description cannot have wildcards, a symmetric matching (both sides have
+  wildcards) can be used for matching.
+
+*/
+
+
+
+/*
+
+implementation:
+
+there are 2 lists with conversion progams:
+* the global list, containing all registered programs.
+* the cached list, containing all recently used registered programs, or combinations thereof
+
+if there is no cached, perfectly matching rule, a new one will be created, and added to
+the head of the conversion list.
+
+all conversion methods should keep their hand's off the source packet. it is treated as readonly.
+this is to ensure a more flexible operation (i.e. be able to put the conversion at the register_ro
+level) this will need a bit more logic in running the conversion program though..
+
+
+*/
+
+#ifndef PDP_TYPE_H
+#define PDP_TYPE_H
+
+/* the conversion method accepts a packet (which is freed) and a destination wildcard 
+   and produces a new packet, or the invalid packet if the conversion failed */
+typedef int (*t_pdp_conversion_method)(int, t_pdp_symbol *);
+
+/* a conversion program is alist of conversion methods */
+typedef struct _pdp_conversion_program
+{
+    t_pdp_conversion_method method;          // conversion method
+    struct _pdp_conversion_program *next;    // next method in program
+} t_pdp_conversion_program;
+
+/* a conversion has source and dest wildcards, and a conversion program */
+typedef struct _pdp_conversion
+{
+    t_pdp_symbol *src_pattern;                   // source type pattern
+    t_pdp_symbol *dst_pattern;                   // destination type pattern 
+    t_pdp_conversion_program *program;       // the conversion program for this conversion
+    struct _pdp_conversion *next;            // next conversion program record
+} t_pdp_conversion;
+
+/* all symbols are C style */
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/* pdp_packet methods */
+t_pdp_symbol *pdp_packet_get_description(int packet);
+int pdp_packet_convert_ro(int packet, t_pdp_symbol *dest_pattern);
+int pdp_packet_convert_rw(int packet, t_pdp_symbol *dest_pattern);
+
+
+/* pdp_conversion_program methods */
+void pdp_conversion_program_free(t_pdp_conversion_program *program);
+t_pdp_conversion_program *pdp_conversion_program_new(t_pdp_conversion_method method, ...);
+t_pdp_conversion_program *pdp_conversion_program_copy(t_pdp_conversion_program *program);
+void pdp_conversion_program_add(t_pdp_conversion_program *program, t_pdp_conversion_program *tail);
+
+/* pdp_type (central type object) methods */
+int pdp_type_description_match(t_pdp_symbol *description, t_pdp_symbol *pattern);
+void pdp_type_register_conversion (t_pdp_symbol *src_pattern, t_pdp_symbol *dst_pattern, t_pdp_conversion_program *program);
+void pdp_type_register_cached_conversion (t_pdp_symbol *src_pattern, t_pdp_symbol *dst_pattern, t_pdp_conversion_program *program);
+
+    //t_pdp_symbol *pdp_type_gendesc(char *desc); //generate a type description (with description list attached)
+t_pdp_list *pdp_type_to_list(t_pdp_symbol *type);
+
+/* pdp's (threadsafe) symbol */
+t_pdp_symbol *pdp_gensym(char *s);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/include/pdp_types.h b/include/pdp_types.h
new file mode 100644
index 0000000..b021dd7
--- /dev/null
+++ b/include/pdp_types.h
@@ -0,0 +1,57 @@
+
+/*
+ *   Pure Data Packet header file. Scalar type definitions.
+ *   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.
+ *
+ */
+
+/* some typedefs and utility classes */
+
+#ifndef PDP_TYPES_H
+#define PDP_TYPES_H
+
+typedef signed char        s8;
+typedef signed short       s16;
+typedef signed long        s32;
+typedef signed long long   s64;
+
+typedef unsigned char      u8;
+typedef unsigned short     u16;
+typedef unsigned long      u32;
+typedef unsigned long long u64;
+
+
+#ifndef __cplusplus
+typedef int bool;
+#define true 1;
+#define false 0;
+#endif
+
+
+typedef struct _pdp t_pdp;
+typedef void (*t_pdp_packet_method1)(t_pdp *);              /* dst */
+typedef void (*t_pdp_packet_method2)(t_pdp *, t_pdp *);     /* dst, src */
+
+
+
+
+/* generic packet subheader */
+//typedef unsigned char t_raw[PDP_SUBHEADER_SIZE];
+typedef unsigned int t_raw;
+
+
+#endif
diff --git a/include/pdp_xvideo.h b/include/pdp_xvideo.h
new file mode 100644
index 0000000..c395605
--- /dev/null
+++ b/include/pdp_xvideo.h
@@ -0,0 +1,78 @@
+
+/*
+ *   Pure Data Packet header file: xwindow glue code
+ *   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.
+ *
+ */
+
+
+// x stuff
+#include <X11/Xlib.h>
+#include <X11/Xatom.h>
+#include <X11/extensions/Xv.h>
+#include <X11/extensions/Xvlib.h>
+
+// image formats for communication with the X Server
+#define FOURCC_YV12 0x32315659  /* YV12   YUV420P */
+#define FOURCC_YUV2 0x32595559  /* YUV2   YUV422 */
+#define FOURCC_I420 0x30323449  /* I420   Intel Indeo 4 */
+
+
+
+/* xvideo class */
+typedef struct _pdp_xvideo
+{
+
+    t_pdp_xdisplay *xdpy;
+    t_pdp_xwindow  *xwin;
+    //Display *dpy;
+    //int screen;
+    //Window win;
+    
+
+
+    int xv_format;
+    int xv_port;
+
+    XvImage *xvi;
+    unsigned char *data;
+    unsigned int width;
+    unsigned int height;
+    int last_encoding;
+
+    int  initialized;
+
+} t_pdp_xvideo;
+
+
+/* cons */
+void pdp_xvideo_init(t_pdp_xvideo *x);
+t_pdp_xvideo *pdp_xvideo_new(void);
+
+/* des */
+void pdp_xvideo_cleanup(t_pdp_xvideo* x);
+void pdp_xvideo_free(t_pdp_xvideo* x);
+
+
+/* open an xv port (and create XvImage) */
+int pdp_xvideo_open_on_display(t_pdp_xvideo *x, t_pdp_xdisplay *d);
+
+/* close xv port (and delete XvImage */
+void pdp_xvideo_close(t_pdp_xvideo* x);
+
+/* display a packet */
+void pdp_xvideo_display_packet(t_pdp_xvideo *x, t_pdp_xwindow *w, int packet);
diff --git a/include/pdp_xwindow.h b/include/pdp_xwindow.h
new file mode 100644
index 0000000..1787062
--- /dev/null
+++ b/include/pdp_xwindow.h
@@ -0,0 +1,122 @@
+
+/*
+ *   Pure Data Packet header file: xwindow glue code
+ *   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.
+ *
+ */
+
+
+// x stuff
+#include <X11/Xlib.h>
+#include <X11/Xatom.h>
+#include "pdp_list.h"
+#include "pdp_mem.h"
+
+/* x display class */
+typedef struct _pdp_xdisplay
+{
+    Display *dpy;              // the display connection
+    int screen;                // the screen
+    t_pdp_list *windowlist;    // all windows belonging to this connection
+                               // this contains (id, eventlist)
+
+    int dragbutton;
+
+} t_pdp_xdisplay;
+
+
+/* cons */
+t_pdp_xdisplay *pdp_xdisplay_new(char *dpy_string);
+
+/* des */
+void pdp_xdisplay_free(t_pdp_xdisplay *d);
+
+struct _pdp_xwindow;
+
+void pdp_xdisplay_register_window(t_pdp_xdisplay *d, struct _pdp_xwindow *w);
+void pdp_xdisplay_unregister_window(t_pdp_xdisplay *d, struct _pdp_xwindow *w);
+
+/* x window class */
+typedef struct _pdp_xwindow
+{
+    //Display *dpy;
+    //int screen;
+    t_pdp_xdisplay *xdisplay; // the display object
+    Window win;               // window reference
+    GC gc;                    // graphics context
+    Atom WM_DELETE_WINDOW;
+
+
+    int winwidth;             // dim states
+    int winheight;
+    int winxoffset;
+    int winyoffset;
+
+    int  initialized;
+    int  autocreate;
+
+    char lastbut; // last button pressed (for drag)
+
+    //t_symbol *dragbutton;
+    
+    float cursor;
+
+} t_pdp_xwindow;
+
+/* cons */
+void pdp_xwindow_init(t_pdp_xwindow *b);
+t_pdp_xwindow *pdp_xwindow_new(void);
+
+/* des */    
+void pdp_xwindow_cleanup(t_pdp_xwindow *b);
+void pdp_xwindow_free(t_pdp_xwindow *b);
+
+/* move the pointer */
+void pdp_xwindow_warppointer(t_pdp_xwindow *xwin, int x, int y);
+
+
+/* fullscreen message */
+void pdp_xwindow_fullscreen(t_pdp_xwindow *xwin);
+
+/* resize window */
+void pdp_xwindow_resize(t_pdp_xwindow *b, int width, int height);
+
+/* resize window */
+void pdp_xwindow_moveresize(t_pdp_xwindow *b, int xoffset, int yoffset, int width, int height);
+
+/* fill a tile of the screen */
+void pdp_xwindow_tile(t_pdp_xwindow *xwin, int x_tiles, int y_tiles, int i, int j);
+
+/* move window */
+void pdp_xwindow_move(t_pdp_xwindow *xwin, int xoffset, int yoffset);
+
+/* receive events */
+t_pdp_list *pdp_xwindow_get_eventlist(t_pdp_xwindow *xwin);
+
+/* enable/disable cursor */
+void pdp_xwindow_cursor(t_pdp_xwindow *b, int flag);
+
+/* create xwindow. return code != NULL on succes */
+int pdp_xwindow_create_on_display(t_pdp_xwindow *b, t_pdp_xdisplay *d);
+
+/* close window */    
+void pdp_xwindow_close(t_pdp_xwindow *b);
+
+/* set title */
+void pdp_xwindow_title(t_pdp_xwindow *xwin, char *title);
+
+
diff --git a/include/pwc-ioctl.h b/include/pwc-ioctl.h
new file mode 100644
index 0000000..4977036
--- /dev/null
+++ b/include/pwc-ioctl.h
@@ -0,0 +1,176 @@
+#ifndef PWC_IOCTL_H
+#define PWC_IOCTL_H
+
+/* (C) 2001-2002 Nemosoft Unv.    webcam@smcc.demon.nl
+   
+   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+/*         This is pwc-ioctl.h belonging to PWC 8.6                        */
+
+/* 
+   Changes
+   2001/08/03  Alvarado   Added ioctl constants to access methods for 
+                          changing white balance and red/blue gains
+ */
+
+/* These are private ioctl() commands, specific for the Philips webcams.
+   They contain functions not found in other webcams, and settings not
+   specified in the Video4Linux API. 
+   
+   The #define names are built up like follows:
+   VIDIOC		VIDeo IOCtl prefix
+         PWC		Philps WebCam
+            G           optional: Get
+            S           optional: Set
+             ... 	the function
+ */
+
+
+
+
+/* The frame rate is encoded in the video_window.flags parameter using
+   the upper 16 bits, since some flags are defined nowadays. The following
+   defines provide a mask and shift to filter out this value.
+   
+   In 'Snapshot' mode the camera freezes its automatic exposure and colour 
+   balance controls.
+ */
+#define PWC_FPS_SHIFT		16
+#define PWC_FPS_MASK		0x00FF0000
+#define PWC_FPS_FRMASK		0x003F0000
+#define PWC_FPS_SNAPSHOT	0x00400000
+
+
+
+struct pwc_probe
+{
+	char name[32];
+	int type;
+};
+
+
+/* pwc_whitebalance.mode values */
+#define PWC_WB_INDOOR		0
+#define PWC_WB_OUTDOOR		1
+#define PWC_WB_FL		2
+#define PWC_WB_MANUAL		3
+#define PWC_WB_AUTO		4
+
+/* Used with VIDIOCPWC[SG]AWB (Auto White Balance). 
+   Set mode to one of the PWC_WB_* values above.
+   *red and *blue are the respective gains of these colour components inside 
+   the camera; range 0..65535
+   When 'mode' == PWC_WB_MANUAL, 'manual_red' and 'manual_blue' are set or read; 
+   otherwise undefined.
+   'read_red' and 'read_blue' are read-only.
+*/   
+   
+struct pwc_whitebalance
+{
+	int mode;
+	int manual_red, manual_blue;	/* R/W */
+	int read_red, read_blue;	/* R/O */
+};
+
+/* 
+   'control_speed' and 'control_delay' are used in automatic whitebalance mode,
+   and tell the camera how fast it should react to changes in lighting, and 
+   with how much delay. Valid values are 0..65535.
+*/
+struct pwc_wb_speed
+{
+	int control_speed;
+	int control_delay;
+
+};
+
+/* Used with VIDIOCPWC[SG]LED */
+struct pwc_leds
+{
+	int led_on;			/* Led on-time; range = 0..25000 */
+	int led_off;			/* Led off-time; range = 0..25000  */
+};
+
+
+
+ /* Restore user settings */
+#define VIDIOCPWCRUSER		_IO('v', 192)
+ /* Save user settings */
+#define VIDIOCPWCSUSER		_IO('v', 193)
+ /* Restore factory settings */
+#define VIDIOCPWCFACTORY	_IO('v', 194)
+
+ /* You can manipulate the compression factor. A compression preference of 0
+    means use uncompressed modes when available; 1 is low compression, 2 is
+    medium and 3 is high compression preferred. Of course, the higher the
+    compression, the lower the bandwidth used but more chance of artefacts
+    in the image. The driver automatically chooses a higher compression when
+    the preferred mode is not available.
+  */
+ /* Set preferred compression quality (0 = uncompressed, 3 = highest compression) */
+#define VIDIOCPWCSCQUAL		_IOW('v', 195, int)
+ /* Get preferred compression quality */
+#define VIDIOCPWCGCQUAL		_IOR('v', 195, int)
+
+
+ /* This is a probe function; since so many devices are supported, it
+    becomes difficult to include all the names in programs that want to
+    check for the enhanced Philips stuff. So in stead, try this PROBE;
+    it returns a structure with the original name, and the corresponding 
+    Philips type.
+    To use, fill the structure with zeroes, call PROBE and if that succeeds,
+    compare the name with that returned from VIDIOCGCAP; they should be the
+    same. If so, you can be assured it is a Philips (OEM) cam and the type
+    is valid.
+ */    
+#define VIDIOCPWCPROBE		_IOR('v', 199, struct pwc_probe)
+
+ /* Set AGC (Automatic Gain Control); int < 0 = auto, 0..65535 = fixed */
+#define VIDIOCPWCSAGC		_IOW('v', 200, int)
+ /* Get AGC; int < 0 = auto; >= 0 = fixed, range 0..65535 */
+#define VIDIOCPWCGAGC		_IOR('v', 200, int)
+ /* Set shutter speed; int < 0 = auto; >= 0 = fixed, range 0..65535 */
+#define VIDIOCPWCSSHUTTER	_IOW('v', 201, int)
+
+ /* Color compensation (Auto White Balance) */
+#define VIDIOCPWCSAWB           _IOW('v', 202, struct pwc_whitebalance)
+#define VIDIOCPWCGAWB           _IOR('v', 202, struct pwc_whitebalance)
+
+ /* Auto WB speed */
+#define VIDIOCPWCSAWBSPEED	_IOW('v', 203, struct pwc_wb_speed)
+#define VIDIOCPWCGAWBSPEED	_IOR('v', 203, struct pwc_wb_speed)
+
+ /* LEDs on/off/blink; int range 0..65535 */
+#define VIDIOCPWCSLED           _IOW('v', 205, struct pwc_leds)
+#define VIDIOCPWCGLED           _IOR('v', 205, struct pwc_leds)
+
+  /* Contour (sharpness); int < 0 = auto, 0..65536 = fixed */
+#define VIDIOCPWCSCONTOUR	_IOW('v', 206, int)
+#define VIDIOCPWCGCONTOUR	_IOR('v', 206, int)
+
+  /* Backlight compensation; 0 = off, otherwise on */
+#define VIDIOCPWCSBACKLIGHT	_IOW('v', 207, int)
+#define VIDIOCPWCGBACKLIGHT	_IOR('v', 207, int)
+
+  /* Flickerless mode; = 0 off, otherwise on */
+#define VIDIOCPWCSFLICKER	_IOW('v', 208, int)
+#define VIDIOCPWCGFLICKER	_IOR('v', 208, int)  
+
+  /* Dynamic noise reduction; 0 off, 3 = high noise reduction */
+#define VIDIOCPWCSDYNNOISE	_IOW('v', 209, int)
+#define VIDIOCPWCGDYNNOISE	_IOR('v', 209, int)
+
+#endif