*
* Author: Robert Nagy, ronag89@gmail.com
*/
-#include "../../stdafx.h"
+#include "../../StdAfx.h"
#include "image_mixer.h"
#include <common/gl/gl_check.h>
#include <common/future.h>
#include <common/array.h>
+#include <common/linq.h>
#include <core/frame/frame.h>
#include <core/frame/frame_transform.h>
#include <asmlib.h>
-#include <gl/glew.h>
+#include <GL/glew.h>
-#include <boost/foreach.hpp>
#include <boost/range/algorithm_ext/erase.hpp>
#include <boost/thread/future.hpp>
#include <algorithm>
#include <vector>
-using namespace boost::assign;
-
namespace caspar { namespace accelerator { namespace ogl {
-typedef boost::shared_future<spl::shared_ptr<texture>> future_texture;
+typedef std::shared_future<std::shared_ptr<texture>> future_texture;
struct item
{
- core::pixel_format_desc pix_desc;
- std::vector<future_texture> textures;
- core::image_transform transform;
- core::frame_geometry geometry;
-
- item()
- : pix_desc(core::pixel_format::invalid)
- {
- }
+ core::pixel_format_desc pix_desc = core::pixel_format::invalid;
+ std::vector<future_texture> textures;
+ core::image_transform transform;
+ core::frame_geometry geometry = core::frame_geometry::get_default();
};
struct layer
{
+ std::vector<layer> sublayers;
std::vector<item> items;
core::blend_mode blend_mode;
- layer()
- : blend_mode(core::blend_mode::normal)
- {
- }
-
- layer(std::vector<item> items, core::blend_mode blend_mode)
- : items(std::move(items))
- , blend_mode(blend_mode)
+ layer(core::blend_mode blend_mode)
+ : blend_mode(blend_mode)
{
}
};
+std::size_t get_max_video_format_size()
+{
+ auto format_size = [](core::video_format format) { return core::video_format_desc(format).size; };
+ return cpplinq::from(enum_constants<core::video_format>())
+ .select(std::ref(format_size))
+ .max();
+}
+
class image_renderer
{
spl::shared_ptr<device> ogl_;
image_kernel kernel_;
public:
- image_renderer(const spl::shared_ptr<device>& ogl)
+ image_renderer(const spl::shared_ptr<device>& ogl, bool blend_modes_wanted, bool straight_alpha_wanted)
: ogl_(ogl)
- , kernel_(ogl_)
+ , kernel_(ogl_, blend_modes_wanted, straight_alpha_wanted)
{
}
- boost::unique_future<array<const std::uint8_t>> operator()(std::vector<layer> layers, const core::video_format_desc& format_desc)
+ std::future<array<const std::uint8_t>> operator()(std::vector<layer> layers, const core::video_format_desc& format_desc, bool straighten_alpha)
{
if(layers.empty())
{ // Bypass GPU with empty frame.
- auto buffer = spl::make_shared<const std::vector<uint8_t, tbb::cache_aligned_allocator<uint8_t>>>(format_desc.size, 0);
- return async(launch::deferred, [=]
- {
- return array<const std::uint8_t>(buffer->data(), format_desc.size, true, buffer);
- });
- }
+ static const cache_aligned_vector<uint8_t> buffer(get_max_video_format_size(), 0);
+ return make_ready_future(array<const std::uint8_t>(buffer.data(), format_desc.size, true));
+ }
if(format_desc.field_mode != core::field_mode::progressive)
{ // Remove jitter from still.
- BOOST_FOREACH(auto& layer, layers)
- {
+ for (auto& layer : layers)
+ {
// Remove first field stills.
boost::range::remove_erase_if(layer.items, [&](const item& item)
{
return item.transform.is_still && item.transform.field_mode == format_desc.field_mode; // only us last field for stills.
});
-
+
// Stills are progressive
- BOOST_FOREACH(auto& item, layer.items)
+ for (auto& item : layer.items)
{
if(item.transform.is_still)
item.transform.field_mode = core::field_mode::progressive;
}
}
- return flatten(ogl_->begin_invoke([=]() mutable ->
boost::shared_future<array<const std::uint8_t>>
+ return flatten(ogl_->begin_invoke([=]() mutable ->
std::shared_future<array<const std::uint8_t>>
{
- auto target_texture = ogl_->create_texture(format_desc.width, format_desc.height, 4);
+ auto target_texture = ogl_->create_texture(format_desc.width, format_desc.height, 4, false);
- if(format_desc.field_mode != core::field_mode::progressive)
+ if (format_desc.field_mode != core::field_mode::progressive)
{
- draw(target_texture, layers, format_desc, core::field_mode::upper);
+ draw(target_texture, layers, format_desc, core::field_mode::upper);
draw(target_texture, std::move(layers), format_desc, core::field_mode::lower);
}
- else
+ else
draw(target_texture, std::move(layers), format_desc, core::field_mode::progressive);
-
+
+ kernel_.post_process(target_texture, straighten_alpha);
+
return ogl_->copy_async(target_texture);
}));
}
{
std::shared_ptr<texture> layer_key_texture;
- BOOST_FOREACH(auto& layer, layers)
+ for (auto& layer : layers)
+ {
+ draw(target_texture, layer.sublayers, format_desc, field_mode);
draw(target_texture, std::move(layer), layer_key_texture, format_desc, field_mode);
+ }
}
void draw(spl::shared_ptr<texture>& target_texture,
//}
// Mask out fields
- BOOST_FOREACH(auto& item, layer.items)
+ for (auto& item : layer.items)
item.transform.field_mode &= field_mode;
// Remove empty items.
if(layer.blend_mode != core::blend_mode::normal)
{
- auto layer_texture = ogl_->create_texture(target_texture->width(), target_texture->height(), 4);
+ auto layer_texture = ogl_->create_texture(target_texture->width(), target_texture->height(), 4, false);
- BOOST_FOREACH(auto& item, layer.items)
- draw(layer_texture, std::move(item), layer_key_texture, local_key_texture, local_mix_texture);
+ for (auto& item : layer.items)
+ draw(layer_texture, std::move(item), layer_key_texture, local_key_texture, local_mix_texture, format_desc);
draw(layer_texture, std::move(local_mix_texture), core::blend_mode::normal);
draw(target_texture, std::move(layer_texture), layer.blend_mode);
}
else // fast path
{
- BOOST_FOREACH(auto& item, layer.items)
- draw(target_texture, std::move(item), layer_key_texture, local_key_texture, local_mix_texture);
+ for (auto& item : layer.items)
+ draw(target_texture, std::move(item), layer_key_texture, local_key_texture, local_mix_texture, format_desc);
draw(target_texture, std::move(local_mix_texture), core::blend_mode::normal);
}
layer_key_texture = std::move(local_key_texture);
}
- void draw(spl::shared_ptr<texture>& target_texture,
- item item,
- std::shared_ptr<texture>& layer_key_texture,
- std::shared_ptr<texture>& local_key_texture,
- std::shared_ptr<texture>& local_mix_texture)
+ void draw(spl::shared_ptr<texture>& target_texture,
+ item item,
+ std::shared_ptr<texture>& layer_key_texture,
+ std::shared_ptr<texture>& local_key_texture,
+ std::shared_ptr<texture>& local_mix_texture,
+ const core::video_format_desc& format_desc)
{
draw_params draw_params;
- draw_params.pix_desc = std::move(item.pix_desc);
- draw_params.transform = std::move(item.transform);
- draw_params.geometry = item.geometry;
+ draw_params.pix_desc = std::move(item.pix_desc);
+ draw_params.transform = std::move(item.transform);
+ draw_params.geometry = item.geometry;
+ draw_params.aspect_ratio = static_cast<double>(format_desc.square_width) / static_cast<double>(format_desc.square_height);
- BOOST_FOREACH(auto& future_texture, item.textures)
- draw_params.textures.push_back(future_texture.get());
+ for (auto& future_texture : item.textures)
+ draw_params.textures.push_back(spl::make_shared_ptr(future_texture.get()));
if(item.transform.is_key)
{
- local_key_texture = local_key_texture ? local_key_texture : ogl_->create_texture(target_texture->width(), target_texture->height(), 1);
+ local_key_texture = local_key_texture ? local_key_texture : ogl_->create_texture(target_texture->width(), target_texture->height(), 1, draw_params.transform.use_mipmap);
- draw_params.background = local_key_texture;
- draw_params.local_key = nullptr;
- draw_params.layer_key = nullptr;
+ draw_params.background = local_key_texture;
+ draw_params.local_key = nullptr;
+ draw_params.layer_key = nullptr;
kernel_.draw(std::move(draw_params));
}
else if(item.transform.is_mix)
{
- local_mix_texture = local_mix_texture ? local_mix_texture : ogl_->create_texture(target_texture->width(), target_texture->height(), 4);
+ local_mix_texture = local_mix_texture ? local_mix_texture : ogl_->create_texture(target_texture->width(), target_texture->height(), 4, draw_params.transform.use_mipmap);
- draw_params.background = local_mix_texture;
- draw_params.local_key = std::move(local_key_texture);
- draw_params.layer_key = layer_key_texture;
+ draw_params.background = local_mix_texture;
+ draw_params.local_key = std::move(local_key_texture);
+ draw_params.layer_key = layer_key_texture;
- draw_params.keyer = keyer::additive;
+ draw_params.keyer = keyer::additive;
kernel_.draw(std::move(draw_params));
}
{
draw(target_texture, std::move(local_mix_texture), core::blend_mode::normal);
- draw_params.background = target_texture;
- draw_params.local_key = std::move(local_key_texture);
- draw_params.layer_key = layer_key_texture;
+ draw_params.background = target_texture;
+ draw_params.local_key = std::move(local_key_texture);
+ draw_params.layer_key = layer_key_texture;
kernel_.draw(std::move(draw_params));
}
return;
draw_params draw_params;
- draw_params.pix_desc.format = core::pixel_format::bgra;
- draw_params.pix_desc.planes = list_of(core::pixel_format_desc::plane(source_buffer->width(), source_buffer->height(), 4));
- draw_params.textures = list_of(source_buffer);
- draw_params.transform = core::image_transform();
- draw_params.blend_mode = blend_mode;
- draw_params.background = target_texture;
- draw_params.geometry = core::frame_geometry::default();
+ draw_params.pix_desc.format = core::pixel_format::bgra;
+ draw_params.pix_desc.planes = { core::pixel_format_desc::plane(source_buffer->width(), source_buffer->height(), 4) };
+ draw_params.textures = { spl::make_shared_ptr(source_buffer) };
+ draw_params.transform = core::image_transform();
+ draw_params.blend_mode = blend_mode;
+ draw_params.background = target_texture;
+ draw_params.geometry = core::frame_geometry::get_default();
kernel_.draw(std::move(draw_params));
}
image_renderer renderer_;
std::vector<core::image_transform> transform_stack_;
std::vector<layer> layers_; // layer/stream/items
+ std::vector<layer*> layer_stack_;
public:
- impl(const spl::shared_ptr<device>& ogl)
+ impl(const spl::shared_ptr<device>& ogl, bool blend_modes_wanted, bool straight_alpha_wanted, int channel_id)
: ogl_(ogl)
- , renderer_(ogl)
+ , renderer_(ogl, blend_modes_wanted, straight_alpha_wanted)
, transform_stack_(1)
{
- CASPAR_LOG(info) << L"Initialized OpenGL Accelerated GPU Image Mixer";
- }
-
- void begin_layer(core::blend_mode blend_mode)
- {
- layers_.push_back(layer(std::vector<item>(), blend_mode));
+ CASPAR_LOG(info) << L"Initialized OpenGL Accelerated GPU Image Mixer for channel " << channel_id;
}
void push(const core::frame_transform& transform)
{
- transform_stack_.push_back(transform_stack_.back()*transform.image_transform);
+ auto previous_layer_depth = transform_stack_.back().layer_depth;
+ transform_stack_.push_back(transform_stack_.back() * transform.image_transform);
+ auto new_layer_depth = transform_stack_.back().layer_depth;
+
+ if (previous_layer_depth < new_layer_depth)
+ {
+ layer new_layer(transform_stack_.back().blend_mode);
+
+ if (layer_stack_.empty())
+ {
+ layers_.push_back(std::move(new_layer));
+ layer_stack_.push_back(&layers_.back());
+ }
+ else
+ {
+ layer_stack_.back()->sublayers.push_back(std::move(new_layer));
+ layer_stack_.push_back(&layer_stack_.back()->sublayers.back());
+ }
+ }
+
}
void visit(const core::const_frame& frame)
// NOTE: Once we have copied the arrays they are no longer valid for reading!!! Check for alternative solution e.g. transfer with AMD_pinned_memory.
for(int n = 0; n < static_cast<int>(item.pix_desc.planes.size()); ++n)
- item.textures.push_back(ogl_->copy_async(frame.image_data(n), item.pix_desc.planes[n].width, item.pix_desc.planes[n].height, item.pix_desc.planes[n].stride));
+ item.textures.push_back(ogl_->copy_async(frame.image_data(n), item.pix_desc.planes[n].width, item.pix_desc.planes[n].height, item.pix_desc.planes[n].stride, item.transform.use_mipmap));
- layers_.back().items.push_back(item);
+ layer_stack_.back()->items.push_back(item);
}
void pop()
{
transform_stack_.pop_back();
- }
-
- void end_layer()
- {
+ layer_stack_.resize(transform_stack_.back().layer_depth);
}
- boost::unique_future<array<const std::uint8_t>> render(const core::video_format_desc& format_desc)
+ std::future<array<const std::uint8_t>> render(const core::video_format_desc& format_desc, bool straighten_alpha)
{
- return renderer_(std::move(layers_), format_desc);
+ return renderer_(std::move(layers_), format_desc, straighten_alpha);
}
- core::mutable_frame create_frame(const void* tag, const core::pixel_format_desc& desc) override
+ core::mutable_frame create_frame(const void* tag, const core::pixel_format_desc& desc, const core::audio_channel_layout& channel_layout) override
{
std::vector<array<std::uint8_t>> buffers;
- BOOST_FOREACH(auto& plane, desc.planes)
+ for (auto& plane : desc.planes)
buffers.push_back(ogl_->create_array(plane.size));
- return core::mutable_frame(std::move(buffers), core::audio_buffer(), tag, desc);
+ return core::mutable_frame(std::move(buffers), core::mutable_audio_buffer(), tag, desc, channel_layout);
+ }
+
+ int get_max_frame_size() override
+ {
+ return ogl_->invoke([]
+ {
+ GLint64 params[1];
+ glGetInteger64v(GL_MAX_TEXTURE_SIZE, params);
+ return static_cast<int>(params[0]);
+ });
}
};
-image_mixer::image_mixer(const spl::shared_ptr<device>& ogl) : impl_(new impl(ogl)){}
+image_mixer::image_mixer(const spl::shared_ptr<device>& ogl, bool blend_modes_wanted, bool straight_alpha_wanted, int channel_id) : impl_(new impl(ogl, blend_modes_wanted, straight_alpha_wanted, channel_id)){}
image_mixer::~image_mixer(){}
void image_mixer::push(const core::frame_transform& transform){impl_->push(transform);}
void image_mixer::visit(const core::const_frame& frame){impl_->visit(frame);}
void image_mixer::pop(){impl_->pop();}
-boost::unique_future<array<const std::uint8_t>> image_mixer::operator()(const core::video_format_desc& format_desc){return impl_->render(format_desc);}
-void image_mixer::begin_layer(core::blend_mode blend_mode){impl_->begin_layer(blend_mode);}
-void image_mixer::end_layer(){impl_->end_layer();}
-core::mutable_frame image_mixer::create_frame(const void* tag, const core::pixel_format_desc& desc) {return impl_->create_frame(tag, desc);}
+int image_mixer::get_max_frame_size() { return impl_->get_max_frame_size(); }
+std::future<array<const std::uint8_t>> image_mixer::operator()(const core::video_format_desc& format_desc, bool straighten_alpha){return impl_->render(format_desc, straighten_alpha);}
+core::mutable_frame image_mixer::create_frame(const void* tag, const core::pixel_format_desc& desc, const core::audio_channel_layout& channel_layout) {return impl_->create_frame(tag, desc, channel_layout);}
-}}}
\ No newline at end of file
+}}}
projects / casparcg / blobdiff