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