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
  32 #include <gl/glew.h>
  33
  34 #include <tbb/atomic.h>
  35
  36 namespace caspar { namespace accelerator { namespace ogl {
  37
  38 static tbb::atomic<int> g_w_total_count;
  39 static tbb::atomic<int> g_r_total_count;
  40
  41 struct buffer::impl : boost::noncopyable
  42 {
  43         GLuint                                          pbo_;
  44         const std::size_t                       size_;
  45         tbb::atomic<uint8_t*>           data_;
  46         GLenum                                          usage_;
  47         GLenum                                          target_;
  48
  49 public:
  50         impl(std::size_t size, buffer::usage usage)
  51                 : size_(size)
  52                 , target_(usage == buffer::usage::write_only ? GL_PIXEL_UNPACK_BUFFER : GL_PIXEL_PACK_BUFFER)
  53                 , usage_(usage == buffer::usage::write_only ? GL_STREAM_DRAW : GL_STREAM_READ)
  54         {
  55                 boost::timer timer;
  56
  57                 data_ = nullptr;
  58                 GL(glGenBuffers(1, &pbo_));
  59                 bind();
  60                 GL(glBufferData(target_, size_, NULL, usage_));
  61                 if(usage_ == GL_STREAM_DRAW)
  62                         data_ = (uint8_t*)GL2(glMapBuffer(target_, usage_ == GL_STREAM_DRAW ? GL_WRITE_ONLY : GL_READ_ONLY));
  63                 unbind();
  64
  65                 if(!pbo_)
  66                         CASPAR_THROW_EXCEPTION(caspar_exception() << msg_info("Failed to allocate buffer."));
  67
  68                 if(timer.elapsed() > 0.02)
  69                         CASPAR_LOG(debug) << L"[buffer] Performance warning. Buffer allocation blocked: " << timer.elapsed();
  70
  71                 //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");
  72         }
  73
  74         ~impl()
  75         {
  76                 glDeleteBuffers(1, &pbo_);
  77         }
  78
  79         void* map()
  80         {
  81                 if(data_ != nullptr)
  82                         return data_;
  83
  84                 boost::timer timer;
  85
  86                 GL(glBindBuffer(target_, pbo_));
  87                 if(usage_ == GL_STREAM_DRAW)
  88                         GL(glBufferData(target_, size_, NULL, usage_)); // Notify OpenGL that we don't care about previous data.
  89
  90                 data_ = (uint8_t*)GL2(glMapBuffer(target_, usage_ == GL_STREAM_DRAW ? GL_WRITE_ONLY : GL_READ_ONLY));
  91
  92                 if(timer.elapsed() > 0.02)
  93                         CASPAR_LOG(debug) << L"[buffer] Performance warning. Buffer mapping blocked: " << timer.elapsed();
  94
  95                 GL(glBindBuffer(target_, 0));
  96                 if(!data_)
  97                         CASPAR_THROW_EXCEPTION(invalid_operation() << msg_info("Failed to map target OpenGL Pixel Buffer Object."));
  98
  99                 return data_;
 100         }
 101
 102         void unmap()
 103         {
 104                 if(data_ == nullptr)
 105                         return;
 106
 107                 GL(glBindBuffer(target_, pbo_));
 108                 GL(glUnmapBuffer(target_));
 109                 if(usage_ == GL_STREAM_READ)
 110                         GL(glBufferData(target_, size_, NULL, usage_)); // Notify OpenGL that we don't care about previous data.
 111                 data_ = nullptr;
 112                 GL(glBindBuffer(target_, 0));
 113         }
 114
 115         void bind()
 116         {
 117                 GL(glBindBuffer(target_, pbo_));
 118         }
 119
 120         void unbind()
 121         {
 122                 GL(glBindBuffer(target_, 0));
 123         }
 124 };
 125
 126 buffer::buffer(std::size_t size, usage usage) : impl_(new impl(size, usage)){}
 127 buffer::buffer(buffer&& other) : impl_(std::move(other.impl_)){}
 128 buffer::~buffer(){}
 129 buffer& buffer::operator=(buffer&& other){impl_ = std::move(other.impl_); return *this;}
 130 uint8_t* buffer::data(){return impl_->data_;}
 131 void buffer::map(){impl_->map();}
 132 void buffer::unmap(){impl_->unmap();}
 133 void buffer::bind() const{impl_->bind();}
 134 void buffer::unbind() const{impl_->unbind();}
 135 std::size_t buffer::size() const { return impl_->size_; }
 136 int buffer::id() const {return impl_->pbo_;}
 137
 138 }}}