Credit Andrew for build mods and cineform format
[goodguy/cinelerra.git] / cinelerra-5.1 / plugins / huesaturation / huesaturation.C
1
2 /*
3  * CINELERRA
4  * Copyright (C) 2008 Adam Williams <broadcast at earthling dot net>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  *
20  */
21
22 #include "bccolors.h"
23 #include "bcdisplayinfo.h"
24 #include "clip.h"
25 #include "bchash.h"
26 #include "filexml.h"
27 #include "huesaturation.h"
28 #include "guicast.h"
29 #include "language.h"
30 #include "loadbalance.h"
31 #include "bccolors.h"
32 #include "playback3d.h"
33 #include "pluginvclient.h"
34 #include "theme.h"
35 #include "vframe.h"
36
37 #include <stdint.h>
38 #include <string.h>
39
40
41
42 REGISTER_PLUGIN(HueEffect)
43
44
45
46
47
48 HueConfig::HueConfig()
49 {
50         reset(RESET_ALL);
51 }
52
53 void HueConfig::reset(int clear)
54 {
55         switch(clear) {
56                 case RESET_HUV : hue = 0;
57                         break;
58                 case RESET_SAT : saturation = 0;
59                         break;
60                 case RESET_VAL : value = 0;
61                         break;
62                 case RESET_ALL :
63                 default:
64                         hue = saturation = value = 0;
65                         break;
66         }
67 }
68
69 void HueConfig::copy_from(HueConfig &src)
70 {
71         hue = src.hue;
72         saturation = src.saturation;
73         value = src.value;
74 }
75 int HueConfig::equivalent(HueConfig &src)
76 {
77         return EQUIV(hue, src.hue) &&
78                 EQUIV(saturation, src.saturation) &&
79                 EQUIV(value, src.value);
80 }
81 void HueConfig::interpolate(HueConfig &prev,
82         HueConfig &next,
83         long prev_frame,
84         long next_frame,
85         long current_frame)
86 {
87         double next_scale = (double)(current_frame - prev_frame) / (next_frame - prev_frame);
88         double prev_scale = (double)(next_frame - current_frame) / (next_frame - prev_frame);
89
90         this->hue = prev.hue * prev_scale + next.hue * next_scale;
91         this->saturation = prev.saturation * prev_scale + next.saturation * next_scale;
92         this->value = prev.value * prev_scale + next.value * next_scale;
93 }
94
95
96
97
98
99
100 /* SATURATION VALUES
101   saturation is stored    from -100.00  to +100.00
102   saturation_slider  goes from -100.00  to +100.00
103   saturation_caption goes from    0.000 to   +2.000 (clear to +1.000)
104   saturation_text    goes from -100.00  to +100.00
105 */
106 /* VALUE VALUES
107   value is stored    from -100.00  to +100.00
108   value_slider  goes from -100.00  to +100.00
109   value_caption goes from    0.000 to   +2.000 (clear to +1.000)
110   value_text    goes from -100.00  to +100.00
111 */
112
113 HueText::HueText(HueEffect *plugin, HueWindow *gui, int x, int y)
114  : BC_TumbleTextBox(gui, plugin->config.hue,
115         (float)MINHUE, (float)MAXHUE, x, y, xS(60), 2)
116 {
117         this->gui = gui;
118         this->plugin = plugin;
119         set_increment(0.01);
120 }
121
122 HueText::~HueText()
123 {
124 }
125
126 int HueText::handle_event()
127 {
128         float min = MINHUE, max = MAXHUE;
129         float output = atof(get_text());
130         if(output > max) output = max;
131         if(output < min) output = min;
132         plugin->config.hue = output;
133         gui->hue_slider->update(plugin->config.hue);
134         plugin->send_configure_change();
135         return 1;
136 }
137
138 HueSlider::HueSlider(HueEffect *plugin, HueWindow *gui, int x, int y, int w)
139  : BC_FSlider(x, y, 0, w, w,
140         (float)MINHUE, (float)MAXHUE,
141         plugin->config.hue)
142 {
143         this->plugin = plugin;
144         this->gui = gui;
145         enable_show_value(0); // Hide caption
146 }
147 int HueSlider::handle_event()
148 {
149         plugin->config.hue = get_value();
150         gui->hue_text->update(plugin->config.hue);
151         plugin->send_configure_change();
152         return 1;
153 }
154
155
156 SaturationText::SaturationText(HueEffect *plugin, HueWindow *gui, int x, int y)
157  : BC_TumbleTextBox(gui, plugin->config.saturation,
158         (float)MINSATURATION, (float)MAXSATURATION, x, y, xS(60), 2)
159 {
160         this->gui = gui;
161         this->plugin = plugin;
162         set_increment(0.01);
163 }
164
165 SaturationText::~SaturationText()
166 {
167 }
168
169 int SaturationText::handle_event()
170 {
171         float min = MINSATURATION, max = MAXSATURATION;
172         float output = atof(get_text());
173         if(output > max) output = max;
174         if(output < min) output = min;
175         plugin->config.saturation = output;
176         gui->sat_slider->update(plugin->config.saturation);
177         plugin->send_configure_change();
178         return 1;
179 }
180
181 SaturationSlider::SaturationSlider(HueEffect *plugin, HueWindow *gui, int x, int y, int w)
182  : BC_FSlider(x, y, 0, w, w,
183         (float)MINSATURATION, (float)MAXSATURATION,
184         plugin->config.saturation)
185 {
186         this->plugin = plugin;
187         this->gui = gui;
188         enable_show_value(0); // Hide caption
189 }
190 int SaturationSlider::handle_event()
191 {
192         plugin->config.saturation = get_value();
193         gui->sat_text->update(plugin->config.saturation);
194         plugin->send_configure_change();
195         return 1;
196 }
197
198 char* SaturationSlider::get_caption()
199 {
200         float fraction = ((float)plugin->config.saturation - MINSATURATION) /
201                 MAXSATURATION;
202         sprintf(string, "%0.4f", fraction);
203         return string;
204 }
205
206
207 ValueText::ValueText(HueEffect *plugin, HueWindow *gui, int x, int y)
208  : BC_TumbleTextBox(gui, plugin->config.value,
209         (float)MINVALUE, (float)MAXVALUE, x, y, xS(60), 2)
210 {
211         this->gui = gui;
212         this->plugin = plugin;
213         set_increment(0.01);
214 }
215
216 ValueText::~ValueText()
217 {
218 }
219
220 int ValueText::handle_event()
221 {
222         float min = MINVALUE, max = MAXVALUE;
223         float output = atof(get_text());
224         if(output > max) output = max;
225         if(output < min) output = min;
226         plugin->config.value = output;
227         gui->value_slider->update(plugin->config.value);
228         plugin->send_configure_change();
229         return 1;
230 }
231
232 ValueSlider::ValueSlider(HueEffect *plugin, HueWindow *gui, int x, int y, int w)
233  : BC_FSlider(x, y, 0, w, w,
234         (float)MINVALUE, (float)MAXVALUE,
235         plugin->config.value)
236 {
237         this->plugin = plugin;
238         this->gui = gui;
239         enable_show_value(0); // Hide caption
240 }
241 int ValueSlider::handle_event()
242 {
243         plugin->config.value = get_value();
244         gui->value_text->update(plugin->config.value);
245         plugin->send_configure_change();
246         return 1;
247 }
248
249 char* ValueSlider::get_caption()
250 {
251         float fraction = ((float)plugin->config.value - MINVALUE) / MAXVALUE;
252         sprintf(string, "%0.4f", fraction);
253         return string;
254 }
255
256
257 HueReset::HueReset(HueEffect *plugin, HueWindow *gui, int x, int y)
258  : BC_GenericButton(x, y, _("Reset"))
259 {
260         this->plugin = plugin;
261         this->gui = gui;
262 }
263 HueReset::~HueReset()
264 {
265 }
266 int HueReset::handle_event()
267 {
268         plugin->config.reset(RESET_ALL); // clear=0 ==> reset all
269         gui->update_gui(RESET_ALL);
270         plugin->send_configure_change();
271         return 1;
272 }
273
274
275 HueClr::HueClr(HueEffect *plugin, HueWindow *gui, int x, int y, int clear)
276  : BC_Button(x, y, plugin->get_theme()->get_image_set("reset_button"))
277 {
278         this->plugin = plugin;
279         this->gui = gui;
280         this->clear = clear;
281 }
282 HueClr::~HueClr()
283 {
284 }
285 int HueClr::handle_event()
286 {
287         // clear==1 ==> Hue
288         // clear==2 ==> Saturation
289         // clear==3 ==> Value
290         plugin->config.reset(clear);
291         gui->update_gui(clear);
292         plugin->send_configure_change();
293         return 1;
294 }
295
296
297
298
299 HueWindow::HueWindow(HueEffect *plugin)
300  : PluginClientWindow(plugin, xS(420), yS(160), xS(420), yS(160), 0)
301 {
302         this->plugin = plugin;
303 }
304 void HueWindow::create_objects()
305 {
306         int xs10 = xS(10), xs200 = xS(200);
307         int ys10 = yS(10), ys30 = yS(30), ys40 = yS(40);
308         int x = xs10, y = ys10;
309         int x2 = xS(80), x3 = xS(180);
310         int clr_x = get_w()-x - xS(22); // note: clrBtn_w = 22
311
312         BC_Bar *bar;
313
314 // Hue
315         y += ys10;
316         add_subwindow(new BC_Title(x, y, _("Hue:")));
317         hue_text = new HueText(plugin, this, (x + x2), y);
318         hue_text->create_objects();
319         add_subwindow(hue_slider = new HueSlider(plugin, this, x3, y, xs200));
320         clr_x = x3 + hue_slider->get_w() + x;
321         add_subwindow(hue_clr = new HueClr(plugin, this, clr_x, y, RESET_HUV));
322         y += ys30;
323
324 // Saturation
325         add_subwindow(new BC_Title(x, y, _("Saturation:")));
326         sat_text = new SaturationText(plugin, this, (x + x2), y);
327         sat_text->create_objects();
328         add_subwindow(sat_slider = new SaturationSlider(plugin, this, x3, y, xs200));
329         add_subwindow(sat_clr = new HueClr(plugin, this, clr_x, y, RESET_SAT));
330         y += ys30;
331
332 // Value
333         add_subwindow(new BC_Title(x, y, _("Value:")));
334         value_text = new ValueText(plugin, this, (x + x2), y);
335         value_text->create_objects();
336         add_subwindow(value_slider = new ValueSlider(plugin, this, x3, y, xs200));
337         add_subwindow(value_clr = new HueClr(plugin, this, clr_x, y, RESET_VAL));
338         y += ys40;
339
340 // Reset section
341         add_subwindow(bar = new BC_Bar(x, y, get_w()-2*x));
342         y += ys10;
343         add_subwindow(reset = new HueReset(plugin, this, x, y));
344         show_window();
345         flush();
346 }
347
348
349 // for Reset button
350 void HueWindow::update_gui(int clear)
351 {
352         switch(clear) {
353                 case RESET_HUV :
354                         hue_text->update(plugin->config.hue);
355                         hue_slider->update(plugin->config.hue);
356                         break;
357                 case RESET_SAT :
358                         sat_text->update(plugin->config.saturation);
359                         sat_slider->update(plugin->config.saturation);
360                         break;
361                 case RESET_VAL :
362                         value_text->update(plugin->config.value);
363                         value_slider->update(plugin->config.value);
364                         break;
365                 case RESET_ALL :
366                 default:
367                         hue_text->update(plugin->config.hue);
368                         hue_slider->update(plugin->config.hue);
369                         sat_text->update(plugin->config.saturation);
370                         sat_slider->update(plugin->config.saturation);
371                         value_text->update(plugin->config.value);
372                         value_slider->update(plugin->config.value);
373                         break;
374         }
375 }
376
377
378
379
380
381
382
383
384 HueEngine::HueEngine(HueEffect *plugin, int cpus)
385  : LoadServer(cpus, cpus)
386 {
387         this->plugin = plugin;
388 }
389 void HueEngine::init_packages()
390 {
391         for(int i = 0; i < LoadServer::get_total_packages(); i++)
392         {
393                 HuePackage *pkg = (HuePackage*)get_package(i);
394                 pkg->row1 = plugin->input->get_h() * i / LoadServer::get_total_packages();
395                 pkg->row2 = plugin->input->get_h() * (i + 1) / LoadServer::get_total_packages();
396         }
397 }
398 LoadClient* HueEngine::new_client()
399 {
400         return new HueUnit(plugin, this);
401 }
402 LoadPackage* HueEngine::new_package()
403 {
404         return new HuePackage;
405 }
406
407
408
409
410
411
412
413
414 HuePackage::HuePackage()
415  : LoadPackage()
416 {
417 }
418
419 HueUnit::HueUnit(HueEffect *plugin, HueEngine *server)
420  : LoadClient(server)
421 {
422         this->plugin = plugin;
423 }
424
425
426
427
428
429
430
431 #define HUESATURATION(type, max, components, use_yuv) \
432 { \
433         float h_offset = plugin->config.hue; \
434         float s_offset = ((float)plugin->config.saturation - MINSATURATION) / MAXSATURATION; \
435         float v_offset = ((float)plugin->config.value - MINVALUE) / MAXVALUE; \
436         for(int i = pkg->row1; i < pkg->row2; i++) \
437         { \
438                 type* in_row = (type*)plugin->input->get_rows()[i]; \
439                 type* out_row = (type*)plugin->output->get_rows()[i]; \
440  \
441                 for(int j = 0; j < w; j++) \
442                 { \
443                         float h, s, va; \
444                         int y, u, v; \
445                         float r, g, b; \
446                         int r_i, g_i, b_i; \
447  \
448                         if(use_yuv) \
449                         { \
450                                 y = (int)in_row[0]; \
451                                 u = (int)in_row[1]; \
452                                 v = (int)in_row[2]; \
453                                 if(max == 0xffff) \
454                                         YUV::yuv.yuv_to_rgb_16(r_i, g_i, b_i, y, u, v); \
455                                 else \
456                                         YUV::yuv.yuv_to_rgb_8(r_i, g_i, b_i, y, u, v); \
457                                 HSV::rgb_to_hsv((float)r_i / max, \
458                                         (float)g_i / max, \
459                                         (float)b_i / max, \
460                                         h, \
461                                         s, \
462                                         va); \
463                         } \
464                         else \
465                         { \
466                                 r = (float)in_row[0] / max; \
467                                 g = (float)in_row[1] / max; \
468                                 b = (float)in_row[2] / max; \
469                                 HSV::rgb_to_hsv(r, g, b, h, s, va); \
470                         } \
471  \
472  \
473                         h += h_offset; \
474                         s *= s_offset; \
475                         va *= v_offset; \
476  \
477                         if(h >= 360) h -= 360; \
478                         if(h < 0) h += 360; \
479                         if(sizeof(type) < 4) \
480                         { \
481                                 if(s > 1) s = 1; \
482                                 if(va > 1) va = 1; \
483                                 if(s < 0) s = 0; \
484                                 if(va < 0) va = 0; \
485                         } \
486  \
487                         if(use_yuv) \
488                         { \
489                                 HSV::hsv_to_yuv(y, u, v, h, s, va, max); \
490                                 out_row[0] = y; \
491                                 out_row[1] = u; \
492                                 out_row[2] = v; \
493                         } \
494                         else \
495                         { \
496                                 HSV::hsv_to_rgb(r, g, b, h, s, va); \
497                                 if(sizeof(type) < 4) \
498                                 { \
499                                         r *= max; \
500                                         g *= max; \
501                                         b *= max; \
502                                         out_row[0] = (type)CLIP(r, 0, max); \
503                                         out_row[1] = (type)CLIP(g, 0, max); \
504                                         out_row[2] = (type)CLIP(b, 0, max); \
505                                 } \
506                                 else \
507                                 { \
508                                         out_row[0] = (type)r; \
509                                         out_row[1] = (type)g; \
510                                         out_row[2] = (type)b; \
511                                 } \
512                         } \
513  \
514                         in_row += components; \
515                         out_row += components; \
516                 } \
517         } \
518 }
519
520
521 void HueUnit::process_package(LoadPackage *package)
522 {
523         HuePackage *pkg = (HuePackage*)package;
524         int w = plugin->input->get_w();
525
526         switch(plugin->input->get_color_model())
527         {
528                 case BC_RGB888:
529                         HUESATURATION(unsigned char, 0xff, 3, 0)
530                         break;
531
532                 case BC_RGB_FLOAT:
533                         HUESATURATION(float, 1, 3, 0)
534                         break;
535
536                 case BC_YUV888:
537                         HUESATURATION(unsigned char, 0xff, 3, 1)
538                         break;
539
540                 case BC_RGB161616:
541                         HUESATURATION(uint16_t, 0xffff, 3, 0)
542                         break;
543
544                 case BC_YUV161616:
545                         HUESATURATION(uint16_t, 0xffff, 3, 1)
546                         break;
547
548                 case BC_RGBA_FLOAT:
549                         HUESATURATION(float, 1, 4, 0)
550                         break;
551
552                 case BC_RGBA8888:
553                         HUESATURATION(unsigned char, 0xff, 4, 0)
554                         break;
555
556                 case BC_YUVA8888:
557                         HUESATURATION(unsigned char, 0xff, 4, 1)
558                         break;
559
560                 case BC_RGBA16161616:
561                         HUESATURATION(uint16_t, 0xffff, 4, 0)
562                         break;
563
564                 case BC_YUVA16161616:
565                         HUESATURATION(uint16_t, 0xffff, 4, 1)
566                         break;
567
568         }
569 }
570
571
572
573
574
575
576 HueEffect::HueEffect(PluginServer *server)
577  : PluginVClient(server)
578 {
579         engine = 0;
580
581 }
582 HueEffect::~HueEffect()
583 {
584
585         if(engine) delete engine;
586 }
587
588 int HueEffect::process_buffer(VFrame *frame,
589         int64_t start_position,
590         double frame_rate)
591 {
592         load_configuration();
593
594         read_frame(frame,
595                 0,
596                 start_position,
597                 frame_rate,
598                 get_use_opengl());
599
600
601         this->input = frame;
602         this->output = frame;
603         if(EQUIV(config.hue, 0) && EQUIV(config.saturation, 0) && EQUIV(config.value, 0))
604         {
605                 return 0;
606         }
607         else
608         {
609                 if(get_use_opengl())
610                 {
611                         run_opengl();
612                         return 0;
613                 }
614
615                 if(!engine) engine = new HueEngine(this, PluginClient::smp + 1);
616
617                 engine->process_packages();
618         }
619         return 0;
620 }
621
622 const char* HueEffect::plugin_title() { return N_("Hue saturation"); }
623 int HueEffect::is_realtime() { return 1; }
624
625 NEW_WINDOW_MACRO(HueEffect, HueWindow)
626 LOAD_CONFIGURATION_MACRO(HueEffect, HueConfig)
627
628
629 void HueEffect::save_data(KeyFrame *keyframe)
630 {
631         FileXML output;
632         output.set_shared_output(keyframe->xbuf);
633         output.tag.set_title("HUESATURATION");
634         output.tag.set_property("HUE", config.hue);
635         output.tag.set_property("SATURATION", config.saturation);
636         output.tag.set_property("VALUE", config.value);
637         output.append_tag();
638         output.tag.set_title("/HUESATURATION");
639         output.append_tag();
640         output.append_newline();
641         output.terminate_string();
642 }
643 void HueEffect::read_data(KeyFrame *keyframe)
644 {
645         FileXML input;
646         input.set_shared_input(keyframe->xbuf);
647         while(!input.read_tag())
648         {
649                 if(input.tag.title_is("HUESATURATION"))
650                 {
651                         config.hue = input.tag.get_property("HUE", config.hue);
652                         config.saturation = input.tag.get_property("SATURATION", config.saturation);
653                         config.value = input.tag.get_property("VALUE", config.value);
654                 }
655         }
656 }
657 void HueEffect::update_gui()
658 {
659         if(thread)
660         {
661                 ((HueWindow*)thread->window)->lock_window();
662                 load_configuration();
663                 ((HueWindow*)thread->window)->hue_text->update(config.hue);
664                 ((HueWindow*)thread->window)->hue_slider->update(config.hue);
665                 ((HueWindow*)thread->window)->sat_text->update(config.saturation);
666                 ((HueWindow*)thread->window)->sat_slider->update(config.saturation);
667                 ((HueWindow*)thread->window)->value_text->update(config.value);
668                 ((HueWindow*)thread->window)->value_slider->update(config.value);
669                 ((HueWindow*)thread->window)->unlock_window();
670         }
671 }
672
673 int HueEffect::handle_opengl()
674 {
675 #ifdef HAVE_GL
676         const char *yuv_saturation_frag =
677                 "uniform sampler2D tex;\n"
678                 "uniform float s_offset;\n"
679                 "uniform float v_offset;\n"
680                 "void main()\n"
681                 "{\n"
682                 "       vec4 pixel = texture2D(tex, gl_TexCoord[0].st);\n"
683                 "       pixel.r *= v_offset;\n"
684                 "       pixel.gb -= vec2(0.5, 0.5);\n"
685                 "       pixel.g *= s_offset;\n"
686                 "       pixel.b *= s_offset;\n"
687                 "       pixel.gb += vec2(0.5, 0.5);\n"
688                 "       gl_FragColor = pixel;\n"
689                 "}\n";
690
691
692         const char *yuv_frag =
693                 "uniform sampler2D tex;\n"
694                 "uniform float h_offset;\n"
695                 "uniform float s_offset;\n"
696                 "uniform float v_offset;\n"
697                 "void main()\n"
698                 "{\n"
699                 "       vec4 pixel = texture2D(tex, gl_TexCoord[0].st);\n"
700                         YUV_TO_RGB_FRAG("pixel")
701                         RGB_TO_HSV_FRAG("pixel")
702                 "       pixel.r += h_offset;\n"
703                 "       pixel.g *= s_offset;\n"
704                 "       pixel.b *= v_offset;\n"
705                 "       if(pixel.r >= 360.0) pixel.r -= 360.0;\n"
706                 "       if(pixel.r < 0.0) pixel.r += 360.0;\n"
707                         HSV_TO_RGB_FRAG("pixel")
708                         RGB_TO_YUV_FRAG("pixel")
709                 "       gl_FragColor = pixel;\n"
710                 "}\n";
711
712         const char *rgb_frag =
713                 "uniform sampler2D tex;\n"
714                 "uniform float h_offset;\n"
715                 "uniform float s_offset;\n"
716                 "uniform float v_offset;\n"
717                 "void main()\n"
718                 "{\n"
719                 "       vec4 pixel = texture2D(tex, gl_TexCoord[0].st);\n"
720                         RGB_TO_HSV_FRAG("pixel")
721                 "       pixel.r += h_offset;\n"
722                 "       pixel.g *= s_offset;\n"
723                 "       pixel.b *= v_offset;\n"
724                 "       if(pixel.r >= 360.0) pixel.r -= 360.0;\n"
725                 "       if(pixel.r < 0.0) pixel.r += 360.0;\n"
726                         HSV_TO_RGB_FRAG("pixel")
727                 "       gl_FragColor = pixel;\n"
728                 "}\n";
729
730
731         get_output()->to_texture();
732         get_output()->enable_opengl();
733
734         const char *shader_stack[16];
735         memset(shader_stack,0, sizeof(shader_stack));
736         int current_shader = 0;
737
738         int need_color_matrix = BC_CModels::is_yuv(get_output()->get_color_model()) ? 1 : 0;
739         if( need_color_matrix ) shader_stack[current_shader++] = bc_gl_colors;
740         shader_stack[current_shader++] = !need_color_matrix ? rgb_frag :
741                 EQUIV(config.hue, 0) ? yuv_saturation_frag: yuv_frag ;
742
743         shader_stack[current_shader] = 0;
744         unsigned int shader = VFrame::make_shader(shader_stack);
745         if(shader > 0) {
746                 glUseProgram(shader);
747                 glUniform1i(glGetUniformLocation(shader, "tex"), 0);
748                 glUniform1f(glGetUniformLocation(shader, "h_offset"), config.hue);
749                 glUniform1f(glGetUniformLocation(shader, "s_offset"),
750                         ((float)config.saturation - MINSATURATION) / MAXSATURATION);
751                 glUniform1f(glGetUniformLocation(shader, "v_offset"),
752                         ((float)config.value - MINVALUE) / MAXVALUE);
753                 if( need_color_matrix ) BC_GL_COLORS(shader);
754         }
755
756         get_output()->init_screen();
757         get_output()->bind_texture(0);
758         get_output()->draw_texture();
759         glUseProgram(0);
760         get_output()->set_opengl_state(VFrame::SCREEN);
761 #endif
762         return 0;
763 }
764
765
766
767
768