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

   1 #include "../../StdAfx.h"\r
   2 \r
   3 #include "image_mixer.h"\r
   4 #include "image_kernel.h"\r
   5 \r
   6 #include "../gpu/ogl_device.h"\r
   7 #include "../gpu/host_buffer.h"\r
   8 #include "../gpu/device_buffer.h"\r
   9 \r
  10 #include <common/exception/exceptions.h>\r
  11 #include <common/gl/gl_check.h>\r
  12 #include <common/concurrency/executor.h>\r
  13 \r
  14 #include <Glee.h>\r
  15 #include <SFML/Window/Context.hpp>\r
  16 #include <unordered_map>\r
  17 \r
  18 namespace caspar { namespace core {\r
  19                 \r
  20 image_transform::image_transform() \r
  21         : opacity_(1.0)\r
  22         , gain_(1.0)\r
  23         , mode_(video_mode::invalid)\r
  24 {\r
  25         std::fill(pos_.begin(), pos_.end(), 0.0);\r
  26         std::fill(uv_.begin(), uv_.end(), 0.0);\r
  27 }\r
  28 \r
  29 void image_transform::set_opacity(double value)\r
  30 {\r
  31         tbb::spin_mutex::scoped_lock(mutex_);   \r
  32         opacity_ = value;\r
  33 }\r
  34 \r
  35 double image_transform::get_opacity() const\r
  36 {\r
  37         tbb::spin_mutex::scoped_lock(mutex_);\r
  38         return opacity_;\r
  39 }\r
  40 \r
  41 void image_transform::set_gain(double value)\r
  42 {\r
  43         tbb::spin_mutex::scoped_lock(mutex_);\r
  44         gain_ = value;\r
  45 }\r
  46 \r
  47 double image_transform::get_gain() const\r
  48 {\r
  49         tbb::spin_mutex::scoped_lock(mutex_);\r
  50         return gain_;\r
  51 }\r
  52 \r
  53 void image_transform::set_position(double x, double y)\r
  54 {\r
  55         std::array<double, 2> value = {x, y};\r
  56         tbb::spin_mutex::scoped_lock(mutex_);\r
  57         pos_ = value;\r
  58 }\r
  59 \r
  60 std::array<double, 2> image_transform::get_position() const\r
  61 {\r
  62         tbb::spin_mutex::scoped_lock(mutex_);\r
  63         return pos_;\r
  64 }\r
  65 \r
  66 void image_transform::set_uv(double left, double top, double right, double bottom)\r
  67 {\r
  68         std::array<double, 4> value = {left, top, right, bottom};\r
  69         tbb::spin_mutex::scoped_lock(mutex_);\r
  70         uv_ = value;\r
  71 }\r
  72 \r
  73 std::array<double, 4> image_transform::get_uv() const\r
  74 {\r
  75         tbb::spin_mutex::scoped_lock(mutex_);\r
  76         return uv_;\r
  77 }\r
  78 \r
  79 void image_transform::set_mode(video_mode::type mode)\r
  80 {\r
  81         tbb::spin_mutex::scoped_lock(mutex_);\r
  82         mode_ = mode;\r
  83 }\r
  84 \r
  85 video_mode::type image_transform::get_mode() const\r
  86 {\r
  87         tbb::spin_mutex::scoped_lock(mutex_);\r
  88         return mode_;\r
  89 }\r
  90 \r
  91 \r
  92 image_transform& image_transform::operator*=(const image_transform &other)\r
  93 {\r
  94         tbb::spin_mutex::scoped_lock(mutex_);\r
  95         opacity_ *= other.opacity_;\r
  96         mode_ = other.mode_;\r
  97         gain_ *= other.gain_;\r
  98         uv_[0] += other.uv_[0];\r
  99         uv_[1] += other.uv_[1];\r
 100         uv_[2] += other.uv_[2];\r
 101         uv_[3] += other.uv_[3];\r
 102         pos_[0] += other.pos_[0];\r
 103         pos_[1] += other.pos_[1];\r
 104         return *this;\r
 105 }\r
 106 \r
 107 const image_transform image_transform::operator*(const image_transform &other) const\r
 108 {\r
 109         return image_transform(*this) *= other;\r
 110 }\r
 111 \r
 112 struct image_mixer::implementation : boost::noncopyable\r
 113 {                       \r
 114         const video_format_desc format_desc_;\r
 115         \r
 116         std::stack<image_transform> transform_stack_;\r
 117 \r
 118         GLuint fbo_;\r
 119         std::array<std::shared_ptr<device_buffer>, 2> render_targets_;\r
 120 \r
 121         std::shared_ptr<host_buffer> reading_;\r
 122 \r
 123         image_kernel kernel_;\r
 124 \r
 125         safe_ptr<ogl_device> context_;\r
 126 \r
 127 public:\r
 128         implementation(const video_format_desc& format_desc) \r
 129                 : format_desc_(format_desc)\r
 130                 , context_(ogl_device::create())\r
 131         {\r
 132                 context_->begin_invoke([=]\r
 133                 {\r
 134                         transform_stack_.push(image_transform());\r
 135                         transform_stack_.top().set_mode(video_mode::progressive);\r
 136                         transform_stack_.top().set_uv(0.0, 1.0, 1.0, 0.0);\r
 137 \r
 138                         GL(glEnable(GL_TEXTURE_2D));\r
 139                         GL(glDisable(GL_DEPTH_TEST));           \r
 140 \r
 141                         render_targets_[0] = context_->create_device_buffer(format_desc.width, format_desc.height, 4);\r
 142                         render_targets_[1] = context_->create_device_buffer(format_desc.width, format_desc.height, 4);\r
 143                         \r
 144                         GL(glGenFramebuffers(1, &fbo_));                \r
 145                         GL(glBindFramebuffer(GL_FRAMEBUFFER_EXT, fbo_));\r
 146                         GL(glReadBuffer(GL_COLOR_ATTACHMENT0_EXT));\r
 147 \r
 148                         reading_ = context_->create_host_buffer(format_desc_.size, host_buffer::read_only);\r
 149                 });\r
 150         }\r
 151 \r
 152         ~implementation()\r
 153         {\r
 154                 glDeleteFramebuffersEXT(1, &fbo_);\r
 155         }\r
 156 \r
 157         void begin(const image_transform& transform)\r
 158         {\r
 159                 transform_stack_.push(transform_stack_.top()*transform);\r
 160         }\r
 161                 \r
 162         void render(const pixel_format_desc& desc, std::vector<safe_ptr<host_buffer>>& buffers)\r
 163         {\r
 164                 auto transform = transform_stack_.top();\r
 165                 context_->begin_invoke([=]\r
 166                 {\r
 167                         GL(glLoadIdentity());\r
 168                         GL(glTranslated(transform.get_position()[0]*2.0, transform.get_position()[1]*2.0, 0.0));\r
 169                         GL(glColor4d(1.0, 1.0, 1.0, transform.get_opacity()));\r
 170                         GL(glViewport(0, 0, format_desc_.width, format_desc_.height));\r
 171                         kernel_.apply(desc.pix_fmt, transform);\r
 172 \r
 173                         std::vector<safe_ptr<device_buffer>> device_buffers;\r
 174                         for(size_t n = 0; n < buffers.size(); ++n)\r
 175                         {\r
 176                                 auto texture = context_->create_device_buffer(desc.planes[n].width, desc.planes[n].height, desc.planes[n].channels);\r
 177                                 texture->read(*buffers[n]);\r
 178                                 device_buffers.push_back(texture);\r
 179                         }\r
 180 \r
 181                         for(size_t n = 0; n < buffers.size(); ++n)\r
 182                         {\r
 183                                 glActiveTexture(GL_TEXTURE0+n);\r
 184                                 device_buffers[n]->bind();\r
 185                         }\r
 186 \r
 187                         auto t = transform;\r
 188                         glBegin(GL_QUADS);\r
 189                                 glTexCoord2d(t.get_uv()[0], t.get_uv()[3]); glVertex2d(-1.0, -1.0);\r
 190                                 glTexCoord2d(t.get_uv()[2], t.get_uv()[3]); glVertex2d( 1.0, -1.0);\r
 191                                 glTexCoord2d(t.get_uv()[2], t.get_uv()[1]); glVertex2d( 1.0,  1.0);\r
 192                                 glTexCoord2d(t.get_uv()[0], t.get_uv()[1]); glVertex2d(-1.0,  1.0);\r
 193                         glEnd();\r
 194                 });\r
 195         }\r
 196 \r
 197         void end()\r
 198         {\r
 199                 transform_stack_.pop();\r
 200         }\r
 201 \r
 202         boost::unique_future<safe_ptr<const host_buffer>> begin_pass()\r
 203         {\r
 204                 return context_->begin_invoke([=]() -> safe_ptr<const host_buffer>\r
 205                 {\r
 206                         reading_->map();\r
 207                         render_targets_[0]->attach(0);\r
 208                         GL(glClear(GL_COLOR_BUFFER_BIT));\r
 209                         return safe_ptr<const host_buffer>(reading_);\r
 210                 });\r
 211         }\r
 212 \r
 213         void end_pass()\r
 214         {\r
 215                 context_->begin_invoke([=]\r
 216                 {\r
 217                         reading_ = context_->create_host_buffer(format_desc_.size, host_buffer::read_only);\r
 218                         render_targets_[0]->write(*reading_);\r
 219                         std::rotate(render_targets_.begin(), render_targets_.begin() + 1, render_targets_.end());\r
 220                 });\r
 221         }\r
 222                 \r
 223         std::vector<safe_ptr<host_buffer>> create_buffers(const pixel_format_desc& format)\r
 224         {\r
 225                 std::vector<safe_ptr<host_buffer>> buffers;\r
 226                 std::transform(format.planes.begin(), format.planes.end(), std::back_inserter(buffers), [&](const pixel_format_desc::plane& plane) -> safe_ptr<host_buffer>\r
 227                 {\r
 228                         return context_->create_host_buffer(plane.size, host_buffer::write_only);\r
 229                 });\r
 230                 return buffers;\r
 231         }\r
 232 };\r
 233 \r
 234 image_mixer::image_mixer(const video_format_desc& format_desc) : impl_(new implementation(format_desc)){}\r
 235 void image_mixer::begin(const image_transform& transform) {     impl_->begin(transform);}\r
 236 void image_mixer::process(const pixel_format_desc& desc, std::vector<safe_ptr<host_buffer>>& buffers){  impl_->render(desc, buffers);}\r
 237 void image_mixer::end(){impl_->end();}\r
 238 boost::unique_future<safe_ptr<const host_buffer>> image_mixer::begin_pass(){    return impl_->begin_pass();}\r
 239 void image_mixer::end_pass(){impl_->end_pass();}\r
 240 std::vector<safe_ptr<host_buffer>> image_mixer::create_buffers(const pixel_format_desc& format){return impl_->create_buffers(format);}\r
 241 \r
 242 }}