X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=core%2Fmixer%2Fimage%2Fimage_kernel.cpp;h=e659c618b1678a5888aac89054ac98cdc81e35db;hb=134faacd0105bffe3bd051d708f175010dd1e9b8;hp=4a837172d2581cb08d3e103fdfa1e55c04c0f515;hpb=11f2a57b1d27aaf02f27d8e5d88c312b292f254c;p=casparcg

diff --git a/core/mixer/image/image_kernel.cpp b/core/mixer/image/image_kernel.cpp
index 4a837172d..e659c618b 100644
--- a/core/mixer/image/image_kernel.cpp
+++ b/core/mixer/image/image_kernel.cpp
@@ -34,7 +34,7 @@
 
 #include <core/video_format.h>
 #include <core/producer/frame/pixel_format.h>
-#include <core/producer/frame/image_transform.h>
+#include <core/producer/frame/frame_transform.h>
 
 #include <GL/glew.h>
 
@@ -61,23 +61,19 @@ struct image_kernel::implementation : boost::noncopyable
 	std::shared_ptr<shader>	shader_;
 	bool					blend_modes_;
 							
-	void draw(ogl_device&									ogl,
-			  render_item&&									item,
-			  const safe_ptr<device_buffer>&				background,
-			  const std::shared_ptr<device_buffer>&			local_key,			  
-			  const std::shared_ptr<device_buffer>&			layer_key)
+	void draw(ogl_device& ogl, draw_params&& params)
 	{
 		static const double epsilon = 0.001;
 
-		CASPAR_ASSERT(item.pix_desc.planes.size() == item.textures.size());
+		CASPAR_ASSERT(params.pix_desc.planes.size() == params.textures.size());
 
-		if(item.textures.empty())
+		if(params.textures.empty() || !params.background)
 			return;
 
-		if(item.transform.get_opacity() < epsilon)
+		if(params.transform.opacity < epsilon)
 			return;
 		
-		if(!std::all_of(item.textures.begin(), item.textures.end(), std::mem_fn(&device_buffer::ready)))
+		if(!std::all_of(params.textures.begin(), params.textures.end(), std::mem_fn(&device_buffer::ready)))
 		{
 			CASPAR_LOG(warning) << L"[image_mixer] Performance warning. Host to device transfer not complete, GPU will be stalled";
 			ogl.yield(); // Try to give it some more time.
@@ -85,14 +81,14 @@ struct image_kernel::implementation : boost::noncopyable
 		
 		// Bind textures
 
-		for(size_t n = 0; n < item.textures.size(); ++n)
-			item.textures[n]->bind(n);
+		for(size_t n = 0; n < params.textures.size(); ++n)
+			params.textures[n]->bind(n);
 
-		if(local_key)
-			local_key->bind(texture_id::local_key);
+		if(params.local_key)
+			params.local_key->bind(texture_id::local_key);
 		
-		if(layer_key)
-			layer_key->bind(texture_id::layer_key);
+		if(params.layer_key)
+			params.layer_key->bind(texture_id::layer_key);
 			
 		// Setup shader
 
@@ -107,110 +103,99 @@ struct image_kernel::implementation : boost::noncopyable
 		shader_->set("plane[3]",		texture_id::plane3);
 		shader_->set("local_key",		texture_id::local_key);
 		shader_->set("layer_key",		texture_id::layer_key);
-		shader_->set("is_hd",		 	item.pix_desc.planes.at(0).height > 700 ? 1 : 0);
-		shader_->set("has_local_key",	local_key);
-		shader_->set("has_layer_key",	layer_key);
-		shader_->set("pixel_format",	item.pix_desc.pix_fmt);	
-		shader_->set("opacity",			item.transform.get_is_key() ? 1.0 : item.transform.get_opacity());	
+		shader_->set("is_hd",		 	params.pix_desc.planes.at(0).height > 700 ? 1 : 0);
+		shader_->set("has_local_key",	params.local_key);
+		shader_->set("has_layer_key",	params.layer_key);
+		shader_->set("pixel_format",	params.pix_desc.pix_fmt);	
+		shader_->set("opacity",			params.transform.is_key ? 1.0 : params.transform.opacity);	
 		
 		// Setup blend_func
 		
-		if(item.transform.get_is_key())
-			item.blend_mode = blend_mode::normal;
+		if(params.transform.is_key)
+			params.blend_mode = blend_mode::normal;
 
 		if(blend_modes_)
 		{
-			background->bind(6);
+			params.background->bind(6);
 
 			shader_->set("background",	texture_id::background);
-			shader_->set("blend_mode",	item.blend_mode);
+			shader_->set("blend_mode",	params.blend_mode);
 		}
 		else
 		{
-			switch(item.blend_mode)
-			{
-			case blend_mode::replace:			
-				ogl.blend_func_separate(GL_ONE, GL_ZERO, GL_ONE, GL_ONE);
-				break;
-			case blend_mode::normal:
-			default:
-				ogl.blend_func_separate(GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
-				break;
-			}
+			ogl.blend_func_separate(GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);			
 		}
 
 		// Setup image-adjustements
-
-		auto levels = item.transform.get_levels();
-
-		if(levels.min_input  > epsilon		||
-		   levels.max_input  < 1.0-epsilon	||
-		   levels.min_output > epsilon		||
-		   levels.max_output < 1.0-epsilon	||
-		   std::abs(levels.gamma - 1.0) > epsilon)
+		
+		if(params.transform.levels.min_input  > epsilon		||
+		   params.transform.levels.max_input  < 1.0-epsilon	||
+		   params.transform.levels.min_output > epsilon		||
+		   params.transform.levels.max_output < 1.0-epsilon	||
+		   std::abs(params.transform.levels.gamma - 1.0) > epsilon)
 		{
 			shader_->set("levels", true);	
-			shader_->set("min_input", levels.min_input);	
-			shader_->set("max_input", levels.max_input);
-			shader_->set("min_output", levels.min_output);
-			shader_->set("max_output", levels.max_output);
-			shader_->set("gamma", levels.gamma);
+			shader_->set("min_input",	params.transform.levels.min_input);	
+			shader_->set("max_input",	params.transform.levels.max_input);
+			shader_->set("min_output",	params.transform.levels.min_output);
+			shader_->set("max_output",	params.transform.levels.max_output);
+			shader_->set("gamma",		params.transform.levels.gamma);
 		}
 		else
 			shader_->set("levels", false);	
 
-		if(std::abs(item.transform.get_brightness() - 1.0) > epsilon ||
-		   std::abs(item.transform.get_saturation() - 1.0) > epsilon ||
-		   std::abs(item.transform.get_contrast() - 1.0) > epsilon)
+		if(std::abs(params.transform.brightness - 1.0) > epsilon ||
+		   std::abs(params.transform.saturation - 1.0) > epsilon ||
+		   std::abs(params.transform.contrast - 1.0)   > epsilon)
 		{
 			shader_->set("csb",	true);	
 			
-			shader_->set("brt", item.transform.get_brightness());	
-			shader_->set("sat", item.transform.get_saturation());
-			shader_->set("con", item.transform.get_contrast());
+			shader_->set("brt", params.transform.brightness);	
+			shader_->set("sat", params.transform.saturation);
+			shader_->set("con", params.transform.contrast);
 		}
 		else
 			shader_->set("csb",	false);	
 		
 		// Setup interlacing
 
-		if(item.mode == core::video_mode::progressive)			
+		if(params.transform.field_mode == core::field_mode::progressive)			
 			ogl.disable(GL_POLYGON_STIPPLE);			
 		else			
 		{
 			ogl.enable(GL_POLYGON_STIPPLE);
 
-			if(item.mode == core::video_mode::upper)
+			if(params.transform.field_mode == core::field_mode::upper)
 				ogl.stipple_pattern(upper_pattern);
-			else if(item.mode == core::video_mode::lower)
+			else if(params.transform.field_mode == core::field_mode::lower)
 				ogl.stipple_pattern(lower_pattern);
 		}
 
 		// Setup drawing area
 		
-		ogl.viewport(0, 0, background->width(), background->height());
+		ogl.viewport(0, 0, params.background->width(), params.background->height());
 								
-		auto m_p = item.transform.get_clip_translation();
-		auto m_s = item.transform.get_clip_scale();
+		auto m_p = params.transform.clip_translation;
+		auto m_s = params.transform.clip_scale;
 
-		bool scissor = m_p[0] > std::numeric_limits<double>::epsilon()		 || m_p[1] > std::numeric_limits<double>::epsilon() &&
-					   m_s[0] < 1.0 - std::numeric_limits<double>::epsilon() || m_s[1] < 1.0 - std::numeric_limits<double>::epsilon();
+		bool scissor = m_p[0] > std::numeric_limits<double>::epsilon()			|| m_p[1] > std::numeric_limits<double>::epsilon() ||
+					   m_s[0] < (1.0 - std::numeric_limits<double>::epsilon())	|| m_s[1] < (1.0 - std::numeric_limits<double>::epsilon());
 
 		if(scissor)
 		{
-			double w = static_cast<double>(background->width());
-			double h = static_cast<double>(background->height());
+			double w = static_cast<double>(params.background->width());
+			double h = static_cast<double>(params.background->height());
 		
 			ogl.enable(GL_SCISSOR_TEST);
 			ogl.scissor(static_cast<size_t>(m_p[0]*w), static_cast<size_t>(m_p[1]*h), static_cast<size_t>(m_s[0]*w), static_cast<size_t>(m_s[1]*h));
 		}
 
-		auto f_p = item.transform.get_fill_translation();
-		auto f_s = item.transform.get_fill_scale();
+		auto f_p = params.transform.fill_translation;
+		auto f_s = params.transform.fill_scale;
 		
 		// Set render target
 		
-		ogl.attach(*background);
+		ogl.attach(*params.background);
 		
 		// Draw
 
@@ -225,7 +210,7 @@ struct image_kernel::implementation : boost::noncopyable
 
 		ogl.disable(GL_SCISSOR_TEST);	
 				
-		item.textures.clear();
+		params.textures.clear();
 		ogl.yield(); // Return resources to pool as early as possible.
 
 		if(blend_modes_)
@@ -238,18 +223,9 @@ struct image_kernel::implementation : boost::noncopyable
 };
 
 image_kernel::image_kernel() : impl_(new implementation()){}
-void image_kernel::draw(ogl_device& ogl, 
-						render_item&& item, 
-						const safe_ptr<device_buffer>& background,
-						const std::shared_ptr<device_buffer>& local_key, 
-						const std::shared_ptr<device_buffer>& layer_key)
-{
-	impl_->draw(ogl, std::move(item), background, local_key, layer_key);
-}
-
-bool operator==(const render_item& lhs, const render_item& rhs)
+void image_kernel::draw(ogl_device& ogl, draw_params&& params)
 {
-	return lhs.textures == rhs.textures && lhs.transform == rhs.transform && lhs.tag == rhs.tag && lhs.mode == rhs.mode;
+	impl_->draw(ogl, std::move(params));
 }
 
 }}
\ No newline at end of file