2.0. color_producer: Fixed bug where color was not transferred to frame.

[casparcg] / core / mixer / image / image_kernel.cpp

diff --git a/core/mixer/image/image_kernel.cpp b/core/mixer/image/image_kernel.cpp
index 1df01ad73deb4b3283b2820d3cdcce984a9fe024..3165a7508b702ca3c6a978681e802ced719ea17c 100644 (file)
--- a/core/mixer/image/image_kernel.cpp
+++ b/core/mixer/image/image_kernel.cpp
@@ -62,6 +62,7 @@ struct image_kernel::implementation : boost::noncopyable
                        "uniform bool           has_local_key;                                                                                                  \n"\r
                        "uniform bool           has_layer_key;                                                                                                  \n"\r
                        "uniform int            blend_mode;                                                                                                             \n"\r
+                       "uniform int            alpha_mode;                                                                                                             \n"\r
                        "uniform int            interlace_mode;                                                                                                 \n"\r
                        "uniform int            pixel_format;                                                                                                   \n"\r
                        "                                                                                                                                                                       \n"\r
@@ -79,8 +80,6 @@ struct image_kernel::implementation : boost::noncopyable
                        "uniform float          sat;                                                                                                                    \n"\r
                        "uniform float          con;                                                                                                                    \n"\r
                        "                                                                                                                                                                       \n"\r
-                       "uniform bool           desaturate;                                                                                                             \n"\r
-                       "uniform float          desaturation;                                                                                                   \n"\r
 \r
                        +\r
 \r
@@ -121,6 +120,7 @@ struct image_kernel::implementation : boost::noncopyable
                        "       case 26: return BlendSaturation(back, fore);                                                                    \n"\r
                        "       case 27: return BlendColor(back, fore);                                                                                 \n"\r
                        "       case 28: return BlendLuminosity(back, fore);                                                                    \n"\r
+                       "       case 29: return BlendInvert(back, fore);                                                                                \n"\r
                        "       }                                                                                                                                                               \n"\r
                        "                                                                                                                                                                       \n"\r
                        "       return BlendNormal(back, fore);                                                                                                 \n"\r
@@ -128,14 +128,15 @@ struct image_kernel::implementation : boost::noncopyable
                        "                                                                                                                                                                       \n"                                                                                                                                                       \r
                        "vec4 blend_color(vec4 fore)                                                                                                            \n"\r
                        "{                                                                                                                                                                      \n"\r
+                       "   fore.rgb = fore.bgr; // bgr to rgb                                                                                          \n"\r
                        "   vec4 back = texture2D(background, gl_TexCoord[1].st);                                                       \n"\r
-                       "   if(desaturate)                                                                                                                                      \n"\r
-                       "               fore.rgb = Desaturate(fore.rgb, desaturation);                                                          \n"\r
                        "   if(levels)                                                                                                                                          \n"\r
                        "               fore.rgb = LevelsControl(fore.rgb, min_input, max_input, gamma, min_output, max_output); \n"\r
                        "       if(csb)                                                                                                                                                 \n"\r
                        "               fore.rgb = ContrastSaturationBrightness(fore.rgb, brt, sat, con);                       \n"\r
-                       "   fore.rgb = get_blend_color(back.rgb, fore.rgb);                                                                     \n"\r
+                       "   fore.rgb = get_blend_color(back.bgr, fore.rgb);                                                                     \n"\r
+                       "   fore.rgb = fore.bgr; // rgb to bgr                                                                                          \n"\r
+                       "                                                                                                                                                                       \n"\r
                        "       return vec4(fore.rgb * fore.a + back.rgb * (1.0-fore.a), back.a + fore.a);              \n"\r
                        "}                                                                                                                                                                      \n"\r
                        "                                                                                                                                                                       \n"\r
@@ -219,14 +220,14 @@ struct image_kernel::implementation : boost::noncopyable
                        "       case 1: // lower                                                                                                                                \n"\r
                        "               {                                                                                                                                                       \n"\r
                        "                       bool odd = mod(floor(gl_FragCoord.y), 2.0) > 0.5;                                               \n"\r
-                       "                       if(odd)                                                                                                                                 \n"\r
+                       "                       if(!odd)                                                                                                                                \n"\r
                        "                               discard;                                                                                                                        \n"\r
                        "                       break;                                                                                                                                  \n"\r
                        "               }                                                                                                                                                       \n"\r
                        "       case 2: //upper                                                                                                                                 \n"\r
                        "               {                                                                                                                                                       \n"\r
                        "                       bool odd = mod(floor(gl_FragCoord.y), 2.0) > 0.5;                                               \n"\r
-                       "                       if(!odd)                                                                                                                                \n"\r
+                       "                       if(odd)                                                                                                                                 \n"\r
                        "                               discard;                                                                                                                        \n"\r
                        "                       break;                                                                                                                                  \n"\r
                        "               }                                                                                                                                                       \n"\r
@@ -290,18 +291,46 @@ struct image_kernel::implementation : boost::noncopyable
                shader_->set("local_key",               4);\r
                shader_->set("layer_key",               5);\r
                shader_->set("background",              6);\r
-               shader_->set("gain",                    static_cast<GLfloat>(transform.get_gain()));\r
+               shader_->set("gain",                    transform.get_gain());\r
                shader_->set("is_hd",                   pix_desc.planes.at(0).height > 700 ? 1 : 0);\r
                shader_->set("has_local_key",   local_key ? 1 : 0);\r
                shader_->set("has_layer_key",   layer_key ? 1 : 0);\r
                shader_->set("blend_mode",              transform.get_blend_mode());\r
+               shader_->set("alpha_mode",              transform.get_alpha_mode());\r
                shader_->set("interlace_mode",  transform.get_mode());\r
                shader_->set("pixel_format",    pix_desc.pix_fmt);      \r
 \r
-               shader_->set("levels",                  false); \r
-               shader_->set("csb",                             false); \r
-               shader_->set("desaturate",              false); \r
+               auto levels = transform.get_levels();\r
 \r
+               if(levels.min_input  > 0.001 ||\r
+                  levels.max_input  < 0.999 ||\r
+                  levels.min_output > 0.001 ||\r
+                  levels.max_output < 0.999 ||\r
+                  std::abs(levels.gamma - 1.0) > 0.001)\r
+               {\r
+                       shader_->set("levels", true);   \r
+                       shader_->set("min_input", levels.min_input);    \r
+                       shader_->set("max_input", levels.max_input);\r
+                       shader_->set("min_output", levels.min_output);\r
+                       shader_->set("max_output", levels.max_output);\r
+                       shader_->set("gamma", levels.gamma);\r
+               }\r
+               else\r
+                       shader_->set("levels", false);  \r
+\r
+               if(std::abs(transform.get_brightness() - 1.0) > 0.001 ||\r
+                  std::abs(transform.get_saturation() - 1.0) > 0.001 ||\r
+                  std::abs(transform.get_contrast() - 1.0) > 0.001)\r
+               {\r
+                       shader_->set("csb",     true);  \r
+                       \r
+                       shader_->set("brt", transform.get_brightness());        \r
+                       shader_->set("sat", transform.get_saturation());\r
+                       shader_->set("con", transform.get_contrast());\r
+               }\r
+               else\r
+                       shader_->set("csb",     false); \r
+               \r
                // Setup drawing area\r
 \r
                GL(glColor4d(1.0, 1.0, 1.0, transform.get_opacity()));\r