git.sesse.net Git - casparcg/blob - core/mixer/image/image_kernel.cpp

   1 /*\r
   2 * copyright (c) 2010 Sveriges Television AB <info@casparcg.com>\r
   3 *\r
   4 *  This file is part of CasparCG.\r
   5 *\r
   6 *    CasparCG is free software: you can redistribute it and/or modify\r
   7 *    it under the terms of the GNU General Public License as published by\r
   8 *    the Free Software Foundation, either version 3 of the License, or\r
   9 *    (at your option) any later version.\r
  10 *\r
  11 *    CasparCG is distributed in the hope that it will be useful,\r
  12 *    but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  13 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  14 *    GNU General Public License for more details.\r
  15 \r
  16 *    You should have received a copy of the GNU General Public License\r
  17 *    along with CasparCG.  If not, see <http://www.gnu.org/licenses/>.\r
  18 *\r
  19 */\r
  20 #include "../../stdafx.h"\r
  21 \r
  22 #include "image_kernel.h"\r
  23 \r
  24 #include "blending_glsl.h"\r
  25 #include "../gpu/shader.h"\r
  26 #include "../gpu/device_buffer.h"\r
  27 \r
  28 #include <common/exception/exceptions.h>\r
  29 #include <common/gl/gl_check.h>\r
  30 \r
  31 #include <core/video_format.h>\r
  32 #include <core/producer/frame/pixel_format.h>\r
  33 #include <core/producer/frame/image_transform.h>\r
  34 \r
  35 #include <GL/glew.h>\r
  36 \r
  37 #include <boost/noncopyable.hpp>\r
  38 \r
  39 #include <unordered_map>\r
  40 \r
  41 namespace caspar { namespace core {\r
  42         \r
  43 GLubyte upper_pattern[] = {\r
  44         0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,\r
  45         0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,\r
  46         0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,\r
  47         0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00};\r
  48                 \r
  49 GLubyte lower_pattern[] = {\r
  50         0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, \r
  51         0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,\r
  52         0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,\r
  53         0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff};\r
  54 \r
  55 struct image_kernel::implementation : boost::noncopyable\r
  56 {       \r
  57         std::unique_ptr<shader> shader_;\r
  58         \r
  59         core::video_mode::type  last_mode_;\r
  60         size_t                                  last_width_;\r
  61         size_t                                  last_height_;\r
  62         \r
  63         //std::string get_blend_color_func()\r
  64         //{\r
  65         //      return \r
  66         //              \r
  67         //      get_blend_glsl()\r
  68         //      \r
  69         //      +\r
  70         //              \r
  71         //      "vec3 get_blend_color(vec3 back, vec3 fore)                                                                                     \n"\r
  72         //      "{                                                                                                                                                                      \n"\r
  73         //      "       switch(blend_mode)                                                                                                                              \n"\r
  74         //      "       {                                                                                                                                                               \n"\r
  75         //      "       case  0: return BlendNormal(back, fore);                                                                                \n"\r
  76         //      "       case  1: return BlendLighten(back, fore);                                                                               \n"\r
  77         //      "       case  2: return BlendDarken(back, fore);                                                                                \n"\r
  78         //      "       case  3: return BlendMultiply(back, fore);                                                                              \n"\r
  79         //      "       case  4: return BlendAverage(back, fore);                                                                               \n"\r
  80         //      "       case  5: return BlendAdd(back, fore);                                                                                   \n"\r
  81         //      "       case  6: return BlendSubstract(back, fore);                                                                             \n"\r
  82         //      "       case  7: return BlendDifference(back, fore);                                                                    \n"\r
  83         //      "       case  8: return BlendNegation(back, fore);                                                                              \n"\r
  84         //      "       case  9: return BlendExclusion(back, fore);                                                                             \n"\r
  85         //      "       case 10: return BlendScreen(back, fore);                                                                                \n"\r
  86         //      "       case 11: return BlendOverlay(back, fore);                                                                               \n"\r
  87         //      //"     case 12: return BlendSoftLight(back, fore);                                                                             \n"\r
  88         //      "       case 13: return BlendHardLight(back, fore);                                                                             \n"\r
  89         //      "       case 14: return BlendColorDodge(back, fore);                                                                    \n"\r
  90         //      "       case 15: return BlendColorBurn(back, fore);                                                                             \n"\r
  91         //      "       case 16: return BlendLinearDodge(back, fore);                                                                   \n"\r
  92         //      "       case 17: return BlendLinearBurn(back, fore);                                                                    \n"\r
  93         //      "       case 18: return BlendLinearLight(back, fore);                                                                   \n"\r
  94         //      "       case 19: return BlendVividLight(back, fore);                                                                    \n"\r
  95         //      "       case 20: return BlendPinLight(back, fore);                                                                              \n"\r
  96         //      "       case 21: return BlendHardMix(back, fore);                                                                               \n"\r
  97         //      "       case 22: return BlendReflect(back, fore);                                                                               \n"\r
  98         //      "       case 23: return BlendGlow(back, fore);                                                                                  \n"\r
  99         //      "       case 24: return BlendPhoenix(back, fore);                                                                               \n"\r
 100         //      "       case 25: return BlendHue(back, fore);                                                                                   \n"\r
 101         //      "       case 26: return BlendSaturation(back, fore);                                                                    \n"\r
 102         //      "       case 27: return BlendColor(back, fore);                                                                                 \n"\r
 103         //      "       case 28: return BlendLuminosity(back, fore);                                                                    \n"\r
 104         //      "       }                                                                                                                                                               \n"\r
 105         //      "       return BlendNormal(back, fore);                                                                                                 \n"\r
 106         //      "}                                                                                                                                                                      \n"\r
 107         //      "                                                                                                                                                                       \n"                                                                                                                                                       \r
 108         //      "vec4 blend_color(vec4 fore)                                                                                                            \n"\r
 109         //      "{                                                                                                                                                                      \n"\r
 110         //      "   vec4 back = texture2D(background, gl_TexCoord[1].st);                                                       \n"\r
 111         //      "   fore.rgb = get_blend_color(back.bgr, fore.rgb);                                                                     \n"\r
 112         //      "                                                                                                                                                                       \n"\r
 113         //      "       return vec4(mix(back.rgb, fore.rgb, fore.a), back.a + fore.a);                                  \n"\r
 114         //      "}                                                                                                                                                                      \n";\r
 115         //}\r
 116         //      \r
 117         //std::string get_simple_blend_color_func()\r
 118         //{\r
 119         //      return  \r
 120 \r
 121         //      "vec4 blend_color(vec4 fore)                                                                                                            \n"\r
 122         //      "{                                                                                                                                                                      \n"\r
 123         //      "   vec4 back = texture2D(background, gl_TexCoord[1].st);                                                       \n"\r
 124         //      "       return vec4(mix(back.rgb, fore.rgb, fore.a), back.a + fore.a);                                  \n"\r
 125         //      "}                                                                                                                                                                      \n";\r
 126         //}\r
 127 \r
 128         std::string get_vertex()\r
 129         {\r
 130                 return \r
 131 \r
 132                 "void main()                                                                                                                                            \n"\r
 133                 "{                                                                                                                                                                      \n"\r
 134                 "       gl_TexCoord[0] = gl_MultiTexCoord0;                                                                                             \n"\r
 135                 "       gl_TexCoord[1] = gl_MultiTexCoord1;                                                                                             \n"\r
 136                 "       gl_FrontColor  = gl_Color;                                                                                                              \n"\r
 137                 "       gl_Position    = ftransform();                                                                                                  \n"\r
 138                 "}                                                                                                                                                                      \n";\r
 139         }\r
 140 \r
 141         std::string get_fragment(bool compability_mode)\r
 142         {\r
 143                 return\r
 144 \r
 145                 "#version 120                                                                                                                                           \n"\r
 146                 //"uniform sampler2D    background;                                                                                                     \n"\r
 147                 "uniform sampler2D      plane[4];                                                                                                               \n"\r
 148                 "uniform sampler2D      local_key;                                                                                                              \n"\r
 149                 "uniform sampler2D      layer_key;                                                                                                              \n"\r
 150                 "                                                                                                                                                                       \n"\r
 151                 "uniform bool           is_hd;                                                                                                                  \n"\r
 152                 "uniform bool           has_local_key;                                                                                                  \n"\r
 153                 "uniform bool           has_layer_key;                                                                                                  \n"\r
 154                 //"uniform int          blend_mode;                                                                                                             \n"\r
 155                 //"uniform int          alpha_mode;                                                                                                             \n"\r
 156                 "uniform int            pixel_format;                                                                                                   \n"\r
 157                 "                                                                                                                                                                       \n"\r
 158                 "uniform bool           levels;                                                                                                                 \n"\r
 159                 "uniform float          min_input;                                                                                                              \n"\r
 160                 "uniform float          max_input;                                                                                                              \n"\r
 161                 "uniform float          gamma;                                                                                                                  \n"\r
 162                 "uniform float          min_output;                                                                                                             \n"\r
 163                 "uniform float          max_output;                                                                                                             \n"\r
 164                 "                                                                                                                                                                       \n"\r
 165                 "uniform bool           csb;                                                                                                                    \n"\r
 166                 "uniform float          brt;                                                                                                                    \n"\r
 167                 "uniform float          sat;                                                                                                                    \n"\r
 168                 "uniform float          con;                                                                                                                    \n"\r
 169                 "                                                                                                                                                                       \n"     \r
 170 \r
 171                 +\r
 172                 \r
 173                 get_blend_glsl()\r
 174 \r
 175                 +\r
 176 \r
 177                 "//http://slouken.blogspot.com/2011/02/mpeg-acceleration-with-glsl.html                         \n"\r
 178                 "vec4 ycbcra_to_rgba_sd(float y, float cb, float cr, float a)                                           \n"\r
 179                 "{                                                                                                                                                                      \n"\r
 180                 "       // YUV offset                                                                                                                                   \n"\r
 181                 "       const vec3 offset = vec3(-0.0625, -0.5, -0.5);                                                                  \n"\r
 182                 "                                                                                                                                                                       \n"\r
 183                 "       // RGB coefficients                                                                                                                     \n"\r
 184                 "       const vec3 Rcoeff = vec3(1.164,  0.000,  1.596);                                                                \n"\r
 185                 "       const vec3 Gcoeff = vec3(1.164, -0.391, -0.813);                                                                \n"\r
 186                 "       const vec3 Bcoeff = vec3(1.164,  2.018,  0.000);                                                                \n"\r
 187                 "                                                                                                                                                                       \n"\r
 188                 "       vec3 yuv = vec3(y, cr, cb);                                                                                                             \n"\r
 189                 "   vec4 rgba;                                                                                                                                          \n"\r
 190                 "                                                                                                                                                                       \n"\r
 191                 "       yuv += offset;                                                                                                                                  \n"\r
 192                 "       rgba.r = dot(yuv, Rcoeff);                                                                                                              \n"\r
 193                 "       rgba.g = dot(yuv, Gcoeff);                                                                                                              \n"\r
 194                 "       rgba.b = dot(yuv, Bcoeff);                                                                                                              \n"\r
 195                 "       rgba.a = a;                                                                                                                                             \n"\r
 196                 "                                                                                                                                                                       \n"\r
 197                 "       return rgba;                                                                                                                                    \n"\r
 198                 "}                                                                                                                                                                      \n"                     \r
 199                 "                                                                                                                                                                       \n"\r
 200                 "vec4 ycbcra_to_rgba_hd(float y, float cb, float cr, float a)                                           \n"\r
 201                 "{                                                                                                                                                                      \n"\r
 202                 "       // YUV offset                                                                                                                                   \n"\r
 203                 "       const vec3 offset = vec3(-0.0625, -0.5, -0.5);                                                                  \n"\r
 204                 "                                                                                                                                                                       \n"\r
 205                 "       // RGB coefficients                                                                                                                     \n"\r
 206                 "       const vec3 Rcoeff = vec3(1.164,  0.000,  1.793);                                                                \n"\r
 207                 "       const vec3 Gcoeff = vec3(1.164, -0.213, -0.534);                                                                \n"\r
 208                 "       const vec3 Bcoeff = vec3(1.164,  2.115,  0.000);                                                                \n"\r
 209                 "                                                                                                                                                                       \n"\r
 210                 "       vec3 yuv = vec3(y, cr, cb);                                                                                                             \n"\r
 211                 "   vec4 rgba;                                                                                                                                          \n"\r
 212                 "                                                                                                                                                                       \n"\r
 213                 "       yuv += offset;                                                                                                                                  \n"\r
 214                 "       rgba.r = dot(yuv, Rcoeff);                                                                                                              \n"\r
 215                 "       rgba.g = dot(yuv, Gcoeff);                                                                                                              \n"\r
 216                 "       rgba.b = dot(yuv, Bcoeff);                                                                                                              \n"\r
 217                 "       rgba.a = a;                                                                                                                                             \n"\r
 218                 "                                                                                                                                                                       \n"\r
 219                 "       return rgba;                                                                                                                                    \n"\r
 220                 "}                                                                                                                                                                      \n"                     \r
 221                 "                                                                                                                                                                       \n"             \r
 222                 "vec4 ycbcra_to_rgba(float y, float cb, float cr, float a)                                                      \n"\r
 223                 "{                                                                                                                                                                      \n"\r
 224                 "       if(is_hd)                                                                                                                                               \n"\r
 225                 "               return ycbcra_to_rgba_hd(y, cb, cr, a);                                                                         \n"\r
 226                 "       else                                                                                                                                                    \n"\r
 227                 "               return ycbcra_to_rgba_sd(y, cb, cr, a);                                                                         \n"\r
 228                 "}                                                                                                                                                                      \n"\r
 229                 "                                                                                                                                                                       \n"\r
 230                 "vec4 get_rgba_color()                                                                                                                          \n"\r
 231                 "{                                                                                                                                                                      \n"\r
 232                 "       switch(pixel_format)                                                                                                                    \n"\r
 233                 "       {                                                                                                                                                               \n"\r
 234                 "       case 0:         //gray                                                                                                                          \n"\r
 235                 "               return vec4(texture2D(plane[0], gl_TexCoord[0].st).rrr, 1.0);                           \n"\r
 236                 "       case 1:         //bgra,                                                                                                                         \n"\r
 237                 "               return texture2D(plane[0], gl_TexCoord[0].st).bgra;                                                     \n"\r
 238                 "       case 2:         //rgba,                                                                                                                         \n"\r
 239                 "               return texture2D(plane[0], gl_TexCoord[0].st).rgba;                                                     \n"\r
 240                 "       case 3:         //argb,                                                                                                                         \n"\r
 241                 "               return texture2D(plane[0], gl_TexCoord[0].st).argb;                                                     \n"\r
 242                 "       case 4:         //abgr,                                                                                                                         \n"\r
 243                 "               return texture2D(plane[0], gl_TexCoord[0].st).gbar;                                                     \n"\r
 244                 "       case 5:         //ycbcr,                                                                                                                        \n"\r
 245                 "               {                                                                                                                                                       \n"\r
 246                 "                       float y  = texture2D(plane[0], gl_TexCoord[0].st).r;                                    \n"\r
 247                 "                       float cb = texture2D(plane[1], gl_TexCoord[0].st).r;                                    \n"\r
 248                 "                       float cr = texture2D(plane[2], gl_TexCoord[0].st).r;                                    \n"\r
 249                 "                       return ycbcra_to_rgba(y, cb, cr, 1.0);                                                                  \n"\r
 250                 "               }                                                                                                                                                       \n"\r
 251                 "       case 6:         //ycbcra                                                                                                                        \n"\r
 252                 "               {                                                                                                                                                       \n"\r
 253                 "                       float y  = texture2D(plane[0], gl_TexCoord[0].st).r;                                    \n"\r
 254                 "                       float cb = texture2D(plane[1], gl_TexCoord[0].st).r;                                    \n"\r
 255                 "                       float cr = texture2D(plane[2], gl_TexCoord[0].st).r;                                    \n"\r
 256                 "                       float a  = texture2D(plane[3], gl_TexCoord[0].st).r;                                    \n"\r
 257                 "                       return ycbcra_to_rgba(y, cb, cr, a);                                                                    \n"\r
 258                 "               }                                                                                                                                                       \n"\r
 259                 "       case 7:         //luma                                                                                                                          \n"\r
 260                 "               {                                                                                                                                                       \n"\r
 261                 "                       vec3 y3 = texture2D(plane[0], gl_TexCoord[0].st).rrr;                                   \n"\r
 262                 "                       return vec4((y3-0.065)/0.859, 1.0);                                                                             \n"\r
 263                 "               }                                                                                                                                                       \n"\r
 264                 "       }                                                                                                                                                               \n"\r
 265                 "       return vec4(0.0, 0.0, 0.0, 0.0);                                                                                                \n"\r
 266                 "}                                                                                                                                                                      \n"\r
 267                 "                                                                                                                                                                       \n"\r
 268                 "void main()                                                                                                                                            \n"\r
 269                 "{                                                                                                                                                                      \n"\r
 270                 "       vec4 color = get_rgba_color();                                                                                                  \n"\r
 271                 "   if(levels)                                                                                                                                          \n"\r
 272                 "               color.rgb = LevelsControl(color.rgb, min_input, max_input, gamma, min_output, max_output); \n"\r
 273                 "       if(csb)                                                                                                                                                 \n"\r
 274                 "               color.rgb = ContrastSaturationBrightness(color.rgb, brt, sat, con);                     \n"\r
 275                 "       if(has_local_key)                                                                                                                               \n"\r
 276                 "               color.a *= texture2D(local_key, gl_TexCoord[1].st).r;                                           \n"\r
 277                 "       if(has_layer_key)                                                                                                                               \n"\r
 278                 "               color.a *= texture2D(layer_key, gl_TexCoord[1].st).r;                                           \n"\r
 279                 "       gl_FragColor = color.bgra * gl_Color;                                                                                   \n"\r
 280                 "}                                                                                                                                                                      \n";\r
 281         }\r
 282 \r
 283 \r
 284         implementation() \r
 285                 : last_mode_(core::video_mode::progressive)\r
 286                 , last_width_(0)\r
 287                 , last_height_(0)\r
 288         {                       \r
 289         }\r
 290 \r
 291         \r
 292         void draw(const render_item&                                                    item,\r
 293                           const safe_ptr<device_buffer>&                                background,\r
 294                           const std::shared_ptr<device_buffer>&                 local_key,                        \r
 295                           const std::shared_ptr<device_buffer>&                 layer_key)\r
 296         {\r
 297                 static const double epsilon = 0.001;\r
 298 \r
 299                 CASPAR_ASSERT(item.pix_desc.planes.size() == item.textures.size());\r
 300 \r
 301                 if(item.textures.empty())\r
 302                         return;\r
 303 \r
 304                 if(item.transform.get_opacity() < epsilon)\r
 305                         return;\r
 306 \r
 307                 if(!shader_)\r
 308                 {\r
 309                         try\r
 310                         {\r
 311                                 shader_.reset(new shader(get_vertex(), get_fragment(false)));\r
 312                         }\r
 313                         catch(...)\r
 314                         {\r
 315                                 CASPAR_LOG_CURRENT_EXCEPTION();\r
 316                                 CASPAR_LOG(warning) << "Failed to compile shader. Trying to compile without blend-modes.";\r
 317                                 shader_.reset(new shader(get_vertex(), get_fragment(true)));\r
 318                         }\r
 319                         \r
 320                         GL(glEnable(GL_TEXTURE_2D));\r
 321                         GL(glEnable(GL_BLEND));\r
 322                         GL(glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE));\r
 323                 }\r
 324 \r
 325                 if(last_mode_ != item.mode)\r
 326                 {\r
 327                         last_mode_ = item.mode;\r
 328                         \r
 329                         if(item.mode == core::video_mode::progressive)                  \r
 330                                 GL(glDisable(GL_POLYGON_STIPPLE));                      \r
 331                         else                    \r
 332                         {\r
 333                                 GL(glEnable(GL_POLYGON_STIPPLE));                       \r
 334 \r
 335                                 if(item.mode == core::video_mode::upper)\r
 336                                         glPolygonStipple(upper_pattern);\r
 337                                 else if(item.mode == core::video_mode::lower)\r
 338                                         glPolygonStipple(lower_pattern);\r
 339                         }\r
 340                 }\r
 341 \r
 342                 if(last_width_ != background->width() || last_height_ != background->height())\r
 343                 {\r
 344                         last_width_ = background->width();\r
 345                         last_height_ = background->height();\r
 346                         GL(glViewport(0, 0, background->width(), background->height()));\r
 347                 }\r
 348 \r
 349                 // Bind textures\r
 350 \r
 351                 for(size_t n = 0; n < item.textures.size(); ++n)\r
 352                         item.textures[n]->bind(n);\r
 353 \r
 354                 if(local_key)\r
 355                         local_key->bind(4);\r
 356                 \r
 357                 if(layer_key)\r
 358                         layer_key->bind(5);\r
 359 \r
 360                 //background->bind(6);\r
 361 \r
 362                 // Setup shader\r
 363 \r
 364                 shader_->use(); \r
 365 \r
 366                 shader_->set("plane[0]",                0);\r
 367                 shader_->set("plane[1]",                1);\r
 368                 shader_->set("plane[2]",                2);\r
 369                 shader_->set("plane[3]",                3);\r
 370                 shader_->set("local_key",               4);\r
 371                 shader_->set("layer_key",               5);\r
 372                 //shader_->set("background",            6);\r
 373                 shader_->set("is_hd",                   item.pix_desc.planes.at(0).height > 700 ? 1 : 0);\r
 374                 shader_->set("has_local_key",   local_key ? 1 : 0);\r
 375                 shader_->set("has_layer_key",   layer_key ? 1 : 0);\r
 376                 //shader_->set("blend_mode",            item.transform.get_is_key() ? core::image_transform::blend_mode::normal : item.transform.get_blend_mode());\r
 377                 //shader_->set("alpha_mode",            item.transform.get_alpha_mode());\r
 378                 shader_->set("pixel_format",    item.pix_desc.pix_fmt); \r
 379 \r
 380                 auto levels = item.transform.get_levels();\r
 381 \r
 382                 if(levels.min_input  > epsilon          ||\r
 383                    levels.max_input  < 1.0-epsilon      ||\r
 384                    levels.min_output > epsilon          ||\r
 385                    levels.max_output < 1.0-epsilon      ||\r
 386                    std::abs(levels.gamma - 1.0) > epsilon)\r
 387                 {\r
 388                         shader_->set("levels", true);   \r
 389                         shader_->set("min_input", levels.min_input);    \r
 390                         shader_->set("max_input", levels.max_input);\r
 391                         shader_->set("min_output", levels.min_output);\r
 392                         shader_->set("max_output", levels.max_output);\r
 393                         shader_->set("gamma", levels.gamma);\r
 394                 }\r
 395                 else\r
 396                         shader_->set("levels", false);  \r
 397 \r
 398                 if(std::abs(item.transform.get_brightness() - 1.0) > epsilon ||\r
 399                    std::abs(item.transform.get_saturation() - 1.0) > epsilon ||\r
 400                    std::abs(item.transform.get_contrast() - 1.0) > epsilon)\r
 401                 {\r
 402                         shader_->set("csb",     true);  \r
 403                         \r
 404                         shader_->set("brt", item.transform.get_brightness());   \r
 405                         shader_->set("sat", item.transform.get_saturation());\r
 406                         shader_->set("con", item.transform.get_contrast());\r
 407                 }\r
 408                 else\r
 409                         shader_->set("csb",     false); \r
 410                 \r
 411                 // Setup drawing area\r
 412 \r
 413                 GL(glColor4d(item.transform.get_gain(), item.transform.get_gain(), item.transform.get_gain(), item.transform.get_opacity()));\r
 414                                                 \r
 415                 auto m_p = item.transform.get_clip_translation();\r
 416                 auto m_s = item.transform.get_clip_scale();\r
 417 \r
 418                 bool scissor = m_p[0] > std::numeric_limits<double>::epsilon()           || m_p[1] > std::numeric_limits<double>::epsilon() &&\r
 419                                            m_s[0] < 1.0 - std::numeric_limits<double>::epsilon() || m_s[1] < 1.0 - std::numeric_limits<double>::epsilon();\r
 420 \r
 421                 if(scissor)\r
 422                 {\r
 423                         double w = static_cast<double>(background->width());\r
 424                         double h = static_cast<double>(background->height());\r
 425                 \r
 426                         GL(glEnable(GL_SCISSOR_TEST));\r
 427                         GL(glScissor(static_cast<size_t>(m_p[0]*w), static_cast<size_t>(m_p[1]*h), static_cast<size_t>(m_s[0]*w), static_cast<size_t>(m_s[1]*h)));\r
 428                 }\r
 429 \r
 430                 auto f_p = item.transform.get_fill_translation();\r
 431                 auto f_s = item.transform.get_fill_scale();\r
 432                 \r
 433                 // Draw\r
 434 \r
 435                 glBegin(GL_QUADS);\r
 436                         glMultiTexCoord2d(GL_TEXTURE0, 0.0, 0.0); glMultiTexCoord2d(GL_TEXTURE1,  f_p[0]        ,  f_p[1]        );             glVertex2d( f_p[0]        *2.0-1.0,  f_p[1]        *2.0-1.0);\r
 437                         glMultiTexCoord2d(GL_TEXTURE0, 1.0, 0.0); glMultiTexCoord2d(GL_TEXTURE1, (f_p[0]+f_s[0]),  f_p[1]        );             glVertex2d((f_p[0]+f_s[0])*2.0-1.0,  f_p[1]        *2.0-1.0);\r
 438                         glMultiTexCoord2d(GL_TEXTURE0, 1.0, 1.0); glMultiTexCoord2d(GL_TEXTURE1, (f_p[0]+f_s[0]), (f_p[1]+f_s[1]));             glVertex2d((f_p[0]+f_s[0])*2.0-1.0, (f_p[1]+f_s[1])*2.0-1.0);\r
 439                         glMultiTexCoord2d(GL_TEXTURE0, 0.0, 1.0); glMultiTexCoord2d(GL_TEXTURE1,  f_p[0]        , (f_p[1]+f_s[1]));             glVertex2d( f_p[0]        *2.0-1.0, (f_p[1]+f_s[1])*2.0-1.0);\r
 440                 glEnd();\r
 441 \r
 442                 if(scissor)\r
 443                         GL(glDisable(GL_SCISSOR_TEST)); \r
 444         }\r
 445 };\r
 446 \r
 447 image_kernel::image_kernel() : impl_(new implementation()){}\r
 448 void image_kernel::draw(const render_item& item, const safe_ptr<device_buffer>& background, const std::shared_ptr<device_buffer>& local_key, const std::shared_ptr<device_buffer>& layer_key)\r
 449 {\r
 450         impl_->draw(item, background, local_key, layer_key);\r
 451 }\r
 452 \r
 453 bool operator==(const render_item& lhs, const render_item& rhs)\r
 454 {\r
 455         return lhs.textures == rhs.textures && lhs.transform == rhs.transform && lhs.tag == rhs.tag && lhs.mode == rhs.mode;\r
 456 }\r
 457 \r
 458 }}