From f8d8ce4d35bfbba5391af2a3fbce2ad88f94dd69 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Juha=20Vehvil=C3=A4inen?= Date: Tue, 9 Jul 2002 12:36:46 +0000 Subject: PeRColate svn path=/trunk/Framestein/; revision=31 --- Plugins/cga.c | 78 +++++ Plugins/cga.dll | Bin 0 -> 36864 bytes Plugins/constrain.c | 106 +++++++ Plugins/constrain.dll | Bin 0 -> 36864 bytes Plugins/cutout.c | 131 +++++++++ Plugins/cutout.dll | Bin 0 -> 36864 bytes Plugins/eclipse.c | 177 +++++++++++ Plugins/eclipse.dll | Bin 0 -> 49152 bytes Plugins/eclipse02.c | 178 +++++++++++ Plugins/eclipse02.dll | Bin 0 -> 45056 bytes Plugins/eclipse03.c | 244 +++++++++++++++ Plugins/eclipse03.dll | Bin 0 -> 49152 bytes Plugins/fromage.c | 191 ++++++++++++ Plugins/fromage.dll | Bin 0 -> 36864 bytes Plugins/keyscreen.c | 131 +++++++++ Plugins/keyscreen.dll | Bin 0 -> 36864 bytes Plugins/makefile | 54 +++- Plugins/modgain.c | 89 ++++++ Plugins/modgain.dll | Bin 0 -> 36864 bytes Plugins/rene.c | 245 ++++++++++++++++ Plugins/rene.dll | Bin 0 -> 49152 bytes Plugins/rgbavg.c | 654 +++++++++++++++++++++++++++++++++++++++++ Plugins/rgbavg.dll | Bin 0 -> 49152 bytes Plugins/rgbavg02.c | 799 ++++++++++++++++++++++++++++++++++++++++++++++++++ Plugins/rgbavg02.dll | Bin 0 -> 53248 bytes Plugins/rgbseek.c | 97 ++++++ Plugins/rgbseek.dll | Bin 0 -> 36864 bytes Plugins/traffic.c | 106 +++++++ Plugins/traffic.dll | Bin 0 -> 49152 bytes 29 files changed, 3279 insertions(+), 1 deletion(-) create mode 100644 Plugins/cga.c create mode 100644 Plugins/cga.dll create mode 100644 Plugins/constrain.c create mode 100644 Plugins/constrain.dll create mode 100644 Plugins/cutout.c create mode 100644 Plugins/cutout.dll create mode 100644 Plugins/eclipse.c create mode 100644 Plugins/eclipse.dll create mode 100644 Plugins/eclipse02.c create mode 100644 Plugins/eclipse02.dll create mode 100644 Plugins/eclipse03.c create mode 100644 Plugins/eclipse03.dll create mode 100644 Plugins/fromage.c create mode 100644 Plugins/fromage.dll create mode 100644 Plugins/keyscreen.c create mode 100644 Plugins/keyscreen.dll create mode 100644 Plugins/modgain.c create mode 100644 Plugins/modgain.dll create mode 100644 Plugins/rene.c create mode 100644 Plugins/rene.dll create mode 100644 Plugins/rgbavg.c create mode 100644 Plugins/rgbavg.dll create mode 100644 Plugins/rgbavg02.c create mode 100644 Plugins/rgbavg02.dll create mode 100644 Plugins/rgbseek.c create mode 100644 Plugins/rgbseek.dll create mode 100644 Plugins/traffic.c create mode 100644 Plugins/traffic.dll diff --git a/Plugins/cga.c b/Plugins/cga.c new file mode 100644 index 0000000..bc329d7 --- /dev/null +++ b/Plugins/cga.c @@ -0,0 +1,78 @@ +// 242.cga -- does bit-level quantization on an input image. +// by r. luke dubois (luke@music.columbia.edu), +// computer music center, columbia university, 2001. +// +// Pd / Framestein port by Olaf Matthes , June 2002 +// +// objects and source are provided without warranty of any kind, express or implied. +// +// usage: cga +// + +#include +#include +#include +#include "plugin.h" + +#pragma warning( disable : 4761 ) // the (lossy) conversion _IS_ our effect ! + +void perform_effect(struct frame f, struct args arg) +{ + int x,y; + int red, green, blue; // parameters + byte r, g, b; + byte bits = f.pixelformat/8; + pixel16 *c16; + pixel24 *c24; + pixel32 *c32; + char *t; + + // get r g b and alpha params + if(!arg.s) return; + red = atoi(arg.s); + if(!(t = strstr(arg.s, " "))) return; + green = atoi(t+1); + if(!(t = strstr(t+1, " "))) return; + blue = atoi(t+1); + + printf("cga: r%d g%d b%d\n", red, green, blue); + + for(y = 0; y < f.height; y++) + { + for(x = 0; x < f.width; x++) + { + switch(f.pixelformat) + { + case 16: + c16 = scanline16(f, y); + r = r16(c16[x]); + g = g16(c16[x]); + b = b16(c16[x]); + // shift it up, then shift it back down + c16[x] = rgbtocolor16((r>>red<>green<>blue<>red<>green<>blue<>red<>green<>blue<, June 2002 +// +// objects and source are provided without warranty of any kind, express or implied. +// +// usage: constrain +// + +#include +#include +#include "plugin.h" + +void perform_effect(struct frame f, struct args a) +{ + int x,y; + byte redmin, greenmin, bluemin, redmax, greenmax, bluemax; + byte redpix, greenpix, bluepix; // the color values + pixel16 *c16; + pixel24 *c24; + pixel32 *c32; + char *t; + + // get params + if(!a.s) return; + redmin = atoi(a.s); + if(!(t = strstr(a.s, " "))) return; + greenmin = atoi(t+1); + if(!(t = strstr(t+1, " "))) return; + bluemin = atoi(t+1); + if(!(t = strstr(t+1, " "))) return; + redmax = atoi(t+1); + if(!(t = strstr(t+1, " "))) return; + greenmax = atoi(t+1); + if(!(t = strstr(t+1, " "))) return; + bluemax = atoi(t+1); + + printf("constrain: rmin%d gmin%d bmin%d - rmax%d gmax%d - bmax%d\n", + redmin, greenmin, bluemin, redmax, greenmax, bluemax); + + + for(y = 0; y < f.height; y++) + { + for(x = 0; x < f.width; x++) + { + switch(f.pixelformat) + { + case 16: + *c16 = scanline16(f, y); + redpix = r16(c16[x]); + greenpix = g16(c16[x]); + bluepix = b16(c16[x]); + + if(redpix < redmin) redpix = redmin; + if(redpix > redmax) redpix = redmax; + if(greenpix < greenmin) greenpix = greenmin; + if(greenpix > greenmax) greenpix = greenmax; + if(bluepix < bluemin) bluepix = bluemin; + if(bluepix > bluemax) bluepix = bluemax; + + // set the output pixel + c16[x] = rgbtocolor16(redpix, greenpix, bluepix); + break; + case 24: + c24 = scanline24(f, y); + redpix = r24(c24[x]); + greenpix = g24(c24[x]); + bluepix = b24(c24[x]); + + if(redpix < redmin) redpix = redmin; + if(redpix > redmax) redpix = redmax; + if(greenpix < greenmin) greenpix = greenmin; + if(greenpix > greenmax) greenpix = greenmax; + if(bluepix < bluemin) bluepix = bluemin; + if(bluepix > bluemax) bluepix = bluemax; + + // set the output pixel + c24[x] = rgbtocolor24(redpix, greenpix, bluepix); + break; + case 32: + c32 = scanline32(f, y); + redpix = r32(c32[x]); + greenpix = g32(c32[x]); + bluepix = b32(c32[x]); + + if(redpix < redmin) redpix = redmin; + if(redpix > redmax) redpix = redmax; + if(greenpix < greenmin) greenpix = greenmin; + if(greenpix > greenmax) greenpix = greenmax; + if(bluepix < bluemin) bluepix = bluemin; + if(bluepix > bluemax) bluepix = bluemax; + + // set the output pixel + c32[x] = rgbtocolor32(redpix, greenpix, bluepix); + break; + } + } + } +} + +void perform_copy(struct frame f1, struct frame f2, struct args a) +{ + printf("Using constrain as copy operation does nothing!\n"); +} diff --git a/Plugins/constrain.dll b/Plugins/constrain.dll new file mode 100644 index 0000000..9fc83eb Binary files /dev/null and b/Plugins/constrain.dll differ diff --git a/Plugins/cutout.c b/Plugins/cutout.c new file mode 100644 index 0000000..9ad1984 --- /dev/null +++ b/Plugins/cutout.c @@ -0,0 +1,131 @@ +// 242.cutout -- does a rectangular mask really quickly. +// by r. luke dubois (luke@music.columbia.edu), +// computer music center, columbia university, 2001. +// +// Pd / Framestein port by Olaf Matthes , June 2002 +// +// objects and source are provided without warranty of any kind, express or implied. +// +// usage: cutout +// + +#include +#include +#include "plugin.h" + +void perform_effect(struct frame f, struct args a) +{ + printf("Using cutout as effect does nothing!\n"); +} + +void perform_copy(struct frame f1, struct frame f2, struct args a) +{ + short x, y, w, h, x_c, y_c, w_c, h_c, x_m, y_m, check, flip = 0; + byte pixelsize = f1.pixelformat/8; + pixel16 *pix1_16, *pix2_16; + pixel24 *pix1_24, *pix2_24; + pixel32 *pix1_32, *pix2_32; + char *t; + + w = f1.width= x_c) && (x <= x_m) && (y >= y_c) && (y <= y_m)) + { + check = 0; + } + else + { + check = 1; + } // occlude or don't occlude + + // sort out which image input goes over and which goes under + if(flip)check = !check; + + if(!check) + { + pix2_16[x] = pix1_16[x]; // set output1 + } + } + } + break; + case 24: + for(y = 0; y < h; y++) + { + pix1_24 = scanline24(f1, y); + pix2_24 = scanline24(f2, y); + for(x = 0; x < w; x++) + { + if((x >= x_c) && (x <= x_m) && (y >= y_c) && (y <= y_m)) + { + check = 0; + } + else + { + check = 1; + } // occlude or don't occlude + + // sort out which image input goes over and which goes under + if(flip)check = !check; + + if(!check) + { + pix2_24[x] = pix1_24[x]; // set output1 + } + } + } + break; + case 32: + for(y = 0; y < h; y++) + { + pix1_32 = scanline32(f1, y); + pix2_32 = scanline32(f2, y); + for(x = 0; x < w; x++) + { + if((x >= x_c) && (x <= x_m) && (y >= y_c) && (y <= y_m)) + { + check = 0; + } + else + { + check = 1; + } // occlude or don't occlude + + // sort out which image input goes over and which goes under + if(flip)check = !check; + + if(!check) + { + pix2_32[x] = pix1_32[x]; // set output1 + } + } + } + break; + } +} diff --git a/Plugins/cutout.dll b/Plugins/cutout.dll new file mode 100644 index 0000000..939cfe4 Binary files /dev/null and b/Plugins/cutout.dll differ diff --git a/Plugins/eclipse.c b/Plugins/eclipse.c new file mode 100644 index 0000000..6c2021c --- /dev/null +++ b/Plugins/eclipse.c @@ -0,0 +1,177 @@ +// 242.eclipse -- does meta-imaging on an input image. +// by r. luke dubois (luke@music.columbia.edu), +// computer music center, columbia university, 2001. +// grid quantization algorithm massively improved by jeremy bernstein, bootsquadresearch. +// +// Pd / Framestein port by Olaf Matthes , June 2002 +// +// objects and source are provided without warranty of any kind, express or implied. +// +// usage: eclipse +// + +#include +#include +#include "plugin.h" + +// the process image routines work like this: +// +// two pointers (src and src2) access the pixels in the input image +// src controls the output of the smaller grids, src2 controls the tinting from +// the upper-left corner of the point in the image that the grid is supposed to represent. +// +// the grid dimensions are computed by the size of the input image and are used to define +// the size of each pixel in the grid (which is why some row and columns combinations +// leave orphaned pixels on the edges). +// the loop goes like this: +// +// do each row { +// do each column { +// get the 'tint pixel' for that frame; +// +// do the height within each meta-frame { +// do the width within each meta-frame { +// output the pixels for each frame, tinting it; +// } +// } +// } +// } +// +// + +void perform_effect(struct frame f, struct args a) // color tints color +{ + int i, i1, j, j1, r, c, src2[2]; + int rows, columns, rowstep, colstep, rowoffset, coloffset, check; + byte red, green, blue, r2, g2, b2; + byte bits = f.pixelformat/8; + byte redpix, greenpix, bluepix; // the color values + pixel16 *pix_16, *pix2_16; + pixel24 *pix_24, *pix2_24; + pixel32 *pix_32, *pix2_32; + char *t; + + // get r g b and fuzzy params + if(!a.s) return; + red = atoi(a.s); + if(!(t = strstr(a.s, " "))) return; + green = atoi(t+1); + if(!(t = strstr(t+1, " "))) return; + blue = atoi(t+1); + if(!(t = strstr(t+1, " "))) return; + rows = atoi(t+1); + if(!(t = strstr(t+1, " "))) return; + columns = atoi(t+1); + + printf("eclipse: r%d g%d b%d - r%d c%d\n", red, green, blue, rows, columns); + + + rowstep = (f.height / rows) + .5; + colstep = (f.width / columns) + .5; + // printf("red is %ld green is %ld blue is %ld", red, green, blue); + + if ( rows > (f.height * .1) ) + rowoffset = rows - (f.height * .1); + else + rowoffset = 1; + + if ( columns > (f.width * .1) ) + coloffset = columns - (f.width * .1); + else + coloffset = 1; + + + for(r = 0; r <= ( rows + rowoffset ); r++ ) + { + for(i = 0, i1 = ( r * rowstep ); i < f.height; i+=rows, i1++) + { + for( c = 0; c <= columns + coloffset; c++ ) + { + switch(f.pixelformat) + { + case 16: + src2[0] = c * colstep; + src2[1] = r * rowstep; + pix2_16 = scanline16(f, src2[1]); + r2 = r16(pix2_16[src2[0]]); + g2 = g16(pix2_16[src2[0]]); + b2 = b16(pix2_16[src2[0]]); + + for(j = 0, j1 = c * colstep; j < f.width; j += columns, j1++) + { + if ( j1 >= f.width ) + goto dink; + + if ( i1 >= f.height ) + goto yoink; + + pix_16 = scanline16(f, i1); + redpix = r16(pix_16[j1]) + r2 + red; + greenpix = g16(pix_16[j1]) + g2 + green; + bluepix = b16(pix_16[j1]) + b2 + blue; + + pix_16[j1] = rgbtocolor16(redpix, greenpix, bluepix); + } + break; + case 24: + src2[0] = c * colstep; + src2[1] = r * rowstep; + pix2_24 = scanline24(f, src2[1]); + r2 = r24(pix2_24[src2[0]]); + g2 = g24(pix2_24[src2[0]]); + b2 = b24(pix2_24[src2[0]]); + + for(j = 0, j1 = c * colstep; j < f.width; j += columns, j1++) + { + if ( j1 >= f.width ) + goto dink; + + if ( i1 >= f.height ) + goto yoink; + + pix_24 = scanline24(f, i1); + redpix = r24(pix_24[j1]) + r2 + red; + greenpix = g24(pix_24[j1]) + g2 + green; + bluepix = b24(pix_24[j1]) + b2 + blue; + + pix_24[j1] = rgbtocolor24(redpix, greenpix, bluepix); + } + break; + case 32: + src2[0] = c * colstep; + src2[1] = r * rowstep; + pix2_32 = scanline32(f, src2[1]); + r2 = r32(pix2_32[src2[0]]); + g2 = g32(pix2_32[src2[0]]); + b2 = b32(pix2_32[src2[0]]); + + for(j = 0, j1 = c * colstep; j < f.width; j += columns, j1++) + { + if ( j1 >= f.width ) + goto dink; + + if ( i1 >= f.height ) + goto yoink; + + pix_32 = scanline32(f, i1); + redpix = r32(pix_32[j1]) + r2 + red; + greenpix = g32(pix_32[j1]) + g2 + green; + bluepix = b32(pix_32[j1]) + b2 + blue; + + pix_32[j1] = rgbtocolor32(redpix, greenpix, bluepix); + } + break; + } + } + dink: + ; + } + } + yoink: + ; +} + +void perform_copy(struct frame f1, struct frame f2, struct args a) +{ + printf("Using eclipse as copy operation does nothing!\n"); +} diff --git a/Plugins/eclipse.dll b/Plugins/eclipse.dll new file mode 100644 index 0000000..e9a29df Binary files /dev/null and b/Plugins/eclipse.dll differ diff --git a/Plugins/eclipse02.c b/Plugins/eclipse02.c new file mode 100644 index 0000000..d1d5301 --- /dev/null +++ b/Plugins/eclipse02.c @@ -0,0 +1,178 @@ +// 242.eclipse02 -- does meta-imaging on two input images. +// by r. luke dubois (luke@music.columbia.edu), +// computer music center, columbia university, 2001. +// grid quantization algorithm massively improved by jeremy bernstein, bootsquadresearch. +// +// Pd / Framestein port by Olaf Matthes , June 2002 +// +// objects and source are provided without warranty of any kind, express or implied. +// +// usage: eclipse02 +// + +#include +#include +#include "plugin.h" + +// the process image routines work like this: +// +// two pointers (src and src2) access the pixels in the input image +// src controls the output of the smaller grids, src2 controls the tinting from +// the upper-left corner of the point in the image that the grid is supposed to represent. +// +// the grid dimensions are computed by the size of the input image and are used to define +// the size of each pixel in the grid (which is why some row and columns combinations +// leave orphaned pixels on the edges). +// the loop goes like this: +// +// do each row { +// do each column { +// get the 'tint pixel' for that frame; +// +// do the height within each meta-frame { +// do the width within each meta-frame { +// output the pixels for each frame, tinting it; +// } +// } +// } +// } +// +// + +void perform_effect(struct frame f, struct args a) // color tints color +{ + printf("Using eclipse02 as effect does nothing!\n"); +} + +void perform_copy(struct frame f1, struct frame f2, struct args a) +{ + short i, i1, j, j1, r, c, src1[2], w, h; + short rows, columns, rowstep, colstep, rowoffset, coloffset; + byte red, green, blue, check, r1, g1, b1; + byte bits = f1.pixelformat/8; + byte redpix, greenpix, bluepix; // the color values + pixel16 *pix2_16, *pix1_16; + pixel24 *pix2_24, *pix1_24; + pixel32 *pix2_32, *pix1_32; + char *t; + + w = f1.width (h * .1) ) + rowoffset = rows - (h * .1); + else + rowoffset = 1; + + if ( columns > (w * .1) ) + coloffset = columns - (w * .1); + else + coloffset = 1; + + + for(r = 0; r <= ( rows + rowoffset ); r++ ) + { + for(i = 0, i1 = ( r * rowstep ); i < h; i += rows, i1++) + { + for( c = 0; c <= columns + coloffset; c++ ) + { + switch(f1.pixelformat) + { + case 16: + src1[0] = c * colstep; + src1[1] = r * rowstep; + pix1_16 = scanline16(f1, src1[1]); + r1 = r16(pix1_16[src1[0]]); + g1 = g16(pix1_16[src1[0]]); + b1 = b16(pix1_16[src1[0]]); + + for(j = 0, j1 = c * colstep; j < w; j += columns, j1++) + { + if ( j1 >= w ) + goto dink; + + if ( i1 >= h ) + goto yoink; + + pix2_16 = scanline16(f2, i1); + redpix = r16(pix2_16[j1]) + r1 + red; + greenpix = g16(pix2_16[j1]) + g1 + green; + bluepix = b16(pix2_16[j1]) + b1 + blue; + + pix2_16[j1] = rgbtocolor16(redpix, greenpix, bluepix); + } + break; + case 24: + src1[0] = c * colstep; + src1[1] = r * rowstep; + pix1_24 = scanline24(f1, src1[1]); + r1 = r24(pix1_24[src1[0]]); + g1 = g24(pix1_24[src1[0]]); + b1 = b24(pix1_24[src1[0]]); + + for(j = 0, j1 = c * colstep; j < w; j += columns, j1++) + { + if ( j1 >= w ) + goto dink; + + if ( i1 >= h ) + goto yoink; + + pix2_24 = scanline24(f2, i1); + redpix = r24(pix2_24[j1]) + r1 + red; + greenpix = g24(pix2_24[j1]) + g1 + green; + bluepix = b24(pix2_24[j1]) + b1 + blue; + + pix2_24[j1] = rgbtocolor24(redpix, greenpix, bluepix); + } + break; + case 32: + src1[0] = c * colstep; + src1[1] = r * rowstep; + pix1_32 = scanline32(f1, src1[1]); + r1 = r32(pix1_32[src1[0]]); + g1 = g32(pix1_32[src1[0]]); + b1 = b32(pix1_32[src1[0]]); + + for(j = 0, j1 = c * colstep; j < w; j += columns, j1++) + { + if ( j1 >= w ) + goto dink; + + if ( i1 >= h ) + goto yoink; + + pix2_32 = scanline32(f2, i1); + redpix = r32(pix2_32[j1]) + r1 + red; + greenpix = g32(pix2_32[j1]) + g1 + green; + bluepix = b32(pix2_32[j1]) + b1 + blue; + + pix2_32[j1] = rgbtocolor32(redpix, greenpix, bluepix); + } + break; + } + } + dink: + ; + } + } + yoink: + ; +} diff --git a/Plugins/eclipse02.dll b/Plugins/eclipse02.dll new file mode 100644 index 0000000..e13a72f Binary files /dev/null and b/Plugins/eclipse02.dll differ diff --git a/Plugins/eclipse03.c b/Plugins/eclipse03.c new file mode 100644 index 0000000..8d6b31d --- /dev/null +++ b/Plugins/eclipse03.c @@ -0,0 +1,244 @@ +// 242.eclipse0303 -- does meta-imaging on an input image using an inversion threshhold. +// by r. luke dubois (luke@music.columbia.edu), +// computer music center, columbia university, 2001. +// grid quantization algorithm massively improved by jeremy bernstein, bootsquadresearch. +// +// Pd / Framestein port by Olaf Matthes , June 2002 +// +// objects and source are provided without warranty of any kind, express or implied. +// +// usage: eclipse +// + +#include +#include +#include "plugin.h" + +// the process image routines work like this: +// +// two pointers (src and src2) access the pixels in the input image +// src controls the output of the smaller grids, src2 controls the tinting from +// the upper-left corner of the point in the image that the grid is supposed to represent. +// +// the grid dimensions are computed by the size of the input image and are used to define +// the size of each pixel in the grid (which is why some row and columns combinations +// leave orphaned pixels on the edges). +// the loop goes like this: +// +// do each row { +// do each column { +// get the 'tint pixel' for that frame; +// +// do the height within each meta-frame { +// do the width within each meta-frame { +// output the pixels for each frame, tinting it; +// } +// } +// } +// } +// +// + +void perform_effect(struct frame f, struct args a) // color tints color +{ + short i, i1, j, j1, r, c, src2[2]; + short rows, columns, rowstep, colstep, rowoffset, coloffset; + short cut, flip, tint, inv, thresh; + byte red, green, blue, check, r2, g2, b2; + byte bits = f.pixelformat/8; + byte redpix, greenpix, bluepix; // the color values + pixel16 *pix_16, *pix2_16; + pixel24 *pix_24, *pix2_24; + pixel32 *pix_32, *pix2_32; + char *t; + + // get params + if(!a.s) return; + red = atoi(a.s); + if(!(t = strstr(a.s, " "))) return; + green = atoi(t+1); + if(!(t = strstr(t+1, " "))) return; + blue = atoi(t+1); + if(!(t = strstr(t+1, " "))) return; + rows = atoi(t+1); + if(!(t = strstr(t+1, " "))) return; + columns = atoi(t+1); + if(!(t = strstr(t+1, " "))) return; + tint = atoi(t+1); + if(!(t = strstr(t+1, " "))) return; + inv = atoi(t+1); + if(!(t = strstr(t+1, " "))) return; + thresh = atoi(t+1); + + printf("eclipse03: r%d g%d b%d - r%d c%d - t%d i%d t%d\n", + red, green, blue, rows, columns, tint, inv, thresh); + + rowstep = (f.height / rows) + .5; + colstep = (f.width / columns) + .5; + + if ( rows > (f.height * .1) ) + rowoffset = rows - (f.height * .1); + else + rowoffset = 1; + + if ( columns > (f.width * .1) ) + coloffset = columns - (f.width * .1); + else + coloffset = 1; + + if (thresh < 0) flip = 1; else flip = 0; + + for (r = 0; r <= ( rows + rowoffset ); r++ ) + { + for(i = 0, i1 = ( r * rowstep ); i < f.height; i+=rows, i1++) + { + for ( c = 0; c <= columns + coloffset; c++ ) + { + switch (f.pixelformat) + { + case 16: + src2[0] = c * colstep; + src2[1] = r * rowstep; + pix2_16 = scanline16(f, src2[1]); + r2 = r16(pix2_16[src2[0]]); + g2 = g16(pix2_16[src2[0]]); + b2 = b16(pix2_16[src2[0]]); + if (((r2 + g2 + b2) / 3.0) >= fabs(thresh)) cut = 1; + if (!tint) r2 = g2 = b2 = 0; + + for(j = 0, j1 = c * colstep; j < f.width; j += columns, j1++) + { + if ( j1 >= f.width ) + goto dink; + + if ( i1 >= f.height ) + goto yoink; + + pix_16 = scanline16(f, i1); + + if ((cut && !flip) || (!cut && flip)) { + redpix = r16(pix_16[j1]) + r2 + red; + greenpix = g16(pix_16[j1]) + g2 + green; + bluepix = b16(pix_16[j1]) + + b2 + blue; + } + else + { + if (!inv) + { + redpix = 255 - r16(pix_16[j1]) + r2 + red; + greenpix = 255 - g16(pix_16[j1]) + g2 + green; + bluepix = 255 - b16(pix_16[j1]) + b2 + blue; + } + else + { + redpix = 255 - r16(pix_16[j1]) + r2 - red; + greenpix = 255 - g16(pix_16[j1]) + g2 - green; + bluepix = 255 - b16(pix_16[j1]) + b2 - blue; + } + } + + pix_16[j1] = rgbtocolor16(redpix, greenpix, bluepix); + } + break; + case 24: + src2[0] = c * colstep; + src2[1] = r * rowstep; + pix2_24 = scanline24(f, src2[1]); + r2 = r24(pix2_24[src2[0]]); + g2 = g24(pix2_24[src2[0]]); + b2 = b24(pix2_24[src2[0]]); + if (((r2 + g2 + b2) / 3.0) >= fabs(thresh)) cut = 1; + if (!tint) r2 = g2 = b2 = 0; + + for(j = 0, j1 = c * colstep; j < f.width; j += columns, j1++) + { + if ( j1 >= f.width ) + goto dink; + + if ( i1 >= f.height ) + goto yoink; + + pix_24 = scanline24(f, i1); + + if ((cut && !flip) || (!cut && flip)) { + redpix = r24(pix_24[j1]) + r2 + red; + greenpix = g24(pix_24[j1]) + g2 + green; + bluepix = b24(pix_24[j1]) + + b2 + blue; + } + else + { + if (!inv) + { + redpix = 255 - r24(pix_24[j1]) + r2 + red; + greenpix = 255 - g24(pix_24[j1]) + g2 + green; + bluepix = 255 - b24(pix_24[j1]) + b2 + blue; + } + else + { + redpix = 255 - r24(pix_24[j1]) + r2 - red; + greenpix = 255 - g24(pix_24[j1]) + g2 - green; + bluepix = 255 - b24(pix_24[j1]) + b2 - blue; + } + } + + pix_24[j1] = rgbtocolor24(redpix, greenpix, bluepix); + } + break; + case 32: + src2[0] = c * colstep; + src2[1] = r * rowstep; + pix2_32 = scanline32(f, src2[1]); + r2 = r32(pix2_32[src2[0]]); + g2 = g32(pix2_32[src2[0]]); + b2 = b32(pix2_32[src2[0]]); + if (((r2 + g2 + b2) / 3.0) >= fabs(thresh)) cut = 1; + if (!tint) r2 = g2 = b2 = 0; + + for(j = 0, j1 = c * colstep; j < f.width; j += columns, j1++) + { + if ( j1 >= f.width ) + goto dink; + + if ( i1 >= f.height ) + goto yoink; + + pix_32 = scanline32(f, i1); + + if ((cut && !flip) || (!cut && flip)) { + redpix = r32(pix_32[j1]) + r2 + red; + greenpix = g32(pix_32[j1]) + g2 + green; + bluepix = b32(pix_32[j1]) + + b2 + blue; + } + else + { + if (!inv) + { + redpix = 255 - r32(pix_32[j1]) + r2 + red; + greenpix = 255 - g32(pix_32[j1]) + g2 + green; + bluepix = 255 - b32(pix_32[j1]) + b2 + blue; + } + else + { + redpix = 255 - r32(pix_32[j1]) + r2 - red; + greenpix = 255 - g32(pix_32[j1]) + g2 - green; + bluepix = 255 - b32(pix_32[j1]) + b2 - blue; + } + } + + pix_32[j1] = rgbtocolor32(redpix, greenpix, bluepix); + } + break; + } + } + dink: + ; + } + } + yoink: + ; +} + +void perform_copy(struct frame f1, struct frame f2, struct args a) +{ + printf("Using eclipse03 as copy operation does nothing!\n"); +} diff --git a/Plugins/eclipse03.dll b/Plugins/eclipse03.dll new file mode 100644 index 0000000..60560e2 Binary files /dev/null and b/Plugins/eclipse03.dll differ diff --git a/Plugins/fromage.c b/Plugins/fromage.c new file mode 100644 index 0000000..0c8b48a --- /dev/null +++ b/Plugins/fromage.c @@ -0,0 +1,191 @@ +// 242.fromage -- does cheezy wipes between two input images. +// by r. luke dubois (luke@music.columbia.edu), +// computer music center, columbia university, 2001. +// +// Pd / Framestein port by Olaf Matthes , June 2002 +// +// objects and source are provided without warranty of any kind, express or implied. +// +// usage: fromage +// + +#include +#include +#include "plugin.h" + +void perform_effect(struct frame f, struct args a) +{ + printf("Using fromage as effect does nothing!\n"); +} + +void perform_copy(struct frame f1, struct frame f2, struct args a) +{ + short x, y, w, h, wf, hf, x_c, y_c, c, r, columns, rows, checky, checkx, flip = 0; + pixel16 *pix1_16, *pix2_16; + pixel24 *pix1_24, *pix2_24; + pixel32 *pix1_32, *pix2_32; + char *t; + + // get params + if(!a.s) return; + x_c = atoi(a.s); + if(!(t = strstr(a.s, " "))) return; + y_c = atoi(t+1); + if(!(t = strstr(t+1, " "))) return; + columns = atoi(t+1); + if(!(t = strstr(t+1, " "))) return; + rows = atoi(t+1); + if(!(t = strstr(t+1, " "))) return; + flip = atoi(t+1); + + printf("fromage: x%d y%d c%d r%d - f%d\n", x_c, y_c, columns, rows, flip); + + // calculate size we need to process + wf = f1.width= hf) continue; + + if(y < (y_c + (r * h))) // occlude or don't occlude + { + checky = 1; + } + else + { + checky = 0; + } + if(flip) checky = !checky; + + for(c = 0; c < (columns + 1); c++) + { + for(x = c * w; x < w * (c + 1); x++) + { + if (x >= wf) continue; + + if(x < (x_c + (c * w))) // occlude or don't occlude + { + checkx = 1; + } + else + { + checkx = 0; + } + if(flip) checkx = !checkx; + + if (checkx || checky) + { + pix2_16[x] = pix1_16[x]; // set output1 + } + } + } + + } + } + break; + case 24: + for(r = 0; r < (rows + 1); r++) + { + for(y = r * h; y < h * (r + 1); y++) + { + pix1_24 = scanline24(f1, y); + pix2_24 = scanline24(f2, y); + + if(y >= hf) continue; + + if(y < (y_c + (r*h))) // occlude or don't occlude + { + checky = 1; + } + else + { + checky = 0; + } + if(flip) checky = !checky; + + for(c = 0; c < (columns + 1); c++) + { + for(x = c * w; x < w * (c + 1); x++) + { + if (x >= wf) continue; + + if(x < (x_c + (c * w))) // occlude or don't occlude + { + checkx = 1; + } + else + { + checkx = 0; + } + if(flip) checkx = !checkx; + + if (checkx || checky) + { + pix2_24[x] = pix1_24[x]; // set output2 + } + } + } + + } + } + break; + case 32: + for(r = 0; r < (rows + 1); r++) + { + for(y = r * h; y < h * (r + 1); y++) + { + pix1_32 = scanline32(f1, y); + pix2_32 = scanline32(f2, y); + + if(y >= hf) continue; + + if(y < (y_c + (r * h))) // occlude or don't occlude + { + checky = 1; + } + else + { + checky = 0; + } + if(flip) checky = !checky; + + for(c = 0; c < (columns + 1); c++) + { + for(x = c * w; x < w * (c + 1); x++) + { + if (x >= wf) continue; + + if(x < (x_c + (c * w))) // occlude or don't occlude + { + checkx = 1; + } + else + { + checkx = 0; + } + if(flip) checkx = !checkx; + + if (checkx || checky) + { + pix2_32[x] = pix1_32[x]; // set output2 + } + } + } + + } + } + break; + } +} diff --git a/Plugins/fromage.dll b/Plugins/fromage.dll new file mode 100644 index 0000000..913caee Binary files /dev/null and b/Plugins/fromage.dll differ diff --git a/Plugins/keyscreen.c b/Plugins/keyscreen.c new file mode 100644 index 0000000..45aea88 --- /dev/null +++ b/Plugins/keyscreen.c @@ -0,0 +1,131 @@ +// 242.keyscreen -- does 3-source chroma keying. +// by r. luke dubois (luke@music.columbia.edu), +// computer music center, columbia university, 2001. +// +// Pd / Framestein port by Olaf Matthes , June 2002 +// +// objects and source are provided without warranty of any kind, express or implied. +// +// usage: keyscreen +// +// f2 is the key & target, f1 is the mask +// + +#include +#include +#include "plugin.h" + +void perform_effect(struct frame f, struct args a) +{ + printf("Using keyscreen as effect does nothing!\n"); +} + +void perform_copy(struct frame f1, struct frame f2, struct args a) +{ + short x, y, w, h; + pixel16 *pix1_16, *pix2_16; + pixel24 *pix1_24, *pix2_24; + pixel32 *pix1_32, *pix2_32; + byte redpix, greenpix, bluepix; + byte red, green, blue, check, rf, gf, bf; + char *t; + + w = f1.width=(red-rf))&&(redpix<=(red+rf))&&(greenpix>=(green-gf))&&(greenpix<=(green+gf))&&(bluepix>=(blue-bf))&&(bluepix<=(blue+bf))) + { + check = 1; // mask it + } + + + if(check) // output frame 1 + { + pix2_16[x] = pix1_16[x]; + } + } + } + break; + case 24: + for(y = 0; y < h; y++) + { + pix1_24 = scanline24(f1, y); + pix2_24 = scanline24(f2, y); + for(x = 0; x < w; x++) + { + check = 0; // start with each pixel anew + + redpix = r24(pix2_24[x]); + greenpix = g24(pix2_24[x]); + bluepix = b24(pix2_24[x]); + if ((redpix>=(red-rf))&&(redpix<=(red+rf))&&(greenpix>=(green-gf))&&(greenpix<=(green+gf))&&(bluepix>=(blue-bf))&&(bluepix<=(blue+bf))) + { + check = 1; // mask it + } + + + if(check) // output frame 1 + { + pix1_24[x] = pix1_24[x]; + } + } + } + break; + case 32: + for(y = 0; y < h; y++) + { + pix1_32 = scanline32(f1, y); + pix2_32 = scanline32(f2, y); + for(x = 0; x < w; x++) + { + check = 0; // start with each pixel anew + + redpix = r32(pix2_32[x]); + greenpix = g32(pix2_32[x]); + bluepix = b32(pix2_32[x]); + if ((redpix>=(red-rf))&&(redpix<=(red+rf))&&(greenpix>=(green-gf))&&(greenpix<=(green+gf))&&(bluepix>=(blue-bf))&&(bluepix<=(blue+bf))) + { + check = 1; // mask it + } + + + if(check) // output frame 1 + { + pix2_32[x] = pix1_32[x]; + } + } + } + break; + } +} diff --git a/Plugins/keyscreen.dll b/Plugins/keyscreen.dll new file mode 100644 index 0000000..6631ea3 Binary files /dev/null and b/Plugins/keyscreen.dll differ diff --git a/Plugins/makefile b/Plugins/makefile index 198a611..4e92a8a 100644 --- a/Plugins/makefile +++ b/Plugins/makefile @@ -2,7 +2,9 @@ all: noize colortv subtract xbend bend gol shuffle green \ tile rgbcopy copyvert black rgb hist setbits xshred \ sonogram vf2fs fs2vf swap 2colors plot makesliders \ convolution compare darken deinterlace difference interlace lighten \ - multiply overlay screen shadowcaster softlight + multiply overlay screen shadowcaster softlight \ + rgbseek modgain traffic constrain eclipse eclipse02 eclipse03 \ + cga keyscreen rene cutout fromage rgbavg rgbavg02 dir *.dll @@ -129,3 +131,53 @@ softlight: # # # + +# +# PeRColate +# + +rgbseek: + cl rgbseek.c $(FLAGS) /link $(EFFECT) + +modgain: + cl modgain.c $(FLAGS) /link $(EFFECT) + +traffic: + cl traffic.c $(FLAGS) /link $(EFFECT) + +constrain: + cl constrain.c $(FLAGS) /link $(EFFECT) + +eclipse: + cl eclipse.c $(FLAGS) /link $(EFFECT) + +eclipse02: + cl eclipse02.c $(FLAGS) /link $(COPY) + +eclipse03: + cl eclipse03.c $(FLAGS) /link $(EFFECT) + +cga: + cl cga.c $(FLAGS) /link $(EFFECT) + +keyscreen: + cl keyscreen.c $(FLAGS) /link $(COPY) + +rene: + cl rene.c $(FLAGS) /link $(COPY) + +cutout: + cl cutout.c $(FLAGS) /link $(COPY) + +fromage: + cl fromage.c $(FLAGS) /link $(COPY) + +rgbavg: + cl rgbavg.c $(FLAGS) /link $(EFFECT) + +rgbavg02: + cl rgbavg02.c $(FLAGS) /link $(COPY) + +# +# +# diff --git a/Plugins/modgain.c b/Plugins/modgain.c new file mode 100644 index 0000000..1c4ce56 --- /dev/null +++ b/Plugins/modgain.c @@ -0,0 +1,89 @@ +// 242.modgain -- does modulo channel shifting on an input image. +// by r. luke dubois (luke@music.columbia.edu), +// computer music center, columbia university, 2001. +// +// Pd / Framestein port by Olaf Matthes , June 2002 +// +// objects and source are provided without warranty of any kind, express or implied. +// +// usage: modgain +// + +#include +#include +#include +#include "plugin.h" + +void perform_effect(struct frame f, struct args arg) +{ + int x,y; + int red, green, blue, alpha; // parameters + byte r, g, b, a; + byte bits = f.pixelformat/8; + byte redpix, greenpix, bluepix; // the color values + pixel16 *c16; + pixel24 *c24; + pixel32 *c32; + char *t; + + // get params + if(!arg.s) return; + red = atoi(arg.s); + if(!(t = strstr(arg.s, " "))) return; + green = atoi(t+1); + if(!(t = strstr(arg.s, " "))) return; + blue = atoi(t+1); + + printf("modgain: r%d g%d b%d\n", red, green, blue); + + for(y = 0; y < f.height; y++) + { + for(x = 0; x < f.width; x++) + { + switch(f.pixelformat) + { + case 16: + c16 = scanline16(f, y); + r = (r16(c16[x]) + red) % 255; + g = (g16(c16[x]) + green) % 255; + b = (b16(c16[x]) + blue) % 255; + // shift the pixels and wrap them + if(r<0) r += 255; + if(g<0) g += 255; + if(b<0) b += 255; + + c16[x] = rgbtocolor16(r, g, b); + break; + case 24: + c24 = scanline24(f, y); + r = (r24(c24[x]) + red) % 255; + g = (g24(c24[x]) + green) % 255; + b = (b24(c24[x]) + blue) % 255; + // shift the pixels and wrap them + if(r<0) r += 255; + if(g<0) g += 255; + if(b<0) b += 255; + + c24[x] = rgbtocolor24(r, g, b); + break; + case 32: + c32 = scanline32(f, y); + r = (r32(c32[x]) + red) % 255; + g = (g32(c32[x]) + green) % 255; + b = (b32(c32[x]) + blue) % 255; + // shift the pixels and wrap them + if(r<0) r += 255; + if(g<0) g += 255; + if(b<0) b += 255; + + c32[x] = rgbtocolor32(r, g, b); + break; + } + } + } +} + +void perform_copy(struct frame f1, struct frame f2, struct args a) +{ + printf("Using modgain as copy operation does nothing!\n"); +} diff --git a/Plugins/modgain.dll b/Plugins/modgain.dll new file mode 100644 index 0000000..14946a3 Binary files /dev/null and b/Plugins/modgain.dll differ diff --git a/Plugins/rene.c b/Plugins/rene.c new file mode 100644 index 0000000..d8e6082 --- /dev/null +++ b/Plugins/rene.c @@ -0,0 +1,245 @@ +// 242.rene -- does 3-source chroma keying with transparency. +// by r. luke dubois (luke@music.columbia.edu), +// computer music center, columbia university, 2001. +// for rene beekman. +// +// Pd / Framestein port by Olaf Matthes , June 2002 +// +// objects and source are provided without warranty of any kind, express or implied. +// +// usage: rene +// +// f1 is the key & target, f2 is the mask +// + +#include +#include +#include "plugin.h" + +void perform_effect(struct frame f, struct args a) +{ + printf("Using keyscreen as effect does nothing!\n"); +} + +void perform_copy(struct frame f1, struct frame f2, struct args a) +{ + short x, y, w, h; + pixel16 *pix1_16, *pix2_16; + pixel24 *pix1_24, *pix2_24; + pixel32 *pix1_32, *pix2_32; + byte redpix, greenpix, bluepix, rkeyed, gkeyed, bkeyed; + byte red, green, blue, check, rf, gf, bf, rfl, gfl, bfl; + float lum, keylum, lowfuzz, highfuzz, lowfloor, highfloor, coeff; + char *t; + + w = f1.width=(red-rf))&&(redpix<=(red+rf))&&(greenpix>=(green-gf))&&(greenpix<=(green+gf))&&(bluepix>=(blue-bf))&&(bluepix<=(blue+bf))) + { + check = 1; // mask it + } + if ((redpix<(red-rfl))||(redpix>(red+rfl))&&(greenpix<(green-gfl))||(greenpix>(green+gfl))&&(bluepix<(blue-bfl))||(bluepix>(blue+bfl))) + { + check = 2; // target it + } + + if (!check) + { + lum = (redpix + greenpix + bluepix) / 3.0; + keylum = (red + blue + green) / 3.0; + lowfuzz = (rf + gf + bf) / 3.0; + if (lowfuzz < 0.0) lowfuzz = 0.0; + highfuzz = (rf + gf + bf) / 3.0; + if (highfuzz > 1.0) highfuzz = 1.0; + lowfloor = keylum - ((rfl + gfl + bfl) / 3.0); + if (lowfloor < 0.0) lowfloor = 0.; + highfloor = keylum + (rfl + gfl + bfl) / 3.0; + if (highfloor > 1.0) highfloor = 1.0; + if (lum < keylum) + { + coeff = ((lum - lowfloor) / (keylum - lowfuzz)); + } + if (lum >= keylum) + { + coeff = ((255 - lum - highfloor) / (255 - keylum - highfuzz)); + } + + rkeyed = ((float)r16(pix2_16[x]) * coeff) + ((float)r16(pix1_16[x]) * (1.0 - coeff)); + gkeyed = ((float)g16(pix2_16[x]) * coeff) + ((float)g16(pix1_16[x]) * (1.0 - coeff)); + bkeyed = ((float)b16(pix2_16[x]) * coeff) + ((float)b16(pix1_16[x]) * (1.0 - coeff)); + + pix2_16[x] = rgbtocolor16(rkeyed, gkeyed, bkeyed); + } + + if (check==1) + { // was pix3 + // pix2_16[x] = rgbtocolor16(r16(pix2_16[x]), g16(pix2_16[x]), b16(pix2_16[x])); + } + if (check==2) + { // was pix2 + pix2_16[x] = rgbtocolor16(r16(pix1_16[x]), g16(pix1_16[x]), b16(pix1_16[x])); + } + } + } + break; + case 24: + for(y = 0; y < h; y++) + { + pix1_24 = scanline24(f1, y); + pix2_24 = scanline24(f2, y); + for(x = 0; x < w; x++) + { + check = 0; // start with each pixel anew + + redpix = r24(pix2_24[x]); + greenpix = g24(pix2_24[x]); + bluepix = b24(pix2_24[x]); + if ((redpix>=(red-rf))&&(redpix<=(red+rf))&&(greenpix>=(green-gf))&&(greenpix<=(green+gf))&&(bluepix>=(blue-bf))&&(bluepix<=(blue+bf))) + { + check = 1; // mask it + } + if ((redpix<(red-rfl))||(redpix>(red+rfl))&&(greenpix<(green-gfl))||(greenpix>(green+gfl))&&(bluepix<(blue-bfl))||(bluepix>(blue+bfl))) + { + check = 2; // target it + } + + if (!check) + { + lum = (redpix + greenpix + bluepix) / 3.0; + keylum = (red + blue + green) / 3.0; + lowfuzz = (rf + gf + bf) / 3.0; + if (lowfuzz < 0.0) lowfuzz = 0.0; + highfuzz = (rf + gf + bf) / 3.0; + if (highfuzz > 1.0) highfuzz = 1.0; + lowfloor = keylum - ((rfl + gfl + bfl) / 3.0); + if (lowfloor < 0.0) lowfloor = 0.; + highfloor = keylum + (rfl + gfl + bfl) / 3.0; + if (highfloor > 1.0) highfloor = 1.0; + if (lum < keylum) + { + coeff = ((lum - lowfloor) / (keylum - lowfuzz)); + } + if (lum >= keylum) + { + coeff = ((255 - lum - highfloor) / (255 - keylum - highfuzz)); + } + + rkeyed = ((float)r24(pix2_24[x]) * coeff) + ((float)r24(pix1_24[x]) * (1.0 - coeff)); + gkeyed = ((float)g24(pix2_24[x]) * coeff) + ((float)g24(pix1_24[x]) * (1.0 - coeff)); + bkeyed = ((float)b24(pix2_24[x]) * coeff) + ((float)b24(pix1_24[x]) * (1.0 - coeff)); + + pix2_24[x] = rgbtocolor24(rkeyed, gkeyed, bkeyed); + } + + if (check==1) + { // was pix3 + // pix2_24[x] = rgbtocolor24(r24(pix2_24[x]), g24(pix2_24[x]), b24(pix2_24[x])); + } + if (check==2) + { // was pix2 + pix2_24[x] = rgbtocolor24(r24(pix1_24[x]), g24(pix1_24[x]), b24(pix1_24[x])); + } + } + } + break; + case 32: + for(y = 0; y < h; y++) + { + pix1_32 = scanline32(f1, y); + pix2_32 = scanline32(f2, y); + for(x = 0; x < w; x++) + { + check = 0; // start with each pixel anew + + redpix = r32(pix2_32[x]); + greenpix = g32(pix2_32[x]); + bluepix = b32(pix2_32[x]); + if ((redpix>=(red-rf))&&(redpix<=(red+rf))&&(greenpix>=(green-gf))&&(greenpix<=(green+gf))&&(bluepix>=(blue-bf))&&(bluepix<=(blue+bf))) + { + check = 1; // mask it + } + if ((redpix<(red-rfl))||(redpix>(red+rfl))&&(greenpix<(green-gfl))||(greenpix>(green+gfl))&&(bluepix<(blue-bfl))||(bluepix>(blue+bfl))) + { + check = 2; // target it + } + + if (!check) + { + lum = (redpix + greenpix + bluepix) / 3.0; + keylum = (red + blue + green) / 3.0; + lowfuzz = (rf + gf + bf) / 3.0; + if (lowfuzz < 0.0) lowfuzz = 0.0; + highfuzz = (rf + gf + bf) / 3.0; + if (highfuzz > 1.0) highfuzz = 1.0; + lowfloor = keylum - ((rfl + gfl + bfl) / 3.0); + if (lowfloor < 0.0) lowfloor = 0.; + highfloor = keylum + (rfl + gfl + bfl) / 3.0; + if (highfloor > 1.0) highfloor = 1.0; + if (lum < keylum) + { + coeff = ((lum - lowfloor) / (keylum - lowfuzz)); + } + if (lum >= keylum) + { + coeff = ((255 - lum - highfloor) / (255 - keylum - highfuzz)); + } + + rkeyed = ((float)r32(pix2_32[x]) * coeff) + ((float)r32(pix1_32[x]) * (1.0 - coeff)); + gkeyed = ((float)g32(pix2_32[x]) * coeff) + ((float)g32(pix1_32[x]) * (1.0 - coeff)); + bkeyed = ((float)b32(pix2_32[x]) * coeff) + ((float)b32(pix1_32[x]) * (1.0 - coeff)); + + pix2_32[x] = rgbtocolor32(rkeyed, gkeyed, bkeyed); + } + + if (check==1) + { // was pix3 + // pix2_32[x] = rgbtocolor32(r32(pix2_32[x]), g32(pix2_32[x]), b32(pix2_32[x])); + } + if (check==2) + { // was pix2 + pix2_32[x] = rgbtocolor32(r32(pix1_32[x]), g32(pix1_32[x]), b32(pix1_32[x])); + } + } + } + break; + } +} diff --git a/Plugins/rene.dll b/Plugins/rene.dll new file mode 100644 index 0000000..d5fb95b Binary files /dev/null and b/Plugins/rene.dll differ diff --git a/Plugins/rgbavg.c b/Plugins/rgbavg.c new file mode 100644 index 0000000..c903ab1 --- /dev/null +++ b/Plugins/rgbavg.c @@ -0,0 +1,654 @@ +// 242.rgbavg -- does funky pixel averaging on an input image. +// by r. luke dubois (luke@music.columbia.edu), +// computer music center, columbia university, 2001. +// +// Pd / Framestein port by Olaf Matthes , June 2002 +// +// objects and source are provided without warranty of any kind, express or implied. +// +// usage: rgbavg +// + +#include +#include +#include +#include "plugin.h" + +#pragma warning( disable : 4761 ) // that's why it's funky !! + +void perform_effect(struct frame f, struct args a) +{ + short x,y; + long red, green, blue; + short alpha, mode = 0; + byte bits = f.pixelformat/8; + long redpix, greenpix, bluepix; + pixel16 *c16; + pixel24 *c24; + pixel32 *c32; + char *t; + + // get params + if(!a.s) return; + red = atoi(a.s); + if(!(t = strstr(a.s, " "))) return; + green = atoi(t+1); + if(!(t = strstr(t+1, " "))) return; + blue = atoi(t+1); + if(!(t = strstr(t+1, " "))) return; + mode = atoi(t+1); // mode=0 = bypass + + printf("rgbavg: %d %d %d - %d\n", red, green, blue, mode); + + // perform routines do different pixel averagings in the main loop + switch (mode) + { + case 1: // output: color / (sum of other two colors) + switch (f.pixelformat) + { + case 16: + for(y = 0; y < f.height; y++) + { + c16 = scanline16(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r16(c16[x]) + red; + greenpix = g16(c16[x]) + green; + bluepix = b16(c16[x]) + blue; + c16[x] = rgbtocolor16(klamp255(redpix/(greenpix+bluepix)), + klamp255(greenpix/(redpix+bluepix)), + klamp255(bluepix/(redpix+greenpix))); + } + } + break; + case 24: + for(y = 0; y < f.height; y++) + { + c24 = scanline24(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r24(c24[x]) + red; + greenpix = g24(c24[x]) + green; + bluepix = b24(c24[x]) + blue; + c24[x] = rgbtocolor24(klamp255(redpix/(greenpix+bluepix)), + klamp255(greenpix/(redpix+bluepix)), + klamp255(bluepix/(redpix+greenpix))); + } + } + break; + case 32: + for(y = 0; y < f.height; y++) + { + c32 = scanline32(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r32(c32[x]) + red; + greenpix = g32(c32[x]) + green; + bluepix = b32(c32[x]) + blue; + c32[x] = rgbtocolor32(klamp255(redpix/(greenpix+bluepix)), + klamp255(greenpix/(redpix+bluepix)), + klamp255(bluepix/(redpix+greenpix))); + } + } + break; + } + break; + case 2: // output: (sum of two colors) / third color + switch (f.pixelformat) + { + case 16: + for(y = 0; y < f.height; y++) + { + c16 = scanline16(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r16(c16[x]) + red; + greenpix = g16(c16[x]) + green; + bluepix = b16(c16[x]) + blue; + c16[x] = rgbtocolor16(klamp255((greenpix+bluepix)/redpix), + klamp255((redpix+bluepix)/greenpix), + klamp255((redpix+greenpix)/bluepix)); + } + } + break; + case 24: + for(y = 0; y < f.height; y++) + { + c24 = scanline24(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r24(c24[x]) + red; + greenpix = g24(c24[x]) + green; + bluepix = b24(c24[x]) + blue; + c24[x] = rgbtocolor24(klamp255((greenpix+bluepix)/redpix), + klamp255((redpix+bluepix)/greenpix), + klamp255((redpix+greenpix)/bluepix)); + } + } + break; + case 32: + for(y = 0; y < f.height; y++) + { + c32 = scanline32(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r32(c32[x]) + red; + greenpix = g32(c32[x]) + green; + bluepix = b32(c32[x]) + blue; + c32[x] = rgbtocolor32(klamp255((greenpix+bluepix)/redpix), + klamp255((redpix+bluepix)/greenpix), + klamp255((redpix+greenpix)/bluepix)); + } + } + break; + } + break; + case 3: // output: color / (sum of other two colors) + color(input) + switch (f.pixelformat) + { + case 16: + for(y = 0; y < f.height; y++) + { + c16 = scanline16(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r16(c16[x]) + 1; + greenpix = g16(c16[x]) + 1; + bluepix = b16(c16[x]) + 1; + c16[x] = rgbtocolor16(klamp255(redpix/(greenpix+bluepix) + red), + klamp255(greenpix/(redpix+bluepix) + green), + klamp255(bluepix/(redpix+greenpix) + blue)); + } + } + break; + case 24: + for(y = 0; y < f.height; y++) + { + c24 = scanline24(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r24(c24[x]) + 1; + greenpix = g24(c24[x]) + 1; + bluepix = b24(c24[x]) + 1; + c24[x] = rgbtocolor24(klamp255(redpix/(greenpix+bluepix) + red), + klamp255(greenpix/(redpix+bluepix) + green), + klamp255(bluepix/(redpix+greenpix) + blue)); + } + } + break; + case 32: + for(y = 0; y < f.height; y++) + { + c32 = scanline32(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r32(c32[x]) + 1; + greenpix = g32(c32[x]) + 1; + bluepix = b32(c32[x]) + 1; + c32[x] = rgbtocolor32(klamp255(redpix/(greenpix+bluepix) + red), + klamp255(greenpix/(redpix+bluepix) + green), + klamp255(bluepix/(redpix+greenpix) + blue)); + } + } + break; + } + break; + case 4: + switch (f.pixelformat) + { + case 16: + for(y = 0; y < f.height; y++) + { + c16 = scanline16(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r16(c16[x]) + 1; + greenpix = g16(c16[x]) + 1; + bluepix = b16(c16[x]) + 1; + c16[x] = rgbtocolor16(klamp255(((greenpix*green)+(bluepix*blue))/redpix), + klamp255(((redpix*red)+(bluepix*blue))/greenpix), + klamp255(((redpix*red)+(greenpix*green))/bluepix)); + } + } + break; + case 24: + for(y = 0; y < f.height; y++) + { + c24 = scanline24(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r24(c24[x]) + 1; + greenpix = g24(c24[x]) + 1; + bluepix = b24(c24[x]) + 1; + c24[x] = rgbtocolor24(klamp255(((greenpix*green)+(bluepix*blue))/redpix), + klamp255(((redpix*red)+(bluepix*blue))/greenpix), + klamp255(((redpix*red)+(greenpix*green))/bluepix)); + } + } + break; + case 32: + for(y = 0; y < f.height; y++) + { + c32 = scanline32(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r32(c32[x]) + 1; + greenpix = g32(c32[x]) + 1; + bluepix = b32(c32[x]) + 1; + c32[x] = rgbtocolor32(klamp255(((greenpix*green)+(bluepix*blue))/redpix), + klamp255(((redpix*red)+(bluepix*blue))/greenpix), + klamp255(((redpix*red)+(greenpix*green))/bluepix)); + } + } + break; + } + break; + case 5: + switch (f.pixelformat) + { + case 16: + for(y = 0; y < f.height; y++) + { + c16 = scanline16(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r16(c16[x]) + 1; + greenpix = g16(c16[x]) + 1; + bluepix = b16(c16[x]) + 1; + c16[x] = rgbtocolor16(klamp255(((greenpix*green)+(bluepix*blue))/(redpix*red)), + klamp255(((redpix*red)+(bluepix*blue))/(greenpix*green)), + klamp255(((redpix*red)+(greenpix*green))/(bluepix*blue))); + } + } + break; + case 24: + for(y = 0; y < f.height; y++) + { + c24 = scanline24(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r24(c24[x]) + 1; + greenpix = g24(c24[x]) + 1; + bluepix = b24(c24[x]) + 1; + c24[x] = rgbtocolor24(klamp255(((greenpix*green)+(bluepix*blue))/(redpix*red)), + klamp255(((redpix*red)+(bluepix*blue))/(greenpix*green)), + klamp255(((redpix*red)+(greenpix*green))/(bluepix*blue))); + } + } + break; + case 32: + for(y = 0; y < f.height; y++) + { + c32 = scanline32(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r32(c32[x]) + 1; + greenpix = g32(c32[x]) + 1; + bluepix = b32(c32[x]) + 1; + c32[x] = rgbtocolor32(klamp255(((greenpix*green)+(bluepix*blue))/(redpix*red)), + klamp255(((redpix*red)+(bluepix*blue))/(greenpix*green)), + klamp255(((redpix*red)+(greenpix*green))/(bluepix*blue))); + } + } + break; + } + break; + case 6: + switch (f.pixelformat) + { + case 16: + for(y = 0; y < f.height; y++) + { + c16 = scanline16(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r16(c16[x]) + 1; + greenpix = g16(c16[x]) + 1; + bluepix = b16(c16[x]) + 1; + c16[x] = rgbtocolor16(klamp255((redpix*red)/(greenpix*green)+(bluepix*blue)), + klamp255((greenpix*green)/(redpix*red)+(bluepix*blue)), + klamp255((bluepix*blue)/(redpix*red)+(greenpix*green))); + } + } + break; + case 24: + for(y = 0; y < f.height; y++) + { + c24 = scanline24(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r24(c24[x]) + 1; + greenpix = g24(c24[x]) + 1; + bluepix = b24(c24[x]) + 1; + c24[x] = rgbtocolor24(klamp255((redpix*red)/(greenpix*green)+(bluepix*blue)), + klamp255((greenpix*green)/(redpix*red)+(bluepix*blue)), + klamp255((bluepix*blue)/(redpix*red)+(greenpix*green))); + } + } + break; + case 32: + for(y = 0; y < f.height; y++) + { + c32 = scanline32(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r32(c32[x]) + 1; + greenpix = g32(c32[x]) + 1; + bluepix = b32(c32[x]) + 1; + c32[x] = rgbtocolor32(klamp255((redpix*red)/(greenpix*green)+(bluepix*blue)), + klamp255((greenpix*green)/(redpix*red)+(bluepix*blue)), + klamp255((bluepix*blue)/(redpix*red)+(greenpix*green))); + } + } + break; + } + break; + case 7: + switch (f.pixelformat) + { + case 16: + for(y = 0; y < f.height; y++) + { + c16 = scanline16(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r16(c16[x]) + red; + greenpix = g16(c16[x]) + green; + bluepix = b16(c16[x]) + blue; + c16[x] = rgbtocolor16(klamp255((redpix/(greenpix+bluepix))*red), + klamp255((greenpix/(redpix+bluepix))*green), + klamp255((bluepix/(redpix+greenpix))*blue)); + } + } + break; + case 24: + for(y = 0; y < f.height; y++) + { + c24 = scanline24(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r24(c24[x]) + red; + greenpix = g24(c24[x]) + green; + bluepix = b24(c24[x]) + blue; + c24[x] = rgbtocolor24(klamp255((redpix/(greenpix+bluepix))*red), + klamp255((greenpix/(redpix+bluepix))*green), + klamp255((bluepix/(redpix+greenpix))*blue)); + } + } + break; + case 32: + for(y = 0; y < f.height; y++) + { + c32 = scanline32(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r32(c32[x]) + red; + greenpix = g32(c32[x]) + green; + bluepix = b32(c32[x]) + blue; + c32[x] = rgbtocolor32(klamp255((redpix/(greenpix+bluepix))*red), + klamp255((greenpix/(redpix+bluepix))*green), + klamp255((bluepix/(redpix+greenpix))*blue)); + } + } + break; + } + break; + case 8: + switch (f.pixelformat) + { + case 16: + for(y = 0; y < f.height; y++) + { + c16 = scanline16(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r16(c16[x]) + red; + greenpix = g16(c16[x]) + green; + bluepix = b16(c16[x]) + blue; + c16[x] = rgbtocolor16(klamp255(((greenpix+bluepix)/redpix)*red), + klamp255(((redpix+bluepix)/greenpix)*green), + klamp255(((redpix+greenpix)/bluepix)*blue)); + + } + } + break; + case 24: + for(y = 0; y < f.height; y++) + { + c24 = scanline24(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r24(c24[x]) + red; + greenpix = g24(c24[x]) + green; + bluepix = b24(c24[x]) + blue; + c24[x] = rgbtocolor24(klamp255(((greenpix+bluepix)/redpix)*red), + klamp255(((redpix+bluepix)/greenpix)*green), + klamp255(((redpix+greenpix)/bluepix)*blue)); + } + } + break; + case 32: + for(y = 0; y < f.height; y++) + { + c32 = scanline32(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r32(c32[x]) + red; + greenpix = g32(c32[x]) + green; + bluepix = b32(c32[x]) + blue; + c32[x] = rgbtocolor32(klamp255(((greenpix+bluepix)/redpix)*red), + klamp255(((redpix+bluepix)/greenpix)*green), + klamp255(((redpix+greenpix)/bluepix)*blue)); + } + } + break; + } + break; + case 9: + switch (f.pixelformat) + { + case 16: + for(y = 0; y < f.height; y++) + { + c16 = scanline16(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r16(c16[x]) + 1; + greenpix = g16(c16[x]) + 1; + bluepix = b16(c16[x]) + 1; + c16[x] = rgbtocolor16(klamp255((red + ((greenpix+bluepix)/redpix))*red), + klamp255((green + ((redpix+bluepix)/greenpix))*green), + klamp255((blue + ((redpix+greenpix)/bluepix))*blue)); + } + } + break; + case 24: + for(y = 0; y < f.height; y++) + { + c24 = scanline24(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r24(c24[x]) + 1; + greenpix = g24(c24[x]) + 1; + bluepix = b24(c24[x]) + 1; + c24[x] = rgbtocolor24(klamp255((red + ((greenpix+bluepix)/redpix))*red), + klamp255((green + ((redpix+bluepix)/greenpix))*green), + klamp255((blue + ((redpix+greenpix)/bluepix))*blue)); + } + } + break; + case 32: + for(y = 0; y < f.height; y++) + { + c32 = scanline32(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r32(c32[x]) + 1; + greenpix = g32(c32[x]) + 1; + bluepix = b32(c32[x]) + 1; + c32[x] = rgbtocolor32(klamp255((red + ((greenpix+bluepix)/redpix))*red), + klamp255((green + ((redpix+bluepix)/greenpix))*green), + klamp255((blue + ((redpix+greenpix)/bluepix))*blue)); + } + } + break; + } + break; + case 10: + switch (f.pixelformat) + { + case 16: + for(y = 0; y < f.height; y++) + { + c16 = scanline16(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r16(c16[x]) + 1; + greenpix = g16(c16[x]) + 1; + bluepix = b16(c16[x]) + 1; + c16[x] = rgbtocolor16(klamp255((((greenpix*green)+(bluepix*blue))/redpix)*red), + klamp255((((redpix*red)+(bluepix*blue))/greenpix)*green), + klamp255((((redpix*red)+(greenpix*green))/bluepix)*blue)); + } + } + break; + case 24: + for(y = 0; y < f.height; y++) + { + c24 = scanline24(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r24(c24[x]) + 1; + greenpix = g24(c24[x]) + 1; + bluepix = b24(c24[x]) + 1; + c24[x] = rgbtocolor24(klamp255((((greenpix*green)+(bluepix*blue))/redpix)*red), + klamp255((((redpix*red)+(bluepix*blue))/greenpix)*green), + klamp255((((redpix*red)+(greenpix*green))/bluepix)*blue)); + } + } + break; + case 32: + for(y = 0; y < f.height; y++) + { + c32 = scanline32(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r32(c32[x]) + 1; + greenpix = g32(c32[x]) + 1; + bluepix = b32(c32[x]) + 1; + c32[x] = rgbtocolor32(klamp255((((greenpix*green)+(bluepix*blue))/redpix)*red), + klamp255((((redpix*red)+(bluepix*blue))/greenpix)*green), + klamp255((((redpix*red)+(greenpix*green))/bluepix)*blue)); + } + } + break; + } + break; + case 11: + switch (f.pixelformat) + { + case 16: + for(y = 0; y < f.height; y++) + { + c16 = scanline16(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r16(c16[x]) + 1; + greenpix = g16(c16[x]) + 1; + bluepix = b16(c16[x]) + 1; + c16[x] = rgbtocolor16(klamp255((((greenpix*green)+(bluepix*blue))/(redpix*red))*red), + klamp255((((redpix*red)+(bluepix*blue))/(greenpix*green))*green), + klamp255((((redpix*red)+(greenpix*green))/(bluepix*blue))*blue)); + } + } + break; + case 24: + for(y = 0; y < f.height; y++) + { + c24 = scanline24(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r24(c24[x]) + 1; + greenpix = g24(c24[x]) + 1; + bluepix = b24(c24[x]) + 1; + c24[x] = rgbtocolor24(klamp255((((greenpix*green)+(bluepix*blue))/(redpix*red))*red), + klamp255((((redpix*red)+(bluepix*blue))/(greenpix*green))*green), + klamp255((((redpix*red)+(greenpix*green))/(bluepix*blue))*blue)); + } + } + break; + case 32: + for(y = 0; y < f.height; y++) + { + c32 = scanline32(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r32(c32[x]) + 1; + greenpix = g32(c32[x]) + 1; + bluepix = b32(c32[x]) + 1; + c32[x] = rgbtocolor32(klamp255((((greenpix*green)+(bluepix*blue))/(redpix*red))*red), + klamp255((((redpix*red)+(bluepix*blue))/(greenpix*green))*green), + klamp255((((redpix*red)+(greenpix*green))/(bluepix*blue))*blue)); + } + } + break; + } + break; + case 12: + switch (f.pixelformat) + { + case 16: + for(y = 0; y < f.height; y++) + { + c16 = scanline16(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r16(c16[x]) + 1; + greenpix = g16(c16[x]) + 1; + bluepix = b16(c16[x]) + 1; + c16[x] = rgbtocolor16(klamp255(((redpix*red)/(greenpix*green)+(bluepix*blue))*red), + klamp255(((greenpix*green)/(redpix*red)+(bluepix*blue))*green), + klamp255(((bluepix*blue)/(redpix*red)+(greenpix*green))*blue)); + } + } + break; + case 24: + for(y = 0; y < f.height; y++) + { + c24 = scanline24(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r24(c24[x]) + 1; + greenpix = g24(c24[x]) + 1; + bluepix = b24(c24[x]) + 1; + c24[x] = rgbtocolor24(klamp255(((redpix*red)/(greenpix*green)+(bluepix*blue))*red), + klamp255(((greenpix*green)/(redpix*red)+(bluepix*blue))*green), + klamp255(((bluepix*blue)/(redpix*red)+(greenpix*green))*blue)); + } + } + break; + case 32: + for(y = 0; y < f.height; y++) + { + c32 = scanline32(f, y); + for(x = 0; x < f.width; x++) + { + redpix = r32(c32[x]) + 1; + greenpix = g32(c32[x]) + 1; + bluepix = b32(c32[x]) + 1; + c32[x] = rgbtocolor32(klamp255(((redpix*red)/(greenpix*green)+(bluepix*blue))*red), + klamp255(((greenpix*green)/(redpix*red)+(bluepix*blue))*green), + klamp255(((bluepix*blue)/(redpix*red)+(greenpix*green))*blue)); + } + } + break; + } + break; + } + +} + +void perform_copy(struct frame f1, struct frame f2, struct args a) +{ + printf("Using rgbavg as copy operation does nothing!\n"); +} diff --git a/Plugins/rgbavg.dll b/Plugins/rgbavg.dll new file mode 100644 index 0000000..8b5fe70 Binary files /dev/null and b/Plugins/rgbavg.dll differ diff --git a/Plugins/rgbavg02.c b/Plugins/rgbavg02.c new file mode 100644 index 0000000..5fc773e --- /dev/null +++ b/Plugins/rgbavg02.c @@ -0,0 +1,799 @@ +// 242.rgbavg02 -- does 2-source funky pixel averaging. +// by r. luke dubois (luke@music.columbia.edu), +// computer music center, columbia university, 2001. +// +// Pd / Framestein port by Olaf Matthes , June 2002 +// +// objects and source are provided without warranty of any kind, express or implied. +// +// usage: rgbavg +// + +#include +#include +#include +#include "plugin.h" + +#pragma warning( disable : 4761 ) // that's why it's funky !! + +void perform_effect(struct frame f1, struct frame f2, struct args a) +{ + printf("Using rgbavg as effect does nothing!\n"); +} + +void perform_copy(struct frame f1, struct frame f2, struct args a) +{ + short x,y, h, w; + long red, green, blue; + short alpha, mode; + long redpix, greenpix, bluepix, rp, gp, bp; + pixel16 *c1_16, *c2_16; + pixel24 *c1_24, *c2_24; + pixel32 *c1_32, *c2_32; + char *t; + + // get params + if(!a.s) return; + red = atoi(a.s); + if(!(t = strstr(a.s, " "))) return; + green = atoi(t+1); + if(!(t = strstr(t+1, " "))) return; + blue = atoi(t+1); + if(!(t = strstr(t+1, " "))) return; + mode = atoi(t+1); // mode=0 = bypass + + printf("rgbavg: %d %d %d - %d\n", red, green, blue, mode); + + w = f1.width, June 2002 +// +// objects and source are provided without warranty of any kind, express or implied. +// +// usage: rgbseek +// +// return: 1 if color exists in frame, 0 if not +// + +#include +#include +#include "plugin.h" + +void perform_effect(struct frame f, struct args a) +{ + int x,y; + byte red = 0, green = 0, blue = 0, check = 0, rf = 0, gf = 0, bf = 0; + byte bits = f.pixelformat/8; + byte redpix, greenpix, bluepix; // the color values + pixel16 c16; + pixel24 c24; + pixel32 c32; + char *ret_check; // returns the result + char *t; + + // get r g b and fuzzi params + if(!a.s) return; + red = atoi(a.s); + if(!(t = strstr(a.s, " "))) return; + green = atoi(t+1); + if(!(t = strstr(t+1, " "))) return; + blue = atoi(t+1); + if(!(t = strstr(t+1, " "))) return; + rf = atoi(t+1); + if(!(t = strstr(t+1, " "))) return; + gf = atoi(t+1); + if(!(t = strstr(t+1, " "))) return; + bf = atoi(t+1); + + printf("rgbseek: %d %d %d\n", red, green, blue); + + // get returnvaluereceivenames + if(!(t = strstr(t+1, " "))) return; + ret_check = t+1; + t[0]=0; + + for(y = 0; y < f.height; y++) + { + for(x = 0; x < f.width; x++) + { + switch (f.pixelformat) + { + case 16: + c16 = scanline16(f, y)[x]; + redpix = r16(c16); + greenpix = g16(c16); + bluepix = b16(c16); + break; + case 24: + c24 = scanline24(f, y)[x]; + redpix = r24(c24); + greenpix = g24(c24); + bluepix = b24(c24); + break; + case 32: + c32 = scanline32(f, y)[x]; + redpix = r32(c32); + greenpix = g32(c32); + bluepix = b32(c32); + break; + } + if ((redpix>=(red-rf))&&(redpix<=(red+rf))&&(greenpix>=(green-gf))&&(greenpix<=(green+gf))&&(bluepix>=(blue-bf))&&(bluepix<=(blue+bf))) + { + check = 1; // found the color, let's get outta here + goto done; + } + } + } + check = 0; // didn't find the color + +done: + // return-values: + // + // framestein will send data given in the form "pd_receiver_name=value" + // back to pd. + + sprintf(a.ret, "%s=%d", ret_check, check); +} + +void perform_copy(struct frame f1, struct frame f2, struct args a) +{ + printf("Using rgbseek as copy operation does nothing!\n"); +} diff --git a/Plugins/rgbseek.dll b/Plugins/rgbseek.dll new file mode 100644 index 0000000..151b10c Binary files /dev/null and b/Plugins/rgbseek.dll differ diff --git a/Plugins/traffic.c b/Plugins/traffic.c new file mode 100644 index 0000000..be2dbba --- /dev/null +++ b/Plugins/traffic.c @@ -0,0 +1,106 @@ +// 242.traffic -- does tristimulus matrix operations on an input image. +// by r. luke dubois (luke@music.columbia.edu), +// computer music center, columbia university, 2001. +// +// Pd / Framestein port by Olaf Matthes , June 2002 +// +// objects and source are provided without warranty of any kind, express or implied. +// + +#include +#include +#include +#include +#include "plugin.h" + +// tristimulus product used for matrix conversions + +static void tristimulus_product(float *matrix, byte *input, byte *output) +{ + int f, g; + for(f = 0; f < 3; f++) + { + output[f] = (byte)input[0]*matrix[f*3+0]+ + input[1]*matrix[f*3+1]+ + input[2]*matrix[f*3+2]; + } +} + + +void perform_effect(struct frame f, struct args a) +{ + int i, x, y; + float matrix[9]; + byte bits = f.pixelformat/8; + byte input[3], output[3]; // the color values + byte r, g, b; + pixel16 *c16; + pixel24 *c24; + pixel32 *c32; + char *t; + + // get matrix params + if(!a.s) return; + matrix[0] = atof(a.s); + for(i = 1; i < 9; i++) + { + if(!(t = strstr(t+1, " "))) return; + matrix[i] = atof(t+1); + } + + printf("traffic: matrix: %d %d %d\n" + " %d %d %d\n" + " %d %d %d\n", matrix[0], matrix[1], matrix[2], + matrix[3], matrix[4], matrix[5], matrix[6], matrix[7], matrix[8]); + + for(y = 0; y < f.height; y++) + { + for(x = 0; x < f.width; x++) + { + switch (f.pixelformat) + { + case 16: + c16 = scanline16(f, y); + input[0] = r16(c16[x]); + input[1] = g16(c16[x]); + input[2] = b16(c16[x]); + tristimulus_product(matrix,input,output); + r = output[0]; + g = output[1]; + b = output[2]; + + c16[x] = rgbtocolor16(r, g, b); + break; + case 24: + c24 = scanline24(f, y); + input[0] = r24(c24[x]); + input[1] = g24(c24[x]); + input[2] = b24(c24[x]); + tristimulus_product(matrix,input,output); + r = output[0]; + g = output[1]; + b = output[2]; + + c24[x] = rgbtocolor24(r, g, b); + break; + case 32: + c32 = scanline32(f, y); + input[0] = r32(c32[x]); + input[1] = g32(c32[x]); + input[2] = b32(c32[x]); + tristimulus_product(matrix,input,output); + r = output[0]; + g = output[1]; + b = output[2]; + + c32[x] = rgbtocolor32(r, g, b); + break; + } + } + } +} + +void perform_copy(struct frame f1, struct frame f2, struct args a) +{ + printf("Using traffic as copy operation does nothing!\n"); +} diff --git a/Plugins/traffic.dll b/Plugins/traffic.dll new file mode 100644 index 0000000..f6bacce Binary files /dev/null and b/Plugins/traffic.dll differ -- cgit v1.2.1