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

   1 /*\r
   2 * Copyright (c) 2011 Sveriges Television AB <info@casparcg.com>\r
   3 *\r
   4 * This file is part of CasparCG (www.casparcg.com).\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 * Author: Robert Nagy, ronag89@gmail.com\r
  20 */\r
  21 \r
  22 #include "../../stdafx.h"\r
  23 \r
  24 #include "image_kernel.h"\r
  25 \r
  26 #include "shader/image_shader.h"\r
  27 #include "shader/blending_glsl.h"\r
  28 \r
  29 #include "../gpu/shader.h"\r
  30 #include "../gpu/device_buffer.h"\r
  31 #include "../gpu/ogl_device.h"\r
  32 \r
  33 #include <common/exception/exceptions.h>\r
  34 #include <common/gl/gl_check.h>\r
  35 #include <common/env.h>\r
  36 \r
  37 #include <core/video_format.h>\r
  38 #include <core/producer/frame/pixel_format.h>\r
  39 #include <core/producer/frame/frame_transform.h>\r
  40 \r
  41 #include <boost/noncopyable.hpp>\r
  42 \r
  43 namespace caspar { namespace core {\r
  44         \r
  45 GLubyte upper_pattern[] = {\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         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
  49         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
  50                 \r
  51 GLubyte lower_pattern[] = {\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         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
  55         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
  56 \r
  57 struct image_kernel::implementation : boost::noncopyable\r
  58 {       \r
  59         safe_ptr<ogl_device>    ogl_;\r
  60         safe_ptr<shader>                shader_;\r
  61         bool                                    blend_modes_;\r
  62                                                         \r
  63         implementation(const safe_ptr<ogl_device>& ogl)\r
  64                 : ogl_(ogl)\r
  65                 , shader_(ogl_->invoke([&]{return get_image_shader(*ogl, blend_modes_);}))\r
  66         {\r
  67         }\r
  68 \r
  69         void draw(draw_params&& params)\r
  70         {\r
  71                 static const double epsilon = 0.001;\r
  72 \r
  73                 CASPAR_ASSERT(params.pix_desc.planes.size() == params.textures.size());\r
  74 \r
  75                 if(params.textures.empty() || !params.background)\r
  76                         return;\r
  77 \r
  78                 if(params.transform.opacity < epsilon)\r
  79                         return;\r
  80                 \r
  81                 if(!std::all_of(params.textures.begin(), params.textures.end(), std::mem_fn(&device_buffer::ready)))\r
  82                 {\r
  83                         CASPAR_LOG(trace) << "[image_mixer] Performance warning. Host to device transfer not complete, GPU will be stalled";\r
  84                         ogl_->yield(); // Try to give it some more time.\r
  85                 }               \r
  86                 \r
  87                 // Bind textures\r
  88 \r
  89                 for(size_t n = 0; n < params.textures.size(); ++n)\r
  90                         params.textures[n]->bind(n);\r
  91 \r
  92                 if(params.local_key)\r
  93                         params.local_key->bind(texture_id::local_key);\r
  94                 \r
  95                 if(params.layer_key)\r
  96                         params.layer_key->bind(texture_id::layer_key);\r
  97                         \r
  98                 // Setup shader\r
  99                                                                 \r
 100                 ogl_->use(*shader_);\r
 101 \r
 102                 shader_->set("plane[0]",                texture_id::plane0);\r
 103                 shader_->set("plane[1]",                texture_id::plane1);\r
 104                 shader_->set("plane[2]",                texture_id::plane2);\r
 105                 shader_->set("plane[3]",                texture_id::plane3);\r
 106                 shader_->set("local_key",               texture_id::local_key);\r
 107                 shader_->set("layer_key",               texture_id::layer_key);\r
 108                 shader_->set("is_hd",                   params.pix_desc.planes.at(0).height > 700 ? 1 : 0);\r
 109                 shader_->set("has_local_key",   params.local_key);\r
 110                 shader_->set("has_layer_key",   params.layer_key);\r
 111                 shader_->set("pixel_format",    params.pix_desc.pix_fmt);       \r
 112                 shader_->set("opacity",                 params.transform.is_key ? 1.0 : params.transform.opacity);      \r
 113                 \r
 114                 // Setup blend_func\r
 115                 \r
 116                 if(params.transform.is_key)\r
 117                         params.blend_mode = blend_mode::normal;\r
 118 \r
 119                 if(blend_modes_)\r
 120                 {\r
 121                         params.background->bind(6);\r
 122 \r
 123                         shader_->set("background",      texture_id::background);\r
 124                         shader_->set("blend_mode",      params.blend_mode);\r
 125                         shader_->set("keyer",           params.keyer);\r
 126                 }\r
 127                 else\r
 128                 {\r
 129                         switch(params.keyer)\r
 130                         {\r
 131                         case keyer::additive:\r
 132                                 ogl_->blend_func(GL_ONE, GL_ONE);       \r
 133                                 break;\r
 134                         case keyer::linear:\r
 135                         default:                                \r
 136                                 ogl_->blend_func(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);       \r
 137                         }               \r
 138                 }\r
 139 \r
 140                 // Setup image-adjustements\r
 141                 \r
 142                 if(params.transform.levels.min_input  > epsilon         ||\r
 143                    params.transform.levels.max_input  < 1.0-epsilon     ||\r
 144                    params.transform.levels.min_output > epsilon         ||\r
 145                    params.transform.levels.max_output < 1.0-epsilon     ||\r
 146                    std::abs(params.transform.levels.gamma - 1.0) > epsilon)\r
 147                 {\r
 148                         shader_->set("levels", true);   \r
 149                         shader_->set("min_input",       params.transform.levels.min_input);     \r
 150                         shader_->set("max_input",       params.transform.levels.max_input);\r
 151                         shader_->set("min_output",      params.transform.levels.min_output);\r
 152                         shader_->set("max_output",      params.transform.levels.max_output);\r
 153                         shader_->set("gamma",           params.transform.levels.gamma);\r
 154                 }\r
 155                 else\r
 156                         shader_->set("levels", false);  \r
 157 \r
 158                 if(std::abs(params.transform.brightness - 1.0) > epsilon ||\r
 159                    std::abs(params.transform.saturation - 1.0) > epsilon ||\r
 160                    std::abs(params.transform.contrast - 1.0)   > epsilon)\r
 161                 {\r
 162                         shader_->set("csb",     true);  \r
 163                         \r
 164                         shader_->set("brt", params.transform.brightness);       \r
 165                         shader_->set("sat", params.transform.saturation);\r
 166                         shader_->set("con", params.transform.contrast);\r
 167                 }\r
 168                 else\r
 169                         shader_->set("csb",     false); \r
 170                 \r
 171                 // Setup interlacing\r
 172 \r
 173                 if(params.transform.field_mode == core::field_mode::progressive)                        \r
 174                         ogl_->disable(GL_POLYGON_STIPPLE);                      \r
 175                 else                    \r
 176                 {\r
 177                         ogl_->enable(GL_POLYGON_STIPPLE);\r
 178 \r
 179                         if(params.transform.field_mode == core::field_mode::upper)\r
 180                                 ogl_->stipple_pattern(upper_pattern);\r
 181                         else if(params.transform.field_mode == core::field_mode::lower)\r
 182                                 ogl_->stipple_pattern(lower_pattern);\r
 183                 }\r
 184 \r
 185                 // Setup drawing area\r
 186                 \r
 187                 ogl_->viewport(0, 0, params.background->width(), params.background->height());\r
 188                                                                 \r
 189                 auto m_p = params.transform.clip_translation;\r
 190                 auto m_s = params.transform.clip_scale;\r
 191 \r
 192                 bool scissor = m_p[0] > std::numeric_limits<double>::epsilon()                  || m_p[1] > std::numeric_limits<double>::epsilon() ||\r
 193                                            m_s[0] < (1.0 - std::numeric_limits<double>::epsilon())      || m_s[1] < (1.0 - std::numeric_limits<double>::epsilon());\r
 194 \r
 195                 if(scissor)\r
 196                 {\r
 197                         double w = static_cast<double>(params.background->width());\r
 198                         double h = static_cast<double>(params.background->height());\r
 199                 \r
 200                         ogl_->enable(GL_SCISSOR_TEST);\r
 201                         ogl_->scissor(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
 202                 }\r
 203 \r
 204                 auto f_p = params.transform.fill_translation;\r
 205                 auto f_s = params.transform.fill_scale;\r
 206                 \r
 207                 // Set render target\r
 208                 \r
 209                 ogl_->attach(*params.background);\r
 210                 \r
 211                 // Draw\r
 212                                 \r
 213                 glBegin(GL_QUADS);\r
 214                         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
 215                         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
 216                         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
 217                         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
 218                 glEnd();\r
 219                 \r
 220                 // Cleanup\r
 221 \r
 222                 ogl_->disable(GL_SCISSOR_TEST); \r
 223                                                 \r
 224                 params.textures.clear();\r
 225                 ogl_->yield(); // Return resources to pool as early as possible.\r
 226 \r
 227                 if(blend_modes_)\r
 228                 {\r
 229                         // http://www.opengl.org/registry/specs/NV/texture_barrier.txt\r
 230                         // This allows us to use framebuffer (background) both as source and target while blending.\r
 231                         glTextureBarrierNV(); \r
 232                 }\r
 233         }\r
 234 };\r
 235 \r
 236 image_kernel::image_kernel(const safe_ptr<ogl_device>& ogl) : impl_(new implementation(ogl)){}\r
 237 void image_kernel::draw(draw_params&& params)\r
 238 {\r
 239         impl_->draw(std::move(params));\r
 240 }\r
 241 \r
 242 }}