include/c/sk_types.h

   1 /*
   2  * Copyright 2014 Google Inc.
   3  * Copyright 2015 Xamarin Inc.
   4  * Copyright 2017 Microsoft Corporation. All rights reserved.
   5  *
   6  * Use of this source code is governed by a BSD-style license that can be
   7  * found in the LICENSE file.
   8  */
   9
  10 #ifndef sk_types_DEFINED
  11 #define sk_types_DEFINED
  12
  13 #include <stdint.h>
  14 #include <stddef.h>
  15
  16 #ifdef __cplusplus
  17     #define SK_C_PLUS_PLUS_BEGIN_GUARD    extern "C" {
  18     #define SK_C_PLUS_PLUS_END_GUARD      }
  19 #else
  20     #include <stdbool.h>
  21     #define SK_C_PLUS_PLUS_BEGIN_GUARD
  22     #define SK_C_PLUS_PLUS_END_GUARD
  23 #endif
  24
  25 #if !defined(SK_C_API)
  26     #if defined(SKIA_C_DLL)
  27         #if defined(_MSC_VER)
  28             #if SKIA_IMPLEMENTATION
  29                 #define SK_C_API __declspec(dllexport)
  30             #else
  31                 #define SK_C_API __declspec(dllimport)
  32             #endif
  33         #else
  34             #define SK_C_API __attribute__((visibility("default")))
  35         #endif
  36     #else
  37         #define SK_C_API
  38     #endif
  39 #endif
  40
  41 ///////////////////////////////////////////////////////////////////////////////////////
  42
  43 SK_C_PLUS_PLUS_BEGIN_GUARD
  44
  45 typedef uint32_t sk_color_t;
  46 typedef uint32_t sk_pmcolor_t;
  47
  48 /* This macro assumes all arguments are >=0 and <=255. */
  49 #define sk_color_set_argb(a, r, g, b)   (((a) << 24) | ((r) << 16) | ((g) << 8) | (b))
  50 #define sk_color_get_a(c)               (((c) >> 24) & 0xFF)
  51 #define sk_color_get_r(c)               (((c) >> 16) & 0xFF)
  52 #define sk_color_get_g(c)               (((c) >>  8) & 0xFF)
  53 #define sk_color_get_b(c)               (((c) >>  0) & 0xFF)
  54
  55 typedef enum {
  56     UNKNOWN_SK_COLORTYPE = 0,
  57     ALPHA_8_SK_COLORTYPE,
  58     RGB_565_SK_COLORTYPE,
  59     ARGB_4444_SK_COLORTYPE,
  60     RGBA_8888_SK_COLORTYPE,
  61     BGRA_8888_SK_COLORTYPE,
  62     Index_8_SK_COLORTYPE,
  63     Gray_8_SK_COLORTYPE,
  64     RGBA_F16_SK_COLORTYPE,
  65 } sk_colortype_t;
  66
  67 typedef enum {
  68     UNKNOWN_SK_ALPHATYPE,
  69     OPAQUE_SK_ALPHATYPE,
  70     PREMUL_SK_ALPHATYPE,
  71     UNPREMUL_SK_ALPHATYPE,
  72 } sk_alphatype_t;
  73
  74 typedef enum {
  75     UNKNOWN_SK_PIXELGEOMETRY,
  76     RGB_H_SK_PIXELGEOMETRY,
  77     BGR_H_SK_PIXELGEOMETRY,
  78     RGB_V_SK_PIXELGEOMETRY,
  79     BGR_V_SK_PIXELGEOMETRY,
  80 } sk_pixelgeometry_t;
  81
  82 typedef enum {
  83     USE_DEVICE_INDEPENDENT_FONTS_SK_SURFACE_PROPS_FLAGS = 1 << 0,
  84 } sk_surfaceprops_flags_t;
  85
  86 typedef struct {
  87     sk_pixelgeometry_t pixelGeometry;
  88     sk_surfaceprops_flags_t flags;
  89 } sk_surfaceprops_t;
  90
  91 typedef struct {
  92     float   x;
  93     float   y;
  94 } sk_point_t;
  95
  96 typedef sk_point_t sk_vector_t;
  97
  98 typedef struct {
  99     int32_t left;
 100     int32_t top;
 101     int32_t right;
 102     int32_t bottom;
 103 } sk_irect_t;
 104
 105 typedef struct {
 106     float   left;
 107     float   top;
 108     float   right;
 109     float   bottom;
 110 } sk_rect_t;
 111
 112 /**
 113     The sk_matrix_t struct holds a 3x3 perspective matrix for
 114     transforming coordinates:
 115
 116         (X,Y) = T[M]((x,y))
 117         X = (M[0] * x + M[1] * y + M[2]) / (M[6] * x + M[7] * y + M[8]);
 118         Y = (M[3] * x + M[4] * y + M[5]) / (M[6] * x + M[7] * y + M[8]);
 119
 120     Therefore, the identity matrix is
 121
 122         sk_matrix_t identity = {{1, 0, 0,
 123                                  0, 1, 0,
 124                                  0, 0, 1}};
 125
 126     A matrix that scales by sx and sy is:
 127
 128         sk_matrix_t scale = {{sx, 0,  0,
 129                               0,  sy, 0,
 130                               0,  0,  1}};
 131
 132     A matrix that translates by tx and ty is:
 133
 134         sk_matrix_t translate = {{1, 0, tx,
 135                                   0, 1, ty,
 136                                   0, 0, 1}};
 137
 138     A matrix that rotates around the origin by A radians:
 139
 140         sk_matrix_t rotate = {{cos(A), -sin(A), 0,
 141                                sin(A),  cos(A), 0,
 142                                0,       0,      1}};
 143
 144     Two matrixes can be concatinated by:
 145
 146          void concat_matrices(sk_matrix_t* dst,
 147                              const sk_matrix_t* matrixU,
 148                              const sk_matrix_t* matrixV) {
 149             const float* u = matrixU->mat;
 150             const float* v = matrixV->mat;
 151             sk_matrix_t result = {{
 152                     u[0] * v[0] + u[1] * v[3] + u[2] * v[6],
 153                     u[0] * v[1] + u[1] * v[4] + u[2] * v[7],
 154                     u[0] * v[2] + u[1] * v[5] + u[2] * v[8],
 155                     u[3] * v[0] + u[4] * v[3] + u[5] * v[6],
 156                     u[3] * v[1] + u[4] * v[4] + u[5] * v[7],
 157                     u[3] * v[2] + u[4] * v[5] + u[5] * v[8],
 158                     u[6] * v[0] + u[7] * v[3] + u[8] * v[6],
 159                     u[6] * v[1] + u[7] * v[4] + u[8] * v[7],
 160                     u[6] * v[2] + u[7] * v[5] + u[8] * v[8]
 161             }};
 162             *dst = result;
 163         }
 164 */
 165 typedef struct {
 166     float   mat[9];
 167 } sk_matrix_t;
 168
 169 typedef struct sk_matrix44_t sk_matrix44_t;
 170
 171 typedef enum {
 172     IDENTITY_SK_MATRIX44_TYPE_MASK = 0,
 173     TRANSLATE_SK_MATRIX44_TYPE_MASK = 0x01,
 174     SCALE_SK_MATRIX44_TYPE_MASK = 0x02,
 175     AFFINE_SK_MATRIX44_TYPE_MASK = 0x04,
 176     PERSPECTIVE_SK_MATRIX44_TYPE_MASK = 0x08
 177 } sk_matrix44_type_mask_t;
 178
 179 /**
 180     A sk_canvas_t encapsulates all of the state about drawing into a
 181     destination This includes a reference to the destination itself,
 182     and a stack of matrix/clip values.
 183 */
 184 typedef struct sk_canvas_t sk_canvas_t;
 185 typedef struct sk_nodraw_canvas_t sk_nodraw_canvas_t;
 186 typedef struct sk_nway_canvas_t sk_nway_canvas_t;
 187 /**
 188     A sk_data_ holds an immutable data buffer.
 189 */
 190 typedef struct sk_data_t sk_data_t;
 191 /**
 192     A sk_image_t is an abstraction for drawing a rectagle of pixels.
 193     The content of the image is always immutable, though the actual
 194     storage may change, if for example that image can be re-created via
 195     encoded data or other means.
 196 */
 197 typedef struct sk_image_t sk_image_t;
 198 /**
 199     A sk_maskfilter_t is an object that perform transformations on an
 200     alpha-channel mask before drawing it; it may be installed into a
 201     sk_paint_t.  Each time a primitive is drawn, it is first
 202     scan-converted into a alpha mask, which os handed to the
 203     maskfilter, which may create a new mask is to render into the
 204     destination.
 205  */
 206 typedef struct sk_maskfilter_t sk_maskfilter_t;
 207 /**
 208     A sk_paint_t holds the style and color information about how to
 209     draw geometries, text and bitmaps.
 210 */
 211 typedef struct sk_paint_t sk_paint_t;
 212 /**
 213     A sk_path_t encapsulates compound (multiple contour) geometric
 214     paths consisting of straight line segments, quadratic curves, and
 215     cubic curves.
 216 */
 217 typedef struct sk_path_t sk_path_t;
 218 /**
 219     A sk_picture_t holds recorded canvas drawing commands to be played
 220     back at a later time.
 221 */
 222 typedef struct sk_picture_t sk_picture_t;
 223 /**
 224     A sk_picture_recorder_t holds a sk_canvas_t that records commands
 225     to create a sk_picture_t.
 226 */
 227 typedef struct sk_picture_recorder_t sk_picture_recorder_t;
 228 /**
 229     A sk_shader_t specifies the source color(s) for what is being drawn. If a
 230     paint has no shader, then the paint's color is used. If the paint
 231     has a shader, then the shader's color(s) are use instead, but they
 232     are modulated by the paint's alpha.
 233 */
 234 typedef struct sk_shader_t sk_shader_t;
 235 /**
 236     A sk_surface_t holds the destination for drawing to a canvas. For
 237     raster drawing, the destination is an array of pixels in memory.
 238     For GPU drawing, the destination is a texture or a framebuffer.
 239 */
 240 typedef struct sk_surface_t sk_surface_t;
 241 /**
 242     The sk_region encapsulates the geometric region used to specify
 243     clipping areas for drawing.
 244 */
 245 typedef struct sk_region_t sk_region_t;
 246
 247 typedef enum {
 248     CLEAR_SK_BLENDMODE,
 249     SRC_SK_BLENDMODE,
 250     DST_SK_BLENDMODE,
 251     SRCOVER_SK_BLENDMODE,
 252     DSTOVER_SK_BLENDMODE,
 253     SRCIN_SK_BLENDMODE,
 254     DSTIN_SK_BLENDMODE,
 255     SRCOUT_SK_BLENDMODE,
 256     DSTOUT_SK_BLENDMODE,
 257     SRCATOP_SK_BLENDMODE,
 258     DSTATOP_SK_BLENDMODE,
 259     XOR_SK_BLENDMODE,
 260     PLUS_SK_BLENDMODE,
 261     MODULATE_SK_BLENDMODE,
 262     SCREEN_SK_BLENDMODE,
 263     OVERLAY_SK_BLENDMODE,
 264     DARKEN_SK_BLENDMODE,
 265     LIGHTEN_SK_BLENDMODE,
 266     COLORDODGE_SK_BLENDMODE,
 267     COLORBURN_SK_BLENDMODE,
 268     HARDLIGHT_SK_BLENDMODE,
 269     SOFTLIGHT_SK_BLENDMODE,
 270     DIFFERENCE_SK_BLENDMODE,
 271     EXCLUSION_SK_BLENDMODE,
 272     MULTIPLY_SK_BLENDMODE,
 273     HUE_SK_BLENDMODE,
 274     SATURATION_SK_BLENDMODE,
 275     COLOR_SK_BLENDMODE,
 276     LUMINOSITY_SK_BLENDMODE,
 277 } sk_blendmode_t;
 278
 279 //////////////////////////////////////////////////////////////////////////////////////////
 280
 281 typedef struct {
 282     float   x;
 283     float   y;
 284     float   z;
 285 } sk_point3_t;
 286
 287 typedef struct {
 288     float   x;
 289     float   y;
 290 } sk_ipoint_t;
 291
 292 typedef struct {
 293     float   w;
 294     float   h;
 295 } sk_size_t;
 296
 297 typedef struct {
 298     float   w;
 299     float   h;
 300 } sk_isize_t;
 301
 302 typedef struct {
 303     uint32_t fFlags;            // Bit field to identify which values are unknown
 304     float    fTop;              // The greatest distance above the baseline for any glyph (will be <= 0)
 305     float    fAscent;           // The recommended distance above the baseline (will be <= 0)
 306     float    fDescent;          // The recommended distance below the baseline (will be >= 0)
 307     float    fBottom;           // The greatest distance below the baseline for any glyph (will be >= 0)
 308     float    fLeading;          // The recommended distance to add between lines of text (will be >= 0)
 309     float    fAvgCharWidth;     // the average character width (>= 0)
 310     float    fMaxCharWidth;     // the max character width (>= 0)
 311     float    fXMin;             // The minimum bounding box x value for all glyphs
 312     float    fXMax;             // The maximum bounding box x value for all glyphs
 313     float    fXHeight;          // The height of an 'x' in px, or 0 if no 'x' in face
 314     float    fCapHeight;        // The cap height (> 0), or 0 if cannot be determined.
 315     float    fUnderlineThickness; // underline thickness, or 0 if cannot be determined
 316     float    fUnderlinePosition; // underline position, or 0 if cannot be determined
 317 } sk_fontmetrics_t;
 318
 319 // Flags for fFlags member of sk_fontmetrics_t
 320 #define FONTMETRICS_FLAGS_UNDERLINE_THICKNESS_IS_VALID (1U << 0)
 321 #define FONTMETRICS_FLAGS_UNDERLINE_POSITION_IS_VALID (1U << 1)
 322
 323 /**
 324     A lightweight managed string.
 325 */
 326 typedef struct sk_string_t sk_string_t;
 327 /**
 328
 329     A sk_bitmap_t is an abstraction that specifies a raster bitmap.
 330 */
 331 typedef struct sk_bitmap_t sk_bitmap_t;
 332 typedef struct sk_pixmap_t sk_pixmap_t;
 333 typedef struct sk_pixelserializer_t sk_pixelserializer_t;
 334 typedef struct sk_colorfilter_t sk_colorfilter_t;
 335 typedef struct sk_imagefilter_t sk_imagefilter_t;
 336 typedef struct sk_imagefilter_croprect_t sk_imagefilter_croprect_t;
 337
 338 /**
 339    A sk_typeface_t pecifies the typeface and intrinsic style of a font.
 340     This is used in the paint, along with optionally algorithmic settings like
 341     textSize, textSkewX, textScaleX, kFakeBoldText_Mask, to specify
 342     how text appears when drawn (and measured).
 343
 344     Typeface objects are immutable, and so they can be shared between threads.
 345 */
 346 typedef struct sk_typeface_t sk_typeface_t;
 347 typedef uint32_t sk_font_table_tag_t;
 348 typedef struct sk_fontmgr_t sk_fontmgr_t;
 349 /**
 350  *  Abstraction layer directly on top of an image codec.
 351  */
 352 typedef struct sk_codec_t sk_codec_t;
 353 typedef struct sk_colorspace_t sk_colorspace_t;
 354 /**
 355    Various stream types
 356 */
 357 typedef struct sk_stream_t sk_stream_t;
 358 typedef struct sk_stream_filestream_t sk_stream_filestream_t;
 359 typedef struct sk_stream_asset_t sk_stream_asset_t;
 360 typedef struct sk_stream_memorystream_t sk_stream_memorystream_t;
 361 typedef struct sk_stream_streamrewindable_t sk_stream_streamrewindable_t;
 362 typedef struct sk_wstream_t sk_wstream_t;
 363 typedef struct sk_wstream_filestream_t sk_wstream_filestream_t;
 364 typedef struct sk_wstream_dynamicmemorystream_t sk_wstream_dynamicmemorystream_t;
 365 /**
 366    High-level API for creating a document-based canvas.
 367 */
 368 typedef struct sk_document_t sk_document_t;
 369
 370 typedef enum {
 371     UTF8_ENCODING,
 372     UTF16_ENCODING,
 373     UTF32_ENCODING
 374 } sk_encoding_t;
 375
 376 typedef enum {
 377     POINTS_SK_POINT_MODE,
 378     LINES_SK_POINT_MODE,
 379     POLYGON_SK_POINT_MODE
 380 } sk_point_mode_t;
 381
 382 typedef enum {
 383     LEFT_SK_TEXT_ALIGN,
 384     CENTER_SK_TEXT_ALIGN,
 385     RIGHT_SK_TEXT_ALIGN
 386 } sk_text_align_t;
 387
 388 typedef enum {
 389     UTF8_SK_TEXT_ENCODING,
 390     UTF16_SK_TEXT_ENCODING,
 391     UTF32_SK_TEXT_ENCODING,
 392     GLYPH_ID_SK_TEXT_ENCODING
 393 } sk_text_encoding_t;
 394
 395 typedef enum {
 396     WINDING_SK_PATH_FILLTYPE,
 397     EVENODD_SK_PATH_FILLTYPE,
 398     INVERSE_WINDING_SK_PATH_FILLTYPE,
 399     INVERSE_EVENODD_SK_PATH_FILLTYPE,
 400 } sk_path_filltype_t;
 401
 402 typedef enum {
 403     NORMAL_TYPEFACE_STYLE      = 0,
 404     BOLD_TYPEFACE_STYLE        = 0x01,
 405     ITALIC_TYPEFACE_STYLE      = 0x02,
 406     BOLD_ITALIC_TYPEFACE_STYLE = 0x03
 407 } sk_typeface_style_t;
 408
 409 typedef enum {
 410     UPRIGHT_SK_FONT_STYLE_SLANT = 0,
 411     ITALIC_SK_FONT_STYLE_SLANT  = 1,
 412     OBLIQUE_SK_FONT_STYLE_SLANT = 2,
 413 } sk_font_style_slant_t;
 414
 415 typedef enum {
 416     NONE_SK_FILTER_QUALITY,
 417     LOW_SK_FILTER_QUALITY,
 418     MEDIUM_SK_FILTER_QUALITY,
 419     HIGH_SK_FILTER_QUALITY
 420 } sk_filter_quality_t;
 421
 422 typedef enum {
 423     HAS_LEFT_SK_CROP_RECT_FLAG   = 0x01,
 424     HAS_TOP_SK_CROP_RECT_FLAG    = 0x02,
 425     HAS_WIDTH_SK_CROP_RECT_FLAG  = 0x04,
 426     HAS_HEIGHT_SK_CROP_RECT_FLAG = 0x08,
 427     HAS_ALL_SK_CROP_RECT_FLAG    = 0x0F,
 428 } sk_crop_rect_flags_t;
 429
 430 typedef enum {
 431     DRAW_SHADOW_AND_FOREGROUND_SK_DROP_SHADOW_IMAGE_FILTER_SHADOW_MODE,
 432     DRAW_SHADOW_ONLY_SK_DROP_SHADOW_IMAGE_FILTER_SHADOW_MODE,
 433 } sk_drop_shadow_image_filter_shadow_mode_t;
 434
 435 typedef enum {
 436     UNKNOWN_SK_DISPLACEMENT_MAP_EFFECT_CHANNEL_SELECTOR_TYPE,
 437     R_SK_DISPLACEMENT_MAP_EFFECT_CHANNEL_SELECTOR_TYPE,
 438     G_SK_DISPLACEMENT_MAP_EFFECT_CHANNEL_SELECTOR_TYPE,
 439     B_SK_DISPLACEMENT_MAP_EFFECT_CHANNEL_SELECTOR_TYPE,
 440     A_SK_DISPLACEMENT_MAP_EFFECT_CHANNEL_SELECTOR_TYPE,
 441 } sk_displacement_map_effect_channel_selector_type_t;
 442
 443 typedef enum {
 444     CLAMP_SK_MATRIX_CONVOLUTION_TILEMODE,
 445     REPEAT_SK_MATRIX_CONVOLUTION_TILEMODE,
 446     CLAMP_TO_BLACK_SK_MATRIX_CONVOLUTION_TILEMODE,
 447 } sk_matrix_convolution_tilemode_t;
 448
 449 /**
 450     The logical operations that can be performed when combining two regions.
 451 */
 452 typedef enum {
 453     DIFFERENCE_SK_REGION_OP,          //!< subtract the op region from the first region
 454     INTERSECT_SK_REGION_OP,           //!< intersect the two regions
 455     UNION_SK_REGION_OP,               //!< union (inclusive-or) the two regions
 456     XOR_SK_REGION_OP,                 //!< exclusive-or the two regions
 457     REVERSE_DIFFERENCE_SK_REGION_OP,  //!< subtract the first region from the op region
 458     REPLACE_SK_REGION_OP,             //!< replace the dst region with the op region
 459 } sk_region_op_t;
 460
 461 typedef enum {
 462     DIFFERENCE_SK_CLIPOP,
 463     INTERSECT_SK_CLIPOP,
 464 } sk_clipop_t;
 465
 466 /**
 467  *  Enum describing format of encoded data.
 468  */
 469 typedef enum {
 470     BMP_SK_ENCODED_FORMAT,
 471     GIF_SK_ENCODED_FORMAT,
 472     ICO_SK_ENCODED_FORMAT,
 473     JPEG_SK_ENCODED_FORMAT,
 474     PNG_SK_ENCODED_FORMAT,
 475     WBMP_SK_ENCODED_FORMAT,
 476     WEBP_SK_ENCODED_FORMAT,
 477     PKM_SK_ENCODED_FORMAT,
 478     KTX_SK_ENCODED_FORMAT,
 479     ASTC_SK_ENCODED_FORMAT,
 480     DNG_SK_ENCODED_FORMAT
 481 } sk_encoded_image_format_t;
 482
 483 typedef enum {
 484     TOP_LEFT_SK_CODEC_ORIGIN     = 1, // Default
 485     TOP_RIGHT_SK_CODEC_ORIGIN    = 2, // Reflected across y-axis
 486     BOTTOM_RIGHT_SK_CODEC_ORIGIN = 3, // Rotated 180
 487     BOTTOM_LEFT_SK_CODEC_ORIGIN  = 4, // Reflected across x-axis
 488     LEFT_TOP_SK_CODEC_ORIGIN     = 5, // Reflected across x-axis, Rotated 90 CCW
 489     RIGHT_TOP_SK_CODEC_ORIGIN    = 6, // Rotated 90 CW
 490     RIGHT_BOTTOM_SK_CODEC_ORIGIN = 7, // Reflected across x-axis, Rotated 90 CW
 491     LEFT_BOTTOM_SK_CODEC_ORIGIN  = 8, // Rotated 90 CCW
 492 } sk_codec_origin_t;
 493
 494 typedef enum {
 495     SUCCESS_SK_CODEC_RESULT,
 496     INCOMPLETE_INPUT_SK_CODEC_RESULT,
 497     INVALID_CONVERSION_SK_CODEC_RESULT,
 498     INVALID_SCALE_SK_CODEC_RESULT,
 499     INVALID_PARAMETERS_SK_CODEC_RESULT,
 500     INVALID_INPUT_SK_CODEC_RESULT,
 501     COULD_NOT_REWIND_SK_CODEC_RESULT,
 502     UNIMPLEMENTED_SK_CODEC_RESULT,
 503 } sk_codec_result_t;
 504
 505 typedef enum {
 506     YES_SK_CODEC_ZERO_INITIALIZED,
 507     NO_SK_CODEC_ZERO_INITIALIZED,
 508 } sk_codec_zero_initialized_t;
 509
 510 typedef enum {
 511     RESPECT_SK_TRANSFER_FUNCTION_BEHAVIOR,
 512     IGNORE_SK_TRANSFER_FUNCTION_BEHAVIOR,
 513 } sk_transfer_function_behavior_t;
 514
 515 typedef struct {
 516     sk_codec_zero_initialized_t fZeroInitialized;
 517     sk_irect_t* fSubset;
 518     int fFrameIndex;
 519     bool fHasPriorFrame;
 520     sk_transfer_function_behavior_t fPremulBehavior;
 521 } sk_codec_options_t;
 522
 523 typedef enum {
 524     TOP_DOWN_SK_CODEC_SCANLINE_ORDER,
 525     BOTTOM_UP_SK_CODEC_SCANLINE_ORDER,
 526 } sk_codec_scanline_order_t;
 527
 528 // The verbs that can be foudn on a path
 529 typedef enum {
 530     MOVE_SK_PATH_VERB,
 531     LINE_SK_PATH_VERB,
 532     QUAD_SK_PATH_VERB,
 533     CONIC_SK_PATH_VERB,
 534     CUBIC_SK_PATH_VERB,
 535     CLOSE_SK_PATH_VERB,
 536     DONE_SK_PATH_VERB
 537 } sk_path_verb_t;
 538
 539 typedef struct sk_path_iterator_t sk_path_iterator_t;
 540 typedef struct sk_path_rawiterator_t sk_path_rawiterator_t;
 541
 542 typedef enum {
 543     APPEND_SK_PATH_ADD_MODE,
 544     EXTEND_SK_PATH_ADD_MODE,
 545 } sk_path_add_mode_t;
 546
 547 typedef enum {
 548     LINE_SK_PATH_SEGMENT_MASK  = 1 << 0,
 549     QUAD_SK_PATH_SEGMENT_MASK  = 1 << 1,
 550     CONIC_SK_PATH_SEGMENT_MASK = 1 << 2,
 551     CUBIC_SK_PATH_SEGMENT_MASK = 1 << 3,
 552 } sk_path_segment_mask_t;
 553
 554 typedef enum {
 555     TRANSLATE_SK_PATH_EFFECT_1D_STYLE,
 556     ROTATE_SK_PATH_EFFECT_1D_STYLE,
 557     MORPH_SK_PATH_EFFECT_1D_STYLE,
 558 } sk_path_effect_1d_style_t;
 559
 560 typedef struct sk_path_effect_t sk_path_effect_t;
 561
 562 typedef enum {
 563     BUTT_SK_STROKE_CAP,
 564     ROUND_SK_STROKE_CAP,
 565     SQUARE_SK_STROKE_CAP
 566 } sk_stroke_cap_t;
 567
 568 typedef enum {
 569     MITER_SK_STROKE_JOIN,
 570     ROUND_SK_STROKE_JOIN,
 571     BEVEL_SK_STROKE_JOIN
 572 } sk_stroke_join_t;
 573
 574 typedef enum {
 575     CLAMP_SK_SHADER_TILEMODE,
 576     REPEAT_SK_SHADER_TILEMODE,
 577     MIRROR_SK_SHADER_TILEMODE,
 578 } sk_shader_tilemode_t;
 579
 580 typedef enum {
 581     NORMAL_SK_BLUR_STYLE,   //!< fuzzy inside and outside
 582     SOLID_SK_BLUR_STYLE,    //!< solid inside, fuzzy outside
 583     OUTER_SK_BLUR_STYLE,    //!< nothing inside, fuzzy outside
 584     INNER_SK_BLUR_STYLE,    //!< fuzzy inside, nothing outside
 585 } sk_blurstyle_t;
 586
 587 typedef enum {
 588     NONE_SK_BLUR_MASK_FILTER_BLUR_FLAGS = 0x00,
 589     IGNORE_TRANSFORM_SK_BLUR_MASK_FILTER_BLUR_FLAGS = 0x01,
 590     HIGHT_QUALITY_SK_BLUR_MASK_FILTER_BLUR_FLAGS = 0x02,
 591     ALL_SK_BLUR_MASK_FILTER_BLUR_FLAGS = 0x03,
 592 } sk_blurmaskfilter_blurflags_t;
 593
 594 typedef enum {
 595     CW_SK_PATH_DIRECTION,
 596     CCW_SK_PATH_DIRECTION,
 597 } sk_path_direction_t;
 598
 599 typedef enum {
 600     SMALL_SK_PATH_ARC_SIZE,
 601     LARGE_SK_PATH_ARC_SIZE,
 602 } sk_path_arc_size_t;
 603
 604 typedef enum {
 605     FILL_SK_PAINT_STYLE,
 606     STROKE_SK_PAINT_STYLE,
 607     STROKE_AND_FILL_SK_PAINT_STYLE,
 608 } sk_paint_style_t;
 609
 610 typedef enum {
 611     NO_HINTING_SK_PAINT_HINTING,
 612     SLIGHT_HINTING_SK_PAINT_HINTING,
 613     NORMAL_HINTING_SK_PAINT_HINTING,
 614     FULL_HINTING_SK_PAINT_HINTING,
 615 } sk_paint_hinting_t;
 616
 617 typedef struct sk_colortable_t sk_colortable_t;
 618
 619 typedef struct sk_pixelref_factory_t sk_pixelref_factory_t;
 620
 621 typedef enum {
 622     BOX_SK_BITMAP_SCALER_RESIZE_METHOD,
 623     TRIANGLE_SK_BITMAP_SCALER_RESIZE_METHOD,
 624     LANCZOS3_SK_BITMAP_SCALER_RESIZE_METHOD,
 625     HAMMING_SK_BITMAP_SCALER_RESIZE_METHOD,
 626     MITCHELL_SK_BITMAP_SCALER_RESIZE_METHOD,
 627 } sk_bitmapscaler_resizemethod_t;
 628
 629 typedef enum {
 630     TOP_LEFT_GR_SURFACE_ORIGIN = 1,
 631     BOTTOM_LEFT_GR_SURFACE_ORIGIN,
 632 } gr_surfaceorigin_t;
 633
 634 typedef enum {
 635     UNKNOWN_GR_PIXEL_CONFIG,
 636     ALPHA_8_GR_PIXEL_CONFIG,
 637     GRAY_8_GR_PIXEL_CONFIG,
 638     RGB_565_GR_PIXEL_CONFIG,
 639     RGBA_4444_GR_PIXEL_CONFIG,
 640     RGBA_8888_GR_PIXEL_CONFIG,
 641     BGRA_8888_GR_PIXEL_CONFIG,
 642     SRGBA_8888_GR_PIXEL_CONFIG,
 643     SBGRA_8888_GR_PIXEL_CONFIG,
 644     RGBA_8888_SINT_GR_PIXEL_CONFIG,
 645     RGBA_FLOAT_GR_PIXEL_CONFIG,
 646     RG_FLOAT_GR_PIXEL_CONFIG,
 647     ALPHA_HALF_GR_PIXEL_CONFIG,
 648     RGBA_HALF_GR_PIXEL_CONFIG,
 649 } gr_pixelconfig_t;
 650
 651 typedef enum {
 652     BW_SK_MASK_FORMAT,             //!< 1bit per pixel mask (e.g. monochrome)
 653     A8_SK_MASK_FORMAT,             //!< 8bits per pixel mask (e.g. antialiasing)
 654     THREE_D_SK_MASK_FORMAT,        //!< 3 8bit per pixl planes: alpha, mul, add
 655     ARGB32_SK_MASK_FORMAT,         //!< SkPMColor
 656     LCD16_SK_MASK_FORMAT,          //!< 565 alpha for r/g/b
 657 } sk_mask_format_t;
 658
 659 typedef struct {
 660     uint8_t*          fImage;
 661     sk_irect_t        fBounds;
 662     uint32_t          fRowBytes;
 663     sk_mask_format_t  fFormat;
 664 } sk_mask_t;
 665
 666 typedef enum {
 667     NONE_GR_CONTEXT_FLUSHBITS = 0,
 668     DISCARD_GR_CONTEXT_FLUSHBITS = 0x2,
 669 } gr_context_flushbits_t;
 670
 671 typedef intptr_t gr_backendobject_t;
 672
 673 typedef struct {
 674     int fWidth;
 675     int fHeight;
 676     gr_pixelconfig_t fConfig;
 677     gr_surfaceorigin_t fOrigin;
 678     int fSampleCnt;
 679     int fStencilBits;
 680     gr_backendobject_t fRenderTargetHandle;
 681 } gr_backend_rendertarget_desc_t;
 682
 683 typedef enum {
 684     NONE_GR_BACKEND_TEXTURE_FLAGS = 0,
 685     RENDER_TARGET_GR_BACKEND_TEXTURE_FLAGS = 1,
 686 } gr_backendtexture_flags_t;
 687
 688 typedef struct {
 689     gr_backendtexture_flags_t fFlags;
 690     gr_surfaceorigin_t fOrigin;
 691     int fWidth;
 692     int fHeight;
 693     gr_pixelconfig_t fConfig;
 694     int fSampleCnt;
 695     gr_backendobject_t fTextureHandle;
 696 } gr_backend_texture_desc_t;
 697
 698 typedef struct gr_context_t gr_context_t;
 699
 700 typedef enum {
 701     NONE_GR_CONTEXT_OPTIONS_GPU_PATH_RENDERERS              = 0,
 702     DASHLINE_GR_CONTEXT_OPTIONS_GPU_PATH_RENDERERS          = 1 << 0,
 703     STENCIL_AND_COVER_GR_CONTEXT_OPTIONS_GPU_PATH_RENDERERS = 1 << 1,
 704     MSAA_GR_CONTEXT_OPTIONS_GPU_PATH_RENDERERS              = 1 << 2,
 705     AA_HAIRLINE_GR_CONTEXT_OPTIONS_GPU_PATH_RENDERERS       = 1 << 3,
 706     AA_CONVEX_GR_CONTEXT_OPTIONS_GPU_PATH_RENDERERS         = 1 << 4,
 707     AA_LINEARIZING_GR_CONTEXT_OPTIONS_GPU_PATH_RENDERERS    = 1 << 5,
 708     SMALL_GR_CONTEXT_OPTIONS_GPU_PATH_RENDERERS             = 1 << 6,
 709     TESSELLATING_GR_CONTEXT_OPTIONS_GPU_PATH_RENDERERS      = 1 << 7,
 710     DEFAULT_GR_CONTEXT_OPTIONS_GPU_PATH_RENDERERS           = 1 << 8,
 711
 712     ALL_GR_CONTEXT_OPTIONS_GPU_PATH_RENDERERS               = DEFAULT_GR_CONTEXT_OPTIONS_GPU_PATH_RENDERERS | (DEFAULT_GR_CONTEXT_OPTIONS_GPU_PATH_RENDERERS - 1)
 713 } gr_contextoptions_gpupathrenderers_t;
 714
 715 typedef struct {
 716     bool fSuppressPrints;
 717     int  fMaxTextureSizeOverride;
 718     int  fMaxTileSizeOverride;
 719     bool fSuppressDualSourceBlending;
 720     int  fBufferMapThreshold;
 721     bool fUseDrawInsteadOfPartialRenderTargetWrite;
 722     bool fImmediateMode;
 723     bool fUseShaderSwizzling;
 724     bool fDoManualMipmapping;
 725     bool fEnableInstancedRendering;
 726     bool fAllowPathMaskCaching;
 727     bool fRequireDecodeDisableForSRGB;
 728     bool fDisableGpuYUVConversion;
 729     bool fSuppressPathRendering;
 730     bool fWireframeMode;
 731     gr_contextoptions_gpupathrenderers_t fGpuPathRenderers;
 732     float fGlyphCacheTextureMaximumBytes;
 733     bool fAvoidStencilBuffers;
 734 } gr_context_options_t;
 735
 736 typedef enum {
 737     OPENGL_GR_BACKEND,
 738     VULKAN_GR_BACKEND,
 739 } gr_backend_t;
 740
 741 typedef intptr_t gr_backendcontext_t;
 742
 743 typedef struct gr_glinterface_t gr_glinterface_t;
 744
 745 typedef void (*gr_gl_func_ptr)(void);
 746 typedef gr_gl_func_ptr (*gr_gl_get_proc)(void* ctx, const char* name);
 747
 748 typedef enum {
 749     DIFFERENCE_SK_PATHOP,
 750     INTERSECT_SK_PATHOP,
 751     UNION_SK_PATHOP,
 752     XOR_SK_PATHOP,
 753     REVERSE_DIFFERENCE_SK_PATHOP,
 754 } sk_pathop_t;
 755
 756 typedef struct sk_opbuilder_t sk_opbuilder_t;
 757
 758 typedef enum {
 759     UNKNOWN_SK_PATH_CONVEXITY,
 760     CONVEX_SK_PATH_CONVEXITY,
 761     CONCAVE_SK_PATH_CONVEXITY,
 762 } sk_path_convexity_t;
 763
 764 typedef enum {
 765     DEFAULT_SK_LATTICE_FLAGS,
 766     TRANSPARENT_SK_LATTICE_FLAGS = 1 << 0,
 767 } sk_lattice_flags_t;
 768
 769 typedef struct {
 770     const int* fXDivs;
 771     const int* fYDivs;
 772     const sk_lattice_flags_t* fFlags;
 773     int fXCount;
 774     int fYCount;
 775     const sk_irect_t* fBounds;
 776 } sk_lattice_t;
 777
 778 typedef struct sk_pathmeasure_t sk_pathmeasure_t;
 779
 780 typedef enum {
 781     GET_POSITION_SK_PATHMEASURE_MATRIXFLAGS = 0x01,
 782     GET_TANGENT_SK_PATHMEASURE_MATRIXFLAGS = 0x02,
 783     GET_POS_AND_TAN_SK_PATHMEASURE_MATRIXFLAGS = GET_POSITION_SK_PATHMEASURE_MATRIXFLAGS | GET_TANGENT_SK_PATHMEASURE_MATRIXFLAGS,
 784 } sk_pathmeasure_matrixflags_t;
 785
 786 typedef void (*sk_bitmap_release_proc)(void* addr, void* context);
 787
 788 typedef void (*sk_data_release_proc)(const void* ptr, void* context);
 789
 790 typedef void (*sk_image_raster_release_proc)(const void* addr, void* context);
 791 typedef void (*sk_image_texture_release_proc)(void* context);
 792
 793 typedef enum {
 794     ALLOW_SK_IMAGE_CACHING_HINT,
 795     DISALLOW_SK_IMAGE_CACHING_HINT,
 796 } sk_image_caching_hint_t;
 797
 798 typedef enum {
 799     ZERO_PIXELS_SK_BITMAP_ALLOC_FLAGS = 1 << 0,
 800 } sk_bitmap_allocflags_t;
 801
 802 typedef struct {
 803     int16_t  fTimeZoneMinutes;
 804     uint16_t fYear;
 805     uint8_t  fMonth;
 806     uint8_t  fDayOfWeek;
 807     uint8_t  fDay;
 808     uint8_t  fHour;
 809     uint8_t  fMinute;
 810     uint8_t  fSecond;
 811 } sk_time_datetime_t;
 812
 813 typedef struct {
 814     sk_string_t*        fTitle;
 815     sk_string_t*        fAuthor;
 816     sk_string_t*        fSubject;
 817     sk_string_t*        fKeywords;
 818     sk_string_t*        fCreator;
 819     sk_string_t*        fProducer;
 820     sk_time_datetime_t* fCreation;
 821     sk_time_datetime_t* fModified;
 822 } sk_document_pdf_metadata_t;
 823
 824 typedef enum {
 825     OPAQUE_SK_ENCODEDINFO_ALPHA,
 826     UNPREMUL_SK_ENCODEDINFO_ALPHA,
 827     BINARY_SK_ENCODEDINFO_ALPHA,
 828 } sk_encodedinfo_alpha_t;
 829
 830 typedef enum {
 831     GRAY_SK_ENCODEDINFO_COLOR,
 832     GRAY_ALPHA_SK_ENCODEDINFO_COLOR,
 833     PALETTE_SK_ENCODEDINFO_COLOR,
 834     RGB_SK_ENCODEDINFO_COLOR,
 835     RGBA_SK_ENCODEDINFO_COLOR,
 836     BGR_SK_ENCODEDINFO_COLOR,
 837     BGRX_SK_ENCODEDINFO_COLOR,
 838     BGRA_SK_ENCODEDINFO_COLOR,
 839     YUV_SK_ENCODEDINFO_COLOR,
 840     YUVA_SK_ENCODEDINFO_COLOR,
 841     INVERTED_CMYK_SK_ENCODEDINFO_COLOR,
 842     YCCK_SK_ENCODEDINFO_COLOR,
 843 } sk_encodedinfo_color_t;
 844
 845 typedef enum {
 846     SRGB_SK_COLORSPACE_NAMED,
 847     ADOBE_RGB_SK_COLORSPACE_NAMED,
 848     SRGB_LINEAR_SK_COLORSPACE_NAMED,
 849 } sk_colorspace_named_t;
 850
 851 typedef struct {
 852     sk_colorspace_t* colorspace;
 853     int32_t          width;
 854     int32_t          height;
 855     sk_colortype_t   colorType;
 856     sk_alphatype_t   alphaType;
 857 } sk_imageinfo_t;
 858
 859 typedef struct {
 860     sk_encodedinfo_color_t fColor;
 861     sk_encodedinfo_alpha_t fAlpha;
 862     uint8_t fBitsPerComponent;
 863 } sk_encodedinfo_t;
 864
 865 typedef struct {
 866     int fRequiredFrame;
 867     int fDuration;
 868     bool fFullyReceived;
 869     sk_alphatype_t fAlphaType;
 870 } sk_codec_frameinfo_t;
 871
 872 typedef struct sk_xmlstreamwriter_t sk_xmlstreamwriter_t;
 873 typedef struct sk_xmlwriter_t sk_xmlwriter_t;
 874
 875 typedef struct sk_svgcanvas_t sk_svgcanvas_t;
 876
 877 typedef struct sk_3dview_t sk_3dview_t;
 878
 879 typedef enum {
 880     TRIANGLES_SK_VERTICES_VERTEX_MODE,
 881     TRIANGLE_STRIP_SK_VERTICES_VERTEX_MODE,
 882     TRIANGLE_FAN_SK_VERTICES_VERTEX_MODE,
 883 } sk_vertices_vertex_mode_t;
 884
 885 typedef struct sk_vertices_t sk_vertices_t;
 886
 887 typedef enum {
 888     LINEAR_SK_COLORSPACE_RENDER_TARGET_GAMMA,
 889     SRGB_SK_COLORSPACE_RENDER_TARGET_GAMMA,
 890 } sk_colorspace_render_target_gamma_t;
 891
 892 typedef enum {
 893     SRGB_SK_COLORSPACE_GAMUT,
 894     ADOBE_RGB_SK_COLORSPACE_GAMUT,
 895     DCIP3_D65_SK_COLORSPACE_GAMUT,
 896     REC2020_SK_COLORSPACE_GAMUT,
 897 } sk_colorspace_gamut_t;
 898
 899 typedef struct {
 900     float fG;
 901     float fA;
 902     float fB;
 903     float fC;
 904     float fD;
 905     float fE;
 906     float fF;
 907 } sk_colorspace_transfer_fn_t;
 908
 909 typedef struct {
 910     float fRX, fRY;
 911     float fGX, fGY;
 912     float fBX, fBY;
 913     float fWX, fWY;
 914 } sk_colorspaceprimaries_t;
 915
 916 typedef enum {
 917     NO_INVERT_SK_HIGH_CONTRAST_CONFIG_INVERT_STYLE,
 918     INVERT_BRIGHTNESS_SK_HIGH_CONTRAST_CONFIG_INVERT_STYLE,
 919     INVERT_LIGHTNESS_SK_HIGH_CONTRAST_CONFIG_INVERT_STYLE,
 920 } sk_highcontrastconfig_invertstyle_t;
 921
 922 typedef struct {
 923     bool fGrayscale;
 924     sk_highcontrastconfig_invertstyle_t fInvertStyle;
 925     float fContrast;
 926 } sk_highcontrastconfig_t;
 927
 928 typedef enum {
 929     ZERO_SK_PNGENCODER_FILTER_FLAGS  = 0x00,
 930     NONE_SK_PNGENCODER_FILTER_FLAGS  = 0x08,
 931     SUB_SK_PNGENCODER_FILTER_FLAGS   = 0x10,
 932     UP_SK_PNGENCODER_FILTER_FLAGS    = 0x20,
 933     AVG_SK_PNGENCODER_FILTER_FLAGS   = 0x40,
 934     PAETH_SK_PNGENCODER_FILTER_FLAGS = 0x80,
 935     ALL_SK_PNGENCODER_FILTER_FLAGS   = NONE_SK_PNGENCODER_FILTER_FLAGS |
 936                                        SUB_SK_PNGENCODER_FILTER_FLAGS |
 937                                        UP_SK_PNGENCODER_FILTER_FLAGS |
 938                                        AVG_SK_PNGENCODER_FILTER_FLAGS |
 939                                        PAETH_SK_PNGENCODER_FILTER_FLAGS,
 940 } sk_pngencoder_filterflags_t;
 941
 942 typedef struct {
 943     sk_pngencoder_filterflags_t fFilterFlags;
 944     int fZLibLevel;
 945     sk_transfer_function_behavior_t fUnpremulBehavior;
 946 } sk_pngencoder_options_t;
 947
 948 typedef enum {
 949     DOWNSAMPLE_420_SK_JPEGENCODER_DOWNSAMPLE,
 950     DOWNSAMPLE_422_SK_JPEGENCODER_DOWNSAMPLE,
 951     DOWNSAMPLE_444_SK_JPEGENCODER_DOWNSAMPLE,
 952 } sk_jpegencoder_downsample_t;
 953
 954 typedef enum {
 955     IGNORE_SK_JPEGENCODER_ALPHA_OPTION,
 956     BLEND_ON_BLACK_SK_JPEGENCODER_ALPHA_OPTION,
 957 } sk_jpegencoder_alphaoption_t;
 958
 959 typedef struct {
 960     int fQuality;
 961     sk_jpegencoder_downsample_t fDownsample;
 962     sk_jpegencoder_alphaoption_t fAlphaOption;
 963     sk_transfer_function_behavior_t fBlendBehavior;
 964 } sk_jpegencoder_options_t;
 965
 966 typedef enum {
 967     LOSSY_SK_WEBPENCODER_COMPTRESSION,
 968     LOSSLESS_SK_WEBPENCODER_COMPTRESSION,
 969 } sk_webpencoder_compression_t;
 970
 971 typedef struct {
 972     sk_webpencoder_compression_t fCompression;
 973     float fQuality;
 974     sk_transfer_function_behavior_t fUnpremulBehavior;
 975 } sk_webpencoder_options_t;
 976
 977 SK_C_PLUS_PLUS_END_GUARD
 978
 979 #endif