cinelerra-5.1/cinelerra/playback3d.h

   1
   2 /*
   3  * CINELERRA
   4  * Copyright (C) 2009 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 #ifndef PLAYBACK3D_H
  23 #define PLAYBACK3D_H
  24
  25 #include "arraylist.h"
  26 #include "bccolors.h"
  27 #include "bcpixmap.inc"
  28 #include "bcsynchronous.h"
  29 #include "bcwindowbase.inc"
  30 #include "canvas.inc"
  31 #include "condition.inc"
  32 #include "maskauto.inc"
  33 #include "maskautos.inc"
  34 #include "mutex.inc"
  35 #include "mwindow.inc"
  36 #include "pluginclient.inc"
  37 #include "thread.h"
  38 #include "vframe.inc"
  39
  40
  41
  42
  43 // use static presets YUV in bccolors.h
  44 #define BC_GL_MATRIX(shader, mat) \
  45         glUniformMatrix3fv(glGetUniformLocation(shader, #mat), 1, 1, YUV::mat)
  46 #define BC_GL_VECTOR(shader, vec) \
  47         glUniform3fv(glGetUniformLocation(shader, #vec), 1, YUV::vec)
  48
  49 #define BC_GL_YMINF(shader) \
  50         glUniform1f(glGetUniformLocation(shader, "yminf"), YUV::yuv.get_yminf())
  51
  52 #define BC_GL_RGB_TO_YUV(shader) do { \
  53         BC_GL_MATRIX(shader, rgb_to_yuv_matrix); \
  54         BC_GL_YMINF(shader); \
  55 } while(0)
  56
  57 #define BC_GL_RGB_TO_Y(shader) do { \
  58         BC_GL_VECTOR(shader, rgb_to_y_vector); \
  59         BC_GL_YMINF(shader); \
  60 } while(0)
  61
  62 #define BC_GL_YUV_TO_RGB(shader) do { \
  63         BC_GL_MATRIX(shader, yuv_to_rgb_matrix); \
  64         BC_GL_YMINF(shader); \
  65 } while(0)
  66
  67 #define BC_GL_COLORS(shader) do { \
  68         BC_GL_MATRIX(shader, yuv_to_rgb_matrix); \
  69         BC_GL_MATRIX(shader, rgb_to_yuv_matrix); \
  70         BC_GL_YMINF(shader); \
  71 } while(0)
  72
  73
  74 #define bc_gl_yuv_to_rgb "uniform mat3 yuv_to_rgb_matrix;\n"
  75 #define bc_gl_rgb_to_yuv "uniform mat3 rgb_to_yuv_matrix;\n"
  76 #define bc_gl_rgb_to_y   "uniform vec3 rgb_to_y_vector;\n"
  77 #define bc_gl_yminf      "uniform float yminf;\n"
  78 #define bc_gl_colors bc_gl_yuv_to_rgb bc_gl_rgb_to_yuv bc_gl_yminf
  79
  80 // Macros for useful fragment shaders
  81 #define YUV_TO_RGB_FRAG(PIXEL) \
  82         PIXEL ".rgb -= vec3(yminf, 0.5, 0.5);\n" \
  83         PIXEL ".rgb = yuv_to_rgb_matrix * " PIXEL ".rgb;\n"
  84
  85 #define RGB_TO_YUV_FRAG(PIXEL) \
  86         PIXEL ".rgb = rgb_to_yuv_matrix * " PIXEL ".rgb;\n" \
  87         PIXEL ".rgb += vec3(yminf, 0.5, 0.5);\n"
  88
  89 #define RGB_TO_HSV_FRAG(PIXEL) \
  90         "{\n" \
  91         "float r, g, b;\n" \
  92         "float h, s, v;\n" \
  93         "float min, max, delta;\n" \
  94         "float f, p, q, t;\n" \
  95         "r = " PIXEL ".r;\n" \
  96         "g = " PIXEL ".g;\n" \
  97         "b = " PIXEL ".b;\n" \
  98         "min = ((r < g) ? r : g) < b ? ((r < g) ? r : g) : b;\n" \
  99         "max = ((r > g) ? r : g) > b ? ((r > g) ? r : g) : b;\n" \
 100         "v = max;\n" \
 101         "delta = max - min;\n" \
 102         "if(max != 0.0 && delta != 0.0)\n" \
 103     "{\n" \
 104         "    s = delta / max;\n" \
 105         "       if(r == max)\n" \
 106     "           h = (g - b) / delta;\n" \
 107         "       else \n" \
 108         "       if(g == max)\n" \
 109     "           h = 2.0 + (b - r) / delta;\n" \
 110         "       else\n" \
 111     "           h = 4.0 + (r - g) / delta;\n" \
 112         "\n" \
 113         "       h *= 60.0;\n" \
 114         "       if(h < 0.0)\n" \
 115     "           h += 360.0;\n" \
 116         "}\n" \
 117         "else\n"  \
 118         "{\n" \
 119     "    s = 0.0;\n" \
 120     "    h = -1.0;\n" \
 121         "}\n" \
 122         "" PIXEL ".r = h;\n" \
 123         "" PIXEL ".g = s;\n" \
 124         "" PIXEL ".b = v;\n" \
 125         "}\n"
 126
 127 #define HSV_TO_RGB_FRAG(PIXEL) \
 128         "{\n" \
 129     "int i;\n" \
 130         "float r, g, b;\n" \
 131         "float h, s, v;\n" \
 132         "float min, max, delta;\n" \
 133         "float f, p, q, t;\n" \
 134         "h = " PIXEL ".r;\n" \
 135         "s = " PIXEL ".g;\n" \
 136         "v = " PIXEL ".b;\n" \
 137     "if(s == 0.0) \n" \
 138         "{\n" \
 139     "    r = g = b = v;\n" \
 140     "}\n" \
 141         "else\n" \
 142         "{\n" \
 143     "   h /= 60.0;\n" \
 144     "   i = int(h);\n" \
 145     "   f = h - float(i);\n" \
 146     "   p = v * (1.0 - s);\n" \
 147     "   q = v * (1.0 - s * f);\n" \
 148     "   t = v * (1.0 - s * (1.0 - f));\n" \
 149         "\n" \
 150     "   if(i == 0)\n" \
 151         "       {\n" \
 152     "           r = v;\n" \
 153     "           g = t;\n" \
 154     "           b = p;\n" \
 155     "    }\n" \
 156         "       else\n" \
 157         "       if(i == 1)\n" \
 158         "       {\n" \
 159     "           r = q;\n" \
 160     "           g = v;\n" \
 161     "           b = p;\n" \
 162     "    }\n" \
 163         "       else\n" \
 164         "       if(i == 2)\n" \
 165         "       {\n" \
 166     "           r = p;\n" \
 167     "           g = v;\n" \
 168     "           b = t;\n" \
 169     "   }\n" \
 170         "       else\n" \
 171         "       if(i == 3)\n" \
 172         "       {\n" \
 173     "           r = p;\n" \
 174     "           g = q;\n" \
 175     "           b = v;\n" \
 176     "   }\n" \
 177         "       else\n" \
 178         "       if(i == 4)\n" \
 179         "       {\n" \
 180     "           r = t;\n" \
 181     "           g = p;\n" \
 182     "           b = v;\n" \
 183     "    }\n" \
 184         "       else\n" \
 185         "       if(i == 5)\n" \
 186         "       {\n" \
 187     "           r = v;\n" \
 188     "           g = p;\n" \
 189     "           b = q;\n" \
 190     "   }\n" \
 191         "}\n" \
 192         "" PIXEL ".r = r;\n" \
 193         "" PIXEL ".g = g;\n" \
 194         "" PIXEL ".b = b;\n" \
 195         "}\n"
 196
 197 class Playback3DCommand : public BC_SynchronousCommand
 198 {
 199 public:
 200         Playback3DCommand();
 201         void copy_from(BC_SynchronousCommand *command);
 202
 203 // Extra commands
 204         enum
 205         {
 206 // 5
 207                 WRITE_BUFFER = LAST_COMMAND,
 208                 CLEAR_OUTPUT,
 209                 OVERLAY,
 210                 DO_FADE,
 211                 DO_MASK,
 212                 PLUGIN,
 213                 CLEAR_INPUT,
 214                 DO_CAMERA,
 215                 COPY_FROM,
 216                 CONVERT_CMODEL
 217         };
 218
 219         Canvas *canvas;
 220         int is_cleared;
 221
 222 // Parameters for overlay command
 223         float in_x1;
 224         float in_y1;
 225         float in_x2;
 226         float in_y2;
 227         float out_x1;
 228         float out_y1;
 229         float out_x2;
 230         float out_y2;
 231 // 0 - 1
 232         float alpha;
 233         int mode;
 234         int interpolation_type;
 235         VFrame *input;
 236         int want_texture;
 237         int is_nested;
 238
 239         int dst_cmodel;
 240         int64_t start_position_project;
 241         MaskAutos *keyframe_set;
 242         MaskAuto *keyframe;
 243         MaskAuto *default_auto;
 244         PluginClient *plugin_client;
 245 };
 246
 247
 248 class Playback3D : public BC_Synchronous
 249 {
 250 public:
 251         Playback3D(MWindow *mwindow);
 252         ~Playback3D();
 253
 254         BC_SynchronousCommand* new_command();
 255         void handle_command(BC_SynchronousCommand *command);
 256
 257 // Called by VDeviceX11::write_buffer during video playback
 258         void write_buffer(Canvas *canvas,
 259                 VFrame *frame,
 260                 float in_x1,
 261                 float in_y1,
 262                 float in_x2,
 263                 float in_y2,
 264                 float out_x1,
 265                 float out_y1,
 266                 float out_x2,
 267                 float out_y2,
 268                 int is_cleared);
 269
 270 // Reads from pbuffer to either RAM or texture and updates the dst state
 271 // want_texture - causes read into texture if 1
 272         void copy_from(Canvas *canvas,
 273                 VFrame *dst,
 274                 VFrame *src,
 275                 int want_texture = 0);
 276
 277 // Clear framebuffer before composing virtual console
 278 // output - passed when rendering refresh frame.  If 0, the canvas is cleared.
 279         void clear_output(Canvas *canvas, VFrame *output);
 280
 281         void do_fade(Canvas *canvas, VFrame *frame, float fade);
 282         void convert_cmodel(Canvas *canvas, VFrame *output, int dst_cmodel);
 283
 284         void do_mask(Canvas *canvas,
 285                 VFrame *output,
 286                 int64_t start_position_project,
 287                 MaskAutos *keyframe_set,
 288                 MaskAuto *keyframe,
 289                 MaskAuto *default_auto);
 290
 291
 292 // Overlay a virtual node on the framebuffer
 293         void overlay(Canvas *canvas,
 294                 VFrame *input,
 295                 float in_x1,
 296                 float in_y1,
 297                 float in_x2,
 298                 float in_y2,
 299                 float out_x1,
 300                 float out_y1,
 301                 float out_x2,
 302                 float out_y2,
 303                 float alpha,        // 0 - 1
 304                 int mode,
 305                 int interpolation_type,
 306 // supplied if rendering single frame to PBuffer.
 307                 VFrame *output = 0,
 308                 int is_nested = 0);
 309
 310
 311         int run_plugin(Canvas *canvas, PluginClient *client);
 312
 313         void clear_input(Canvas *canvas, VFrame *frame);
 314         void do_camera(Canvas *canvas,
 315                 VFrame *output,
 316                 VFrame *input,
 317                 float in_x1,
 318                 float in_y1,
 319                 float in_x2,
 320                 float in_y2,
 321                 float out_x1,
 322                 float out_y1,
 323                 float out_x2,
 324                 float out_y2);
 325
 326 private:
 327 // Called by write_buffer and clear_frame to initialize OpenGL flags
 328         void init_frame(Playback3DCommand *command, int is_yuv=0);
 329         void write_buffer_sync(Playback3DCommand *command);
 330         void draw_output(Playback3DCommand *command, int flip_y);
 331         void clear_output_sync(Playback3DCommand *command);
 332         void clear_input_sync(Playback3DCommand *command);
 333         void overlay_sync(Playback3DCommand *command);
 334 // Read frame buffer back into texture for overlay operation
 335         void enable_overlay_texture(Playback3DCommand *command);
 336         void do_fade_sync(Playback3DCommand *command);
 337         void do_mask_sync(Playback3DCommand *command);
 338         void run_plugin_sync(Playback3DCommand *command);
 339         void do_camera_sync(Playback3DCommand *command);
 340 //      void draw_refresh_sync(Playback3DCommand *command);
 341         void copy_from_sync(Playback3DCommand *command);
 342         void convert_cmodel_sync(Playback3DCommand *command);
 343
 344 // Print errors from shader compilation
 345         void print_error(unsigned int object, int is_program);
 346
 347 // This quits the program when it's 1.
 348         MWindow *mwindow;
 349 // Temporaries for render to texture
 350         BC_Texture *temp_texture;
 351 // This is set by clear_output and used in compositing directly
 352 // to the output framebuffer.
 353         int canvas_w;
 354         int canvas_h;
 355 };
 356
 357
 358
 359
 360 #endif