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)
{
}
};
spl::shared_ptr<device> ogl_;
image_kernel kernel_;
public:
- image_renderer(const spl::shared_ptr<device>& ogl, bool blend_modes_wanted)
+ image_renderer(const spl::shared_ptr<device>& ogl, bool blend_modes_wanted, bool straight_alpha_wanted)
: ogl_(ogl)
- , kernel_(ogl_, blend_modes_wanted)
+ , kernel_(ogl_, blend_modes_wanted, straight_alpha_wanted)
{
}
- std::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.
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;
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,
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, bool blend_modes_wanted)
+ impl(const spl::shared_ptr<device>& ogl, bool blend_modes_wanted, bool straight_alpha_wanted, int channel_id)
: ogl_(ogl)
- , renderer_(ogl, blend_modes_wanted)
+ , 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)
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.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);
}
- std::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;
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, bool blend_modes_wanted) : impl_(new impl(ogl, blend_modes_wanted)){}
+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();}
-std::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);}
}}}
projects / casparcg / blobdiff