cinelerra-5.1/plugins/framefield/framefield.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 "bcdisplayinfo.h"
  23 #include "bcsignals.h"
  24 #include "bchash.h"
  25 #include "filexml.h"
  26 #include "guicast.h"
  27 #include "keyframe.h"
  28 #include "language.h"
  29 #include "pluginvclient.h"
  30 #include "transportque.inc"
  31 #include "vframe.h"
  32
  33 #include <string.h>
  34 #include <stdint.h>
  35
  36
  37 #define TOP_FIELD_FIRST 0
  38 #define BOTTOM_FIELD_FIRST 1
  39
  40 class FrameField;
  41 class FrameFieldWindow;
  42
  43
  44
  45
  46 class FrameFieldConfig
  47 {
  48 public:
  49         FrameFieldConfig();
  50         int equivalent(FrameFieldConfig &src);
  51         int field_dominance;
  52 };
  53
  54
  55
  56
  57 class FrameFieldTop : public BC_Radial
  58 {
  59 public:
  60         FrameFieldTop(FrameField *plugin, FrameFieldWindow *gui, int x, int y);
  61         int handle_event();
  62         FrameField *plugin;
  63         FrameFieldWindow *gui;
  64 };
  65
  66
  67 class FrameFieldBottom : public BC_Radial
  68 {
  69 public:
  70         FrameFieldBottom(FrameField *plugin, FrameFieldWindow *gui, int x, int y);
  71         int handle_event();
  72         FrameField *plugin;
  73         FrameFieldWindow *gui;
  74 };
  75
  76
  77 class FrameFieldDouble : public BC_CheckBox
  78 {
  79 public:
  80         FrameFieldDouble(FrameField *plugin, FrameFieldWindow *gui, int x, int y);
  81         int handle_event();
  82         FrameField *plugin;
  83         FrameFieldWindow *gui;
  84 };
  85
  86 class FrameFieldShift : public BC_CheckBox
  87 {
  88 public:
  89         FrameFieldShift(FrameField *plugin, FrameFieldWindow *gui, int x, int y);
  90         int handle_event();
  91         FrameField *plugin;
  92         FrameFieldWindow *gui;
  93 };
  94
  95 class FrameFieldAvg : public BC_CheckBox
  96 {
  97 public:
  98         FrameFieldAvg(FrameField *plugin, FrameFieldWindow *gui, int x, int y);
  99         int handle_event();
 100         FrameField *plugin;
 101         FrameFieldWindow *gui;
 102 };
 103
 104 class FrameFieldWindow : public PluginClientWindow
 105 {
 106 public:
 107         FrameFieldWindow(FrameField *plugin);
 108         void create_objects();
 109         FrameField *plugin;
 110         FrameFieldTop *top;
 111         FrameFieldBottom *bottom;
 112 };
 113
 114
 115
 116
 117
 118 class FrameField : public PluginVClient
 119 {
 120 public:
 121         FrameField(PluginServer *server);
 122         ~FrameField();
 123
 124         PLUGIN_CLASS_MEMBERS(FrameFieldConfig);
 125
 126         int process_buffer(VFrame *frame,
 127                 int64_t start_position,
 128                 double frame_rate);
 129         int is_realtime();
 130         void save_data(KeyFrame *keyframe);
 131         void read_data(KeyFrame *keyframe);
 132         void update_gui();
 133
 134 // Constructs odd or even rows from the average of the surrounding rows.
 135         void average_rows(int offset, VFrame *frame);
 136
 137         int handle_opengl();
 138
 139 // Last frame requested
 140         int64_t last_frame;
 141 // Field needed
 142         int64_t field_number;
 143 // Frame needed
 144         int64_t current_frame_number;
 145 // Frame stored
 146         int64_t src_frame_number;
 147         VFrame *src_frame;
 148
 149 // Temporary storage of input frame for OpenGL
 150         BC_Texture *src_texture;
 151 // Signal OpenGL handler a new frame was read.
 152         int new_frame;
 153 // Reading frames at a different rate requires us to store the aggregation
 154 // state when the frame isn't read.
 155         int aggregate_rgb601;
 156         int rgb601_direction;
 157 };
 158
 159
 160
 161
 162
 163
 164
 165
 166
 167 REGISTER_PLUGIN(FrameField)
 168
 169
 170
 171 FrameFieldConfig::FrameFieldConfig()
 172 {
 173         field_dominance = TOP_FIELD_FIRST;
 174 }
 175
 176 int FrameFieldConfig::equivalent(FrameFieldConfig &src)
 177 {
 178         return src.field_dominance == field_dominance;
 179 }
 180
 181
 182
 183
 184
 185
 186
 187
 188 FrameFieldWindow::FrameFieldWindow(FrameField *plugin)
 189  : PluginClientWindow(plugin,
 190         210,
 191         160,
 192         200,
 193         160,
 194         0)
 195 {
 196         this->plugin = plugin;
 197 }
 198
 199 void FrameFieldWindow::create_objects()
 200 {
 201         int x = 10, y = 10;
 202         add_subwindow(top = new FrameFieldTop(plugin, this, x, y));
 203         y += top->get_h() + 5;
 204         add_subwindow(bottom = new FrameFieldBottom(plugin, this, x, y));
 205         y += bottom->get_h() + 5;
 206         show_window();
 207         flush();
 208 }
 209
 210
 211
 212
 213
 214
 215
 216
 217
 218
 219
 220
 221 FrameFieldTop::FrameFieldTop(FrameField *plugin,
 222         FrameFieldWindow *gui,
 223         int x,
 224         int y)
 225  : BC_Radial(x,
 226         y,
 227         plugin->config.field_dominance == TOP_FIELD_FIRST,
 228         _("Top field first"))
 229 {
 230         this->plugin = plugin;
 231         this->gui = gui;
 232 }
 233
 234 int FrameFieldTop::handle_event()
 235 {
 236         plugin->config.field_dominance = TOP_FIELD_FIRST;
 237         gui->bottom->update(0);
 238         plugin->send_configure_change();
 239         return 1;
 240 }
 241
 242
 243
 244
 245
 246 FrameFieldBottom::FrameFieldBottom(FrameField *plugin,
 247         FrameFieldWindow *gui,
 248         int x,
 249         int y)
 250  : BC_Radial(x,
 251         y,
 252         plugin->config.field_dominance == BOTTOM_FIELD_FIRST,
 253         _("Bottom field first"))
 254 {
 255         this->plugin = plugin;
 256         this->gui = gui;
 257 }
 258
 259 int FrameFieldBottom::handle_event()
 260 {
 261         plugin->config.field_dominance = BOTTOM_FIELD_FIRST;
 262         gui->top->update(0);
 263         plugin->send_configure_change();
 264         return 1;
 265 }
 266
 267
 268
 269
 270
 271
 272
 273
 274
 275
 276
 277
 278
 279
 280
 281
 282
 283
 284
 285
 286
 287
 288
 289 FrameField::FrameField(PluginServer *server)
 290  : PluginVClient(server)
 291 {
 292
 293         field_number = 0;
 294         src_frame = 0;
 295         src_frame_number = -1;
 296         last_frame = -1;
 297         src_texture = 0;
 298         aggregate_rgb601 = 0;
 299         rgb601_direction = 0;
 300 }
 301
 302
 303 FrameField::~FrameField()
 304 {
 305
 306
 307         if(src_frame) delete src_frame;
 308         if(src_texture) delete src_texture;
 309 }
 310
 311
 312 // 0 - current frame field 0, prev frame field 1
 313 // 1 - current frame field 0, current frame field 1, copy current to prev
 314 // 2 - current frame field 0, prev frame field 1
 315
 316 int FrameField::process_buffer(VFrame *frame,
 317         int64_t start_position,
 318         double frame_rate)
 319 {
 320         load_configuration();
 321
 322         new_frame = 0;
 323
 324 // Calculate current field based on absolute position so the algorithm isn't
 325 // relative to where playback started.
 326         field_number = get_source_position() % 2;
 327
 328         if (get_direction() == PLAY_REVERSE)
 329         {
 330                 start_position++;
 331                 field_number = (field_number + 1) % 2;
 332         }
 333
 334
 335         current_frame_number = start_position / 2;
 336
 337         VFrame *ptr = frame;
 338         if(get_use_opengl())
 339         {
 340 // Read new frames directly into output frame for hardware
 341         }
 342         else
 343         {
 344 // Read into temporary for software
 345                 if(src_frame &&
 346                         src_frame->get_color_model() != frame->get_color_model())
 347                 {
 348                         delete src_frame;
 349                         src_frame = 0;
 350                 }
 351
 352                 if(!src_frame)
 353                 {
 354                         src_frame = new VFrame(frame->get_w(), frame->get_h(),
 355                                 frame->get_color_model(), 0);
 356                 }
 357                 ptr = src_frame;
 358         }
 359
 360
 361 // Import source frame at half frame rate
 362         if(current_frame_number != src_frame_number ||
 363 // If same frame was requested, assume it was a configuration change and reprocess.
 364                 start_position == last_frame)
 365         {
 366                 read_frame(ptr,
 367                         0,
 368                         current_frame_number,
 369                         frame_rate / 2,
 370                         get_use_opengl());
 371                 src_frame_number = current_frame_number;
 372                 new_frame = 1;
 373         }
 374
 375
 376         if(get_use_opengl())
 377         {
 378                 run_opengl();
 379                 return 0;
 380         }
 381
 382         int row_size = VFrame::calculate_bytes_per_pixel(frame->get_color_model()) *
 383                 frame->get_w();
 384
 385         unsigned char **src_rows = src_frame->get_rows();
 386         unsigned char **output_rows = frame->get_rows();
 387
 388
 389 // Even field
 390         if(field_number == 0)
 391         {
 392                 if(config.field_dominance == TOP_FIELD_FIRST)
 393                 {
 394                         for(int i = 0; i < frame->get_h() - 1; i += 2)
 395                         {
 396 // Copy even lines of src to both lines of output
 397                                 memcpy(output_rows[i],
 398                                         src_rows[i],
 399                                         row_size);
 400                         }
 401
 402 // Average empty rows
 403                         /* if(config.avg) */ average_rows(0, frame);
 404                 }
 405                 else
 406                 {
 407                         for(int i = 0; i < frame->get_h() - 1; i += 2)
 408                         {
 409 // Copy odd lines of current to both lines of output with shift up.
 410                                 memcpy(output_rows[i + 1],
 411                                         src_rows[i + 1],
 412                                         row_size);
 413                         }
 414
 415 // Average empty rows
 416                         /* if(config.avg) */ average_rows(1, frame);
 417                 }
 418         }
 419         else
 420 // Odd field
 421         {
 422                 if(config.field_dominance == TOP_FIELD_FIRST)
 423                 {
 424                         for(int i = 0; i < frame->get_h() - 1; i += 2)
 425                         {
 426 // Copy odd lines of src to both lines of output
 427                                 memcpy(output_rows[i + 1],
 428                                         src_rows[i + 1],
 429                                         row_size);
 430                         }
 431
 432 // Average empty rows
 433                         /* if(config.avg) */ average_rows(1, frame);
 434                 }
 435                 else
 436                 {
 437                         for(int i = 0; i < frame->get_h() - 1; i += 2)
 438                         {
 439 // Copy even lines of src to both lines of output.
 440                                 memcpy(output_rows[i],
 441                                         src_rows[i],
 442                                         row_size);
 443                         }
 444
 445 // Average empty rows
 446                         /* if(config.avg) */ average_rows(0, frame);
 447                 }
 448         }
 449
 450         last_frame = start_position;
 451         return 0;
 452 }
 453
 454
 455 // Averaging 2 pixels
 456 #define AVERAGE(type, temp_type, components, offset) \
 457 { \
 458         type **rows = (type**)frame->get_rows(); \
 459         int w = frame->get_w(); \
 460         int h = frame->get_h(); \
 461         int row_size = components * w; \
 462         for(int i = offset; i < h - 3; i += 2) \
 463         { \
 464                 type *row1 = rows[i]; \
 465                 type *row2 = rows[i + 1]; \
 466                 type *row3 = rows[i + 2]; \
 467                 for(int j = 0; j < row_size; j++) \
 468                 { \
 469                         temp_type sum = (temp_type)*row1++ + (temp_type)*row3++; \
 470                         *row2++ = (sum / 2); \
 471                 } \
 472         } \
 473 }
 474
 475 // Averaging 6 pixels
 476 #define AVERAGE_BAK(type, components, offset) \
 477 { \
 478         type **rows = (type**)frame->get_rows(); \
 479         int w = frame->get_w(); \
 480         int h = frame->get_h(); \
 481         int row_size = w; \
 482         for(int i = offset; i < h - 3; i += 2) \
 483         { \
 484                 type *row1 = rows[i]; \
 485                 type *row2 = rows[i + 1]; \
 486                 type *row3 = rows[i + 2]; \
 487                 int64_t sum; \
 488                 int64_t pixel1[4], pixel2[4], pixel3[4]; \
 489                 int64_t pixel4[4], pixel5[4], pixel6[4]; \
 490  \
 491 /* First pixel */ \
 492                 for(int j = 0; j < components; j++) \
 493                 { \
 494                         pixel1[j] = *row1++; \
 495                         pixel4[j] = *row3++; \
 496                         *row2++ = (pixel1[j] + pixel4[j]) >> 1; \
 497                 } \
 498  \
 499                 for(int j = 2; j < row_size; j++) \
 500                 { \
 501                         for(int k = 0; k < components; k++) \
 502                         { \
 503                                 pixel2[k] = *row1++; \
 504                                 pixel5[k] = *row3++; \
 505                         } \
 506  \
 507                         for(int k = 0; k < components; k++) \
 508                         { \
 509                                 pixel3[k] = *row1; \
 510                                 pixel6[k] = *row3; \
 511                                 *row2++ = (pixel1[k] + \
 512                                         pixel2[k] + \
 513                                         pixel3[k] + \
 514                                         pixel4[k] + \
 515                                         pixel5[k] + \
 516                                         pixel6[k]) / 6; \
 517                                 pixel1[k] = pixel2[k]; \
 518                                 pixel4[k] = pixel5[k]; \
 519                         } \
 520                 } \
 521  \
 522 /* Last pixel */ \
 523                 for(int j = 0; j < components; j++) \
 524                 { \
 525                         *row2++ = (pixel3[j] + pixel6[j]) >> 1; \
 526                 } \
 527         } \
 528 }
 529
 530 void FrameField::average_rows(int offset, VFrame *frame)
 531 {
 532 //printf("FrameField::average_rows 1 %d\n", offset);
 533         switch(frame->get_color_model())
 534         {
 535                 case BC_RGB888:
 536                 case BC_YUV888:
 537                         AVERAGE(unsigned char, int64_t, 3, offset);
 538                         break;
 539                 case BC_RGB_FLOAT:
 540                         AVERAGE(float, float, 3, offset);
 541                         break;
 542                 case BC_RGBA8888:
 543                 case BC_YUVA8888:
 544                         AVERAGE(unsigned char, int64_t, 4, offset);
 545                         break;
 546                 case BC_RGBA_FLOAT:
 547                         AVERAGE(float, float, 4, offset);
 548                         break;
 549                 case BC_RGB161616:
 550                 case BC_YUV161616:
 551                         AVERAGE(uint16_t, int64_t, 3, offset);
 552                         break;
 553                 case BC_RGBA16161616:
 554                 case BC_YUVA16161616:
 555                         AVERAGE(uint16_t, int64_t, 4, offset);
 556                         break;
 557         }
 558 }
 559
 560
 561
 562 const char* FrameField::plugin_title() { return _("Frames to fields"); }
 563 int FrameField::is_realtime() { return 1; }
 564
 565 NEW_WINDOW_MACRO(FrameField, FrameFieldWindow)
 566
 567 int FrameField::load_configuration()
 568 {
 569         KeyFrame *prev_keyframe;
 570         FrameFieldConfig old_config = config;
 571
 572         prev_keyframe = get_prev_keyframe(get_source_position());
 573         read_data(prev_keyframe);
 574
 575         return !old_config.equivalent(config);
 576 }
 577
 578
 579 void FrameField::save_data(KeyFrame *keyframe)
 580 {
 581         FileXML output;
 582
 583 // cause data to be stored directly in text
 584         output.set_shared_output(keyframe->get_data(), MESSAGESIZE);
 585         output.tag.set_title("FRAME_FIELD");
 586         output.tag.set_property("DOMINANCE", config.field_dominance);
 587         output.append_tag();
 588         output.tag.set_title("/FRAME_FIELD");
 589         output.append_tag();
 590         output.append_newline();
 591         output.terminate_string();
 592 }
 593
 594 void FrameField::read_data(KeyFrame *keyframe)
 595 {
 596         FileXML input;
 597
 598         input.set_shared_input(keyframe->get_data(), strlen(keyframe->get_data()));
 599
 600         while(!input.read_tag())
 601         {
 602                 if(input.tag.title_is("FRAME_FIELD"))
 603                 {
 604                         config.field_dominance = input.tag.get_property("DOMINANCE", config.field_dominance);
 605                 }
 606         }
 607 }
 608
 609 void FrameField::update_gui()
 610 {
 611         if(thread)
 612         {
 613                 if(load_configuration())
 614                 {
 615                         thread->window->lock_window();
 616                         ((FrameFieldWindow*)thread->window)->top->update(config.field_dominance == TOP_FIELD_FIRST);
 617                         ((FrameFieldWindow*)thread->window)->bottom->update(config.field_dominance == BOTTOM_FIELD_FIRST);
 618                         thread->window->unlock_window();
 619                 }
 620         }
 621 }
 622
 623 int FrameField::handle_opengl()
 624 {
 625 #ifdef HAVE_GL
 626         static const char *field_frag =
 627                 "uniform sampler2D tex;\n"
 628                 "uniform float double_line_h;\n"
 629                 "uniform float y_offset;\n"
 630                 "void main()\n"
 631                 "{\n"
 632                 "       vec2 coord = gl_TexCoord[0].st;\n"
 633 /* Number of double lines + fraction of current double line */
 634                 "       float half_y = (coord.y - y_offset) / double_line_h;\n"
 635 /* Lines comprising current double line */
 636                 "       float line1 = floor(half_y) * double_line_h + y_offset;\n"
 637                 "       float line2 = line1 + double_line_h;\n"
 638 /* Distance from line1 to line2 */
 639                 "       float frac = fract(half_y);\n"
 640                 "       gl_FragColor =  mix(\n"
 641                 "               texture2D(tex, vec2(coord.x, line1)), \n"
 642                 "               texture2D(tex, vec2(coord.x, line2)), \n"
 643                 "               frac);\n"
 644                 "}\n";
 645
 646         static const char *_601_to_rgb_frag =
 647                 "void main()\n"
 648                 "{\n"
 649                 "       gl_FragColor.rgb = gl_FragColor.rgb * vec3(1.1644, 1.1644, 1.1644) - vec3(0.0627, 0.0627, 0.0627);\n"
 650                 "}\n";
 651
 652         static const char *_601_to_yuv_frag =
 653                 "void main()\n"
 654                 "{\n"
 655                 "       gl_FragColor.r = gl_FragColor.r * 1.1644 - 0.0627;\n"
 656                 "}\n";
 657
 658         static const char *rgb_to_601_frag =
 659                 "void main()\n"
 660                 "{\n"
 661                 "       gl_FragColor.rgb = gl_FragColor.rgb * vec3(0.8588, 0.8588, 0.8588) + vec3(0.0627, 0.0627, 0.0627);\n"
 662                 "}\n";
 663
 664         static const char *yuv_to_601_frag =
 665                 "void main()\n"
 666                 "{\n"
 667                 "       gl_FragColor.r = gl_FragColor.r * 0.8588 + 0.0627;\n"
 668                 "}\n";
 669
 670
 671         if(new_frame)
 672         {
 673                 if(get_output()->get_opengl_state() != VFrame::SCREEN)
 674                 {
 675 // Copy new frame to temporary texture
 676                         get_output()->to_texture();
 677
 678 // Draw it only to copy it to the temporary.
 679                         get_output()->enable_opengl();
 680                         VFrame::init_screen(get_output()->get_w(), get_output()->get_h());
 681                         get_output()->bind_texture(0);
 682                         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 683                         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 684                         get_output()->draw_texture();
 685                 }
 686
 687                 get_output()->enable_opengl();
 688                 VFrame::init_screen(get_output()->get_w(), get_output()->get_h());
 689                 glActiveTexture(GL_TEXTURE0);
 690                 BC_Texture::new_texture(&src_texture,
 691                         get_output()->get_w(),
 692                         get_output()->get_h(),
 693                         get_output()->get_color_model());
 694                 src_texture->bind(0);
 695                 glCopyTexSubImage2D(GL_TEXTURE_2D,
 696                         0,
 697                         0,
 698                         0,
 699                         0,
 700                         0,
 701                         get_output()->get_w(),
 702                         get_output()->get_h());
 703
 704 // Store aggregation state only when reading a frame
 705 //printf("FrameField::handle_opengl %p\n", get_output());
 706 //get_output()->dump_stacks();
 707                 if(prev_effect_is(_("RGB - 601")) ||
 708                         next_effect_is(_("RGB - 601")))
 709                 {
 710                         aggregate_rgb601 = 1;
 711                         rgb601_direction = get_output()->get_params()->get("RGB601_DIRECTION", 0);
 712                 }
 713                 else
 714                         aggregate_rgb601 = 0;
 715         }
 716         else
 717         {
 718                 get_output()->enable_opengl();
 719         }
 720
 721         float y_offset = 0.0;
 722         if(field_number == 0)
 723         {
 724                 if(config.field_dominance == BOTTOM_FIELD_FIRST)
 725                         y_offset = 1.0;
 726         }
 727         else
 728         {
 729                 if(config.field_dominance == TOP_FIELD_FIRST)
 730                         y_offset = 1.0;
 731         }
 732
 733         VFrame::init_screen(get_output()->get_w(), get_output()->get_h());
 734         glActiveTexture(GL_TEXTURE0);
 735         BC_Texture::new_texture(&src_texture,
 736                 get_output()->get_w(),
 737                 get_output()->get_h(),
 738                 get_output()->get_color_model());
 739
 740         const char *shader_stack[16];
 741         memset(shader_stack,0, sizeof(shader_stack));
 742         int current_shader = 0;
 743
 744         shader_stack[current_shader++] = field_frag;
 745
 746 // Aggregate with other effect
 747 //printf("FrameField::handle_opengl %s\n", get_output()->get_next_effect());
 748         if( aggregate_rgb601 ) {
 749                 switch( rgb601_direction ) {
 750                 case 1:
 751                         shader_stack[current_shader++] =
 752                                 BC_CModels::is_yuv(get_output()->get_color_model()) ?
 753                                          yuv_to_601_frag : rgb_to_601_frag;
 754                         break;
 755                 case 2:
 756                         shader_stack[current_shader++] =
 757                                 BC_CModels::is_yuv(get_output()->get_color_model()) ?
 758                                         _601_to_yuv_frag : _601_to_rgb_frag;
 759                         break;
 760                 }
 761         }
 762
 763         shader_stack[current_shader] = 0;
 764         unsigned int shader = VFrame::make_shader(shader_stack);
 765         if( shader > 0 ) {
 766                 glUseProgram(shader);
 767                 glUniform1i(glGetUniformLocation(shader, "tex"), 0);
 768                 glUniform1f(glGetUniformLocation(shader, "double_line_h"),
 769                         2.0 / src_texture->get_texture_h());
 770                 glUniform1f(glGetUniformLocation(shader, "y_offset"),
 771                         y_offset / src_texture->get_texture_h());
 772         }
 773
 774         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 775         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 776         get_output()->draw_texture();
 777
 778         glUseProgram(0);
 779         get_output()->set_opengl_state(VFrame::SCREEN);
 780
 781 // Reset for other operations
 782         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 783         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 784
 785 #endif
 786         return 0;
 787 }
 788
 789