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