Added some C APIs

 - SkColorSpace
 - fixing the enums and structures
Added checks for the C structures

diff --git a/gn/core.gni b/gn/core.gni
index 441fd15..4e63dbc 100644 (file)
--- a/gn/core.gni
+++ b/gn/core.gni
@@ -34,6 +34,7 @@ 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/gr_context.h",
   "$_src/c/sk_bitmap.cpp",
   "$_src/c/sk_canvas.cpp",
@@ -61,8 +62,10 @@ skia_core_sources = [
   "$_src/c/sk_typeface.cpp",
   "$_src/c/sk_xml.cpp",
   "$_src/c/sk_svg.cpp",
+  "$_src/c/sk_colorspace.cpp",
   "$_src/c/sk_types_priv.h",
   "$_src/c/gr_context.cpp",
+  "$_src/c/sk_structs.cpp",
 
   "$_src/core/Sk4px.h",
   "$_src/core/SkAAClip.cpp",

diff --git a/include/c/sk_colorspace.h b/include/c/sk_colorspace.h
new file mode 100644 (file)
index 0000000..2a9be80
--- /dev/null
+++ b/include/c/sk_colorspace.h
@@ -0,0 +1,27 @@
+/*
+ * 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_named(sk_colorspace_named_t named);
+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);
+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 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_colorspaceprimaries_to_xyzd50(const sk_colorspaceprimaries_t* primaries, sk_matrix44_t* toXYZD50);
+
+SK_C_PLUS_PLUS_END_GUARD
+
+#endif

diff --git a/include/c/sk_types.h b/include/c/sk_types.h
index 6616e0b..1739f11 100644 (file)
--- a/include/c/sk_types.h
+++ b/include/c/sk_types.h
@@ -80,15 +80,8 @@ typedef enum {
     BGR_V_SK_PIXELGEOMETRY,
 } sk_pixelgeometry_t;
 
-typedef struct {
-    int32_t         width;
-    int32_t         height;
-    sk_colortype_t  colorType;
-    sk_alphatype_t  alphaType;
-} sk_imageinfo_t;
-
 typedef enum {
-    USE_DEVICE_INDEPENDENT_FONTS_GR_SURFACE_PROPS_FLAGS = 1 << 0,
+    USE_DEVICE_INDEPENDENT_FONTS_SK_SURFACE_PROPS_FLAGS = 1 << 0,
 } sk_surfaceprops_flags_t;
 
 typedef struct {
@@ -654,12 +647,16 @@ typedef struct {
     int  fBufferMapThreshold;
     bool fUseDrawInsteadOfPartialRenderTargetWrite;
     bool fImmediateMode;
-    bool fClipBatchToBounds;
-    bool fDrawBatchBounds;
-    int fMaxBatchLookback;
-    int fMaxBatchLookahead;
+    bool fClipDrawOpsToBounds;
+    int fMaxOpCombineLookback;
+    int fMaxOpCombineLookahead;
     bool fUseShaderSwizzling;
     bool fDoManualMipmapping;
+    bool fEnableInstancedRendering;
+    bool fDisableDistanceFieldPaths;
+    bool fAllowPathMaskCaching;
+    bool fForceSWPathMasks;
+    bool fRequireDecodeDisableForSRGB;
 } gr_context_options_t;
 
 typedef enum {
@@ -767,6 +764,20 @@ typedef enum {
     YCCK_SK_ENCODEDINFO_COLOR,
 } sk_encodedinfo_color_t;
 
+typedef enum {
+    SRGB_SK_COLORSPACE_NAMED,
+    ADOBE_RGB_SK_COLORSPACE_NAMED,
+    SRGB_LINEAR_SK_COLORSPACE_NAMED,
+} sk_colorspace_named_t;
+
+typedef struct {
+    sk_colorspace_t* colorspace;
+    int32_t          width;
+    int32_t          height;
+    sk_colortype_t   colorType;
+    sk_alphatype_t   alphaType;
+} sk_imageinfo_t;
+
 typedef struct {
     sk_encodedinfo_color_t fColor;
     sk_encodedinfo_alpha_t fAlpha;
@@ -792,6 +803,28 @@ typedef enum {
     TRIANGLE_FAN_SK_VERTEX_MODE,
 } sk_vertex_mode_t;
 
+typedef enum {
+    LINEAR_SK_COLORSPACE_RENDER_TARGET_GAMMA,
+    SRGB_SK_COLORSPACE_RENDER_TARGET_GAMMA,
+} sk_colorspace_render_target_gamma_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;
+
 SK_C_PLUS_PLUS_END_GUARD
 
 #endif

diff --git a/src/c/sk_colorspace.cpp b/src/c/sk_colorspace.cpp
new file mode 100644 (file)
index 0000000..629179f
--- /dev/null
+++ b/src/c/sk_colorspace.cpp
@@ -0,0 +1,48 @@
+/*
+ * 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_named(sk_colorspace_named_t named) {
+    return ToColorSpace(SkColorSpace::MakeNamed((SkColorSpace::Named)named).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) {
+    return ToColorSpace(SkColorSpace::MakeRGB((SkColorSpace::RenderTargetGamma)gamma, AsMatrix44(*toXYZD50)).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());
+}
+
+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_colorspaceprimaries_to_xyzd50(const sk_colorspaceprimaries_t* primaries, sk_matrix44_t* toXYZD50) {
+    return AsColorSpacePrimaries(primaries)->toXYZD50(AsMatrix44(toXYZD50));
+}

diff --git a/src/c/sk_enums.cpp b/src/c/sk_enums.cpp
index db7bda2..943061d 100644 (file)
--- a/src/c/sk_enums.cpp
+++ b/src/c/sk_enums.cpp
@@ -10,6 +10,10 @@
 #include "SkBitmapScaler.h"
 #include "SkBlurMaskFilter.h"
 
+#if SK_SUPPORT_GPU
+#include "GrTypes.h"
+#endif
+
 #if __cplusplus >= 199711L
 
 #define STRINGIFY(x) #x
@@ -262,38 +266,7 @@ static_assert ((int)SkCanvas::PointMode::kLines_PointMode     == (int)LINES_SK_P
 static_assert ((int)SkCanvas::PointMode::kPolygon_PointMode   == (int)POLYGON_SK_POINT_MODE,   ASSERT_MSG(SkCanvas::PointMode, sk_point_mode_t));
 
 // sk_surfaceprops_flags_t
-static_assert ((int)SkSurfaceProps::Flags::kUseDeviceIndependentFonts_Flag   == (int)USE_DEVICE_INDEPENDENT_FONTS_GR_SURFACE_PROPS_FLAGS,   ASSERT_MSG(SkSurfaceProps::Flags, sk_surfaceprops_flags_t));
-
-// gr_surfaceorigin_t
-static_assert ((int)GrSurfaceOrigin::kBottomLeft_GrSurfaceOrigin   == (int)BOTTOM_LEFT_GR_SURFACE_ORIGIN,   ASSERT_MSG(GrSurfaceOrigin, gr_surfaceorigin_t));
-static_assert ((int)GrSurfaceOrigin::kTopLeft_GrSurfaceOrigin      == (int)TOP_LEFT_GR_SURFACE_ORIGIN,      ASSERT_MSG(GrSurfaceOrigin, gr_surfaceorigin_t));
-
-// gr_pixelconfig_t
-static_assert ((int)GrPixelConfig::kUnknown_GrPixelConfig          == (int)UNKNOWN_GR_PIXEL_CONFIG,          ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
-static_assert ((int)GrPixelConfig::kAlpha_8_GrPixelConfig          == (int)ALPHA_8_GR_PIXEL_CONFIG,          ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
-static_assert ((int)GrPixelConfig::kGray_8_GrPixelConfig           == (int)GRAY_8_GR_PIXEL_CONFIG,           ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
-static_assert ((int)GrPixelConfig::kRGB_565_GrPixelConfig          == (int)RGB_565_GR_PIXEL_CONFIG,          ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
-static_assert ((int)GrPixelConfig::kRGBA_4444_GrPixelConfig        == (int)RGBA_4444_GR_PIXEL_CONFIG,        ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
-static_assert ((int)GrPixelConfig::kRGBA_8888_GrPixelConfig        == (int)RGBA_8888_GR_PIXEL_CONFIG,        ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
-static_assert ((int)GrPixelConfig::kBGRA_8888_GrPixelConfig        == (int)BGRA_8888_GR_PIXEL_CONFIG,        ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
-static_assert ((int)GrPixelConfig::kSRGBA_8888_GrPixelConfig       == (int)SRGBA_8888_GR_PIXEL_CONFIG,       ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
-static_assert ((int)GrPixelConfig::kSBGRA_8888_GrPixelConfig       == (int)SBGRA_8888_GR_PIXEL_CONFIG,       ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
-static_assert ((int)GrPixelConfig::kRGBA_8888_sint_GrPixelConfig   == (int)RGBA_8888_SINT_GR_PIXEL_CONFIG,   ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
-static_assert ((int)GrPixelConfig::kETC1_GrPixelConfig             == (int)ETC1_GR_PIXEL_CONFIG,             ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
-static_assert ((int)GrPixelConfig::kLATC_GrPixelConfig             == (int)LATC_GR_PIXEL_CONFIG,             ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
-static_assert ((int)GrPixelConfig::kR11_EAC_GrPixelConfig          == (int)R11_EAC_GR_PIXEL_CONFIG,          ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
-static_assert ((int)GrPixelConfig::kASTC_12x12_GrPixelConfig       == (int)ASTC_12X12_GR_PIXEL_CONFIG,       ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
-static_assert ((int)GrPixelConfig::kRGBA_float_GrPixelConfig       == (int)RGBA_FLOAT_GR_PIXEL_CONFIG,       ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
-static_assert ((int)GrPixelConfig::kAlpha_half_GrPixelConfig       == (int)ALPHA_HALF_GR_PIXEL_CONFIG,       ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
-static_assert ((int)GrPixelConfig::kRGBA_half_GrPixelConfig        == (int)RGBA_HALF_GR_PIXEL_CONFIG,        ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
-
-// gr_backendtexture_flags_t
-static_assert ((int)GrBackendTextureFlags::kNone_GrBackendTextureFlag           == (int)NONE_GR_BACKEND_TEXTURE_FLAGS,            ASSERT_MSG(GrBackendTextureFlags, gr_backendtexture_flags_t));
-static_assert ((int)GrBackendTextureFlags::kRenderTarget_GrBackendTextureFlag   == (int)RENDER_TARGET_GR_BACKEND_TEXTURE_FLAGS,   ASSERT_MSG(GrBackendTextureFlags, gr_backendtexture_flags_t));
-
-// gr_backend_t
-static_assert ((int)GrBackend::kOpenGL_GrBackend   == (int)OPENGL_GR_BACKEND,   ASSERT_MSG(GrBackend, gr_backend_t));
-static_assert ((int)GrBackend::kVulkan_GrBackend   == (int)VULKAN_GR_BACKEND,   ASSERT_MSG(GrBackend, gr_backend_t));
+static_assert ((int)SkSurfaceProps::Flags::kUseDeviceIndependentFonts_Flag   == (int)USE_DEVICE_INDEPENDENT_FONTS_SK_SURFACE_PROPS_FLAGS,   ASSERT_MSG(SkSurfaceProps::Flags, sk_surfaceprops_flags_t));
 
 // sk_bitmapscaler_resizemethod_t
 static_assert ((int)SkBitmapScaler::ResizeMethod::RESIZE_BOX        == (int)BOX_SK_BITMAP_SCALER_RESIZE_METHOD,        ASSERT_MSG(SkBitmapScaler::ResizeMethod, sk_bitmapscaler_resizemethod_t));
@@ -318,7 +291,7 @@ static_assert ((int)SkPath::Convexity::kUnknown_Convexity   == (int)UNKNOWN_SK_P
 static_assert ((int)SkPath::Convexity::kConvex_Convexity    == (int)CONVEX_SK_PATH_CONVEXITY,    ASSERT_MSG(SkPath::Convexity, sk_path_convexity_t));
 static_assert ((int)SkPath::Convexity::kConcave_Convexity   == (int)CONCAVE_SK_PATH_CONVEXITY,   ASSERT_MSG(SkPath::Convexity, sk_path_convexity_t));
 
-// gr_backendtexture_flags_t
+// sk_lattice_flags_t
 static_assert ((int)0                                              == (int)DEFAULT_SK_LATTICE_FLAGS,       ASSERT_MSG(SkCanvas::Lattice::Flags, sk_lattice_flags_t));
 static_assert ((int)SkCanvas::Lattice::Flags::kTransparent_Flags   == (int)TRANSPARENT_SK_LATTICE_FLAGS,   ASSERT_MSG(SkCanvas::Lattice::Flags, sk_lattice_flags_t));
 
@@ -346,6 +319,11 @@ static_assert ((int)SkEncodedInfo::Color::kYUVA_Color           == (int)YUVA_SK_
 static_assert ((int)SkEncodedInfo::Color::kInvertedCMYK_Color   == (int)INVERTED_CMYK_SK_ENCODEDINFO_COLOR,   ASSERT_MSG(SkEncodedInfo::Color, sk_encodedinfo_color_t));
 static_assert ((int)SkEncodedInfo::Color::kYCCK_Color           == (int)YCCK_SK_ENCODEDINFO_COLOR,            ASSERT_MSG(SkEncodedInfo::Color, sk_encodedinfo_color_t));
 
+// sk_colorspace_named_t
+static_assert ((int)SkColorSpace::Named::kSRGB_Named         == (int)SRGB_SK_COLORSPACE_NAMED,          ASSERT_MSG(SkColorSpace::Named, sk_colorspace_named_t));
+static_assert ((int)SkColorSpace::Named::kAdobeRGB_Named     == (int)ADOBE_RGB_SK_COLORSPACE_NAMED,     ASSERT_MSG(SkColorSpace::Named, sk_colorspace_named_t));
+static_assert ((int)SkColorSpace::Named::kSRGBLinear_Named   == (int)SRGB_LINEAR_SK_COLORSPACE_NAMED,   ASSERT_MSG(SkColorSpace::Named, sk_colorspace_named_t));
+
 // sk_mask_format_t
 static_assert ((int)SkMask::Format::kBW_Format       == (int)BW_SK_MASK_FORMAT,        ASSERT_MSG(SkMask::Format, sk_mask_format_t));
 static_assert ((int)SkMask::Format::kA8_Format       == (int)A8_SK_MASK_FORMAT,        ASSERT_MSG(SkMask::Format, sk_mask_format_t));
@@ -369,4 +347,43 @@ static_assert ((int)SkCanvas::VertexMode::kTriangleFan_VertexMode     == (int)TR
 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_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));
+
+#if SK_SUPPORT_GPU
+
+// gr_surfaceorigin_t
+static_assert ((int)GrSurfaceOrigin::kBottomLeft_GrSurfaceOrigin   == (int)BOTTOM_LEFT_GR_SURFACE_ORIGIN,   ASSERT_MSG(GrSurfaceOrigin, gr_surfaceorigin_t));
+static_assert ((int)GrSurfaceOrigin::kTopLeft_GrSurfaceOrigin      == (int)TOP_LEFT_GR_SURFACE_ORIGIN,      ASSERT_MSG(GrSurfaceOrigin, gr_surfaceorigin_t));
+
+// gr_pixelconfig_t
+static_assert ((int)GrPixelConfig::kUnknown_GrPixelConfig          == (int)UNKNOWN_GR_PIXEL_CONFIG,          ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
+static_assert ((int)GrPixelConfig::kAlpha_8_GrPixelConfig          == (int)ALPHA_8_GR_PIXEL_CONFIG,          ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
+static_assert ((int)GrPixelConfig::kGray_8_GrPixelConfig           == (int)GRAY_8_GR_PIXEL_CONFIG,           ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
+static_assert ((int)GrPixelConfig::kRGB_565_GrPixelConfig          == (int)RGB_565_GR_PIXEL_CONFIG,          ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
+static_assert ((int)GrPixelConfig::kRGBA_4444_GrPixelConfig        == (int)RGBA_4444_GR_PIXEL_CONFIG,        ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
+static_assert ((int)GrPixelConfig::kRGBA_8888_GrPixelConfig        == (int)RGBA_8888_GR_PIXEL_CONFIG,        ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
+static_assert ((int)GrPixelConfig::kBGRA_8888_GrPixelConfig        == (int)BGRA_8888_GR_PIXEL_CONFIG,        ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
+static_assert ((int)GrPixelConfig::kSRGBA_8888_GrPixelConfig       == (int)SRGBA_8888_GR_PIXEL_CONFIG,       ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
+static_assert ((int)GrPixelConfig::kSBGRA_8888_GrPixelConfig       == (int)SBGRA_8888_GR_PIXEL_CONFIG,       ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
+static_assert ((int)GrPixelConfig::kRGBA_8888_sint_GrPixelConfig   == (int)RGBA_8888_SINT_GR_PIXEL_CONFIG,   ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
+static_assert ((int)GrPixelConfig::kETC1_GrPixelConfig             == (int)ETC1_GR_PIXEL_CONFIG,             ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
+static_assert ((int)GrPixelConfig::kLATC_GrPixelConfig             == (int)LATC_GR_PIXEL_CONFIG,             ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
+static_assert ((int)GrPixelConfig::kR11_EAC_GrPixelConfig          == (int)R11_EAC_GR_PIXEL_CONFIG,          ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
+static_assert ((int)GrPixelConfig::kASTC_12x12_GrPixelConfig       == (int)ASTC_12X12_GR_PIXEL_CONFIG,       ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
+static_assert ((int)GrPixelConfig::kRGBA_float_GrPixelConfig       == (int)RGBA_FLOAT_GR_PIXEL_CONFIG,       ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
+static_assert ((int)GrPixelConfig::kAlpha_half_GrPixelConfig       == (int)ALPHA_HALF_GR_PIXEL_CONFIG,       ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
+static_assert ((int)GrPixelConfig::kRGBA_half_GrPixelConfig        == (int)RGBA_HALF_GR_PIXEL_CONFIG,        ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
+
+// gr_backendtexture_flags_t
+static_assert ((int)GrBackendTextureFlags::kNone_GrBackendTextureFlag           == (int)NONE_GR_BACKEND_TEXTURE_FLAGS,            ASSERT_MSG(GrBackendTextureFlags, gr_backendtexture_flags_t));
+static_assert ((int)GrBackendTextureFlags::kRenderTarget_GrBackendTextureFlag   == (int)RENDER_TARGET_GR_BACKEND_TEXTURE_FLAGS,   ASSERT_MSG(GrBackendTextureFlags, gr_backendtexture_flags_t));
+
+// gr_backend_t
+static_assert ((int)GrBackend::kOpenGL_GrBackend   == (int)OPENGL_GR_BACKEND,   ASSERT_MSG(GrBackend, gr_backend_t));
+static_assert ((int)GrBackend::kVulkan_GrBackend   == (int)VULKAN_GR_BACKEND,   ASSERT_MSG(GrBackend, gr_backend_t));
+
+#endif
+
 #endif

diff --git a/src/c/sk_structs.cpp b/src/c/sk_structs.cpp
new file mode 100644 (file)
index 0000000..e2ad94f
--- /dev/null
+++ b/src/c/sk_structs.cpp
@@ -0,0 +1,63 @@
+/*
+ * 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 "sk_types_priv.h"
+
+#include "SkImageInfo.h"
+#include "SkSurfaceProps.h"
+#include "SkPoint.h"
+#include "SkRect.h"
+#include "SkPoint3.h"
+#include "SkSize.h"
+#include "SkPaint.h"
+#include "SkCodec.h"
+#include "SkMask.h"
+#include "SkCanvas.h"
+#include "SkTime.h"
+#include "SkDocument.h"
+#include "SkEncodedInfo.h"
+
+#if SK_SUPPORT_GPU
+#include "GrTypes.h"
+#include "GrContextOptions.h"
+#endif
+
+#if __cplusplus >= 199711L
+
+#define STRINGIFY(x) #x
+#define TOSTRING(x) STRINGIFY(x)
+#define ASSERT_MSG(SK, C) "ABI changed, you must update the C structure for " TOSTRING(#SK) " to " TOSTRING(#C) "."
+
+// custom mappings:
+//  - sk_imageinfo_t
+//  - sk_surfaceprops_t
+//  - sk_matrix_t
+//  - sk_document_pdf_metadata_t
+
+static_assert (sizeof (sk_ipoint_t) == sizeof (SkIPoint), ASSERT_MSG(SkIPoint, sk_ipoint_t));
+static_assert (sizeof (sk_point_t) == sizeof (SkPoint), ASSERT_MSG(SkPoint, sk_point_t));
+static_assert (sizeof (sk_irect_t) == sizeof (SkIRect), ASSERT_MSG(SkIRect, sk_irect_t));
+static_assert (sizeof (sk_rect_t) == sizeof (SkRect), ASSERT_MSG(SkRect, sk_rect_t));
+static_assert (sizeof (sk_isize_t) == sizeof (SkISize), ASSERT_MSG(SkISize, sk_isize_t));
+static_assert (sizeof (sk_size_t) == sizeof (SkSize), ASSERT_MSG(SkSize, sk_size_t));
+static_assert (sizeof (sk_point3_t) == sizeof (SkPoint3), ASSERT_MSG(SkPoint3, sk_point3_t));
+static_assert (sizeof (sk_fontmetrics_t) == sizeof (SkPaint::FontMetrics), ASSERT_MSG(SkPaint::FontMetrics, sk_fontmetrics_t));
+static_assert (sizeof (sk_codec_options_t) == sizeof (SkCodec::Options), ASSERT_MSG(SkCodec::Options, sk_codec_options_t));
+static_assert (sizeof (sk_mask_t) == sizeof (SkMask), ASSERT_MSG(SkMask, sk_mask_t));
+static_assert (sizeof (sk_lattice_t) == sizeof (SkCanvas::Lattice), ASSERT_MSG(SkCanvas::Lattice, sk_lattice_t));
+static_assert (sizeof (sk_time_datetime_t) == sizeof (SkTime::DateTime), ASSERT_MSG(SkTime::DateTime, sk_time_datetime_t));
+static_assert (sizeof (sk_encodedinfo_t) == sizeof (SkEncodedInfo), ASSERT_MSG(SkEncodedInfo, sk_encodedinfo_t));
+static_assert (sizeof (sk_codec_frameinfo_t) == sizeof (SkCodec::FrameInfo), ASSERT_MSG(SkCodec::FrameInfo, sk_codec_frameinfo_t));
+static_assert (sizeof (sk_colorspace_transfer_fn_t) == sizeof (SkColorSpaceTransferFn), ASSERT_MSG(SkColorSpaceTransferFn, sk_colorspace_transfer_fn_t));
+
+#if SK_SUPPORT_GPU
+static_assert (sizeof (gr_backend_rendertarget_desc_t) == sizeof (GrBackendRenderTargetDesc), ASSERT_MSG(GrBackendRenderTargetDesc, gr_backend_rendertarget_desc_t));
+static_assert (sizeof (gr_backend_texture_desc_t) == sizeof (GrBackendTextureDesc), ASSERT_MSG(GrBackendTextureDesc, gr_backend_texture_desc_t));
+static_assert (sizeof (gr_context_options_t) == sizeof (GrContextOptions), ASSERT_MSG(GrContextOptions, gr_context_options_t));
+#endif
+
+#endif

diff --git a/src/c/sk_types_priv.h b/src/c/sk_types_priv.h
index 43eb05e..cf4dad1 100644 (file)
--- a/src/c/sk_types_priv.h
+++ b/src/c/sk_types_priv.h
@@ -15,6 +15,7 @@
 #include "SkPath.h"
 #include "SkPathMeasure.h"
 #include "SkCodec.h"
+#include "SkColorSpace.h"
 #include "SkPicture.h"
 #include "SkPixmap.h"
 #include "SkPictureRecorder.h"
@@ -298,6 +299,10 @@ static inline SkColorSpace* AsColorSpace(sk_colorspace_t* colorspace) {
     return reinterpret_cast<SkColorSpace*>(colorspace);
 }
 
+static inline const SkColorSpace* AsColorSpace(const sk_colorspace_t* colorspace) {
+    return reinterpret_cast<const SkColorSpace*>(colorspace);
+}
+
 static inline sk_shader_t* ToShader(SkShader* shader) {
     return reinterpret_cast<sk_shader_t*>(shader);
 }
@@ -630,6 +635,70 @@ static inline const sk_encodedinfo_t& ToEncodedInfo(const SkEncodedInfo &p) {
     return reinterpret_cast<const sk_encodedinfo_t&>(p);
 }
 
+static inline const SkColorSpacePrimaries* AsColorSpacePrimaries(const sk_colorspaceprimaries_t* p) {
+    return reinterpret_cast<const SkColorSpacePrimaries*>(p);
+}
+
+static inline const SkColorSpacePrimaries& AsColorSpacePrimaries(const sk_colorspaceprimaries_t& p) {
+    return reinterpret_cast<const SkColorSpacePrimaries&>(p);
+}
+
+static inline SkColorSpacePrimaries* AsColorSpacePrimaries(sk_colorspaceprimaries_t* p) {
+    return reinterpret_cast<SkColorSpacePrimaries*>(p);
+}
+
+static inline SkColorSpacePrimaries& AsColorSpacePrimaries(sk_colorspaceprimaries_t& p) {
+    return reinterpret_cast<SkColorSpacePrimaries&>(p);
+}
+
+static inline sk_colorspaceprimaries_t* ToColorSpacePrimaries(SkColorSpacePrimaries *p) {
+    return reinterpret_cast<sk_colorspaceprimaries_t*>(p);
+}
+
+static inline sk_colorspaceprimaries_t& ToColorSpacePrimaries(SkColorSpacePrimaries &p) {
+    return reinterpret_cast<sk_colorspaceprimaries_t&>(p);
+}
+
+static inline const sk_colorspaceprimaries_t* ToColorSpacePrimaries(const SkColorSpacePrimaries *p) {
+    return reinterpret_cast<const sk_colorspaceprimaries_t*>(p);
+}
+
+static inline const sk_colorspaceprimaries_t& ToColorSpacePrimaries(const SkColorSpacePrimaries &p) {
+    return reinterpret_cast<const sk_colorspaceprimaries_t&>(p);
+}
+
+static inline const SkColorSpaceTransferFn* AsColorSpaceTransferFn(const sk_colorspace_transfer_fn_t* p) {
+    return reinterpret_cast<const SkColorSpaceTransferFn*>(p);
+}
+
+static inline const SkColorSpaceTransferFn& AsColorSpaceTransferFn(const sk_colorspace_transfer_fn_t& p) {
+    return reinterpret_cast<const SkColorSpaceTransferFn&>(p);
+}
+
+static inline SkColorSpaceTransferFn* AsColorSpaceTransferFn(sk_colorspace_transfer_fn_t* p) {
+    return reinterpret_cast<SkColorSpaceTransferFn*>(p);
+}
+
+static inline SkColorSpaceTransferFn& AsColorSpaceTransferFn(sk_colorspace_transfer_fn_t& p) {
+    return reinterpret_cast<SkColorSpaceTransferFn&>(p);
+}
+
+static inline sk_colorspace_transfer_fn_t* ToColorSpaceTransferFn(SkColorSpaceTransferFn *p) {
+    return reinterpret_cast<sk_colorspace_transfer_fn_t*>(p);
+}
+
+static inline sk_colorspace_transfer_fn_t& ToColorSpaceTransferFn(SkColorSpaceTransferFn &p) {
+    return reinterpret_cast<sk_colorspace_transfer_fn_t&>(p);
+}
+
+static inline const sk_colorspace_transfer_fn_t* ToColorSpaceTransferFn(const SkColorSpaceTransferFn *p) {
+    return reinterpret_cast<const sk_colorspace_transfer_fn_t*>(p);
+}
+
+static inline const sk_colorspace_transfer_fn_t& ToColorSpaceTransferFn(const SkColorSpaceTransferFn &p) {
+    return reinterpret_cast<const sk_colorspace_transfer_fn_t&>(p);
+}
+
 static inline SkCodec::FrameInfo* AsFrameInfo(sk_codec_frameinfo_t *p) {
     return reinterpret_cast<SkCodec::FrameInfo*>(p);
 }
@@ -733,27 +802,27 @@ static inline void from_sk(const SkMatrix* matrix, sk_matrix_t* cmatrix) {
     matrix->get9(cmatrix->mat);
 }
 
-static inline bool from_c(const sk_imageinfo_t& cinfo, SkImageInfo* info) {
+static inline void from_c(const sk_imageinfo_t& cinfo, SkImageInfo* info) {
     if (info) { 
         *info = SkImageInfo::Make(
             cinfo.width,
             cinfo.height,
             (SkColorType)cinfo.colorType,
-            (SkAlphaType)cinfo.alphaType); 
+            (SkAlphaType)cinfo.alphaType,
+            sk_ref_sp(AsColorSpace(cinfo.colorspace))); 
     } 
-    return true; 
 } 
 
-static inline bool from_sk(const SkImageInfo& info, sk_imageinfo_t* cinfo) {
+static inline void from_sk(const SkImageInfo& info, sk_imageinfo_t* cinfo) {
     if (cinfo) { 
         *cinfo = {
+            ToColorSpace(info.refColorSpace().release()),
             info.width(),
             info.height(),
             (sk_colortype_t)info.colorType(),
-            (sk_alphatype_t)info.alphaType()
+            (sk_alphatype_t)info.alphaType(),
         }; 
     } 
-    return true; 
 } 
 
 static inline void from_c(const sk_document_pdf_metadata_t& cmetadata, SkDocument::PDFMetadata* metadata) {