X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=accelerator%2Fogl%2Fimage%2Fimage_mixer.cpp;h=19d0191e5fef9a23f5a70e542d24a02806f2d776;hb=c30ace6f19e057aff4d84a54f37596857df93750;hp=5b1293ff0346a6b4efa7ebfdaf2b5807fa2f250b;hpb=6364b9b8329257ac31939ad88c30cfb70a67192b;p=casparcg diff --git a/accelerator/ogl/image/image_mixer.cpp b/accelerator/ogl/image/image_mixer.cpp index 5b1293ff0..19d0191e5 100644 --- a/accelerator/ogl/image/image_mixer.cpp +++ b/accelerator/ogl/image/image_mixer.cpp @@ -18,7 +18,7 @@ * * Author: Robert Nagy, ronag89@gmail.com */ -#include "../../stdafx.h" +#include "../../StdAfx.h" #include "image_mixer.h" @@ -31,6 +31,7 @@ #include #include #include +#include #include #include @@ -40,85 +41,77 @@ #include -#include +#include -#include #include #include #include #include -using namespace boost::assign; - namespace caspar { namespace accelerator { namespace ogl { -typedef boost::shared_future> future_texture; +typedef std::shared_future> future_texture; struct item { - core::pixel_format_desc pix_desc; - std::vector 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 textures; + core::image_transform transform; + core::frame_geometry geometry = core::frame_geometry::get_default(); }; struct layer { + std::vector sublayers; std::vector items; core::blend_mode blend_mode; - layer() - : blend_mode(core::blend_mode::normal) - { - } - - layer(std::vector 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()) + .select(std::ref(format_size)) + .max(); +} + class image_renderer { spl::shared_ptr ogl_; image_kernel kernel_; public: - image_renderer(const spl::shared_ptr& ogl) + image_renderer(const spl::shared_ptr& ogl, bool blend_modes_wanted, bool straight_alpha_wanted) : ogl_(ogl) - , kernel_(ogl_) + , kernel_(ogl_, blend_modes_wanted, straight_alpha_wanted) { } - boost::unique_future> operator()(std::vector layers, const core::video_format_desc& format_desc) + std::future> operator()(std::vector layers, const core::video_format_desc& format_desc, bool straighten_alpha) { if(layers.empty()) { // Bypass GPU with empty frame. - auto buffer = spl::make_shared>>(format_desc.size, 0); - return async(launch::deferred, [=] - { - return array(buffer->data(), format_desc.size, true, buffer); - }); - } + static const cache_aligned_vector buffer(get_max_video_format_size(), 0); + return make_ready_future(array(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; @@ -126,18 +119,20 @@ public: } } - return flatten(ogl_->begin_invoke([=]() mutable -> boost::shared_future> + return flatten(ogl_->begin_invoke([=]() mutable -> std::shared_future> { - 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); })); } @@ -151,8 +146,11 @@ private: { std::shared_ptr 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& target_texture, @@ -183,7 +181,7 @@ private: //} // Mask out fields - BOOST_FOREACH(auto& item, layer.items) + for (auto& item : layer.items) item.transform.field_mode &= field_mode; // Remove empty items. @@ -200,18 +198,18 @@ private: 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); } @@ -219,39 +217,41 @@ private: layer_key_texture = std::move(local_key_texture); } - void draw(spl::shared_ptr& target_texture, - item item, - std::shared_ptr& layer_key_texture, - std::shared_ptr& local_key_texture, - std::shared_ptr& local_mix_texture) + void draw(spl::shared_ptr& target_texture, + item item, + std::shared_ptr& layer_key_texture, + std::shared_ptr& local_key_texture, + std::shared_ptr& 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(format_desc.square_width) / static_cast(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)); } @@ -259,9 +259,9 @@ private: { 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)); } @@ -275,13 +275,13 @@ private: 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::get_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)); } @@ -293,23 +293,38 @@ struct image_mixer::impl : public core::frame_factory image_renderer renderer_; std::vector transform_stack_; std::vector layers_; // layer/stream/items + std::vector layer_stack_; public: - impl(const spl::shared_ptr& ogl) + impl(const spl::shared_ptr& 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(), 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) @@ -330,43 +345,49 @@ public: // 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(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> render(const core::video_format_desc& format_desc) + std::future> 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> 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(params[0]); + }); } }; -image_mixer::image_mixer(const spl::shared_ptr& ogl) : impl_(new impl(ogl)){} +image_mixer::image_mixer(const spl::shared_ptr& 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> 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> 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 +}}}