From: Matthew Leibowitz Date: Mon, 10 Jul 2017 20:54:45 +0000 (+0200) Subject: Merge branch 'xamarin-mobile-bindings' into update-m59 X-Git-Tag: accepted/tizen/5.0/unified/20181102.025319~41 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=d517d04713241402d821ff6443c6231c0d6e60b7;p=platform%2Fupstream%2FlibSkiaSharp.git Merge branch 'xamarin-mobile-bindings' into update-m59 --- d517d04713241402d821ff6443c6231c0d6e60b7 diff --cc gn/core.gni index e2bb2b0,f79cb94..8c8ec30 --- a/gn/core.gni +++ b/gn/core.gni @@@ -34,7 -34,7 +34,8 @@@ skia_core_sources = "$_include/c/sk_types.h", "$_include/c/sk_xml.h", "$_include/c/sk_svg.h", + "$_include/c/sk_colorspace.h", + "$_include/c/sk_vertices.h", "$_include/c/gr_context.h", "$_src/c/sk_bitmap.cpp", "$_src/c/sk_canvas.cpp", @@@ -62,7 -62,7 +63,8 @@@ "$_src/c/sk_typeface.cpp", "$_src/c/sk_xml.cpp", "$_src/c/sk_svg.cpp", + "$_src/c/sk_colorspace.cpp", + "$_src/c/sk_vertices.cpp", "$_src/c/sk_types_priv.h", "$_src/c/gr_context.cpp", "$_src/c/sk_structs.cpp", diff --cc include/c/sk_colorspace.h index 0000000,77f3bec..5457df4 mode 000000,100644..100644 --- a/include/c/sk_colorspace.h +++ b/include/c/sk_colorspace.h @@@ -1,0 -1,31 +1,31 @@@ + /* + * Copyright 2017 Xamarin Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + + #ifndef sk_colorspace_DEFINED + #define sk_colorspace_DEFINED + + #include "sk_types.h" + + SK_C_PLUS_PLUS_BEGIN_GUARD + + SK_C_API void sk_colorspace_unref(sk_colorspace_t* cColorSpace); + SK_C_API sk_colorspace_t* sk_colorspace_new_srgb(); + SK_C_API sk_colorspace_t* sk_colorspace_new_srgb_linear(); + SK_C_API sk_colorspace_t* sk_colorspace_new_icc(const void* input, size_t len); -SK_C_API sk_colorspace_t* sk_colorspace_new_rgb_with_gamma(sk_colorspace_render_target_gamma_t gamma, const sk_matrix44_t* toXYZD50, uint32_t flags); -SK_C_API sk_colorspace_t* sk_colorspace_new_rgb_with_gamma_and_gamut(sk_colorspace_render_target_gamma_t gamma, sk_colorspace_gamut_t gamut, uint32_t flags); -SK_C_API sk_colorspace_t* sk_colorspace_new_rgb_with_coeffs(const sk_colorspace_transfer_fn_t* coeffs, const sk_matrix44_t* toXYZD50, uint32_t flags); -SK_C_API sk_colorspace_t* sk_colorspace_new_rgb_with_coeffs_and_gamut(const sk_colorspace_transfer_fn_t* coeffs, sk_colorspace_gamut_t gamut, uint32_t flags); ++SK_C_API sk_colorspace_t* sk_colorspace_new_rgb_with_gamma(sk_colorspace_render_target_gamma_t gamma, const sk_matrix44_t* toXYZD50); ++SK_C_API sk_colorspace_t* sk_colorspace_new_rgb_with_gamma_and_gamut(sk_colorspace_render_target_gamma_t gamma, sk_colorspace_gamut_t gamut); ++SK_C_API sk_colorspace_t* sk_colorspace_new_rgb_with_coeffs(const sk_colorspace_transfer_fn_t* coeffs, const sk_matrix44_t* toXYZD50); ++SK_C_API sk_colorspace_t* sk_colorspace_new_rgb_with_coeffs_and_gamut(const sk_colorspace_transfer_fn_t* coeffs, sk_colorspace_gamut_t gamut); + SK_C_API bool sk_colorspace_gamma_close_to_srgb(const sk_colorspace_t* cColorSpace); + SK_C_API bool sk_colorspace_gamma_is_linear(const sk_colorspace_t* cColorSpace); + SK_C_API bool sk_colorspace_equals(const sk_colorspace_t* src, const sk_colorspace_t* dst); + SK_C_API bool sk_colorspace_to_xyzd50(const sk_colorspace_t* cColorSpace, sk_matrix44_t* toXYZD50); + SK_C_API bool sk_colorspaceprimaries_to_xyzd50(const sk_colorspaceprimaries_t* primaries, sk_matrix44_t* toXYZD50); + + SK_C_PLUS_PLUS_END_GUARD + + #endif diff --cc include/c/sk_types.h index e7041a3,1fbbb86..c1caf3a --- a/include/c/sk_types.h +++ b/include/c/sk_types.h @@@ -726,7 -661,7 +719,6 @@@ typedef struct int fBufferMapThreshold; bool fUseDrawInsteadOfPartialRenderTargetWrite; bool fImmediateMode; -- bool fClipDrawOpsToBounds; int fMaxOpCombineLookback; int fMaxOpCombineLookahead; bool fUseShaderSwizzling; @@@ -737,6 -672,6 +729,7 @@@ bool fDisableGpuYUVConversion; bool fSuppressPathRendering; gr_contextoptions_gpupathrenderers_t fGpuPathRenderers; ++ bool fAvoidStencilBuffers; } gr_context_options_t; typedef enum { @@@ -869,13 -813,56 +876,54 @@@ typedef struct sk_svgcanvas_t sk_svgcan typedef struct sk_3dview_t sk_3dview_t; typedef enum { - TRIANGLES_SK_VERTEX_MODE, - TRIANGLE_STRIP_SK_VERTEX_MODE, - TRIANGLE_FAN_SK_VERTEX_MODE, -} sk_vertex_mode_t; + TRIANGLES_SK_VERTICES_VERTEX_MODE, + TRIANGLE_STRIP_SK_VERTICES_VERTEX_MODE, + TRIANGLE_FAN_SK_VERTICES_VERTEX_MODE, +} sk_vertices_vertex_mode_t; + +typedef struct sk_vertices_t sk_vertices_t; + typedef enum { + LINEAR_SK_COLORSPACE_RENDER_TARGET_GAMMA, + SRGB_SK_COLORSPACE_RENDER_TARGET_GAMMA, + } sk_colorspace_render_target_gamma_t; + + typedef enum { + SRGB_SK_COLORSPACE_GAMUT, + ADOBE_RGB_SK_COLORSPACE_GAMUT, + DCIP3_D65_SK_COLORSPACE_GAMUT, + REC2020_SK_COLORSPACE_GAMUT, + } sk_colorspace_gamut_t; + -typedef enum { - NON_LINEAR_BLENDING_SK_COLORSPACE_FLAGS = 0x1, -} sk_colorspace_flags_t; - + typedef struct { + float fG; + float fA; + float fB; + float fC; + float fD; + float fE; + float fF; + } sk_colorspace_transfer_fn_t; + + typedef struct { + float fRX, fRY; + float fGX, fGY; + float fBX, fBY; + float fWX, fWY; + } sk_colorspaceprimaries_t; + + typedef enum { + NO_INVERT_SK_HIGH_CONTRAST_CONFIG_INVERT_STYLE, + INVERT_BRIGHTNESS_SK_HIGH_CONTRAST_CONFIG_INVERT_STYLE, + INVERT_LIGHTNESS_SK_HIGH_CONTRAST_CONFIG_INVERT_STYLE, + } sk_highcontrastconfig_invertstyle_t; + + typedef struct { + bool fGrayscale; + sk_highcontrastconfig_invertstyle_t fInvertStyle; + float fContrast; + } sk_highcontrastconfig_t; + SK_C_PLUS_PLUS_END_GUARD #endif diff --cc src/c/sk_colorspace.cpp index 0000000,581b591..dc57380 mode 000000,100644..100644 --- a/src/c/sk_colorspace.cpp +++ b/src/c/sk_colorspace.cpp @@@ -1,0 -1,64 +1,64 @@@ + /* + * Copyright 2017 Xamarin Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + + #include "SkColorSpace.h" + + #include "sk_colorspace.h" + + #include "sk_types_priv.h" + + void sk_colorspace_unref(sk_colorspace_t* cColorSpace) { + SkSafeUnref(AsColorSpace(cColorSpace)); + } + + sk_colorspace_t* sk_colorspace_new_srgb() { + return ToColorSpace(SkColorSpace::MakeSRGB().release()); + } + + sk_colorspace_t* sk_colorspace_new_srgb_linear() { + return ToColorSpace(SkColorSpace::MakeSRGBLinear().release()); + } + + sk_colorspace_t* sk_colorspace_new_icc(const void* input, size_t len) { + return ToColorSpace(SkColorSpace::MakeICC(input, len).release()); + } + -sk_colorspace_t* sk_colorspace_new_rgb_with_gamma(sk_colorspace_render_target_gamma_t gamma, const sk_matrix44_t* toXYZD50, uint32_t flags) { - return ToColorSpace(SkColorSpace::MakeRGB((SkColorSpace::RenderTargetGamma)gamma, AsMatrix44(*toXYZD50), flags).release()); ++sk_colorspace_t* sk_colorspace_new_rgb_with_gamma(sk_colorspace_render_target_gamma_t gamma, const sk_matrix44_t* toXYZD50) { ++ return ToColorSpace(SkColorSpace::MakeRGB((SkColorSpace::RenderTargetGamma)gamma, AsMatrix44(*toXYZD50)).release()); + } + -sk_colorspace_t* sk_colorspace_new_rgb_with_gamma_and_gamut(sk_colorspace_render_target_gamma_t gamma, sk_colorspace_gamut_t gamut, uint32_t flags) { - return ToColorSpace(SkColorSpace::MakeRGB((SkColorSpace::RenderTargetGamma)gamma, (SkColorSpace::Gamut)gamut, flags).release()); ++sk_colorspace_t* sk_colorspace_new_rgb_with_gamma_and_gamut(sk_colorspace_render_target_gamma_t gamma, sk_colorspace_gamut_t gamut) { ++ return ToColorSpace(SkColorSpace::MakeRGB((SkColorSpace::RenderTargetGamma)gamma, (SkColorSpace::Gamut)gamut).release()); + } + -sk_colorspace_t* sk_colorspace_new_rgb_with_coeffs(const sk_colorspace_transfer_fn_t* coeffs, const sk_matrix44_t* toXYZD50, uint32_t flags) { - return ToColorSpace(SkColorSpace::MakeRGB(AsColorSpaceTransferFn(*coeffs), AsMatrix44(*toXYZD50), flags).release()); ++sk_colorspace_t* sk_colorspace_new_rgb_with_coeffs(const sk_colorspace_transfer_fn_t* coeffs, const sk_matrix44_t* toXYZD50) { ++ return ToColorSpace(SkColorSpace::MakeRGB(AsColorSpaceTransferFn(*coeffs), AsMatrix44(*toXYZD50)).release()); + } + -sk_colorspace_t* sk_colorspace_new_rgb_with_coeffs_and_gamut(const sk_colorspace_transfer_fn_t* coeffs, sk_colorspace_gamut_t gamut, uint32_t flags) { - return ToColorSpace(SkColorSpace::MakeRGB(AsColorSpaceTransferFn(*coeffs), (SkColorSpace::Gamut)gamut, flags).release()); ++sk_colorspace_t* sk_colorspace_new_rgb_with_coeffs_and_gamut(const sk_colorspace_transfer_fn_t* coeffs, sk_colorspace_gamut_t gamut) { ++ return ToColorSpace(SkColorSpace::MakeRGB(AsColorSpaceTransferFn(*coeffs), (SkColorSpace::Gamut)gamut).release()); + } + + bool sk_colorspace_gamma_close_to_srgb(const sk_colorspace_t* cColorSpace) { + return AsColorSpace(cColorSpace)->gammaCloseToSRGB(); + } + + bool sk_colorspace_gamma_is_linear(const sk_colorspace_t* cColorSpace) { + return AsColorSpace(cColorSpace)->gammaIsLinear(); + } + + bool sk_colorspace_equals(const sk_colorspace_t* src, const sk_colorspace_t* dst) { + return SkColorSpace::Equals(AsColorSpace(src), AsColorSpace(dst)); + } + + bool sk_colorspace_to_xyzd50(const sk_colorspace_t* cColorSpace, sk_matrix44_t* toXYZD50) { + return AsColorSpace(cColorSpace)->toXYZD50(AsMatrix44(toXYZD50)); + } + + bool sk_colorspaceprimaries_to_xyzd50(const sk_colorspaceprimaries_t* primaries, sk_matrix44_t* toXYZD50) { + return AsColorSpacePrimaries(primaries)->toXYZD50(AsMatrix44(toXYZD50)); + } diff --cc src/c/sk_enums.cpp index 6f2e92e,fa52365..40c7c25 --- a/src/c/sk_enums.cpp +++ b/src/c/sk_enums.cpp @@@ -342,9 -349,18 +349,18 @@@ static_assert ((int)SkVertices::VertexM static_assert ((int)SkImage::CachingHint::kAllow_CachingHint == (int)ALLOW_SK_IMAGE_CACHING_HINT, ASSERT_MSG(SkImage::CachingHint, sk_image_caching_hint_t)); static_assert ((int)SkImage::CachingHint::kDisallow_CachingHint == (int)DISALLOW_SK_IMAGE_CACHING_HINT, ASSERT_MSG(SkImage::CachingHint, sk_image_caching_hint_t)); -// sk_colorspace_flags_t -static_assert ((int)SkColorSpace::ColorSpaceFlags::kNonLinearBlending_ColorSpaceFlag == (int)NON_LINEAR_BLENDING_SK_COLORSPACE_FLAGS, ASSERT_MSG(SkColorSpace::RenderTargetGamma, sk_colorspace_render_target_gamma_t)); - + // sk_colorspace_render_target_gamma_t + static_assert ((int)SkColorSpace::RenderTargetGamma::kLinear_RenderTargetGamma == (int)LINEAR_SK_COLORSPACE_RENDER_TARGET_GAMMA, ASSERT_MSG(SkColorSpace::RenderTargetGamma, sk_colorspace_render_target_gamma_t)); + static_assert ((int)SkColorSpace::RenderTargetGamma::kSRGB_RenderTargetGamma == (int)SRGB_SK_COLORSPACE_RENDER_TARGET_GAMMA, ASSERT_MSG(SkColorSpace::RenderTargetGamma, sk_colorspace_render_target_gamma_t)); + + // sk_highcontrastconfig_invertstyle_t + static_assert ((int)SkHighContrastConfig::InvertStyle::kNoInvert == (int)NO_INVERT_SK_HIGH_CONTRAST_CONFIG_INVERT_STYLE, ASSERT_MSG(SkHighContrastConfig::InvertStyle, sk_highcontrastconfig_invertstyle_t)); + static_assert ((int)SkHighContrastConfig::InvertStyle::kInvertBrightness == (int)INVERT_BRIGHTNESS_SK_HIGH_CONTRAST_CONFIG_INVERT_STYLE, ASSERT_MSG(SkHighContrastConfig::InvertStyle, sk_highcontrastconfig_invertstyle_t)); + static_assert ((int)SkHighContrastConfig::InvertStyle::kInvertLightness == (int)INVERT_LIGHTNESS_SK_HIGH_CONTRAST_CONFIG_INVERT_STYLE, ASSERT_MSG(SkHighContrastConfig::InvertStyle, sk_highcontrastconfig_invertstyle_t)); + +// sk_bitmap_allocflags_t +static_assert ((int)SkBitmap::AllocFlags::kZeroPixels_AllocFlag == (int)ZERO_PIXELS_SK_BITMAP_ALLOC_FLAGS, ASSERT_MSG(SkBitmap::AllocFlags, sk_bitmap_allocflags_t)); + #if SK_SUPPORT_GPU // gr_surfaceorigin_t diff --cc src/c/sk_types_priv.h index d6a2068,b43a07b..99c2a7b --- a/src/c/sk_types_priv.h +++ b/src/c/sk_types_priv.h @@@ -706,22 -796,38 +780,54 @@@ static inline const sk_matrix44_t* ToMa return reinterpret_cast(p); } + static inline const SkHighContrastConfig* AsHighContrastConfig(const sk_highcontrastconfig_t* p) { + return reinterpret_cast(p); + } + + static inline const SkHighContrastConfig& AsHighContrastConfig(const sk_highcontrastconfig_t& p) { + return reinterpret_cast(p); + } + + static inline SkHighContrastConfig* AsHighContrastConfig(sk_highcontrastconfig_t* p) { + return reinterpret_cast(p); + } + + static inline SkHighContrastConfig& AsHighContrastConfig(sk_highcontrastconfig_t& p) { + return reinterpret_cast(p); + } + + static inline sk_highcontrastconfig_t* ToHighContrastConfig(SkHighContrastConfig *p) { + return reinterpret_cast(p); + } + + static inline sk_highcontrastconfig_t& ToHighContrastConfig(SkHighContrastConfig &p) { + return reinterpret_cast(p); + } + + static inline const sk_highcontrastconfig_t* ToHighContrastConfig(const SkHighContrastConfig *p) { + return reinterpret_cast(p); + } + + static inline const sk_highcontrastconfig_t& ToHighContrastConfig(const SkHighContrastConfig &p) { + return reinterpret_cast(p); + } + +static inline const SkVertices* AsVertices(const sk_vertices_t* p) { + return reinterpret_cast(p); +} + +static inline SkVertices* AsVertices(sk_vertices_t* p) { + return reinterpret_cast(p); +} + +static inline sk_vertices_t* ToVertices(SkVertices* p) { + return reinterpret_cast(p); +} + +static inline const sk_vertices_t* ToVertices(const SkVertices* p) { + return reinterpret_cast(p); +} + static inline void from_c(const sk_matrix_t* cmatrix, SkMatrix* matrix) { matrix->setAll( cmatrix->mat[0], cmatrix->mat[1], cmatrix->mat[2],