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