cinelerra-5.1/plugins/rgb601/rgb601.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 "clip.h"
  23 #include "bccmodels.h"
  24 #include "filexml.h"
  25 #include "language.h"
  26 #include "rgb601.h"
  27 #include "rgb601window.h"
  28
  29 #include <stdio.h>
  30 #include <string.h>
  31
  32
  33 REGISTER_PLUGIN(RGB601Main)
  34
  35
  36
  37
  38 RGB601Config::RGB601Config()
  39 {
  40         direction = 0;
  41 }
  42
  43 RGB601Main::RGB601Main(PluginServer *server)
  44  : PluginVClient(server)
  45 {
  46
  47 }
  48
  49 RGB601Main::~RGB601Main()
  50 {
  51
  52 }
  53
  54 const char* RGB601Main::plugin_title() { return N_("RGB - 601"); }
  55 int RGB601Main::is_realtime() { return 1; }
  56
  57
  58 NEW_WINDOW_MACRO(RGB601Main, RGB601Window)
  59
  60
  61 void RGB601Main::update_gui()
  62 {
  63         if(thread)
  64         {
  65                 load_configuration();
  66                 thread->window->lock_window();
  67                 ((RGB601Window*)thread->window)->forward->update(config.direction == 1);
  68                 ((RGB601Window*)thread->window)->reverse->update(config.direction == 2);
  69                 thread->window->unlock_window();
  70         }
  71 }
  72
  73
  74 int RGB601Main::load_configuration()
  75 {
  76         KeyFrame *prev_keyframe;
  77
  78         prev_keyframe = get_prev_keyframe(get_source_position());
  79 // Must also switch between interpolation between keyframes and using first keyframe
  80         read_data(prev_keyframe);
  81         return 1;
  82 }
  83
  84
  85 void RGB601Main::save_data(KeyFrame *keyframe)
  86 {
  87         FileXML output;
  88
  89 // cause data to be stored directly in text
  90         output.set_shared_output(keyframe->xbuf);
  91         output.tag.set_title("RGB601");
  92         output.tag.set_property("DIRECTION", config.direction);
  93         output.append_tag();
  94         output.tag.set_title("/RGB601");
  95         output.append_tag();
  96         output.append_newline();
  97         output.terminate_string();
  98 }
  99
 100 void RGB601Main::read_data(KeyFrame *keyframe)
 101 {
 102         FileXML input;
 103
 104         input.set_shared_input(keyframe->xbuf);
 105
 106         int result = 0;
 107
 108         while(!result)
 109         {
 110                 result = input.read_tag();
 111
 112                 if(!result)
 113                 {
 114                         if(input.tag.title_is("RGB601"))
 115                         {
 116                                 config.direction = input.tag.get_property("DIRECTION", config.direction);
 117                         }
 118                 }
 119         }
 120 }
 121
 122 #define CREATE_TABLE(max) \
 123 { \
 124         for(int i = 0; i < max; i++) \
 125         { \
 126                 int forward_output = (int)((double)0.8588 * i + max * 0.0627 + 0.5); \
 127                 int reverse_output = (int)((double)1.1644 * i - max * 0.0627 + 0.5); \
 128                 forward_table[i] = CLIP(forward_output, 0, max - 1); \
 129                 reverse_table[i] = CLIP(reverse_output, 0, max - 1); \
 130         } \
 131 }
 132
 133 void RGB601Main::create_table(VFrame *input_ptr)
 134 {
 135         switch(input_ptr->get_color_model())
 136         {
 137                 case BC_RGB888:
 138                 case BC_YUV888:
 139                 case BC_RGBA8888:
 140                 case BC_YUVA8888:
 141                         CREATE_TABLE(0x100);
 142                         break;
 143
 144                 case BC_RGB161616:
 145                 case BC_YUV161616:
 146                 case BC_RGBA16161616:
 147                 case BC_YUVA16161616:
 148                         CREATE_TABLE(0x10000);
 149                         break;
 150         }
 151 }
 152
 153 #define PROCESS(table, type, components, yuv) \
 154 { \
 155         for(int i = 0; i < h; i++) \
 156         { \
 157                 type *in_row = (type*)input_ptr->get_rows()[i]; \
 158                 type *out_row = (type*)output_ptr->get_rows()[i]; \
 159  \
 160                 if(yuv) \
 161                 { \
 162 /* Just do Y */ \
 163                         for(int j = 0; j < w; j++) \
 164                         { \
 165                                 out_row[j * components] = table[(int)in_row[j * components]]; \
 166                                 out_row[j * components + 1] = in_row[j * components + 1]; \
 167                                 out_row[j * components + 2] = in_row[j * components + 2]; \
 168                         } \
 169                 } \
 170                 else \
 171                 if(sizeof(type) == 4) \
 172                 { \
 173                         for(int j = 0; j < w; j++) \
 174                         { \
 175                                 if(table == forward_table) \
 176                                 { \
 177                                         out_row[j * components] = (type)(in_row[j * components] * 0.8588 + 0.0627); \
 178                                         out_row[j * components + 1] = (type)(in_row[j * components + 1] * 0.8588 + 0.0627); \
 179                                         out_row[j * components + 2] = (type)(in_row[j * components + 2] * 0.8588 + 0.0627); \
 180                                 } \
 181                                 else \
 182                                 { \
 183                                         out_row[j * components] = (type)(in_row[j * components] * 1.1644 - 0.0627); \
 184                                         out_row[j * components + 1] = (type)(in_row[j * components + 1] * 1.1644 - 0.0627); \
 185                                         out_row[j * components + 2] = (type)(in_row[j * components + 2] * 1.1644 - 0.0627); \
 186                                 } \
 187                         } \
 188                 } \
 189                 else \
 190                 { \
 191                         for(int j = 0; j < w; j++) \
 192                         { \
 193                                 out_row[j * components] = table[(int)in_row[j * components]]; \
 194                                 out_row[j * components + 1] = table[(int)in_row[j * components + 1]]; \
 195                                 out_row[j * components + 2] = table[(int)in_row[j * components + 2]]; \
 196                         } \
 197                 } \
 198         } \
 199 }
 200
 201 void RGB601Main::process(int *table, VFrame *input_ptr, VFrame *output_ptr)
 202 {
 203         int w = input_ptr->get_w();
 204         int h = input_ptr->get_h();
 205
 206         if(config.direction == 1)
 207                 switch(input_ptr->get_color_model())
 208                 {
 209                         case BC_YUV888:
 210                                 PROCESS(forward_table, unsigned char, 3, 1);
 211                                 break;
 212                         case BC_YUVA8888:
 213                                 PROCESS(forward_table, unsigned char, 4, 1);
 214                                 break;
 215                         case BC_YUV161616:
 216                                 PROCESS(forward_table, u_int16_t, 3, 1);
 217                                 break;
 218                         case BC_YUVA16161616:
 219                                 PROCESS(forward_table, u_int16_t, 4, 1);
 220                                 break;
 221                         case BC_RGB888:
 222                                 PROCESS(forward_table, unsigned char, 3, 0);
 223                                 break;
 224                         case BC_RGBA8888:
 225                                 PROCESS(forward_table, unsigned char, 4, 0);
 226                                 break;
 227                         case BC_RGB_FLOAT:
 228                                 PROCESS(forward_table, float, 3, 0);
 229                                 break;
 230                         case BC_RGBA_FLOAT:
 231                                 PROCESS(forward_table, float, 4, 0);
 232                                 break;
 233                         case BC_RGB161616:
 234                                 PROCESS(forward_table, u_int16_t, 3, 0);
 235                                 break;
 236                         case BC_RGBA16161616:
 237                                 PROCESS(forward_table, u_int16_t, 4, 0);
 238                                 break;
 239                 }
 240         else
 241         if(config.direction == 2)
 242                 switch(input_ptr->get_color_model())
 243                 {
 244                         case BC_YUV888:
 245                                 PROCESS(reverse_table, unsigned char, 3, 1);
 246                                 break;
 247                         case BC_YUVA8888:
 248                                 PROCESS(reverse_table, unsigned char, 4, 1);
 249                                 break;
 250                         case BC_YUV161616:
 251                                 PROCESS(reverse_table, u_int16_t, 3, 1);
 252                                 break;
 253                         case BC_YUVA16161616:
 254                                 PROCESS(reverse_table, u_int16_t, 4, 1);
 255                                 break;
 256                         case BC_RGB888:
 257                                 PROCESS(reverse_table, unsigned char, 3, 0);
 258                                 break;
 259                         case BC_RGBA8888:
 260                                 PROCESS(reverse_table, unsigned char, 4, 0);
 261                                 break;
 262                         case BC_RGB_FLOAT:
 263                                 PROCESS(reverse_table, float, 3, 0);
 264                                 break;
 265                         case BC_RGBA_FLOAT:
 266                                 PROCESS(reverse_table, float, 4, 0);
 267                                 break;
 268                         case BC_RGB161616:
 269                                 PROCESS(reverse_table, u_int16_t, 3, 0);
 270                                 break;
 271                         case BC_RGBA16161616:
 272                                 PROCESS(reverse_table, u_int16_t, 4, 0);
 273                                 break;
 274                 }
 275 }
 276
 277 int RGB601Main::process_buffer(VFrame *frame,
 278         int64_t start_position,
 279         double frame_rate)
 280 {
 281         load_configuration();
 282
 283 // Set parameters for aggregation with previous or next effect.
 284         frame->get_params()->update("RGB601_DIRECTION", config.direction);
 285
 286         read_frame(frame,
 287                 0,
 288                 start_position,
 289                 frame_rate,
 290                 get_use_opengl());
 291
 292 // Deinterlace effects may aggregate this one,
 293         if(get_use_opengl() &&
 294                 (prev_effect_is(_("Frames to fields")) ||
 295                 next_effect_is(_("Frames to fields"))))
 296         {
 297                 return 0;
 298         }
 299
 300         if(get_use_opengl() && config.direction)
 301         {
 302                 run_opengl();
 303                 return 0;
 304         }
 305
 306
 307         create_table(frame);
 308
 309         if(config.direction == 1)
 310                 process(forward_table, frame, frame);
 311         else
 312         if(config.direction == 2)
 313                 process(reverse_table, frame, frame);
 314
 315         return 0;
 316 }
 317
 318 int RGB601Main::handle_opengl()
 319 {
 320 #ifdef HAVE_GL
 321         static const char *yuv_fwd_frag =
 322                 "uniform sampler2D tex;\n"
 323                 "void main()\n"
 324                 "{\n"
 325                 "       gl_FragColor = texture2D(tex, gl_TexCoord[0].st);\n"
 326                 "       gl_FragColor.r = gl_FragColor.r * 0.8588 + 0.0627;\n"
 327                 "}\n";
 328         static const char *yuv_rev_frag =
 329                 "uniform sampler2D tex;\n"
 330                 "void main()\n"
 331                 "{\n"
 332                 "       gl_FragColor = texture2D(tex, gl_TexCoord[0].st);\n"
 333                 "       gl_FragColor.r = gl_FragColor.r * 1.1644 - 0.0627;\n"
 334                 "}\n";
 335         static const char *rgb_fwd_frag =
 336                 "uniform sampler2D tex;\n"
 337                 "void main()\n"
 338                 "{\n"
 339                 "       gl_FragColor = texture2D(tex, gl_TexCoord[0].st);\n"
 340                 "       gl_FragColor.rgb = gl_FragColor.rgb * vec3(0.8588, 0.8588, 0.8588) + vec3(0.0627, 0.0627, 0.0627);\n"
 341                 "}\n";
 342         static const char *rgb_rev_frag =
 343                 "uniform sampler2D tex;\n"
 344                 "void main()\n"
 345                 "{\n"
 346                 "       gl_FragColor = texture2D(tex, gl_TexCoord[0].st);\n"
 347                 "       gl_FragColor.rgb = gl_FragColor.rgb * vec3(1.1644, 1.1644, 1.1644) - vec3(0.0627, 0.0627, 0.0627);\n"
 348                 "}\n";
 349
 350
 351         get_output()->to_texture();
 352         get_output()->enable_opengl();
 353         get_output()->bind_texture(0);
 354
 355         unsigned int frag_shader = 0;
 356         switch( get_output()->get_color_model() ) {
 357         case BC_YUV888:
 358         case BC_YUVA8888:
 359                 frag_shader = VFrame::make_shader(0,
 360                         config.direction == 1 ? yuv_fwd_frag : yuv_rev_frag,
 361                         0);
 362                 break;
 363
 364         default:
 365                 frag_shader = VFrame::make_shader(0,
 366                         config.direction == 1 ? rgb_fwd_frag : rgb_rev_frag,
 367                         0);
 368                 break;
 369         }
 370
 371         if( frag_shader > 0 ) {
 372                 glUseProgram(frag_shader);
 373                 glUniform1i(glGetUniformLocation(frag_shader, "tex"), 0);
 374         }
 375         VFrame::init_screen(get_output()->get_w(), get_output()->get_h());
 376         get_output()->draw_texture();
 377         glUseProgram(0);
 378         get_output()->set_opengl_state(VFrame::SCREEN);
 379 #endif
 380         return 0;
 381 }
 382
 383
 384