From 4f59db9ca17630a0289a953574303b77fccb46ff Mon Sep 17 00:00:00 2001 From: Peter Schlaile Date: Sun, 5 Feb 2006 19:04:12 +0000 Subject: 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. --- release/plugins/sequence/color-correction-hsv.c | 279 ++++++++++++++++++++++++ release/plugins/sequence/color-correction-yuv.c | 220 +++++++++++++++++++ release/plugins/sequence/dnr.c | 149 +++++++++++++ release/plugins/sequence/gamma.c | 133 +++++++++++ 4 files changed, 781 insertions(+) create mode 100644 release/plugins/sequence/color-correction-hsv.c create mode 100644 release/plugins/sequence/color-correction-yuv.c create mode 100644 release/plugins/sequence/dnr.c create mode 100644 release/plugins/sequence/gamma.c (limited to 'release') 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 + +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 + +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 + +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 + +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++; + } + } +} -- cgit v1.2.3