git.sesse.net Git - casparcg/blob - accelerator/ogl/util/buffer.cpp

   1 /*
   2 * Copyright (c) 2011 Sveriges Television AB <info@casparcg.com>
   3 *
   4 * This file is part of CasparCG (www.casparcg.com).
   5 *
   6 * CasparCG is free software: you can redistribute it and/or modify
   7 * it under the terms of the GNU General Public License as published by
   8 * the Free Software Foundation, either version 3 of the License, or
   9 * (at your option) any later version.
  10 *
  11 * CasparCG is distributed in the hope that it will be useful,
  12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 * GNU General Public License for more details.
  15 *
  16 * You should have received a copy of the GNU General Public License
  17 * along with CasparCG. If not, see <http://www.gnu.org/licenses/>.
  18 *
  19 * Author: Robert Nagy, ronag89@gmail.com
  20 */
  21
  22 #include "../../StdAfx.h"
  23
  24 #include "buffer.h"
  25
  26 #include "texture.h"
  27 #include "device.h"
  28
  29 #include <common/except.h>
  30 #include <common/gl/gl_check.h>
  31 #include <common/timer.h>
  32
  33 #include <GL/glew.h>
  34
  35 #include <tbb/atomic.h>
  36
  37 namespace caspar { namespace accelerator { namespace ogl {
  38
  39 static tbb::atomic<int> g_w_total_count;
  40 static tbb::atomic<int> g_r_total_count;
  41
  42 struct buffer::impl : boost::noncopyable
  43 {
  44         GLuint                                          pbo_;
  45         const std::size_t                       size_;
  46         tbb::atomic<uint8_t*>           data_;
  47         GLenum                                          usage_;
  48         GLenum                                          target_;
  49
  50 public:
  51         impl(std::size_t size, buffer::usage usage)
  52                 : size_(size)
  53                 , target_(usage == buffer::usage::write_only ? GL_PIXEL_UNPACK_BUFFER : GL_PIXEL_PACK_BUFFER)
  54                 , usage_(usage == buffer::usage::write_only ? GL_STREAM_DRAW : GL_STREAM_READ)
  55         {
  56                 caspar::timer timer;
  57
  58                 data_ = nullptr;
  59                 GL(glGenBuffers(1, &pbo_));
  60                 bind();
  61                 GL(glBufferData(target_, size_, NULL, usage_));
  62                 if(usage_ == GL_STREAM_DRAW)
  63                 {
  64                         auto result = GL2(glMapBuffer(target_, usage_ == GL_STREAM_DRAW ? GL_WRITE_ONLY : GL_READ_ONLY));
  65                         data_ = reinterpret_cast<uint8_t*>(result);
  66                 }
  67                 unbind();
  68
  69                 if(!pbo_)
  70                         CASPAR_THROW_EXCEPTION(caspar_exception() << msg_info("Failed to allocate buffer."));
  71
  72                 if(timer.elapsed() > 0.02)
  73                         CASPAR_LOG(warning) << L"[buffer] Performance warning. Buffer allocation blocked: " << timer.elapsed();
  74
  75                 //CASPAR_LOG(trace) << "[buffer] [" << ++(usage_ == buffer::usage::write_only ? g_w_total_count : g_r_total_count) << L"] allocated size:" << size_ << " usage: " << (usage == buffer::usage::write_only ? "write_only" : "read_only");
  76         }
  77
  78         ~impl()
  79         {
  80                 glDeleteBuffers(1, &pbo_);
  81         }
  82
  83         void* map()
  84         {
  85                 if(data_ != nullptr)
  86                         return data_;
  87
  88                 caspar::timer timer;
  89
  90                 GL(glBindBuffer(target_, pbo_));
  91                 if(usage_ == GL_STREAM_DRAW)
  92                         GL(glBufferData(target_, size_, NULL, usage_)); // Notify OpenGL that we don't care about previous data.
  93
  94                 auto result = GL2(glMapBuffer(target_, usage_ == GL_STREAM_DRAW ? GL_WRITE_ONLY : GL_READ_ONLY));
  95                 data_ = (uint8_t*) result;
  96
  97                 if(timer.elapsed() > 0.02)
  98                         CASPAR_LOG(warning) << L"[buffer] Performance warning. Buffer mapping blocked: " << timer.elapsed();
  99
 100                 GL(glBindBuffer(target_, 0));
 101                 if(!data_)
 102                         CASPAR_THROW_EXCEPTION(invalid_operation() << msg_info("Failed to map target OpenGL Pixel Buffer Object."));
 103
 104                 return data_;
 105         }
 106
 107         void unmap()
 108         {
 109                 if(data_ == nullptr)
 110                         return;
 111
 112                 GL(glBindBuffer(target_, pbo_));
 113                 GL(glUnmapBuffer(target_));
 114                 if(usage_ == GL_STREAM_READ)
 115                         GL(glBufferData(target_, size_, NULL, usage_)); // Notify OpenGL that we don't care about previous data.
 116                 data_ = nullptr;
 117                 GL(glBindBuffer(target_, 0));
 118         }
 119
 120         void bind()
 121         {
 122                 GL(glBindBuffer(target_, pbo_));
 123         }
 124
 125         void unbind()
 126         {
 127                 GL(glBindBuffer(target_, 0));
 128         }
 129 };
 130
 131 buffer::buffer(std::size_t size, usage usage) : impl_(new impl(size, usage)){}
 132 buffer::buffer(buffer&& other) : impl_(std::move(other.impl_)){}
 133 buffer::~buffer(){}
 134 buffer& buffer::operator=(buffer&& other){impl_ = std::move(other.impl_); return *this;}
 135 uint8_t* buffer::data(){return impl_->data_;}
 136 void buffer::map(){impl_->map();}
 137 void buffer::unmap(){impl_->unmap();}
 138 void buffer::bind() const{impl_->bind();}
 139 void buffer::unbind() const{impl_->unbind();}
 140 std::size_t buffer::size() const { return impl_->size_; }
 141 int buffer::id() const {return impl_->pbo_;}
 142
 143 }}}