git.sesse.net Git - casparcg/blob - modules/ogl/consumer/ogl_consumer.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 \r
  21 #include "ogl_consumer.h"\r
  22 \r
  23 #include <GL/glew.h>\r
  24 #include <SFML/Window.hpp>\r
  25 \r
  26 #include <common/diagnostics/graph.h>\r
  27 #include <common/gl/gl_check.h>\r
  28 #include <common/log/log.h>\r
  29 #include <common/memory/safe_ptr.h>\r
  30 #include <common/memory/memcpy.h>\r
  31 #include <common/memory/memshfl.h>\r
  32 #include <common/utility/timer.h>\r
  33 #include <common/utility/string.h>\r
  34 \r
  35 #include <core/video_format.h>\r
  36 #include <core/mixer/read_frame.h>\r
  37 #include <core/consumer/frame_consumer.h>\r
  38 \r
  39 #include <boost/timer.hpp>\r
  40 #include <boost/circular_buffer.hpp>\r
  41 #include <boost/foreach.hpp>\r
  42 #include <boost/thread.hpp>\r
  43 \r
  44 #include <tbb/atomic.h>\r
  45 #include <tbb/concurrent_queue.h>\r
  46 \r
  47 #include <algorithm>\r
  48 #include <vector>\r
  49 \r
  50 namespace caspar {\r
  51                 \r
  52 enum stretch\r
  53 {\r
  54         none,\r
  55         uniform,\r
  56         fill,\r
  57         uniform_to_fill\r
  58 };\r
  59 \r
  60 struct ogl_consumer : boost::noncopyable\r
  61 {               \r
  62         core::video_format_desc format_desc_;\r
  63         \r
  64         GLuint                                  texture_;\r
  65         std::vector<GLuint>             pbos_;\r
  66         \r
  67         float                                   width_;\r
  68         float                                   height_;\r
  69         \r
  70         const stretch                   stretch_;\r
  71 \r
  72         const bool                              windowed_;\r
  73         unsigned int                    screen_x_;\r
  74         unsigned int                    screen_y_;\r
  75         unsigned int                    screen_width_;\r
  76         unsigned int                    screen_height_;\r
  77         const unsigned int              screen_index_;\r
  78 \r
  79         size_t                                  square_width_;\r
  80         size_t                                  square_height_;                         \r
  81         \r
  82         sf::Window                              window_;\r
  83         \r
  84         safe_ptr<diagnostics::graph> graph_;\r
  85         boost::timer                    perf_timer_;\r
  86 \r
  87         boost::circular_buffer<safe_ptr<core::read_frame>>                      input_buffer_;\r
  88         tbb::concurrent_bounded_queue<safe_ptr<core::read_frame>>       frame_buffer_;\r
  89 \r
  90         boost::thread                   thread_;\r
  91         tbb::atomic<bool>               is_running_;\r
  92 \r
  93         const bool key_only_;\r
  94 public:\r
  95         ogl_consumer(unsigned int screen_index, stretch stretch, bool windowed, const core::video_format_desc& format_desc, bool key_only) \r
  96                 : format_desc_(format_desc)\r
  97                 , texture_(0)\r
  98                 , pbos_(2, 0)\r
  99                 , stretch_(stretch)\r
 100                 , windowed_(windowed)\r
 101                 , screen_index_(screen_index)           \r
 102                 , screen_width_(format_desc.width)\r
 103                 , screen_height_(format_desc.height)\r
 104                 , square_width_(format_desc.width)\r
 105                 , square_height_(format_desc.height)\r
 106                 , graph_(diagnostics::create_graph(narrow(print())))\r
 107                 , input_buffer_(core::consumer_buffer_depth()-1)\r
 108                 , key_only_(key_only)\r
 109         {               \r
 110                 frame_buffer_.set_capacity(2);\r
 111 \r
 112                 graph_->add_guide("frame-time", 0.5);\r
 113                 graph_->set_color("frame-time", diagnostics::color(1.0f, 0.0f, 0.0f));\r
 114                 graph_->set_color("dropped-frame", diagnostics::color(0.3f, 0.6f, 0.3f));\r
 115                                                                                 \r
 116                 if(format_desc_.format == core::video_format::pal)\r
 117                 {\r
 118                         square_width_   = 768;\r
 119                         square_height_  = 576;\r
 120                 }\r
 121                 else if(format_desc_.format == core::video_format::ntsc)\r
 122                 {\r
 123                         square_width_   = 720;\r
 124                         square_height_  = 547;\r
 125                 }\r
 126                 \r
 127                 DISPLAY_DEVICE d_device;                        \r
 128                 memset(&d_device, 0, sizeof(d_device));\r
 129                 d_device.cb = sizeof(d_device);\r
 130 \r
 131                 std::vector<DISPLAY_DEVICE> displayDevices;\r
 132                 for(int n = 0; EnumDisplayDevices(NULL, n, &d_device, NULL); ++n)\r
 133                 {\r
 134                         displayDevices.push_back(d_device);\r
 135                         memset(&d_device, 0, sizeof(d_device));\r
 136                         d_device.cb = sizeof(d_device);\r
 137                 }\r
 138 \r
 139                 if(screen_index_ >= displayDevices.size())\r
 140                         BOOST_THROW_EXCEPTION(out_of_range() << arg_name_info("screen_index_") << msg_info(narrow(print())));\r
 141                 \r
 142                 DEVMODE devmode;\r
 143                 memset(&devmode, 0, sizeof(devmode));\r
 144                 \r
 145                 if(!EnumDisplaySettings(displayDevices[screen_index_].DeviceName, ENUM_CURRENT_SETTINGS, &devmode))\r
 146                         BOOST_THROW_EXCEPTION(invalid_operation() << arg_name_info("screen_index") << msg_info(narrow(print()) + " EnumDisplaySettings"));\r
 147                 \r
 148                 screen_x_               = devmode.dmPosition.x;\r
 149                 screen_y_               = devmode.dmPosition.y;\r
 150                 screen_width_   = windowed_ ? square_width_ : devmode.dmPelsWidth;\r
 151                 screen_height_  = windowed_ ? square_height_ : devmode.dmPelsHeight;\r
 152                 \r
 153                 is_running_ = true;\r
 154                 thread_ = boost::thread([this]{run();});\r
 155         }\r
 156         \r
 157         ~ogl_consumer()\r
 158         {\r
 159                 is_running_ = false;\r
 160                 frame_buffer_.try_push(make_safe<core::read_frame>());\r
 161                 thread_.join();\r
 162         }\r
 163 \r
 164         void init()\r
 165         {\r
 166                 if(!GLEW_VERSION_2_1)\r
 167                         BOOST_THROW_EXCEPTION(not_supported() << msg_info("Missing OpenGL 2.1 support."));\r
 168 \r
 169                 window_.Create(sf::VideoMode(screen_width_, screen_height_, 32), narrow(print()), windowed_ ? sf::Style::Resize : sf::Style::Fullscreen);\r
 170                 window_.ShowMouseCursor(false);\r
 171                 window_.SetPosition(screen_x_, screen_y_);\r
 172                 window_.SetSize(screen_width_, screen_height_);\r
 173                 window_.SetActive();\r
 174                 GL(glEnable(GL_TEXTURE_2D));\r
 175                 GL(glDisable(GL_DEPTH_TEST));           \r
 176                 GL(glClearColor(0.0, 0.0, 0.0, 0.0));\r
 177                 GL(glViewport(0, 0, format_desc_.width, format_desc_.height));\r
 178                 GL(glLoadIdentity());\r
 179                                 \r
 180                 calculate_aspect();\r
 181                         \r
 182                 GL(glGenTextures(1, &texture_));\r
 183                 GL(glBindTexture(GL_TEXTURE_2D, texture_));\r
 184                 GL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST));\r
 185                 GL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST));\r
 186                 GL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP));\r
 187                 GL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP));\r
 188                 GL(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, format_desc_.width, format_desc_.height, 0, GL_BGRA, GL_UNSIGNED_BYTE, 0));\r
 189                 GL(glBindTexture(GL_TEXTURE_2D, 0));\r
 190                                         \r
 191                 GL(glGenBuffers(2, pbos_.data()));\r
 192                         \r
 193                 glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pbos_[0]);\r
 194                 glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, format_desc_.size, 0, GL_STREAM_DRAW_ARB);\r
 195                 glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pbos_[1]);\r
 196                 glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, format_desc_.size, 0, GL_STREAM_DRAW_ARB);\r
 197                 glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);\r
 198 \r
 199                 CASPAR_LOG(info) << print() << " Sucessfully Initialized.";\r
 200         }\r
 201 \r
 202         void uninit()\r
 203         {               \r
 204                 if(texture_)\r
 205                         glDeleteTextures(1, &texture_);\r
 206 \r
 207                 BOOST_FOREACH(auto& pbo, pbos_)\r
 208                 {\r
 209                         if(pbo)\r
 210                                 glDeleteBuffers(1, &pbo);\r
 211                 }\r
 212 \r
 213                 CASPAR_LOG(info) << print() << " Sucessfully Uninitialized.";\r
 214         }\r
 215 \r
 216         void run()\r
 217         {\r
 218                 try\r
 219                 {\r
 220                         init();\r
 221 \r
 222                         while(is_running_)\r
 223                         {                       \r
 224                                 try\r
 225                                 {\r
 226                                         perf_timer_.restart();\r
 227 \r
 228                                         sf::Event e;            \r
 229                                         while(window_.GetEvent(e))\r
 230                                         {\r
 231                                                 if(e.Type == sf::Event::Resized)\r
 232                                                         calculate_aspect();\r
 233                                         }\r
 234                         \r
 235                                         safe_ptr<core::read_frame> frame;\r
 236                                         frame_buffer_.pop(frame);\r
 237                                         render(frame);\r
 238 \r
 239                                         window_.Display();\r
 240 \r
 241                                         graph_->update_value("frame-time", static_cast<float>(perf_timer_.elapsed()*format_desc_.fps*0.5));     \r
 242                                 }\r
 243                                 catch(...)\r
 244                                 {\r
 245                                         CASPAR_LOG_CURRENT_EXCEPTION();\r
 246                                         is_running_ = false;\r
 247                                 }\r
 248                         }\r
 249 \r
 250                         uninit();\r
 251                 }\r
 252                 catch(...)\r
 253                 {\r
 254                         CASPAR_LOG_CURRENT_EXCEPTION();\r
 255                 }\r
 256         }\r
 257         \r
 258         const core::video_format_desc& get_video_format_desc() const\r
 259         {\r
 260                 return format_desc_;\r
 261         }\r
 262 \r
 263         void render(const safe_ptr<core::read_frame>& frame)\r
 264         {                       \r
 265                 if(frame->image_data().empty())\r
 266                         return;\r
 267 \r
 268                 glBindTexture(GL_TEXTURE_2D, texture_);\r
 269 \r
 270                 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, pbos_[0]);\r
 271                 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, format_desc_.width, format_desc_.height, GL_BGRA, GL_UNSIGNED_BYTE, 0);\r
 272 \r
 273                 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, pbos_[1]);\r
 274                 glBufferData(GL_PIXEL_UNPACK_BUFFER, format_desc_.size, 0, GL_STREAM_DRAW);\r
 275 \r
 276                 auto ptr = glMapBuffer(GL_PIXEL_UNPACK_BUFFER, GL_WRITE_ONLY);\r
 277                 if(ptr)\r
 278                 {\r
 279                         if(key_only_)\r
 280                                 fast_memshfl(reinterpret_cast<char*>(ptr), frame->image_data().begin(), frame->image_data().size(), 0x0F0F0F0F, 0x0B0B0B0B, 0x07070707, 0x03030303);\r
 281                         else\r
 282                                 fast_memcpy(reinterpret_cast<char*>(ptr), frame->image_data().begin(), frame->image_data().size());\r
 283 \r
 284                         glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER); // release the mapped buffer\r
 285                 }\r
 286 \r
 287                 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);\r
 288                                 \r
 289                 GL(glClear(GL_COLOR_BUFFER_BIT));                       \r
 290                 glBegin(GL_QUADS);\r
 291                                 glTexCoord2f(0.0f,        1.0f);        glVertex2f(-width_, -height_);\r
 292                                 glTexCoord2f(1.0f,        1.0f);        glVertex2f( width_, -height_);\r
 293                                 glTexCoord2f(1.0f,        0.0f);        glVertex2f( width_,  height_);\r
 294                                 glTexCoord2f(0.0f,        0.0f);        glVertex2f(-width_,  height_);\r
 295                 glEnd();\r
 296                 \r
 297                 glBindTexture(GL_TEXTURE_2D, 0);\r
 298 \r
 299                 std::rotate(pbos_.begin(), pbos_.begin() + 1, pbos_.end());\r
 300         }\r
 301 \r
 302         void send(const safe_ptr<core::read_frame>& frame)\r
 303         {\r
 304                 input_buffer_.push_back(frame);\r
 305 \r
 306                 if(input_buffer_.full())\r
 307                 {\r
 308                         if(!frame_buffer_.try_push(input_buffer_.front()))\r
 309                                 graph_->add_tag("dropped-frame");\r
 310                 }\r
 311         }\r
 312                 \r
 313         std::wstring print() const\r
 314         {       \r
 315                 return  L"ogl[" + boost::lexical_cast<std::wstring>(screen_index_) + L"|" + format_desc_.name + L"]";\r
 316         }\r
 317         \r
 318         void calculate_aspect()\r
 319         {\r
 320                 if(windowed_)\r
 321                 {\r
 322                         screen_height_ = window_.GetHeight();\r
 323                         screen_width_ = window_.GetWidth();\r
 324                 }\r
 325                 \r
 326                 GL(glViewport(0, 0, screen_width_, screen_height_));\r
 327 \r
 328                 std::pair<float, float> target_ratio = None();\r
 329                 if(stretch_ == fill)\r
 330                         target_ratio = Fill();\r
 331                 else if(stretch_ == uniform)\r
 332                         target_ratio = Uniform();\r
 333                 else if(stretch_ == uniform_to_fill)\r
 334                         target_ratio = UniformToFill();\r
 335 \r
 336                 width_ = target_ratio.first;\r
 337                 height_ = target_ratio.second;\r
 338         }\r
 339                 \r
 340         std::pair<float, float> None()\r
 341         {\r
 342                 float width = static_cast<float>(square_width_)/static_cast<float>(screen_width_);\r
 343                 float height = static_cast<float>(square_height_)/static_cast<float>(screen_height_);\r
 344 \r
 345                 return std::make_pair(width, height);\r
 346         }\r
 347 \r
 348         std::pair<float, float> Uniform()\r
 349         {\r
 350                 float aspect = static_cast<float>(square_width_)/static_cast<float>(square_height_);\r
 351                 float width = std::min(1.0f, static_cast<float>(screen_height_)*aspect/static_cast<float>(screen_width_));\r
 352                 float height = static_cast<float>(screen_width_*width)/static_cast<float>(screen_height_*aspect);\r
 353 \r
 354                 return std::make_pair(width, height);\r
 355         }\r
 356 \r
 357         std::pair<float, float> Fill()\r
 358         {\r
 359                 return std::make_pair(1.0f, 1.0f);\r
 360         }\r
 361 \r
 362         std::pair<float, float> UniformToFill()\r
 363         {\r
 364                 float wr = static_cast<float>(square_width_)/static_cast<float>(screen_width_);\r
 365                 float hr = static_cast<float>(square_height_)/static_cast<float>(screen_height_);\r
 366                 float r_inv = 1.0f/std::min(wr, hr);\r
 367 \r
 368                 float width = wr*r_inv;\r
 369                 float height = hr*r_inv;\r
 370 \r
 371                 return std::make_pair(width, height);\r
 372         }\r
 373 };\r
 374 \r
 375 \r
 376 struct ogl_consumer_proxy : public core::frame_consumer\r
 377 {\r
 378         size_t screen_index_;\r
 379         caspar::stretch stretch_;\r
 380         bool windowed_;\r
 381         bool key_only_;\r
 382 \r
 383         std::unique_ptr<ogl_consumer> consumer_;\r
 384 \r
 385 public:\r
 386 \r
 387         ogl_consumer_proxy(size_t screen_index, stretch stretch, bool windowed, bool key_only)\r
 388                 : screen_index_(screen_index)\r
 389                 , stretch_(stretch)\r
 390                 , windowed_(windowed)\r
 391                 , key_only_(key_only){}\r
 392         \r
 393         virtual void initialize(const core::video_format_desc& format_desc)\r
 394         {\r
 395                 consumer_.reset(new ogl_consumer(screen_index_, stretch_, windowed_, format_desc, key_only_));\r
 396         }\r
 397         \r
 398         virtual bool send(const safe_ptr<core::read_frame>& frame)\r
 399         {\r
 400                 consumer_->send(frame);\r
 401                 return true;\r
 402         }\r
 403         \r
 404         virtual std::wstring print() const\r
 405         {\r
 406                 return consumer_->print();\r
 407         }\r
 408 \r
 409         virtual bool has_synchronization_clock() const \r
 410         {\r
 411                 return false;\r
 412         }\r
 413 \r
 414         virtual const core::video_format_desc& get_video_format_desc() const\r
 415         {\r
 416                 return consumer_->get_video_format_desc();\r
 417         }\r
 418 };      \r
 419 \r
 420 safe_ptr<core::frame_consumer> create_ogl_consumer(const std::vector<std::wstring>& params)\r
 421 {\r
 422         if(params.size() < 1 || params[0] != L"SCREEN")\r
 423                 return core::frame_consumer::empty();\r
 424         \r
 425         size_t screen_index = 0;\r
 426         stretch stretch = stretch::fill;\r
 427         bool windowed = true;\r
 428         \r
 429         if(params.size() > 1) \r
 430                 screen_index = lexical_cast_or_default<int>(params[2], screen_index);\r
 431 \r
 432         if(params.size() > 2) \r
 433                 windowed = lexical_cast_or_default<bool>(params[3], windowed);\r
 434 \r
 435         bool key_only = std::find(params.begin(), params.end(), L"KEY_ONLY") != params.end();\r
 436 \r
 437         return make_safe<ogl_consumer_proxy>(screen_index, stretch, windowed, key_only);\r
 438 }\r
 439 \r
 440 safe_ptr<core::frame_consumer> create_ogl_consumer(const boost::property_tree::ptree& ptree) \r
 441 {\r
 442         size_t screen_index = ptree.get("device", 0);\r
 443         bool windowed =ptree.get("windowed", true);\r
 444         \r
 445         stretch stretch = stretch::fill;\r
 446         auto key_str = ptree.get("stretch", "default");\r
 447         if(key_str == "uniform")\r
 448                 stretch = stretch::uniform;\r
 449         else if(key_str == "uniform_to_fill")\r
 450                 stretch = stretch::uniform_to_fill;\r
 451 \r
 452         bool key_only = ptree.get("key-only", false);\r
 453 \r
 454         return make_safe<ogl_consumer_proxy>(screen_index, stretch, windowed, key_only);\r
 455 }\r
 456 \r
 457 }