fixes for colorpicker loops/deadlocks, add mask smooth_buttons, rm orig mask_smooth
[goodguy/cinelerra.git] / cinelerra-5.1 / plugins / chromakey / chromakey.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 "bcsignals.h"
25 #include "chromakey.h"
26 #include "clip.h"
27 #include "bchash.h"
28 #include "filexml.h"
29 #include "guicast.h"
30 #include "keyframe.h"
31 #include "language.h"
32 #include "loadbalance.h"
33 #include "playback3d.h"
34 #include "bccolors.h"
35 #include "pluginvclient.h"
36 #include "vframe.h"
37
38 #include <stdint.h>
39 #include <string.h>
40
41
42
43 ChromaKeyConfig::ChromaKeyConfig()
44 {
45        reset();
46 }
47
48 void ChromaKeyConfig::reset()
49
50 {
51         red = 0.0;
52         green = 0.0;
53         blue = 0.0;
54         threshold = 60.0;
55         use_value = 0;
56         slope = 100;
57 }
58
59
60 void ChromaKeyConfig::copy_from(ChromaKeyConfig &src)
61 {
62         red = src.red;
63         green = src.green;
64         blue = src.blue;
65         threshold = src.threshold;
66         use_value = src.use_value;
67         slope = src.slope;
68 }
69
70 int ChromaKeyConfig::equivalent(ChromaKeyConfig &src)
71 {
72         return (EQUIV(red, src.red) &&
73                 EQUIV(green, src.green) &&
74                 EQUIV(blue, src.blue) &&
75                 EQUIV(threshold, src.threshold) &&
76                 EQUIV(slope, src.slope) &&
77                 use_value == src.use_value);
78 }
79
80 void ChromaKeyConfig::interpolate(ChromaKeyConfig &prev,
81         ChromaKeyConfig &next,
82         int64_t prev_frame,
83         int64_t next_frame,
84         int64_t current_frame)
85 {
86         double next_scale = (double)(current_frame - prev_frame) / (next_frame - prev_frame);
87         double prev_scale = (double)(next_frame - current_frame) / (next_frame - prev_frame);
88
89         this->red = prev.red * prev_scale + next.red * next_scale;
90         this->green = prev.green * prev_scale + next.green * next_scale;
91         this->blue = prev.blue * prev_scale + next.blue * next_scale;
92         this->threshold = prev.threshold * prev_scale + next.threshold * next_scale;
93         this->slope = prev.slope * prev_scale + next.slope * next_scale;
94         this->use_value = prev.use_value;
95 }
96
97 int ChromaKeyConfig::get_color()
98 {
99         int red = (int)(CLIP(this->red, 0, 1) * 0xff);
100         int green = (int)(CLIP(this->green, 0, 1) * 0xff);
101         int blue = (int)(CLIP(this->blue, 0, 1) * 0xff);
102         return (red << 16) | (green << 8) | blue;
103 }
104
105
106
107
108
109
110
111 ChromaKeyWindow::ChromaKeyWindow(ChromaKey *plugin)
112  : PluginClientWindow(plugin,
113         320,
114         220,
115         320,
116         220,
117         0)
118 {
119         this->plugin = plugin;
120         color_thread = 0;
121 }
122
123 ChromaKeyWindow::~ChromaKeyWindow()
124 {
125         delete color_thread;
126 }
127
128 void ChromaKeyWindow::create_objects()
129 {
130         int x = 10, y = 10, x1 = 100;
131
132         BC_Title *title;
133         add_subwindow(title = new BC_Title(x, y, _("Color:")));
134         x += title->get_w() + 10;
135         add_subwindow(color = new ChromaKeyColor(plugin, this, x, y));
136         x += color->get_w() + 10;
137         add_subwindow(sample = new BC_SubWindow(x, y, 100, 50));
138         y += sample->get_h() + 10;
139         x = 10;
140
141         add_subwindow(new BC_Title(x, y, _("Slope:")));
142         add_subwindow(slope = new ChromaKeySlope(plugin, x1, y));
143
144         y += 30;
145         add_subwindow(new BC_Title(x, y, _("Threshold:")));
146         add_subwindow(threshold = new ChromaKeyThreshold(plugin, x1, y));
147
148
149         y += 30;
150         add_subwindow(use_value = new ChromaKeyUseValue(plugin, x1, y));
151
152         y += 30;
153         add_subwindow(use_colorpicker = new ChromaKeyUseColorPicker(plugin, this, x1, y));
154
155         y += use_colorpicker->get_h() + 10;
156         add_subwindow(new ChromaKeyReset(plugin, this, x, y));
157
158         color_thread = new ChromaKeyColorThread(plugin, this);
159
160         update_sample();
161         show_window();
162         flush();
163 }
164
165 void ChromaKeyWindow::update_sample()
166 {
167         sample->set_color(plugin->config.get_color());
168         sample->draw_box(0,
169                 0,
170                 sample->get_w(),
171                 sample->get_h());
172         sample->set_color(BLACK);
173         sample->draw_rectangle(0,
174                 0,
175                 sample->get_w(),
176                 sample->get_h());
177         sample->flash();
178 }
179
180 void ChromaKeyWindow::done_event(int result)
181 {
182         color_thread->close_window();
183 }
184
185
186
187
188
189
190
191
192
193 ChromaKeyColor::ChromaKeyColor(ChromaKey *plugin,
194         ChromaKeyWindow *gui,
195         int x,
196         int y)
197  : BC_GenericButton(x,
198         y,
199         _("Color..."))
200 {
201         this->plugin = plugin;
202         this->gui = gui;
203 }
204 int ChromaKeyColor::handle_event()
205 {
206         gui->color_thread->start_window(
207                 plugin->config.get_color(),
208                 0xff);
209         return 1;
210 }
211
212
213
214
215 ChromaKeyThreshold::ChromaKeyThreshold(ChromaKey *plugin, int x, int y)
216  : BC_FSlider(x,
217                         y,
218                         0,
219                         200,
220                         200,
221                         (float)0,
222                         (float)100,
223                         plugin->config.threshold)
224 {
225         this->plugin = plugin;
226         set_precision(0.01);
227 }
228 int ChromaKeyThreshold::handle_event()
229 {
230         plugin->config.threshold = get_value();
231         plugin->send_configure_change();
232         return 1;
233 }
234
235
236 ChromaKeySlope::ChromaKeySlope(ChromaKey *plugin, int x, int y)
237  : BC_FSlider(x,
238                         y,
239                         0,
240                         200,
241                         200,
242                         (float)0,
243                         (float)100,
244                         plugin->config.slope)
245 {
246         this->plugin = plugin;
247         set_precision(0.01);
248 }
249
250 int ChromaKeySlope::handle_event()
251 {
252         plugin->config.slope = get_value();
253         plugin->send_configure_change();
254         return 1;
255 }
256
257 ChromaKeyUseValue::ChromaKeyUseValue(ChromaKey *plugin, int x, int y)
258  : BC_CheckBox(x, y, plugin->config.use_value, _("Use value"))
259 {
260         this->plugin = plugin;
261 }
262 int ChromaKeyUseValue::handle_event()
263 {
264         plugin->config.use_value = get_value();
265         plugin->send_configure_change();
266         return 1;
267 }
268
269 ChromaKeyReset::ChromaKeyReset(ChromaKey *plugin, ChromaKeyWindow *gui, int x, int y)
270  : BC_GenericButton(x, y, _("Reset"))
271 {
272         this->plugin = plugin;
273         this->gui = gui;
274 }
275
276 int ChromaKeyReset::handle_event()
277 {
278         plugin->config.reset();
279         gui->update_gui();
280         plugin->send_configure_change();
281         return 1;
282 }
283
284 ChromaKeyUseColorPicker::ChromaKeyUseColorPicker(ChromaKey *plugin,
285         ChromaKeyWindow *gui,
286         int x,
287         int y)
288  : BC_GenericButton(x, y, _("Use color picker"))
289 {
290         this->plugin = plugin;
291         this->gui = gui;
292 }
293
294 int ChromaKeyUseColorPicker::handle_event()
295 {
296         plugin->config.red = plugin->get_red();
297         plugin->config.green = plugin->get_green();
298         plugin->config.blue = plugin->get_blue();
299         gui->update_sample();
300         plugin->send_configure_change();
301         return 1;
302 }
303
304
305
306
307 ChromaKeyColorThread::ChromaKeyColorThread(ChromaKey *plugin, ChromaKeyWindow *gui)
308  : ColorPicker(1, _("Inner color"))
309 {
310         this->plugin = plugin;
311         this->gui = gui;
312 }
313
314 int ChromaKeyColorThread::handle_new_color(int output, int alpha)
315 {
316         plugin->config.red = (float)(output & 0xff0000) / 0xff0000;
317         plugin->config.green = (float)(output & 0xff00) / 0xff00;
318         plugin->config.blue = (float)(output & 0xff) / 0xff;
319         gui->update_sample();
320         plugin->send_configure_change();
321         return 1;
322 }
323
324
325
326
327
328
329
330
331
332
333 ChromaKeyServer::ChromaKeyServer(ChromaKey *plugin)
334  : LoadServer(plugin->PluginClient::smp + 1, plugin->PluginClient::smp + 1)
335 {
336         this->plugin = plugin;
337 }
338 void ChromaKeyServer::init_packages()
339 {
340         for(int i = 0; i < get_total_packages(); i++)
341         {
342                 ChromaKeyPackage *pkg = (ChromaKeyPackage*)get_package(i);
343                 pkg->y1 = plugin->input->get_h() * i / get_total_packages();
344                 pkg->y2 = plugin->input->get_h() * (i + 1) / get_total_packages();
345         }
346
347 }
348 LoadClient* ChromaKeyServer::new_client()
349 {
350         return new ChromaKeyUnit(plugin, this);
351 }
352 LoadPackage* ChromaKeyServer::new_package()
353 {
354         return new ChromaKeyPackage;
355 }
356
357
358
359 ChromaKeyPackage::ChromaKeyPackage()
360  : LoadPackage()
361 {
362 }
363
364 ChromaKeyUnit::ChromaKeyUnit(ChromaKey *plugin, ChromaKeyServer *server)
365  : LoadClient(server)
366 {
367         this->plugin = plugin;
368 }
369
370
371 void ChromaKeyUnit::process_package(LoadPackage *package)
372 {
373         ChromaKeyPackage *pkg = (ChromaKeyPackage*)package;
374
375         int w = plugin->input->get_w();
376
377         float h, s, v;
378         HSV::rgb_to_hsv(plugin->config.red,
379                 plugin->config.green,
380                 plugin->config.blue,
381                 h,
382                 s,
383                 v);
384         //float min_hue = h - plugin->config.threshold * 360 / 100;
385         //float max_hue = h + plugin->config.threshold * 360 / 100;
386
387
388 #define RGB_TO_VALUE(r, g, b) YUV::yuv.rgb_to_y_f((r),(g),(b))
389
390 #define OUTER_VARIABLES(plugin) \
391         float value = RGB_TO_VALUE(plugin->config.red, \
392                 plugin->config.green, \
393                 plugin->config.blue); \
394         float threshold = plugin->config.threshold / 100; \
395         float min_v = value - threshold; \
396         float max_v = value + threshold; \
397         float r_key = plugin->config.red; \
398         float g_key = plugin->config.green; \
399         float b_key = plugin->config.blue; \
400         int y_key, u_key, v_key; \
401         YUV::yuv.rgb_to_yuv_8( \
402                 (int)(r_key * 0xff), (int)(g_key * 0xff), (int)(b_key * 0xff), \
403                 y_key, u_key, v_key); \
404         float run = plugin->config.slope / 100; \
405         float threshold_run = threshold + run;
406
407         OUTER_VARIABLES(plugin)
408
409
410
411 #define CHROMAKEY(type, components, max, use_yuv) \
412 { \
413         for(int i = pkg->y1; i < pkg->y2; i++) \
414         { \
415                 type *row = (type*)plugin->input->get_rows()[i]; \
416  \
417                 for(int j = 0; j < w; j++) \
418                 { \
419                         float a = 1; \
420  \
421 /* Test for value in range */ \
422                         if(plugin->config.use_value) \
423                         { \
424                                 float current_value; \
425                                 if(use_yuv) \
426                                 { \
427                                         float r = (float)row[0] / max; \
428                                         current_value = r; \
429                                 } \
430                                 else \
431                                 { \
432                                         float r = (float)row[0] / max; \
433                                         float g = (float)row[1] / max; \
434                                         float b = (float)row[2] / max; \
435                                         current_value = RGB_TO_VALUE(r, g, b); \
436                                 } \
437  \
438 /* Full transparency if in range */ \
439                                 if(current_value >= min_v && current_value < max_v) \
440                                 { \
441                                         a = 0; \
442                                 } \
443                                 else \
444 /* Phased out if below or above range */ \
445                                 if(current_value < min_v) \
446                                 { \
447                                         if(min_v - current_value < run) \
448                                                 a = (min_v - current_value) / run; \
449                                 } \
450                                 else \
451                                 if(current_value - max_v < run) \
452                                         a = (current_value - max_v) / run; \
453                         } \
454                         else \
455 /* Use color cube */ \
456                         { \
457                                 float difference; \
458                                 if(use_yuv) \
459                                 { \
460                                         type y = row[0]; \
461                                         type u = row[1]; \
462                                         type v = row[2]; \
463                                         difference = sqrt(SQR(y - y_key) + \
464                                                 SQR(u - u_key) + \
465                                                 SQR(v - v_key)) / max; \
466                                 } \
467                                 else \
468                                 { \
469                                         float r = (float)row[0] / max; \
470                                         float g = (float)row[1] / max; \
471                                         float b = (float)row[2] / max; \
472                                         difference = sqrt(SQR(r - r_key) +  \
473                                                 SQR(g - g_key) + \
474                                                 SQR(b - b_key)); \
475                                 } \
476                                 if(difference < threshold) \
477                                 { \
478                                         a = 0; \
479                                 } \
480                                 else \
481                                 if(difference < threshold_run) \
482                                 { \
483                                         a = (difference - threshold) / run; \
484                                 } \
485  \
486                         } \
487  \
488 /* Multiply alpha and put back in frame */ \
489                         if(components == 4) \
490                         { \
491                                 row[3] = MIN((type)(a * max), row[3]); \
492                         } \
493                         else \
494                         if(use_yuv) \
495                         { \
496                                 row[0] = (type)(a * row[0]); \
497                                 row[1] = (type)(a * (row[1] - (max / 2 + 1)) + max / 2 + 1); \
498                                 row[2] = (type)(a * (row[2] - (max / 2 + 1)) + max / 2 + 1); \
499                         } \
500                         else \
501                         { \
502                                 row[0] = (type)(a * row[0]); \
503                                 row[1] = (type)(a * row[1]); \
504                                 row[2] = (type)(a * row[2]); \
505                         } \
506  \
507                         row += components; \
508                 } \
509         } \
510 }
511
512
513
514
515         switch(plugin->input->get_color_model())
516         {
517                 case BC_RGB_FLOAT:
518                         CHROMAKEY(float, 3, 1.0, 0);
519                         break;
520                 case BC_RGBA_FLOAT:
521                         CHROMAKEY(float, 4, 1.0, 0);
522                         break;
523                 case BC_RGB888:
524                         CHROMAKEY(unsigned char, 3, 0xff, 0);
525                         break;
526                 case BC_RGBA8888:
527                         CHROMAKEY(unsigned char, 4, 0xff, 0);
528                         break;
529                 case BC_YUV888:
530                         CHROMAKEY(unsigned char, 3, 0xff, 1);
531                         break;
532                 case BC_YUVA8888:
533                         CHROMAKEY(unsigned char, 4, 0xff, 1);
534                         break;
535                 case BC_YUV161616:
536                         CHROMAKEY(uint16_t, 3, 0xffff, 1);
537                         break;
538                 case BC_YUVA16161616:
539                         CHROMAKEY(uint16_t, 4, 0xffff, 1);
540                         break;
541         }
542
543 }
544
545
546
547
548
549 REGISTER_PLUGIN(ChromaKey)
550
551
552
553 ChromaKey::ChromaKey(PluginServer *server)
554  : PluginVClient(server)
555 {
556
557         engine = 0;
558 }
559
560 ChromaKey::~ChromaKey()
561 {
562
563         delete engine;
564 }
565
566
567 int ChromaKey::process_buffer(VFrame *frame,
568                 int64_t start_position,
569                 double frame_rate)
570 {
571 SET_TRACE
572
573         load_configuration();
574         this->input = frame;
575         this->output = frame;
576
577         read_frame(frame,
578                 0,
579                 start_position,
580                 frame_rate,
581                 get_use_opengl());
582
583         if(EQUIV(config.threshold, 0))
584         {
585                 return 1;
586         }
587         else
588         {
589                 if(get_use_opengl()) return run_opengl();
590
591                 if(!engine) engine = new ChromaKeyServer(this);
592                 engine->process_packages();
593         }
594 SET_TRACE
595
596         return 1;
597 }
598
599 const char* ChromaKey::plugin_title() { return N_("Chroma key"); }
600 int ChromaKey::is_realtime() { return 1; }
601
602 NEW_WINDOW_MACRO(ChromaKey, ChromaKeyWindow)
603
604 LOAD_CONFIGURATION_MACRO(ChromaKey, ChromaKeyConfig)
605
606
607 void ChromaKey::save_data(KeyFrame *keyframe)
608 {
609         FileXML output;
610         output.set_shared_output(keyframe->xbuf);
611         output.tag.set_title("CHROMAKEY");
612         output.tag.set_property("RED", config.red);
613         output.tag.set_property("GREEN", config.green);
614         output.tag.set_property("BLUE", config.blue);
615         output.tag.set_property("THRESHOLD", config.threshold);
616         output.tag.set_property("SLOPE", config.slope);
617         output.tag.set_property("USE_VALUE", config.use_value);
618         output.append_tag();
619         output.tag.set_title("/CHROMAKEY");
620         output.append_tag();
621         output.append_newline();
622         output.terminate_string();
623 }
624
625 void ChromaKey::read_data(KeyFrame *keyframe)
626 {
627         FileXML input;
628
629         input.set_shared_input(keyframe->xbuf);
630
631         while(!input.read_tag())
632         {
633                 if(input.tag.title_is("CHROMAKEY"))
634                 {
635                         config.red = input.tag.get_property("RED", config.red);
636                         config.green = input.tag.get_property("GREEN", config.green);
637                         config.blue = input.tag.get_property("BLUE", config.blue);
638                         config.threshold = input.tag.get_property("THRESHOLD", config.threshold);
639                         config.slope = input.tag.get_property("SLOPE", config.slope);
640                         config.use_value = input.tag.get_property("USE_VALUE", config.use_value);
641                 }
642         }
643 }
644
645
646
647 void ChromaKey::update_gui()
648 {
649         if(thread)
650         {
651                 load_configuration();
652                 thread->window->lock_window();
653                 ((ChromaKeyWindow *)(thread->window))->update_gui();
654                 thread->window->unlock_window();
655         }
656 }
657
658 void ChromaKeyWindow::update_gui()
659 {
660         ChromaKeyConfig &config = plugin->config;
661         threshold->update(config.threshold);
662         slope->update(config.slope);
663         use_value->update(config.use_value);
664         update_sample();
665 }
666
667 int ChromaKey::handle_opengl()
668 {
669 #ifdef HAVE_GL
670         OUTER_VARIABLES(this)
671
672
673
674         static const char *uniform_frag =
675                 "uniform sampler2D tex;\n"
676                 "uniform float min_v;\n"
677                 "uniform float max_v;\n"
678                 "uniform float run;\n"
679                 "uniform float threshold;\n"
680                 "uniform float threshold_run;\n"
681                 "uniform vec3 key;\n";
682
683         static const char *get_yuvvalue_frag =
684                 "float get_value(vec4 color)\n"
685                 "{\n"
686                 "       return abs(color.r);\n"
687                 "}\n";
688
689         static const char *get_rgbvalue_frag =
690                 "uniform vec3 rgb_to_y_vector;\n"
691                 "uniform float yminf;\n"
692                 "float get_value(vec4 color)\n"
693                 "{\n"
694                 "       return dot(color.rgb, rgb_to_y_vector) + yminf;\n"
695                 "}\n";
696
697         static const char *value_frag =
698                 "void main()\n"
699                 "{\n"
700                 "       vec4 color = texture2D(tex, gl_TexCoord[0].st);\n"
701                 "       float value = get_value(color);\n"
702                 "       float alpha = 1.0;\n"
703                 "\n"
704                 "       if(value >= min_v && value < max_v)\n"
705                 "               alpha = 0.0;\n"
706                 "       else\n"
707                 "       if(value < min_v)\n"
708                 "       {\n"
709                 "               if(min_v - value < run)\n"
710                 "                       alpha = (min_v - value) / run;\n"
711                 "       }\n"
712                 "       else\n"
713                 "       if(value - max_v < run)\n"
714                 "               alpha = (value - max_v) / run;\n"
715                 "\n"
716                 "       gl_FragColor = vec4(color.rgb, alpha);\n"
717                 "}\n";
718
719         static const char *cube_frag =
720                 "void main()\n"
721                 "{\n"
722                 "       vec4 color = texture2D(tex, gl_TexCoord[0].st);\n"
723                 "       float difference = length(color.rgb - key);\n"
724                 "       float alpha = 1.0;\n"
725                 "       if(difference < threshold)\n"
726                 "               alpha = 0.0;\n"
727                 "       else\n"
728                 "       if(difference < threshold_run)\n"
729                 "               alpha = (difference - threshold) / run;\n"
730                 "       gl_FragColor = vec4(color.rgb, min(color.a, alpha));\n"
731                 "}\n";
732
733
734
735         get_output()->to_texture();
736         get_output()->enable_opengl();
737         get_output()->init_screen();
738
739         const char *shader_stack[16];
740         memset(shader_stack,0, sizeof(shader_stack));
741         int current_shader = 0;
742         shader_stack[current_shader++] = uniform_frag;
743
744         switch(get_output()->get_color_model()) {
745         case BC_YUV888:
746         case BC_YUVA8888:
747                 if( config.use_value ) {
748                         shader_stack[current_shader++] = get_yuvvalue_frag;
749                         shader_stack[current_shader++] = value_frag;
750                 }
751                 else {
752                         shader_stack[current_shader++] = cube_frag;
753                 }
754                 break;
755
756         default:
757                 if(config.use_value) {
758                         shader_stack[current_shader++] = get_rgbvalue_frag;
759                         shader_stack[current_shader++] = value_frag;
760                 }
761                 else {
762                         shader_stack[current_shader++] = cube_frag;
763                 }
764                 break;
765         }
766 SET_TRACE
767
768         shader_stack[current_shader] = 0;
769         unsigned int shader = VFrame::make_shader(shader_stack);
770         if( shader > 0 ) {
771                 get_output()->bind_texture(0);
772                 glUseProgram(shader);
773                 glUniform1i(glGetUniformLocation(shader, "tex"), 0);
774                 glUniform1f(glGetUniformLocation(shader, "min_v"), min_v);
775                 glUniform1f(glGetUniformLocation(shader, "max_v"), max_v);
776                 glUniform1f(glGetUniformLocation(shader, "run"), run);
777                 glUniform1f(glGetUniformLocation(shader, "threshold"), threshold);
778                 glUniform1f(glGetUniformLocation(shader, "threshold_run"), threshold_run);
779                 if(get_output()->get_color_model() != BC_YUV888 &&
780                         get_output()->get_color_model() != BC_YUVA8888)
781                         glUniform3f(glGetUniformLocation(shader, "key"),
782                                 r_key, g_key, b_key);
783                 else
784                         glUniform3f(glGetUniformLocation(shader, "key"),
785                                 (float)y_key / 0xff, (float)u_key / 0xff, (float)v_key / 0xff);
786                 if(config.use_value)
787                         BC_GL_RGB_TO_Y(shader);
788         }
789 SET_TRACE
790
791         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
792         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
793
794         if(BC_CModels::components(get_output()->get_color_model()) == 3)
795         {
796                 glEnable(GL_BLEND);
797                 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
798                 get_output()->clear_pbuffer();
799         }
800 SET_TRACE
801
802         get_output()->draw_texture();
803
804         glUseProgram(0);
805         get_output()->set_opengl_state(VFrame::SCREEN);
806         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
807         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
808         glDisable(GL_BLEND);
809 SET_TRACE
810         return 0;
811 #endif
812 }
813