Add several usefull sequencer-plugins:

- color-correction-hsv & color-correction-yuv
  Do color correction in HSV or YUV-space, rather sophisticated but slow.
  You can control setup, gain and gamma and saturation (seperated by
  shadows, midtones and highlights).
- gamma
  a simple RGB-Gamma plugin, but very fast.
- dnr
  Dynamic Noise Reduction (plugin ported from VirtualDub).
  This helps mpeg encoding alot, by ignoring noise /movement
  below a given threshold between frames.
  It is also a lot faster than the original VirtualDub-plugin preserving
  it's quality.

4 files changed, 781 insertions, 0 deletions

diff --git a/release/plugins/sequence/color-correction-hsv.c b/release/plugins/sequence/color-correction-hsv.c
new file mode 100644
index 00000000000..2e57c6f0f48
--- /dev/null
+++ b/release/plugins/sequence/color-correction-hsv.c
@@ -0,0 +1,279 @@
+/*
+ * Color Correction Plugin (YUV Version) 0.01
+ *
+ * Copyright (c) 2005 Peter Schlaile
+ *
+ * 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.
+ *
+ */
+
+#include "math.h"
+#include "plugin.h"
+#include <stdio.h>
+
+char name[]= "Color Correction";
+
+VarStruct varstr[]= {
+	{ NUMSLI|FLO, "St Y:", 0.0,	-1.0,	1.0, "Setup Y"}, 
+	{ NUMSLI|FLO, "Gn Y:",  1.0,	0.0,	10.0,"Gain Y"},
+	{ NUMSLI|FLO, "Ga Y:", 1.0,	0.0,	10.0, "Gamma Y"},
+
+	{ NUMSLI|FLO, "Lo S:",  1.0,	0.0,	10.0,"Saturation Shadows"},
+	{ NUMSLI|FLO, "Md S:",  1.0,	0.0,	10.0,"Saturation Midtones"},
+	{ NUMSLI|FLO, "Hi S:",  1.0,	0.0,	10.0,"Saturation Highlights"},
+
+	{ NUMSLI|FLO, "MA S:",  1.0,	0.0,	10.0,"Master Saturation"}, 
+
+	{ NUMSLI|FLO, "Lo T:",  0.25, 0.0, 1.0,
+	  "Saturation Shadow Thres"}, 
+	{ NUMSLI|FLO, "Hi T:",  0.75, 0.0, 1.0,
+	  "Saturation Highlights Thres"}, 
+	{ TOG|INT,	"Debug", 0.0,	0.0,	1.0,   
+	  "Show curves as overlay."}, 
+};
+
+typedef struct Cast {
+	float setup_y;
+	float gain_y;
+	float gamma_y;
+	float sat_shadows;
+	float sat_midtones;
+	float sat_highlights;
+
+	float master_sat;
+	float lo_thres;
+	float hi_thres;
+	int debug;
+} Cast;
+
+float cfra;
+
+void plugin_seq_doit(Cast *, float, float, int, int, ImBuf *, ImBuf *, ImBuf *, ImBuf *);
+
+int plugin_seq_getversion(void) { return B_PLUGIN_VERSION;}
+void plugin_but_changed(int but) {}
+void plugin_init() {}
+
+void plugin_getinfo(PluginInfo *info) {
+	info->name= name;
+	info->nvars= sizeof(varstr)/sizeof(VarStruct);
+	info->cfra= &cfra;
+
+	info->varstr= varstr;
+
+	info->init= plugin_init;
+	info->seq_doit= (SeqDoit) plugin_seq_doit;
+	info->callback= plugin_but_changed;
+}
+
+static void hsv_to_rgb (double  h, double  s, double  v,
+			double *r, double *g, double *b)
+{
+	int i;
+	double f, w, q, t;
+
+	if (s == 0.0)
+		s = 0.000001;
+	
+	if (h == -1.0)
+	{
+		*r = v;
+		*g = v;
+		*b = v;
+	}
+	else
+	{
+		if (h == 360.0)
+			h = 0.0;
+		h = h / 60.0;
+		i = (int) h;
+		f = h - i;
+		w = v * (1.0 - s);
+		q = v * (1.0 - (s * f));
+		t = v * (1.0 - (s * (1.0 - f)));
+		
+		switch (i)
+		{
+		case 0:
+			*r = v;
+			*g = t;
+			*b = w;
+			break;
+		case 1:
+			*r = q;
+			*g = v;
+			*b = w;
+			break;
+		case 2:
+			*r = w;
+			*g = v;
+			*b = t;
+			break;
+		case 3:
+			*r = w;
+			*g = q;
+			*b = v;
+			break;
+		case 4:
+			*r = t;
+			*g = w;
+			*b = v;
+			break;
+		case 5:
+			*r = v;
+			*g = w;
+			*b = q;
+			break;
+		}
+	}
+}
+
+static void rgb_to_hsv (double  r, double  g, double  b,
+			double *h, double *s, double *v)
+{
+	double max, min, delta;
+
+	max = r;
+	if (g > max)
+		max = g;
+	if (b > max)
+		max = b;
+	
+	min = r;
+	if (g < min)
+		min = g;
+	if (b < min)
+		min = b;
+	
+	*v = max;
+	
+	if (max != 0.0)
+		*s = (max - min) / max;
+	else
+		*s = 0.0;
+	
+	if (*s == 0.0)
+		*h = -1.0;
+	else
+	{
+		delta = max - min;
+		
+		if (r == max)
+			*h = (g - b) / delta;
+		else if (g == max)
+			*h = 2.0 + (b - r) / delta;
+		else if (b == max)
+			*h = 4.0 + (r - g) / delta;
+		
+		*h = *h * 60.0;
+		
+		if (*h < 0.0)
+			*h = *h + 360;
+	}
+}
+
+void plugin_seq_doit(Cast *cast, float facf0, float facf1, int width, 
+	int height, ImBuf *ibuf1, ImBuf *ibuf2, ImBuf *out, ImBuf *use) {
+	char *dest, *src1, *src2;
+	int x, y, c;
+	double gamma_table[256];
+	double uv_table[256];
+	
+	if (!ibuf1) return;
+
+	dest= (char *) out->rect;
+	src1= (char *) ibuf1->rect;
+
+	for (y = 0; y < 256; y++) {
+	        float v = 1.0 * y / 255;
+		v += cast->setup_y;
+		v *= cast->gain_y;
+		v = pow(v, cast->gamma_y);
+		if ( v > 1.0) {
+			v = 1.0;
+		} else if (v < 0.0) {
+			v = 0.0;
+		}
+		gamma_table[y] = v * 255;
+	}
+
+	for (y = 0; y < 256; y++) {
+		float v = 1.0;
+		v *= cast->master_sat;
+		if (y < cast->lo_thres * 255) {
+			v *= cast->sat_shadows;
+		} else if (y > cast->hi_thres * 255) {
+			v *= cast->sat_highlights;
+		} else {
+			v *= cast->sat_midtones;
+		}
+		uv_table[y] = v;
+	}
+
+
+	for (y = 0; y < height; y++) {
+		for (x = 0; x < width; x++) {
+			double h,s,v,r,g,b;
+			double fac;
+
+			rgb_to_hsv((double) src1[0]/255.0,
+				   (double) src1[1]/255.0,
+				   (double) src1[2]/255.0,
+				   &h, &s, &v);
+			v = gamma_table[(int) (v * 255.0)] / 255.0;
+
+			fac = uv_table[(int) (255.0 * v)];
+
+			s *= fac;
+			if (s >= 1.0) {
+				s = 1.0;
+			}
+			hsv_to_rgb(h,s,v, &r, &g, &b);
+			
+			*dest++ = r*255.0;
+			*dest++ = g*255.0;
+			*dest++ = b*255.0;
+			dest++;
+
+			src1 += 4;
+		}
+	}
+
+	if (cast->debug) {
+		dest= (char *) out->rect;
+		for (c = 0; c < 10; c++) {
+			x = 0;
+			for (y = 0; y < 256; y++) {
+				char val = gamma_table[y];
+				while (x < y * width / 255) {
+					*dest++ = val;
+					*dest++ = val;
+					*dest++ = val;
+					dest++;
+					x++;
+				}
+			}
+		}
+		for (c = 0; c < 10; c++) {
+			x = 0;
+			for (y = 0; y < 256; y++) {
+				char val = uv_table[y] * 255.0/10.0;
+				while (x < y * width / 255) {
+					*dest++ = val;
+					*dest++ = val;
+					*dest++ = val;
+					dest++;
+					x++;
+				}
+			}
+		}
+	}
+}
diff --git a/release/plugins/sequence/color-correction-yuv.c b/release/plugins/sequence/color-correction-yuv.c
new file mode 100644
index 00000000000..c68d78c9fc0
--- /dev/null
+++ b/release/plugins/sequence/color-correction-yuv.c
@@ -0,0 +1,220 @@
+/*
+ * Color Correction Plugin (YUV Version) 0.01
+ *
+ * Copyright (c) 2005 Peter Schlaile
+ *
+ * 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.
+ *
+ */
+
+#include "math.h"
+#include "plugin.h"
+#include <stdio.h>
+
+char name[]= "Color Correction";
+
+VarStruct varstr[]= {
+	{ NUMSLI|FLO, "St Y:", 0.0,	-1.0,	1.0, "Setup Y"}, 
+	{ NUMSLI|FLO, "Gn Y:",  1.0,	0.0,	10.0,"Gain Y"},
+	{ NUMSLI|FLO, "Ga Y:", 1.0,	0.0,	10.0, "Gamma Y"},
+
+	{ NUMSLI|FLO, "Lo S:",  1.0,	0.0,	10.0,"Saturation Shadows"},
+	{ NUMSLI|FLO, "Md S:",  1.0,	0.0,	10.0,"Saturation Midtones"},
+	{ NUMSLI|FLO, "Hi S:",  1.0,	0.0,	10.0,"Saturation Highlights"},
+
+	{ NUMSLI|FLO, "MA S:",  1.0,	0.0,	10.0,"Master Saturation"}, 
+	{ NUMSLI|FLO, "Lo T:",  0.25, 0.0, 1.0,
+	  "Saturation Shadow Thres"}, 
+	{ NUMSLI|FLO, "Hi T:",  0.75, 0.0, 1.0,
+	  "Saturation Highlights Thres"}, 
+	{ TOG|INT,	"Debug", 0.0,	0.0,	1.0,   
+	  "Show curves as overlay."}, 
+};
+
+typedef struct Cast {
+	float setup_y;
+	float gain_y;
+	float gamma_y;
+	
+	float sat_shadows;
+	float sat_midtones;
+	float sat_highlights;
+
+	float master_sat;
+	float lo_thres;
+	float hi_thres;
+	int debug;
+} Cast;
+
+float cfra;
+
+void plugin_seq_doit(Cast *, float, float, int, int, ImBuf *, ImBuf *, ImBuf *, ImBuf *);
+
+int plugin_seq_getversion(void) { return B_PLUGIN_VERSION;}
+void plugin_but_changed(int but) {}
+void plugin_init() {}
+
+void plugin_getinfo(PluginInfo *info) {
+	info->name= name;
+	info->nvars= sizeof(varstr)/sizeof(VarStruct);
+	info->cfra= &cfra;
+
+	info->varstr= varstr;
+
+	info->init= plugin_init;
+	info->seq_doit= (SeqDoit) plugin_seq_doit;
+	info->callback= plugin_but_changed;
+}
+
+static void rgb_to_yuv(float rgb[3], float yuv[3]) {
+	yuv[0]= 0.299*rgb[0] + 0.587*rgb[1] + 0.114*rgb[2];
+	yuv[1]= 0.492*(rgb[2] - yuv[0]);
+	yuv[2]= 0.877*(rgb[0] - yuv[0]);
+	
+	/* Normalize */
+	yuv[1] /= 0.436;
+	yuv[2] /= 0.615;
+}
+
+static void yuv_to_rgb(float yuv[3], float rgb[3]) {
+	yuv[1] *= 0.436;
+	yuv[2] *= 0.615;
+
+	rgb[0] = yuv[2]/0.877 + yuv[0];
+	rgb[2] = yuv[1]/0.492 + yuv[0];
+	rgb[1] = (yuv[0] - 0.299*rgb[0] - 0.114*rgb[2]) / 0.587;
+	if (rgb[0] > 1.0) {
+		rgb[0] = 1.0;
+	}
+	if (rgb[0] < 0.0) {
+		rgb[0] = 0.0;
+	}
+	if (rgb[1] > 1.0) {
+		rgb[1] = 1.0;
+	}
+	if (rgb[1] < 0.0) {
+		rgb[1] = 0.0;
+	}
+	if (rgb[2] > 1.0) {
+		rgb[2] = 1.0;
+	}
+	if (rgb[2] < 0.0) {
+		rgb[2] = 0.0;
+	}
+}
+
+void plugin_seq_doit(Cast *cast, float facf0, float facf1, int width, 
+	int height, ImBuf *ibuf1, ImBuf *ibuf2, ImBuf *out, ImBuf *use) {
+	char *dest, *src1, *src2;
+	int x, y, c;
+	float rgb[3];
+	float yuv[3];
+	float gamma_table[256];
+	float uv_table[256];
+	
+	if (!ibuf1) return;
+
+	dest= (char *) out->rect;
+	src1= (char *) ibuf1->rect;
+
+	for (y = 0; y < 256; y++) {
+	        float v = 1.0 * y / 255;
+		v += cast->setup_y;
+		v *= cast->gain_y;
+		v = pow(v, cast->gamma_y);
+		if ( v > 1.0) {
+			v = 1.0;
+		} else if (v < 0.0) {
+			v = 0.0;
+		}
+		gamma_table[y] = v * 255;
+	}
+
+	for (y = 0; y < 256; y++) {
+		float v = 1.0;
+		v *= cast->master_sat;
+		if (y < cast->lo_thres * 255) {
+			v *= cast->sat_shadows;
+		} else if (y > cast->hi_thres * 255) {
+			v *= cast->sat_highlights;
+		} else {
+			v *= cast->sat_midtones;
+		}
+		uv_table[y] = v;
+	}
+
+
+	for (y = 0; y < height; y++) {
+		for (x = 0; x < width; x++) {
+			float fac;
+			rgb[0]= (float)src1[0]/255.0;
+			rgb[1]= (float)src1[1]/255.0;
+			rgb[2]= (float)src1[2]/255.0;
+			rgb_to_yuv(rgb, yuv);
+
+			yuv[0] = gamma_table[(int) (yuv[0] * 255.0)] / 255.0;
+			fac = uv_table[(int) (255.0 * yuv[0])];
+
+			yuv[1] = yuv[1] * fac;
+			yuv[2] = yuv[2] * fac;
+			if (yuv[1] > 1.0) {
+				yuv[1] = 1.0;
+			}
+			if (yuv[1] < -1.0) {
+				yuv[1] = -1.0;
+			}
+			if (yuv[2] > 1.0) {
+				yuv[2] = 1.0;
+			}
+			if (yuv[2] < -1.0) {
+				yuv[2] = -1.0;
+			}
+			yuv_to_rgb(yuv, rgb);
+			
+			*dest++ = rgb[0]*255.0;
+			*dest++ = rgb[1]*255.0;
+			*dest++ = rgb[2]*255.0;
+			dest++;
+
+			src1 += 4;
+		}
+	}
+
+	if (cast->debug) {
+		dest= (char *) out->rect;
+		for (c = 0; c < 10; c++) {
+			x = 0;
+			for (y = 0; y < 256; y++) {
+				char val = gamma_table[y];
+				while (x < y * width / 255) {
+					*dest++ = val;
+					*dest++ = val;
+					*dest++ = val;
+					dest++;
+					x++;
+				}
+			}
+		}
+		for (c = 0; c < 10; c++) {
+			x = 0;
+			for (y = 0; y < 256; y++) {
+				char val = uv_table[y] * 255.0/10.0;
+				while (x < y * width / 255) {
+					*dest++ = val;
+					*dest++ = val;
+					*dest++ = val;
+					dest++;
+					x++;
+				}
+			}
+		}
+	}
+}
diff --git a/release/plugins/sequence/dnr.c b/release/plugins/sequence/dnr.c
new file mode 100644
index 00000000000..7e7c168750e
--- /dev/null
+++ b/release/plugins/sequence/dnr.c
@@ -0,0 +1,149 @@
+/*
+ * Dynamic Noise Reduction (based on the VirtualDub filter by Steven Don)
+ *
+ * Copyright (c) 2005 Peter Schlaile 
+ *
+ * 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.
+ *
+ */
+
+#include "math.h"
+#include "plugin.h"
+#include <stdio.h>
+
+char name[]= "Dynamic Noise Reduction";
+
+VarStruct varstr[]= {
+	{ NUMSLI|INT, "Level:", 10.0,	0.0,	15.0, "Level"}, 
+};
+
+typedef struct Cast {
+	int level;
+} Cast;
+
+float cfra;
+void * plugin_private_data;
+
+struct my_data {
+	unsigned char lookup_table[65536];
+	int last_level;
+	float last_cfra;
+	int last_width;
+	int last_height;
+	unsigned char * last_frame;
+};
+
+void plugin_seq_doit(Cast *, float, float, int, int, 
+		     ImBuf *, ImBuf *, ImBuf *, ImBuf *);
+
+int plugin_seq_getversion(void) { return B_PLUGIN_VERSION;}
+
+static void precalculate(unsigned char * table, int level)
+{
+	int ap_, bp;
+
+	for (ap_ = 0; ap_ < 256; ap_++) {
+		for (bp = 0; bp < 256; bp++) {
+			int ap = ap_;
+			int diff = ap - bp;
+			if (diff < 0) {
+				diff = -diff;
+			}
+			if (diff < level) {
+				if (diff > (level >> 1)) {
+					ap = (ap + ap + bp)/3;
+				} else {
+					ap = bp;
+				}
+			}
+		
+			*table++ = ap;
+                }
+	}
+}
+
+void plugin_but_changed(int but) { }
+void plugin_init() { }
+
+void * plugin_seq_alloc_private_data()
+{
+	struct my_data * result = (struct my_data*) calloc(
+		sizeof(struct my_data), 1);
+	result->last_cfra = -1;
+	return result;
+}
+
+void plugin_seq_free_private_data(void * data)
+{
+	struct my_data * d = (struct my_data*) data;
+	if (d->last_frame) {
+		free(d->last_frame);
+	}
+	free(d);
+}
+
+void plugin_getinfo(PluginInfo *info) {
+	info->name= name;
+	info->nvars= sizeof(varstr)/sizeof(VarStruct);
+	info->cfra= &cfra;
+
+	info->varstr= varstr;
+
+	info->init= plugin_init;
+	info->seq_doit= (SeqDoit) plugin_seq_doit;
+	info->callback= plugin_but_changed;
+}
+
+static void doit(unsigned char * src_, unsigned char * dst_,
+		 unsigned char * table, int width, int height)
+{
+	int count = width * height;
+	unsigned char * src = src_;
+	unsigned char * dst = dst_;
+
+	while (count--) {
+		*dst++ = table[(*src++ << 8) | *dst];
+		*dst++ = table[(*src++ << 8) | *dst];
+		*dst++ = table[(*src++ << 8) | *dst];
+		*dst++ = *src++;
+	}
+
+	memcpy(src_, dst_, width * height * 4);
+}
+
+void plugin_seq_doit(Cast *cast, float facf0, float facf1, int width, 
+	int height, ImBuf *ibuf1, ImBuf *ibuf2, ImBuf *out, ImBuf *use) {
+
+	struct my_data * d = (struct my_data*) plugin_private_data;
+
+	if (!ibuf1) return;
+
+	if (cast->level != d->last_level) {
+		precalculate(d->lookup_table, cast->level);
+		d->last_level = cast->level;
+	}
+
+	if (width != d->last_width || height != d->last_height
+	    || cfra != d->last_cfra + 1) {
+		free(d->last_frame);
+		d->last_frame = (unsigned char*) calloc(width * height, 4);
+		
+		d->last_width = width;
+		d->last_height = height;
+	}
+
+	memcpy(out->rect, ibuf1->rect, width * height * 4);
+
+	doit((unsigned char*) out->rect, 
+	     d->last_frame, d->lookup_table, width, height);
+	
+	d->last_cfra = cfra;
+}
diff --git a/release/plugins/sequence/gamma.c b/release/plugins/sequence/gamma.c
new file mode 100644
index 00000000000..828e2fd8841
--- /dev/null
+++ b/release/plugins/sequence/gamma.c
@@ -0,0 +1,133 @@
+/*
+ * Gamma Correction Plugin (RGB Version) 0.01
+ *
+ * Copyright (c) 2005 Peter Schlaile
+ *
+ * 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.
+ *
+ */
+
+#include "math.h"
+#include "plugin.h"
+#include <stdio.h>
+
+char name[]= "Gamma Correction";
+
+VarStruct varstr[]= {
+	{ NUMSLI|FLO, "St M:", 0.0,	-1.0,	1.0, "Setup Main"}, 
+	{ NUMSLI|FLO, "Gn M:",  1.0,	0.0,	10.0,"Gain Main"},
+	{ NUMSLI|FLO, "Ga M:", 1.0,	0.0,	10.0, "Gamma Main"},
+
+	{ NUMSLI|FLO, "St R:", 0.0,	-1.0,	1.0, "Setup Red"}, 
+	{ NUMSLI|FLO, "Gn R:",  1.0,	0.0,	10.0,"Gain Red"},
+	{ NUMSLI|FLO, "Ga R:", 1.0,	0.0,	10.0, "Gamma Red"},
+
+	{ NUMSLI|FLO, "St G:", 0.0,	-1.0,	1.0, "Setup Green"}, 
+	{ NUMSLI|FLO, "Gn G:",  1.0,	0.0,	10.0,"Gain Green"},
+	{ NUMSLI|FLO, "Ga G:", 1.0,	0.0,	10.0, "Gamma Green"},
+
+	{ NUMSLI|FLO, "St B:", 0.0,	-1.0,	1.0, "Setup Blue"}, 
+	{ NUMSLI|FLO, "Gn B:",  1.0,	0.0,	10.0,"Gain Blue"},
+	{ NUMSLI|FLO, "Ga B:", 1.0,	0.0,	10.0, "Gamma Blue"},
+};
+
+typedef struct Cast {
+	float setup_m;
+	float gain_m;
+	float gamma_m;
+
+	float setup_r;
+	float gain_r;
+	float gamma_r;
+
+	float setup_g;
+	float gain_g;
+	float gamma_g;
+
+	float setup_b;
+	float gain_b;
+	float gamma_b;
+} Cast;
+
+float cfra;
+
+void plugin_seq_doit(Cast *, float, float, int, int, ImBuf *, ImBuf *, ImBuf *, ImBuf *);
+
+int plugin_seq_getversion(void) { return B_PLUGIN_VERSION;}
+void plugin_but_changed(int but) {}
+void plugin_init() {}
+
+void plugin_getinfo(PluginInfo *info) {
+	info->name= name;
+	info->nvars= sizeof(varstr)/sizeof(VarStruct);
+	info->cfra= &cfra;
+
+	info->varstr= varstr;
+
+	info->init= plugin_init;
+	info->seq_doit= (SeqDoit) plugin_seq_doit;
+	info->callback= plugin_but_changed;
+}
+
+static void make_gamma_table(float setup, float gain, float gamma,
+			     unsigned char * table)
+{
+	int y;
+
+	for (y = 0; y < 256; y++) {
+	        float v = 1.0 * y / 255;
+		v += setup;
+		v *= gain;
+		v = pow(v, gamma);
+		if ( v > 1.0) {
+			v = 1.0;
+		} else if (v < 0.0) {
+			v = 0.0;
+		}
+		table[y] = v * 255;
+	}
+
+}
+
+void plugin_seq_doit(Cast *cast, float facf0, float facf1, int width, 
+	int height, ImBuf *ibuf1, ImBuf *ibuf2, ImBuf *out, ImBuf *use) {
+	char *dest, *src1, *src2;
+	int x, y, c;
+	float rgb[3];
+	float yuv[3];
+	unsigned char gamma_table_m[256];
+	unsigned char gamma_table_r[256];
+	unsigned char gamma_table_g[256];
+	unsigned char gamma_table_b[256];
+	
+	if (!ibuf1) return;
+
+	dest= (char *) out->rect;
+	src1= (char *) ibuf1->rect;
+
+	make_gamma_table(cast->setup_m, cast->gain_m, cast->gamma_m,
+			 gamma_table_m);
+	make_gamma_table(cast->setup_r, cast->gain_r, cast->gamma_r,
+			 gamma_table_r);
+	make_gamma_table(cast->setup_g, cast->gain_g, cast->gamma_g,
+			 gamma_table_g);
+	make_gamma_table(cast->setup_b, cast->gain_b, cast->gamma_b,
+			 gamma_table_b);
+
+	for (y = 0; y < height; y++) {
+		for (x = 0; x < width; x++) {
+			*dest++ = gamma_table_r[gamma_table_m[*src1++]];
+			*dest++ = gamma_table_g[gamma_table_m[*src1++]];
+			*dest++ = gamma_table_b[gamma_table_m[*src1++]];
+			dest++; src1++;
+		}
+	}
+}