Add several usefull sequencer-plugins:
authorPeter Schlaile <peter@schlaile.de>
Sun, 5 Feb 2006 19:04:12 +0000 (19:04 +0000)
committerPeter Schlaile <peter@schlaile.de>
Sun, 5 Feb 2006 19:04:12 +0000 (19:04 +0000)
- 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.

release/plugins/sequence/color-correction-hsv.c [new file with mode: 0644]
release/plugins/sequence/color-correction-yuv.c [new file with mode: 0644]
release/plugins/sequence/dnr.c [new file with mode: 0644]
release/plugins/sequence/gamma.c [new file with mode: 0644]

diff --git a/release/plugins/sequence/color-correction-hsv.c b/release/plugins/sequence/color-correction-hsv.c
new file mode 100644 (file)
index 0000000..2e57c6f
--- /dev/null
@@ -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 (file)
index 0000000..c68d78c
--- /dev/null
@@ -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 (file)
index 0000000..7e7c168
--- /dev/null
@@ -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 (file)
index 0000000..828e2fd
--- /dev/null
@@ -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++;
+               }
+       }
+}