include/c/sk_types.h

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