[streaming_consumer] Default to pcm_s24le for containers supporting it instead of...

[casparcg] / modules / psd / misc.cpp

diff --git a/modules/psd/misc.cpp b/modules/psd/misc.cpp
index 8f83410db1611b2dbb83a7fb8f315dd09dfe4b35..ed098a599093946feb10b74b9ba67eddde8e883b 100644 (file)
--- a/modules/psd/misc.cpp
+++ b/modules/psd/misc.cpp
@@ -19,66 +19,80 @@
 * Author: Niklas P Andersson, niklas.p.andersson@svt.se
 */
 
+#include <boost/algorithm/string.hpp>
 #include <vector>
+
 #include "misc.h"
 
 namespace caspar { namespace psd {
 
-blend_mode int_to_blend_mode(unsigned long x)
+layer_type int_to_layer_type(std::uint32_t x, std::uint32_t y)
 {
-       blend_mode mode = static_cast<blend_mode>(x);
+       if (x == 1 || x == 2)
+               return (y == 1) ? layer_type::timeline_group : layer_type::group;
+       else if (x == 3)
+               return layer_type::group_delimiter;
+
+       return layer_type::content;
+}
 
-       switch (mode)
+std::wstring layer_type_to_string(layer_type b)
+{
+       switch (b)
        {
-               case blend_mode::Normal:
-               case blend_mode::Darken:
-               case blend_mode::Lighten:
-               case blend_mode::Hue:
-               case blend_mode::Saturation:
-               case blend_mode::Color:
-               case blend_mode::Luminosity:
-               case blend_mode::Multiply:
-               case blend_mode::Screen:
-               case blend_mode::Dissolve:
-               case blend_mode::Overlay:
-               case blend_mode::HardLight:
-               case blend_mode::SoftLight:
-               case blend_mode::Difference:
-               case blend_mode::Exclusion:
-               case blend_mode::ColorDodge:
-               case blend_mode::ColorBurn:
-                       return mode;
-               default:
-                       return blend_mode::InvalidBlendMode;
+       case layer_type::content: return L"Content";
+       case layer_type::group: return L"Group";
+       case layer_type::timeline_group: return L"TimelineGroup";
+       case layer_type::group_delimiter: return L"GroupDelimiter";
+       default: return L"Invalid";
        }
 }
 
-std::wstring blend_mode_to_string(blend_mode b)
+
+caspar::core::blend_mode int_to_blend_mode(std::uint32_t x)
 {
-       switch(b)
+       switch (x)
        {
-               case blend_mode::Normal: return L"Normal";
-               case blend_mode::Darken: return L"Darken";
-               case blend_mode::Lighten: return L"Lighten";
-               case blend_mode::Hue: return L"Hue";
-               case blend_mode::Saturation: return L"Saturation";
-               case blend_mode::Color: return L"Color";
-               case blend_mode::Luminosity: return L"Luminosity";
-               case blend_mode::Multiply: return L"Multiply";
-               case blend_mode::Screen: return L"Screen";
-               case blend_mode::Dissolve: return L"Dissolve";
-               case blend_mode::Overlay: return L"Overlay";
-               case blend_mode::HardLight: return L"HardLight";
-               case blend_mode::SoftLight: return L"SoftLight";
-               case blend_mode::Difference: return L"Difference";
-               case blend_mode::Exclusion: return L"Exclusion";
-               case blend_mode::ColorDodge: return L"ColorDodge";
-               case blend_mode::ColorBurn: return L"ColorBurn";
-               default: return L"Invalid";
+       case 'norm':
+               return core::blend_mode::normal;
+       case 'dark':
+               return core::blend_mode::darken;
+       case 'lite':
+               return core::blend_mode::lighten;
+       case'hue ':
+               return core::blend_mode::contrast;
+       case 'sat ':
+               return core::blend_mode::saturation;
+       case 'colr':
+               return core::blend_mode::color;
+       case 'lum ':
+               return core::blend_mode::luminosity;
+       case 'mul ':
+               return core::blend_mode::multiply;
+       case 'scrn':
+               return core::blend_mode::screen;
+       case 'diss':    //no support for the 'dissove' blend mode atm
+               return core::blend_mode::normal;
+       case 'over':
+               return core::blend_mode::overlay;
+       case 'hLit':
+               return core::blend_mode::hard_light;
+       case 'sLit':
+               return core::blend_mode::soft_light;
+       case 'diff':
+               return core::blend_mode::difference;
+       case 'smud':
+               return core::blend_mode::exclusion;
+       case 'div ':
+               return core::blend_mode::color_dodge;
+       case 'idiv':
+               return core::blend_mode::color_burn;
        }
+
+       return core::blend_mode::normal;
 }
 
-color_mode int_to_color_mode(unsigned short x)
+color_mode int_to_color_mode(std::uint16_t x)
 {
        color_mode mode = static_cast<color_mode>(x);
 
@@ -114,5 +128,42 @@ std::wstring color_mode_to_string(color_mode c)
        };
 }
 
+layer_tag string_to_layer_tags(const std::wstring& str) {\r
+       std::vector<std::wstring> flags;\r
+       boost::split(flags, str, boost::is_any_of(L", "), boost::token_compress_on);\r
+\r
+       layer_tag result = layer_tag::none;\r
+       for (auto& flag : flags) {\r
+               if (boost::algorithm::iequals(flag, "producer"))\r
+                       result = result | layer_tag::placeholder;\r
+               else if (boost::algorithm::iequals(flag, "dynamic")) {\r
+                       result = result | layer_tag::explicit_dynamic;\r
+                       result = result & (~layer_tag::rasterized);\r
+               }\r
+               else if (boost::algorithm::iequals(flag, "static")) {\r
+                       result = result | layer_tag::rasterized;\r
+                       result = result & (~layer_tag::explicit_dynamic);\r
+               }\r
+               else if (boost::algorithm::iequals(flag, "movable")) {\r
+                       result = result | layer_tag::moveable;\r
+                       result = result & (~layer_tag::resizable);\r
+                       result = result & (~layer_tag::explicit_dynamic);\r
+               }\r
+               else if (boost::algorithm::iequals(flag, "resizable")) {\r
+                       result = result | layer_tag::resizable;\r
+                       result = result & (~layer_tag::moveable);\r
+                       result = result & (~layer_tag::explicit_dynamic);\r
+               }\r
+               else if (boost::algorithm::iequals(flag, "cornerpin")) {\r
+                       result = result | layer_tag::cornerpin;\r
+                       result = result & (~layer_tag::resizable);\r
+                       result = result & (~layer_tag::explicit_dynamic);\r
+               }\r
+       }\r
+\r
+       return result;\r
+}
+
+
 }      //namespace psd
-}      //namespace caspar
\ No newline at end of file
+}      //namespace caspar