"$_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_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",
SK_C_API sk_colorfilter_t* sk_colorfilter_new_compose(sk_colorfilter_t* outer, sk_colorfilter_t* inner);
SK_C_API sk_colorfilter_t* sk_colorfilter_new_color_matrix(const float array[20]);
SK_C_API sk_colorfilter_t* sk_colorfilter_new_luma_color(void);
+SK_C_API sk_colorfilter_t* sk_colorfilter_new_high_contrast(const sk_highcontrastconfig_t* config);
SK_C_API sk_colorfilter_t* sk_colorfilter_new_table(const uint8_t table[256]);
SK_C_API sk_colorfilter_t* sk_colorfilter_new_table_argb(const uint8_t tableA[256], const uint8_t tableR[256], const uint8_t tableG[256], const uint8_t tableB[256]);
--- /dev/null
+/*
+ * 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);
+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
SK_C_API sk_imagefilter_t* sk_imagefilter_new_magnifier(
const sk_rect_t* src,
float inset,
- sk_imagefilter_t* input /*NULL*/);
+ sk_imagefilter_t* input, /*NULL*/
+ const sk_imagefilter_croprect_t* cropRect /*NULL*/);
SK_C_API sk_imagefilter_t* sk_imagefilter_new_matrix_convolution(
const sk_isize_t* kernelSize,
const float kernel[],
sk_imagefilter_t* background,
sk_imagefilter_t* foreground /*NULL*/,
const sk_imagefilter_croprect_t* cropRect /*NULL*/);
+SK_C_API sk_imagefilter_t* sk_imagefilter_new_image_source(
+ sk_image_t* image,
+ const sk_rect_t* srcRect,
+ const sk_rect_t* dstRect,
+ sk_filter_quality_t filterQuality);
+SK_C_API sk_imagefilter_t* sk_imagefilter_new_image_source_default(
+ sk_image_t* image);
+SK_C_API sk_imagefilter_t* sk_imagefilter_new_paint(
+ const sk_paint_t* paint,
+ const sk_imagefilter_croprect_t* cropRect /*NULL*/);
SK_C_PLUS_PLUS_END_GUARD
SK_C_API sk_path_effect_t* sk_path_effect_create_sum(sk_path_effect_t* first, sk_path_effect_t* second);
SK_C_API sk_path_effect_t* sk_path_effect_create_discrete(float segLength, float deviation, uint32_t seedAssist /*0*/);
SK_C_API sk_path_effect_t* sk_path_effect_create_corner(float radius);
+SK_C_API sk_path_effect_t* sk_path_effect_create_arc_to(float radius);
SK_C_API sk_path_effect_t* sk_path_effect_create_1d_path(const sk_path_t* path, float advance, float phase, sk_path_effect_1d_style_t style);
SK_C_API sk_path_effect_t* sk_path_effect_create_2d_line(float width, const sk_matrix_t* matrix);
SK_C_API sk_path_effect_t* sk_path_effect_create_2d_path(const sk_matrix_t* matrix, const sk_path_t* path);
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 {
int fBufferMapThreshold;
bool fUseDrawInsteadOfPartialRenderTargetWrite;
bool fImmediateMode;
- bool fClipDrawOpsToBounds;
int fMaxOpCombineLookback;
int fMaxOpCombineLookahead;
bool fUseShaderSwizzling;
bool fDisableGpuYUVConversion;
bool fSuppressPathRendering;
gr_contextoptions_gpupathrenderers_t fGpuPathRenderers;
+ bool fAvoidStencilBuffers;
} gr_context_options_t;
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;
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 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
SkScalar dpi = SK_ScalarDefaultRasterDPI);
#else
// DEPRECATED; TODO(mattleibow): we should remove this function.
- static sk_sp<SkDocument> MakeXPS(SkWStream* stream,
- SkScalar dpi = SK_ScalarDefaultRasterDPI) {
- return nullptr;
- }
+ static sk_sp<SkDocument> MakeXPS(SkWStream*, SkScalar) { return nullptr; }
#endif
// DEPRECATED; TODO(halcanary): remove this function after Chromium switches to new API.
static sk_sp<SkDocument> MakeXPS(SkWStream*) { return nullptr; }
return ToColorFilter(filter.release());
}
+sk_colorfilter_t* sk_colorfilter_new_high_contrast(const sk_highcontrastconfig_t* config) {
+
+ sk_sp<SkColorFilter> filter = SkHighContrastFilter::Make(AsHighContrastConfig(*config));
+ return ToColorFilter(filter.release());
+}
+
sk_colorfilter_t* sk_colorfilter_new_table(const uint8_t table[256]) {
sk_sp<SkColorFilter> filter = SkTableColorFilter::Make(table);
--- /dev/null
+/*
+ * 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) {
+ 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) {
+ 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) {
+ 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) {
+ 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));
+}
}
sk_document_t* sk_document_create_xps_from_stream(sk_wstream_t* stream, float dpi) {
- return ToDocument(SkDocument::MakeXPS(AsWStream(stream), dpi).release());
+ return ToDocument(SkDocument::MakeXPS(AsWStream(stream), dpi).release());
}
sk_canvas_t* sk_document_begin_page(sk_document_t* document, float width, float height, const sk_rect_t* content) {
#include "SkBlurMaskFilter.h"
#if SK_SUPPORT_GPU
+#include "GrTypes.h"
#include "GrContextOptions.h"
#endif
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));
+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));
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));
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_gamut_t
+static_assert ((int)SkColorSpace::Gamut::kSRGB_Gamut == (int)SRGB_SK_COLORSPACE_GAMUT, ASSERT_MSG(SkColorSpace::Gamut, sk_colorspace_gamut_t));
+static_assert ((int)SkColorSpace::Gamut::kAdobeRGB_Gamut == (int)ADOBE_RGB_SK_COLORSPACE_GAMUT, ASSERT_MSG(SkColorSpace::Gamut, sk_colorspace_gamut_t));
+static_assert ((int)SkColorSpace::Gamut::kDCIP3_D65_Gamut == (int)DCIP3_D65_SK_COLORSPACE_GAMUT, ASSERT_MSG(SkColorSpace::Gamut, sk_colorspace_gamut_t));
+static_assert ((int)SkColorSpace::Gamut::kRec2020_Gamut == (int)REC2020_SK_COLORSPACE_GAMUT, ASSERT_MSG(SkColorSpace::Gamut, sk_colorspace_gamut_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));
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));
+
+// 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));
#include "SkTileImageFilter.h"
#include "SkXfermodeImageFilter.h"
#include "SkArithmeticImageFilter.h"
+#include "SkImageSource.h"
+#include "SkPaintImageFilter.h"
#include "sk_imagefilter.h"
sk_imagefilter_t* sk_imagefilter_new_magnifier(
const sk_rect_t* src,
float inset,
- sk_imagefilter_t* input /*NULL*/) {
+ sk_imagefilter_t* input, /*NULL*/
+ const sk_imagefilter_croprect_t* cropRect) {
sk_sp<SkImageFilter> filter = SkMagnifierImageFilter::Make(
*AsRect(src),
inset,
- sk_ref_sp(AsImageFilter(input)));
+ sk_ref_sp(AsImageFilter(input)),
+ AsImageFilterCropRect(cropRect));
return ToImageFilter(filter.release());
}
AsImageFilterCropRect(cropRect));
return ToImageFilter(filter.release());
}
+
+sk_imagefilter_t* sk_imagefilter_new_image_source(
+ sk_image_t* image,
+ const sk_rect_t* srcRect,
+ const sk_rect_t* dstRect,
+ sk_filter_quality_t filterQuality) {
+
+ sk_sp<SkImageFilter> filter = SkImageSource::Make(
+ sk_ref_sp(AsImage(image)),
+ *AsRect(srcRect),
+ *AsRect(dstRect),
+ (SkFilterQuality)filterQuality);
+ return ToImageFilter(filter.release());
+}
+
+sk_imagefilter_t* sk_imagefilter_new_image_source_default(
+ sk_image_t* image) {
+
+ sk_sp<SkImageFilter> filter = SkImageSource::Make(
+ sk_ref_sp(AsImage(image)));
+ return ToImageFilter(filter.release());
+}
+
+sk_imagefilter_t* sk_imagefilter_new_paint(
+ const sk_paint_t* paint,
+ const sk_imagefilter_croprect_t* cropRect /*NULL*/) {
+
+ sk_sp<SkImageFilter> filter = SkPaintImageFilter::Make(
+ AsPaint(*paint),
+ AsImageFilterCropRect(cropRect));
+ return ToImageFilter(filter.release());
+}
#include "Sk1DPathEffect.h"
#include "Sk2DPathEffect.h"
#include "SkDashPathEffect.h"
+#include "SkArcToPathEffect.h"
#include "SkPath.h"
#include "sk_patheffect.h"
return ToPathEffect(SkCornerPathEffect::Make(radius).release());
}
+sk_path_effect_t* sk_path_effect_create_arc_to(float radius)
+{
+ return ToPathEffect(SkArcToPathEffect::Make(radius).release());
+}
+
sk_path_effect_t* sk_path_effect_create_1d_path(const sk_path_t* path, float advance, float phase, sk_path_effect_1d_style_t style)
{
return ToPathEffect(SkPath1DPathEffect::Make(AsPath(*path), advance, phase, (SkPath1DPathEffect::Style)style).release());
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));
+static_assert (sizeof (sk_colorspaceprimaries_t) == sizeof (SkColorSpacePrimaries), ASSERT_MSG(SkColorSpacePrimaries, sk_colorspaceprimaries_t));
+static_assert (sizeof (sk_highcontrastconfig_t) == sizeof (SkHighContrastConfig), ASSERT_MSG(SkHighContrastConfig, sk_highcontrastconfig_t));
#if SK_SUPPORT_GPU
static_assert (sizeof (gr_backend_rendertarget_desc_t) == sizeof (GrBackendRenderTargetDesc), ASSERT_MSG(GrBackendRenderTargetDesc, gr_backend_rendertarget_desc_t));
#include "SkPath.h"
#include "SkPathMeasure.h"
#include "SkCodec.h"
+#include "SkColorSpace.h"
#include "SkPicture.h"
#include "SkPixmap.h"
#include "SkPictureRecorder.h"
#include "SkEncodedInfo.h"
#include "SkTime.h"
#include "SkCamera.h"
+#include "SkHighContrastFilter.h"
#include "sk_path.h"
#include "sk_paint.h"
return reinterpret_cast<const SkImage*>(cimage);
}
+static inline SkImage* AsImage(sk_image_t* cimage) {
+ return reinterpret_cast<SkImage*>(cimage);
+}
+
static inline sk_image_t* ToImage(SkImage* cimage) {
return reinterpret_cast<sk_image_t*>(cimage);
}
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);
}
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);
}
return reinterpret_cast<const sk_matrix44_t*>(p);
}
+static inline const SkHighContrastConfig* AsHighContrastConfig(const sk_highcontrastconfig_t* p) {
+ return reinterpret_cast<const SkHighContrastConfig*>(p);
+}
+
+static inline const SkHighContrastConfig& AsHighContrastConfig(const sk_highcontrastconfig_t& p) {
+ return reinterpret_cast<const SkHighContrastConfig&>(p);
+}
+
+static inline SkHighContrastConfig* AsHighContrastConfig(sk_highcontrastconfig_t* p) {
+ return reinterpret_cast<SkHighContrastConfig*>(p);
+}
+
+static inline SkHighContrastConfig& AsHighContrastConfig(sk_highcontrastconfig_t& p) {
+ return reinterpret_cast<SkHighContrastConfig&>(p);
+}
+
+static inline sk_highcontrastconfig_t* ToHighContrastConfig(SkHighContrastConfig *p) {
+ return reinterpret_cast<sk_highcontrastconfig_t*>(p);
+}
+
+static inline sk_highcontrastconfig_t& ToHighContrastConfig(SkHighContrastConfig &p) {
+ return reinterpret_cast<sk_highcontrastconfig_t&>(p);
+}
+
+static inline const sk_highcontrastconfig_t* ToHighContrastConfig(const SkHighContrastConfig *p) {
+ return reinterpret_cast<const sk_highcontrastconfig_t*>(p);
+}
+
+static inline const sk_highcontrastconfig_t& ToHighContrastConfig(const SkHighContrastConfig &p) {
+ return reinterpret_cast<const sk_highcontrastconfig_t&>(p);
+}
+
static inline const SkVertices* AsVertices(const sk_vertices_t* p) {
return reinterpret_cast<const SkVertices*>(p);
}
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) {
# define GCC_EVAL_ORDER_BUG 1
# endif
# undef GCC_VERSION
-#elif defined(_MSC_VER) && defined(__clang__)
+#elif defined(_MSC_VER) && (defined(__clang__) || defined(_M_ARM))
# define GCC_EVAL_ORDER_BUG 1
#else
# define GCC_EVAL_ORDER_BUG 0
SkASSERT(nullptr != ctx);
const GLXProcGetter* getter = (const GLXProcGetter*) ctx;
- SkASSERT(nullptr != getter->getCurrentContext())
+ SkASSERT(nullptr != getter->getCurrentContext());
return getter->getProc(reinterpret_cast<const GLubyte*>(name));
}
# found in the LICENSE file.
declare_args() {
- skia_use_system_icu = is_official_build
+ skia_use_system_icu = false
}
import("../third_party.gni")
projects / platform / upstream / libSkiaSharp.git / commitdiff