"$_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",
"$_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",
"$_src/core/SkBitmapController.cpp",
"$_src/core/SkBitmapDevice.cpp",
"$_src/core/SkBitmapDevice.h",
+ "$_src/core/SkThreadedBMPDevice.cpp",
+ "$_src/core/SkThreadedBMPDevice.h",
"$_src/core/SkBitmapFilter.h",
"$_src/core/SkBitmapProcShader.cpp",
"$_src/core/SkBitmapProcShader.h",
"$_src/core/SkCachedData.cpp",
"$_src/core/SkCanvas.cpp",
"$_src/core/SkCanvasPriv.h",
- "$_src/core/SkChunkAlloc.cpp",
"$_src/core/SkClipStack.cpp",
"$_src/core/SkClipStack.h",
"$_src/core/SkClipStackDevice.cpp",
"$_src/core/SkColorSpace_XYZ.h",
"$_src/core/SkColorSpace_ICC.cpp",
"$_src/core/SkColorSpaceXform.cpp",
+ "$_src/core/SkColorSpaceXformCanvas.cpp",
+ "$_src/core/SkColorSpaceXformer.cpp",
+ "$_src/core/SkColorSpaceXformer.h",
"$_src/core/SkColorSpaceXform_A2B.cpp",
"$_src/core/SkColorSpaceXform_A2B.h",
"$_src/core/SkColorTable.cpp",
"$_src/core/SkOpts.cpp",
"$_src/core/SkOpts.h",
"$_src/core/SkOrderedReadBuffer.h",
+ "$_src/core/SkOSFile.h",
"$_src/core/SkOverdrawCanvas.cpp",
"$_src/core/SkOverdrawCanvas.h",
"$_src/core/SkPaint.cpp",
"$_src/core/SkValidatingReadBuffer.h",
"$_src/core/SkValidationUtils.h",
"$_src/core/SkVarAlloc.cpp",
+ "$_src/core/SkVertices.cpp",
"$_src/core/SkVertState.cpp",
"$_src/core/SkWriteBuffer.cpp",
"$_src/core/SkWriter32.cpp",
"$_include/core/SkMatrix44.h",
"$_include/core/SkMetaData.h",
"$_include/core/SkMultiPictureDraw.h",
- "$_include/core/SkOSFile.h",
"$_include/core/SkPaint.h",
"$_include/core/SkPath.h",
"$_include/core/SkPathEffect.h",
# private
"$_include/private/SkAtomics.h",
"$_include/private/SkChecksum.h",
- "$_include/private/SkChunkAlloc.h",
"$_include/private/SkFixed.h",
"$_include/private/SkFloatBits.h",
"$_include/private/SkFloatingPoint.h",
- "$_include/private/SkMiniRecorder.h",
+ "$_include/private/SkMalloc.h",
"$_include/private/SkMessageBus.h",
+ "$_include/private/SkMiniRecorder.h",
"$_include/private/SkMutex.h",
"$_include/private/SkOnce.h",
"$_include/private/SkRecords.h",
"$_src/pathops/SkPathWriter.h",
"$_src/pathops/SkReduceOrder.h",
]
+
+skia_core_sources += [
+ "$_src/jumper/SkJumper.cpp",
+ "$_src/jumper/SkJumper_stages.cpp",
+]
+if (is_win) {
+ skia_core_sources += [ "$_src/jumper/SkJumper_generated_win.S" ]
+} else if (!is_tvos) {
+ skia_core_sources += [ "$_src/jumper/SkJumper_generated.S" ]
+}
--- /dev/null
-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);
+ /*
+ * 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
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 {
float bottom;
} sk_rect_t;
+/**
+ The sk_matrix_t struct holds a 3x3 perspective matrix for
+ transforming coordinates:
+
+ (X,Y) = T[M]((x,y))
+ X = (M[0] * x + M[1] * y + M[2]) / (M[6] * x + M[7] * y + M[8]);
+ Y = (M[3] * x + M[4] * y + M[5]) / (M[6] * x + M[7] * y + M[8]);
+
+ Therefore, the identity matrix is
+
+ sk_matrix_t identity = {{1, 0, 0,
+ 0, 1, 0,
+ 0, 0, 1}};
+
+ A matrix that scales by sx and sy is:
+
+ sk_matrix_t scale = {{sx, 0, 0,
+ 0, sy, 0,
+ 0, 0, 1}};
+
+ A matrix that translates by tx and ty is:
+
+ sk_matrix_t translate = {{1, 0, tx,
+ 0, 1, ty,
+ 0, 0, 1}};
+
+ A matrix that rotates around the origin by A radians:
+
+ sk_matrix_t rotate = {{cos(A), -sin(A), 0,
+ sin(A), cos(A), 0,
+ 0, 0, 1}};
+
+ Two matrixes can be concatinated by:
+
+ void concat_matrices(sk_matrix_t* dst,
+ const sk_matrix_t* matrixU,
+ const sk_matrix_t* matrixV) {
+ const float* u = matrixU->mat;
+ const float* v = matrixV->mat;
+ sk_matrix_t result = {{
+ u[0] * v[0] + u[1] * v[3] + u[2] * v[6],
+ u[0] * v[1] + u[1] * v[4] + u[2] * v[7],
+ u[0] * v[2] + u[1] * v[5] + u[2] * v[8],
+ u[3] * v[0] + u[4] * v[3] + u[5] * v[6],
+ u[3] * v[1] + u[4] * v[4] + u[5] * v[7],
+ u[3] * v[2] + u[4] * v[5] + u[5] * v[8],
+ u[6] * v[0] + u[7] * v[3] + u[8] * v[6],
+ u[6] * v[1] + u[7] * v[4] + u[8] * v[7],
+ u[6] * v[2] + u[7] * v[5] + u[8] * v[8]
+ }};
+ *dst = result;
+ }
+*/
typedef struct {
float mat[9];
} sk_matrix_t;
NO_SK_CODEC_ZERO_INITIALIZED,
} sk_codec_zero_initialized_t;
+typedef enum {
+ RESPECT_SK_TRANSFER_FUNCTION_BEHAVIOR,
+ IGNORE_SK_TRANSFER_FUNCTION_BEHAVIOR,
+} sk_transfer_function_behavior_t;
+
typedef struct {
sk_codec_zero_initialized_t fZeroInitialized;
sk_irect_t* fSubset;
size_t fFrameIndex;
bool fHasPriorFrame;
+ sk_transfer_function_behavior_t fPremulBehavior;
} sk_codec_options_t;
typedef enum {
AA_HAIRLINE_GR_CONTEXT_OPTIONS_GPU_PATH_RENDERERS = 1 << 3,
AA_CONVEX_GR_CONTEXT_OPTIONS_GPU_PATH_RENDERERS = 1 << 4,
AA_LINEARIZING_GR_CONTEXT_OPTIONS_GPU_PATH_RENDERERS = 1 << 5,
- PLS_GR_CONTEXT_OPTIONS_GPU_PATH_RENDERERS = 1 << 6,
- DISTANCE_FIELD_GR_CONTEXT_OPTIONS_GPU_PATH_RENDERERS = 1 << 7,
- TESSELLATING_GR_CONTEXT_OPTIONS_GPU_PATH_RENDERERS = 1 << 8,
- DEFAULT_GR_CONTEXT_OPTIONS_GPU_PATH_RENDERERS = 1 << 9,
+ SMALL_GR_CONTEXT_OPTIONS_GPU_PATH_RENDERERS = 1 << 6,
+ TESSELLATING_GR_CONTEXT_OPTIONS_GPU_PATH_RENDERERS = 1 << 7,
+ DEFAULT_GR_CONTEXT_OPTIONS_GPU_PATH_RENDERERS = 1 << 8,
ALL_GR_CONTEXT_OPTIONS_GPU_PATH_RENDERERS = DEFAULT_GR_CONTEXT_OPTIONS_GPU_PATH_RENDERERS | (DEFAULT_GR_CONTEXT_OPTIONS_GPU_PATH_RENDERERS - 1)
} gr_contextoptions_gpupathrenderers_t;
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 {
DISALLOW_SK_IMAGE_CACHING_HINT,
} sk_image_caching_hint_t;
+typedef enum {
+ ZERO_PIXELS_SK_BITMAP_ALLOC_FLAGS = 1 << 0,
+} sk_bitmap_allocflags_t;
+
typedef struct {
int16_t fTimeZoneMinutes;
uint16_t fYear;
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 {
size_t fRequiredFrame;
size_t fDuration;
- bool fullyRecieved;
+ bool fFullyReceived;
+ sk_alphatype_t fAlphaType;
} sk_codec_frameinfo_t;
typedef struct sk_xmlstreamwriter_t sk_xmlstreamwriter_t;
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 {
- NON_LINEAR_BLENDING_SK_COLORSPACE_FLAGS = 0x1,
-} sk_colorspace_flags_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
--- /dev/null
-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());
+ /*
+ * 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_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(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, uint32_t flags) {
- return ToColorSpace(SkColorSpace::MakeRGB(AsColorSpaceTransferFn(*coeffs), AsMatrix44(*toXYZD50), 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_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(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));
+ }
#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)SkMatrix44::TypeMask::kAffine_Mask == (int)AFFINE_SK_MATRIX44_TYPE_MASK, ASSERT_MSG(SkMatrix44::TypeMask, sk_matrix44_type_mask_t));
static_assert ((int)SkMatrix44::TypeMask::kPerspective_Mask == (int)PERSPECTIVE_SK_MATRIX44_TYPE_MASK, ASSERT_MSG(SkMatrix44::TypeMask, sk_matrix44_type_mask_t));
-// sk_vertex_mode_t
-static_assert ((int)SkCanvas::VertexMode::kTriangles_VertexMode == (int)TRIANGLES_SK_VERTEX_MODE, ASSERT_MSG(SkCanvas::VertexMode, sk_vertex_mode_t));
-static_assert ((int)SkCanvas::VertexMode::kTriangleStrip_VertexMode == (int)TRIANGLE_STRIP_SK_VERTEX_MODE, ASSERT_MSG(SkCanvas::VertexMode, sk_vertex_mode_t));
-static_assert ((int)SkCanvas::VertexMode::kTriangleFan_VertexMode == (int)TRIANGLE_FAN_SK_VERTEX_MODE, ASSERT_MSG(SkCanvas::VertexMode, sk_vertex_mode_t));
+// sk_vertices_vertex_mode_t
+static_assert ((int)SkVertices::VertexMode::kTriangles_VertexMode == (int)TRIANGLES_SK_VERTICES_VERTEX_MODE, ASSERT_MSG(SkVertices::VertexMode, sk_vertices_vertex_mode_t));
+static_assert ((int)SkVertices::VertexMode::kTriangleStrip_VertexMode == (int)TRIANGLE_STRIP_SK_VERTICES_VERTEX_MODE, ASSERT_MSG(SkVertices::VertexMode, sk_vertices_vertex_mode_t));
+static_assert ((int)SkVertices::VertexMode::kTriangleFan_VertexMode == (int)TRIANGLE_FAN_SK_VERTICES_VERTEX_MODE, ASSERT_MSG(SkVertices::VertexMode, sk_vertices_vertex_mode_t));
// sk_image_caching_hint_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_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
static_assert ((int)GrContextOptions::GpuPathRenderers::kAAHairline == (int)AA_HAIRLINE_GR_CONTEXT_OPTIONS_GPU_PATH_RENDERERS, ASSERT_MSG(GrContextOptions::GpuPathRenderers, gr_contextoptions_gpupathrenderers_t));
static_assert ((int)GrContextOptions::GpuPathRenderers::kAAConvex == (int)AA_CONVEX_GR_CONTEXT_OPTIONS_GPU_PATH_RENDERERS, ASSERT_MSG(GrContextOptions::GpuPathRenderers, gr_contextoptions_gpupathrenderers_t));
static_assert ((int)GrContextOptions::GpuPathRenderers::kAALinearizing == (int)AA_LINEARIZING_GR_CONTEXT_OPTIONS_GPU_PATH_RENDERERS, ASSERT_MSG(GrContextOptions::GpuPathRenderers, gr_contextoptions_gpupathrenderers_t));
-static_assert ((int)GrContextOptions::GpuPathRenderers::kPLS == (int)PLS_GR_CONTEXT_OPTIONS_GPU_PATH_RENDERERS, ASSERT_MSG(GrContextOptions::GpuPathRenderers, gr_contextoptions_gpupathrenderers_t));
-static_assert ((int)GrContextOptions::GpuPathRenderers::kDistanceField == (int)DISTANCE_FIELD_GR_CONTEXT_OPTIONS_GPU_PATH_RENDERERS, ASSERT_MSG(GrContextOptions::GpuPathRenderers, gr_contextoptions_gpupathrenderers_t));
+static_assert ((int)GrContextOptions::GpuPathRenderers::kSmall == (int)SMALL_GR_CONTEXT_OPTIONS_GPU_PATH_RENDERERS, ASSERT_MSG(GrContextOptions::GpuPathRenderers, gr_contextoptions_gpupathrenderers_t));
static_assert ((int)GrContextOptions::GpuPathRenderers::kTessellating == (int)TESSELLATING_GR_CONTEXT_OPTIONS_GPU_PATH_RENDERERS, ASSERT_MSG(GrContextOptions::GpuPathRenderers, gr_contextoptions_gpupathrenderers_t));
static_assert ((int)GrContextOptions::GpuPathRenderers::kDefault == (int)DEFAULT_GR_CONTEXT_OPTIONS_GPU_PATH_RENDERERS, ASSERT_MSG(GrContextOptions::GpuPathRenderers, gr_contextoptions_gpupathrenderers_t));
static_assert ((int)GrContextOptions::GpuPathRenderers::kAll == (int)ALL_GR_CONTEXT_OPTIONS_GPU_PATH_RENDERERS, ASSERT_MSG(GrContextOptions::GpuPathRenderers, gr_contextoptions_gpupathrenderers_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_colortable_t*>(p);
}
-static inline const SkPixelRefFactory* AsPixelRefFactory(const sk_pixelref_factory_t* p) {
- return reinterpret_cast<const SkPixelRefFactory*>(p);
-}
-
-static inline SkPixelRefFactory* AsPixelRefFactory(sk_pixelref_factory_t* p) {
- return reinterpret_cast<SkPixelRefFactory*>(p);
-}
-
-static inline sk_pixelref_factory_t* ToColorTable(SkPixelRefFactory* p) {
- return reinterpret_cast<sk_pixelref_factory_t*>(p);
-}
-
-static inline const sk_pixelref_factory_t* ToColorTable(const SkPixelRefFactory* p) {
- return reinterpret_cast<const sk_pixelref_factory_t*>(p);
-}
-
static inline sk_surface_t* ToSurface(SkSurface* p) {
return reinterpret_cast<sk_surface_t*>(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);
}
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);
+}
+
+static inline SkVertices* AsVertices(sk_vertices_t* p) {
+ return reinterpret_cast<SkVertices*>(p);
+}
+
+static inline sk_vertices_t* ToVertices(SkVertices* p) {
+ return reinterpret_cast<sk_vertices_t*>(p);
+}
+
+static inline const sk_vertices_t* ToVertices(const SkVertices* p) {
+ return reinterpret_cast<const sk_vertices_t*>(p);
+}
+
static inline void from_c(const sk_matrix_t* cmatrix, SkMatrix* matrix) {
matrix->setAll(
cmatrix->mat[0], cmatrix->mat[1], cmatrix->mat[2],
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) {
projects / platform / upstream / libSkiaSharp.git / commitdiff