src/c/sk_types_priv.h

   1 /*
   2  * Copyright 2015 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 #ifndef sk_types_priv_DEFINED
   9 #define sk_types_priv_DEFINED
  10
  11 #include "SkImageInfo.h"
  12 #include "SkBlurTypes.h"
  13 #include "SkDocument.h"
  14 #include "SkPaint.h"
  15 #include "SkPath.h"
  16 #include "SkPathMeasure.h"
  17 #include "SkCodec.h"
  18 #include "SkColorSpace.h"
  19 #include "SkPicture.h"
  20 #include "SkPixmap.h"
  21 #include "SkPictureRecorder.h"
  22 #include "SkPoint3.h"
  23 #include "SkStream.h"
  24 #include "SkString.h"
  25 #include "SkDisplacementMapEffect.h"
  26 #include "SkDropShadowImageFilter.h"
  27 #include "SkMatrixConvolutionImageFilter.h"
  28 #include "SkMask.h"
  29 #include "Sk1DPathEffect.h"
  30 #include "SkFontStyle.h"
  31 #include "SkXMLWriter.h"
  32 #include "SkPathOps.h"
  33 #include "SkRegion.h"
  34 #include "SkTypeface.h"
  35 #include "SkFontMgr.h"
  36 #include "SkEncodedInfo.h"
  37 #include "SkTime.h"
  38 #include "SkCamera.h"
  39 #include "SkHighContrastFilter.h"
  40
  41 #include "sk_path.h"
  42 #include "sk_paint.h"
  43 #include "sk_shader.h"
  44 #include "sk_maskfilter.h"
  45
  46 #include "sk_types.h"
  47
  48 class SkMaskFilter;
  49 class SkPaint;
  50 class SkShader;
  51 class GrContext;
  52 struct GrContextOptions;
  53 struct GrGLInterface;
  54
  55 static inline const SkPaint& AsPaint(const sk_paint_t& cpaint) {
  56     return reinterpret_cast<const SkPaint&>(cpaint);
  57 }
  58
  59 static inline const SkPaint* AsPaint(const sk_paint_t* cpaint) {
  60     return reinterpret_cast<const SkPaint*>(cpaint);
  61 }
  62
  63 static inline SkPaint* AsPaint(sk_paint_t* cpaint) {
  64     return reinterpret_cast<SkPaint*>(cpaint);
  65 }
  66
  67 static inline SkMaskFilter* AsMaskFilter(sk_maskfilter_t* cfilter) {
  68     return reinterpret_cast<SkMaskFilter*>(cfilter);
  69 }
  70
  71 static inline sk_maskfilter_t* ToMaskFilter(SkMaskFilter* filter) {
  72     return reinterpret_cast<sk_maskfilter_t*>(filter);
  73 }
  74
  75 static inline SkShader* AsShader(sk_shader_t* cshader) {
  76     return reinterpret_cast<SkShader*>(cshader);
  77 }
  78
  79 static inline SkRect* AsRect(sk_rect_t* crect) {
  80     return reinterpret_cast<SkRect*>(crect);
  81 }
  82
  83 static inline const SkRect* AsRect(const sk_rect_t* crect) {
  84     return reinterpret_cast<const SkRect*>(crect);
  85 }
  86
  87 static inline const SkRect& AsRect(const sk_rect_t& crect) {
  88     return reinterpret_cast<const SkRect&>(crect);
  89 }
  90
  91 static inline sk_rect_t ToRect(const SkRect& rect) {
  92     return reinterpret_cast<const sk_rect_t&>(rect);
  93 }
  94
  95 static inline sk_irect_t ToIRect(const SkIRect& rect) {
  96     return reinterpret_cast<const sk_irect_t&>(rect);
  97 }
  98
  99 static inline SkIRect* AsIRect(sk_irect_t* crect) {
 100     return reinterpret_cast<SkIRect*>(crect);
 101 }
 102
 103 static inline const SkIRect* AsIRect(const sk_irect_t* crect) {
 104     return reinterpret_cast<const SkIRect*>(crect);
 105 }
 106
 107 static inline const SkIRect& AsIRect(const sk_irect_t& crect) {
 108     return reinterpret_cast<const SkIRect&>(crect);
 109 }
 110
 111 static inline SkRegion* AsRegion(sk_region_t* creg) {
 112     return reinterpret_cast<SkRegion*>(creg);
 113 }
 114
 115 static inline SkRegion& AsRegion(sk_region_t& creg) {
 116     return reinterpret_cast<SkRegion&>(creg);
 117 }
 118
 119 static inline const SkRegion* AsRegion(const sk_region_t* creg) {
 120     return reinterpret_cast<const SkRegion*>(creg);
 121 }
 122
 123 static inline const SkRegion& AsRegion(const sk_region_t& creg) {
 124     return reinterpret_cast<const SkRegion&>(creg);
 125 }
 126
 127 static inline sk_region_t* ToRegion(SkRegion* reg) {
 128     return reinterpret_cast<sk_region_t*>(reg);
 129 }
 130
 131 static inline const SkBitmap* AsBitmap(const sk_bitmap_t* cbitmap) {
 132     return reinterpret_cast<const SkBitmap*>(cbitmap);
 133 }
 134
 135 static inline const SkBitmap& AsBitmap(const sk_bitmap_t& cbitmap) {
 136     return reinterpret_cast<const SkBitmap&>(cbitmap);
 137 }
 138
 139 static inline SkBitmap* AsBitmap(sk_bitmap_t* cbitmap) {
 140     return reinterpret_cast<SkBitmap*>(cbitmap);
 141 }
 142
 143 static inline const SkPixmap* AsPixmap(const sk_pixmap_t* cpixmap) {
 144     return reinterpret_cast<const SkPixmap*>(cpixmap);
 145 }
 146
 147 static inline const SkPixmap& AsPixmap(const sk_pixmap_t& cpixmap) {
 148     return reinterpret_cast<const SkPixmap&>(cpixmap);
 149 }
 150
 151 static inline SkPixmap* AsPixmap(sk_pixmap_t* cpixmap) {
 152     return reinterpret_cast<SkPixmap*>(cpixmap);
 153 }
 154
 155 static inline SkPixmap& AsPixmap(sk_pixmap_t& cpixmap) {
 156     return reinterpret_cast<SkPixmap&>(cpixmap);
 157 }
 158
 159 static inline sk_pixmap_t* ToPixmap(SkPixmap* pixmap) {
 160     return reinterpret_cast<sk_pixmap_t*>(pixmap);
 161 }
 162
 163 static inline SkMask* AsMask(sk_mask_t* cmask) {
 164     return reinterpret_cast<SkMask*>(cmask);
 165 }
 166
 167 static inline const SkMask* AsMask(const sk_mask_t* cmask) {
 168     return reinterpret_cast<const SkMask*>(cmask);
 169 }
 170
 171 static inline sk_mask_t* ToMask(SkMask* mask) {
 172     return reinterpret_cast<sk_mask_t*>(mask);
 173 }
 174
 175 static inline SkData* AsData(const sk_data_t* cdata) {
 176     return reinterpret_cast<SkData*>(const_cast<sk_data_t*>(cdata));
 177 }
 178
 179 static inline sk_data_t* ToData(SkData* data) {
 180     return reinterpret_cast<sk_data_t*>(data);
 181 }
 182
 183 static inline sk_path_t* ToPath(SkPath* cpath) {
 184     return reinterpret_cast<sk_path_t*>(cpath);
 185 }
 186
 187 static inline const SkPath& AsPath(const sk_path_t& cpath) {
 188     return reinterpret_cast<const SkPath&>(cpath);
 189 }
 190
 191 static inline SkPath* AsPath(sk_path_t* cpath) {
 192     return reinterpret_cast<SkPath*>(cpath);
 193 }
 194
 195 static inline const SkPath* AsPath(const sk_path_t* cpath) {
 196     return reinterpret_cast<const SkPath*>(cpath);
 197 }
 198
 199 static inline const SkImage* AsImage(const sk_image_t* cimage) {
 200     return reinterpret_cast<const SkImage*>(cimage);
 201 }
 202
 203 static inline SkImage* AsImage(sk_image_t* cimage) {
 204     return reinterpret_cast<SkImage*>(cimage);
 205 }
 206
 207 static inline sk_image_t* ToImage(SkImage* cimage) {
 208     return reinterpret_cast<sk_image_t*>(cimage);
 209 }
 210
 211 static inline sk_canvas_t* ToCanvas(SkCanvas* canvas) {
 212     return reinterpret_cast<sk_canvas_t*>(canvas);
 213 }
 214
 215 static inline SkCanvas* AsCanvas(sk_canvas_t* ccanvas) {
 216     return reinterpret_cast<SkCanvas*>(ccanvas);
 217 }
 218
 219 static inline SkPictureRecorder* AsPictureRecorder(sk_picture_recorder_t* crec) {
 220     return reinterpret_cast<SkPictureRecorder*>(crec);
 221 }
 222
 223 static inline sk_picture_recorder_t* ToPictureRecorder(SkPictureRecorder* rec) {
 224     return reinterpret_cast<sk_picture_recorder_t*>(rec);
 225 }
 226
 227 static inline const SkPicture* AsPicture(const sk_picture_t* cpic) {
 228     return reinterpret_cast<const SkPicture*>(cpic);
 229 }
 230
 231 static inline SkPicture* AsPicture(sk_picture_t* cpic) {
 232     return reinterpret_cast<SkPicture*>(cpic);
 233 }
 234
 235 static inline sk_picture_t* ToPicture(SkPicture* pic) {
 236     return reinterpret_cast<sk_picture_t*>(pic);
 237 }
 238
 239 static inline SkImageFilter* AsImageFilter(sk_imagefilter_t* cfilter) {
 240     return reinterpret_cast<SkImageFilter*>(cfilter);
 241 }
 242
 243 static inline const SkImageFilter* AsImageFilter(const sk_imagefilter_t* cfilter) {
 244     return reinterpret_cast<const SkImageFilter*>(cfilter);
 245 }
 246
 247 static inline SkImageFilter** AsImageFilters(sk_imagefilter_t** cfilter) {
 248     return reinterpret_cast<SkImageFilter**>(cfilter);
 249 }
 250
 251 static inline sk_imagefilter_t* ToImageFilter(SkImageFilter* filter) {
 252     return reinterpret_cast<sk_imagefilter_t*>(filter);
 253 }
 254
 255 static inline SkColorFilter* AsColorFilter(sk_colorfilter_t* cfilter) {
 256     return reinterpret_cast<SkColorFilter*>(cfilter);
 257 }
 258
 259 static inline sk_colorfilter_t* ToColorFilter(SkColorFilter* filter) {
 260     return reinterpret_cast<sk_colorfilter_t*>(filter);
 261 }
 262
 263 static inline const SkCodec* AsCodec(const sk_codec_t* codec) {
 264     return reinterpret_cast<const SkCodec*>(codec);
 265 }
 266
 267 static inline const SkCodec& AsCodec(const sk_codec_t& codec) {
 268     return reinterpret_cast<const SkCodec&>(codec);
 269 }
 270
 271 static inline SkCodec* AsCodec(sk_codec_t* codec) {
 272     return reinterpret_cast<SkCodec*>(codec);
 273 }
 274
 275 static inline sk_codec_t* ToCodec(SkCodec* codec) {
 276     return reinterpret_cast<sk_codec_t*>(codec);
 277 }
 278
 279 static inline const SkCodec::Options* AsCodecOptions(const sk_codec_options_t* t) {
 280     return reinterpret_cast<const SkCodec::Options*>(t);
 281 }
 282
 283 static inline SkTypeface* AsTypeface(sk_typeface_t* typeface) {
 284     return reinterpret_cast<SkTypeface*>(typeface);
 285 }
 286
 287 static inline sk_typeface_t* ToTypeface(SkTypeface* typeface) {
 288     return reinterpret_cast<sk_typeface_t*>(typeface);
 289 }
 290
 291 static inline SkFontMgr* AsFontMgr(sk_fontmgr_t* fontmgr) {
 292     return reinterpret_cast<SkFontMgr*>(fontmgr);
 293 }
 294
 295 static inline sk_fontmgr_t* ToFontMgr(SkFontMgr* fontmgr) {
 296     return reinterpret_cast<sk_fontmgr_t*>(fontmgr);
 297 }
 298
 299 static inline sk_colorspace_t* ToColorSpace(SkColorSpace* colorspace) {
 300     return reinterpret_cast<sk_colorspace_t*>(colorspace);
 301 }
 302
 303 static inline SkColorSpace* AsColorSpace(sk_colorspace_t* colorspace) {
 304     return reinterpret_cast<SkColorSpace*>(colorspace);
 305 }
 306
 307 static inline const SkColorSpace* AsColorSpace(const sk_colorspace_t* colorspace) {
 308     return reinterpret_cast<const SkColorSpace*>(colorspace);
 309 }
 310
 311 static inline sk_shader_t* ToShader(SkShader* shader) {
 312     return reinterpret_cast<sk_shader_t*>(shader);
 313 }
 314
 315 static inline const SkFILEStream* AsFileStream(const sk_stream_filestream_t* cfilestream) {
 316     return reinterpret_cast<const SkFILEStream*>(cfilestream);
 317 }
 318
 319 static inline SkFILEStream* AsFileStream(sk_stream_filestream_t* cfilestream) {
 320     return reinterpret_cast<SkFILEStream*>(cfilestream);
 321 }
 322
 323 static inline sk_stream_filestream_t* ToFileStream(SkFILEStream* stream) {
 324     return reinterpret_cast<sk_stream_filestream_t*>(stream);
 325 }
 326
 327 static inline const SkMemoryStream* AsMemoryStream(const sk_stream_memorystream_t* cmemorystream) {
 328     return reinterpret_cast<const SkMemoryStream*>(cmemorystream);
 329 }
 330
 331 static inline SkMemoryStream* AsMemoryStream(sk_stream_memorystream_t* cmemorystream) {
 332     return reinterpret_cast<SkMemoryStream*>(cmemorystream);
 333 }
 334
 335 static inline sk_stream_memorystream_t* ToMemoryStream(SkMemoryStream* stream) {
 336     return reinterpret_cast<sk_stream_memorystream_t*>(stream);
 337 }
 338
 339 static inline SkStreamRewindable* AsStreamRewindable(sk_stream_streamrewindable_t* cstreamrewindable) {
 340     return reinterpret_cast<SkStreamRewindable*>(cstreamrewindable);
 341 }
 342
 343 static inline const SkStream* AsStream(const sk_stream_t* cstream) {
 344     return reinterpret_cast<const SkStream*>(cstream);
 345 }
 346
 347 static inline SkStream* AsStream(sk_stream_t* cstream) {
 348     return reinterpret_cast<SkStream*>(cstream);
 349 }
 350
 351 static inline sk_stream_t* ToStream(SkStream* cstream) {
 352     return reinterpret_cast<sk_stream_t*>(cstream);
 353 }
 354
 355 static inline sk_stream_asset_t* ToStreamAsset(SkStreamAsset* cstream) {
 356     return reinterpret_cast<sk_stream_asset_t*>(cstream);
 357 }
 358
 359 static inline SkStreamAsset* AsStreamAsset(sk_stream_asset_t* cstream) {
 360     return reinterpret_cast<SkStreamAsset*>(cstream);
 361 }
 362
 363 static inline SkFILEWStream* AsFileWStream(sk_wstream_filestream_t* cfilestream) {
 364     return reinterpret_cast<SkFILEWStream*>(cfilestream);
 365 }
 366
 367 static inline SkDynamicMemoryWStream* AsDynamicMemoryWStream(sk_wstream_dynamicmemorystream_t* cmemorystream) {
 368     return reinterpret_cast<SkDynamicMemoryWStream*>(cmemorystream);
 369 }
 370
 371 static inline SkWStream* AsWStream(sk_wstream_t* cstream) {
 372     return reinterpret_cast<SkWStream*>(cstream);
 373 }
 374
 375 static inline sk_wstream_filestream_t* ToFileWStream(SkFILEWStream* filestream) {
 376     return reinterpret_cast<sk_wstream_filestream_t*>(filestream);
 377 }
 378
 379 static inline sk_wstream_dynamicmemorystream_t* ToDynamicMemoryWStream(SkDynamicMemoryWStream* memorystream) {
 380     return reinterpret_cast<sk_wstream_dynamicmemorystream_t*>(memorystream);
 381 }
 382
 383 static inline sk_wstream_t* ToWStream(SkWStream* stream) {
 384     return reinterpret_cast<sk_wstream_t*>(stream);
 385 }
 386
 387 static inline const SkPoint& AsPoint(const sk_point_t& p) {
 388     return reinterpret_cast<const SkPoint&>(p);
 389 }
 390
 391 static inline const SkPoint* AsPoint(const sk_point_t* p) {
 392     return reinterpret_cast<const SkPoint*>(p);
 393 }
 394
 395 static inline SkPoint* AsPoint(sk_point_t* p) {
 396     return reinterpret_cast<SkPoint*>(p);
 397 }
 398
 399 static inline sk_point_t* ToPoint(SkPoint *p) {
 400     return reinterpret_cast<sk_point_t*>(p);
 401 }
 402
 403 static inline sk_point_t& ToPoint(SkPoint &p) {
 404     return reinterpret_cast<sk_point_t&>(p);
 405 }
 406
 407 static inline const SkIPoint& AsIPoint(const sk_ipoint_t& p) {
 408     return reinterpret_cast<const SkIPoint&>(p);
 409 }
 410
 411 static inline const SkIPoint* AsIPoint(const sk_ipoint_t* p) {
 412     return reinterpret_cast<const SkIPoint*>(p);
 413 }
 414
 415 static inline SkIPoint* AsIPoint(sk_ipoint_t* p) {
 416     return reinterpret_cast<SkIPoint*>(p);
 417 }
 418
 419 static inline const SkSize& AsSize(const sk_size_t& p) {
 420     return reinterpret_cast<const SkSize&>(p);
 421 }
 422
 423 static inline const SkSize* AsSize(const sk_size_t* p) {
 424     return reinterpret_cast<const SkSize*>(p);
 425 }
 426
 427 static inline const SkISize& AsISize(const sk_isize_t& p) {
 428     return reinterpret_cast<const SkISize&>(p);
 429 }
 430
 431 static inline const SkISize* AsISize(const sk_isize_t* p) {
 432     return reinterpret_cast<const SkISize*>(p);
 433 }
 434
 435 static inline SkISize* AsISize(sk_isize_t* p) {
 436     return reinterpret_cast<SkISize*>(p);
 437 }
 438
 439 static inline const sk_isize_t& ToISize(const SkISize& p) {
 440     return reinterpret_cast<const sk_isize_t&>(p);
 441 }
 442
 443 static inline const sk_isize_t* ToISize(const SkISize* p) {
 444     return reinterpret_cast<const sk_isize_t*>(p);
 445 }
 446
 447 static inline const SkPoint3& AsPoint3(const sk_point3_t& p) {
 448     return reinterpret_cast<const SkPoint3&>(p);
 449 }
 450
 451 static inline const SkPoint3* AsPoint3(const sk_point3_t* p) {
 452     return reinterpret_cast<const SkPoint3*>(p);
 453 }
 454
 455 static inline const SkImageFilter::CropRect& AsImageFilterCropRect(const sk_imagefilter_croprect_t& p) {
 456     return reinterpret_cast<const SkImageFilter::CropRect&>(p);
 457 }
 458
 459 static inline const SkImageFilter::CropRect* AsImageFilterCropRect(const sk_imagefilter_croprect_t* p) {
 460     return reinterpret_cast<const SkImageFilter::CropRect*>(p);
 461 }
 462
 463 static inline SkPaint::FontMetrics* AsFontMetrics(sk_fontmetrics_t* p) {
 464     return reinterpret_cast<SkPaint::FontMetrics*>(p);
 465 }
 466
 467 static inline sk_fontmetrics_t* ToFontMetrics(SkPaint::FontMetrics* p) {
 468     return reinterpret_cast<sk_fontmetrics_t*>(p);
 469 }
 470
 471 static inline const SkString* AsString(const sk_string_t* str) {
 472     return reinterpret_cast<const SkString*>(str);
 473 }
 474
 475 static inline SkString* AsString(sk_string_t* str) {
 476     return reinterpret_cast<SkString*>(str);
 477 }
 478
 479 static inline SkString& AsString(sk_string_t& str) {
 480     return reinterpret_cast<SkString&>(str);
 481 }
 482
 483 static inline sk_string_t* ToString(SkString* data) {
 484     return reinterpret_cast<sk_string_t*>(data);
 485 }
 486
 487 static inline SkDocument* AsDocument(sk_document_t* cdocument) {
 488     return reinterpret_cast<SkDocument*>(cdocument);
 489 }
 490
 491 static inline sk_document_t* ToDocument(SkDocument* document) {
 492     return reinterpret_cast<sk_document_t*>(document);
 493 }
 494
 495 static inline SkPath::Iter* AsPathIter(sk_path_iterator_t* iter) {
 496     return reinterpret_cast<SkPath::Iter*>(iter);
 497 }
 498
 499 static inline sk_path_iterator_t* ToPathIter(SkPath::Iter* iter) {
 500     return reinterpret_cast<sk_path_iterator_t*>(iter);
 501 }
 502
 503 static inline SkPath::RawIter* AsPathRawIter(sk_path_rawiterator_t* iter) {
 504     return reinterpret_cast<SkPath::RawIter*>(iter);
 505 }
 506
 507 static inline sk_path_rawiterator_t* ToPathRawIter(SkPath::RawIter* iter) {
 508     return reinterpret_cast<sk_path_rawiterator_t*>(iter);
 509 }
 510
 511 static inline const SkPathEffect* AsPathEffect(const sk_path_effect_t* p) {
 512     return reinterpret_cast<const SkPathEffect*>(p);
 513 }
 514
 515 static inline SkPathEffect* AsPathEffect(sk_path_effect_t* p) {
 516     return reinterpret_cast<SkPathEffect*>(p);
 517 }
 518
 519 static inline sk_path_effect_t* ToPathEffect(SkPathEffect* p) {
 520     return reinterpret_cast<sk_path_effect_t*>(p);
 521 }
 522
 523 static inline const sk_path_effect_t* ToPathEffect(const SkPathEffect* p) {
 524     return reinterpret_cast<const sk_path_effect_t*>(p);
 525 }
 526
 527 static inline const SkColorTable* AsColorTable(const sk_colortable_t* p) {
 528     return reinterpret_cast<const SkColorTable*>(p);
 529 }
 530
 531 static inline SkColorTable* AsColorTable(sk_colortable_t* p) {
 532     return reinterpret_cast<SkColorTable*>(p);
 533 }
 534
 535 static inline sk_colortable_t* ToColorTable(SkColorTable* p) {
 536     return reinterpret_cast<sk_colortable_t*>(p);
 537 }
 538
 539 static inline const sk_colortable_t* ToColorTable(const SkColorTable* p) {
 540     return reinterpret_cast<const sk_colortable_t*>(p);
 541 }
 542
 543 static inline sk_surface_t* ToSurface(SkSurface* p) {
 544     return reinterpret_cast<sk_surface_t*>(p);
 545 }
 546
 547 static inline SkSurface* AsSurface(sk_surface_t* p) {
 548     return reinterpret_cast<SkSurface*>(p);
 549 }
 550
 551 static inline gr_context_t* ToGrContext(GrContext* p) {
 552     return reinterpret_cast<gr_context_t*>(p);
 553 }
 554
 555 static inline GrContext* AsGrContext(gr_context_t* p) {
 556     return reinterpret_cast<GrContext*>(p);
 557 }
 558 static inline const GrContextOptions& AsGrContextOptions(const gr_context_options_t& p) {
 559     return reinterpret_cast<const GrContextOptions&>(p);
 560 }
 561
 562 static inline const GrBackendRenderTargetDesc& AsGrBackendRenderTargetDesc(const gr_backend_rendertarget_desc_t& p) {
 563     return reinterpret_cast<const GrBackendRenderTargetDesc&>(p);
 564 }
 565
 566 static inline const GrBackendTextureDesc& AsGrBackendTextureDesc(const gr_backend_texture_desc_t& p) {
 567     return reinterpret_cast<const GrBackendTextureDesc&>(p);
 568 }
 569
 570
 571 static inline gr_glinterface_t* ToGrGLInterface(GrGLInterface* p) {
 572     return reinterpret_cast<gr_glinterface_t*>(p);
 573 }
 574
 575 static inline GrGLInterface* AsGrGLInterface(gr_glinterface_t* p) {
 576     return reinterpret_cast<GrGLInterface*>(p);
 577 }
 578
 579 static inline const gr_glinterface_t* ToGrGLInterface(const GrGLInterface* p) {
 580     return reinterpret_cast<const gr_glinterface_t*>(p);
 581 }
 582
 583 static inline const GrGLInterface* AsGrGLInterface(const gr_glinterface_t* p) {
 584     return reinterpret_cast<const GrGLInterface*>(p);
 585 }
 586
 587 static inline sk_opbuilder_t* ToOpBuilder(SkOpBuilder* p) {
 588     return reinterpret_cast<sk_opbuilder_t*>(p);
 589 }
 590
 591 static inline SkOpBuilder* AsOpBuilder(sk_opbuilder_t* p) {
 592     return reinterpret_cast<SkOpBuilder*>(p);
 593 }
 594
 595 static inline const SkCanvas::Lattice& AsLattice(const sk_lattice_t& p) {
 596     return reinterpret_cast<const SkCanvas::Lattice&>(p);
 597 }
 598
 599 static inline const SkTime::DateTime& AsTimeDateTime(const sk_time_datetime_t& p) {
 600     return reinterpret_cast<const SkTime::DateTime&>(p);
 601 }
 602
 603 static inline sk_pathmeasure_t* ToPathMeasure(SkPathMeasure* p) {
 604     return reinterpret_cast<sk_pathmeasure_t*>(p);
 605 }
 606
 607 static inline SkPathMeasure* AsPathMeasure(sk_pathmeasure_t* p) {
 608     return reinterpret_cast<SkPathMeasure*>(p);
 609 }
 610
 611 static inline sk_encodedinfo_t* ToEncodedInfo(SkEncodedInfo *p) {
 612     return reinterpret_cast<sk_encodedinfo_t*>(p);
 613 }
 614
 615 static inline sk_encodedinfo_t& ToEncodedInfo(SkEncodedInfo &p) {
 616     return reinterpret_cast<sk_encodedinfo_t&>(p);
 617 }
 618
 619 static inline const sk_encodedinfo_t* ToEncodedInfo(const SkEncodedInfo *p) {
 620     return reinterpret_cast<const sk_encodedinfo_t*>(p);
 621 }
 622
 623 static inline const sk_encodedinfo_t& ToEncodedInfo(const SkEncodedInfo &p) {
 624     return reinterpret_cast<const sk_encodedinfo_t&>(p);
 625 }
 626
 627 static inline const SkColorSpacePrimaries* AsColorSpacePrimaries(const sk_colorspaceprimaries_t* p) {
 628     return reinterpret_cast<const SkColorSpacePrimaries*>(p);
 629 }
 630
 631 static inline const SkColorSpacePrimaries& AsColorSpacePrimaries(const sk_colorspaceprimaries_t& p) {
 632     return reinterpret_cast<const SkColorSpacePrimaries&>(p);
 633 }
 634
 635 static inline SkColorSpacePrimaries* AsColorSpacePrimaries(sk_colorspaceprimaries_t* p) {
 636     return reinterpret_cast<SkColorSpacePrimaries*>(p);
 637 }
 638
 639 static inline SkColorSpacePrimaries& AsColorSpacePrimaries(sk_colorspaceprimaries_t& p) {
 640     return reinterpret_cast<SkColorSpacePrimaries&>(p);
 641 }
 642
 643 static inline sk_colorspaceprimaries_t* ToColorSpacePrimaries(SkColorSpacePrimaries *p) {
 644     return reinterpret_cast<sk_colorspaceprimaries_t*>(p);
 645 }
 646
 647 static inline sk_colorspaceprimaries_t& ToColorSpacePrimaries(SkColorSpacePrimaries &p) {
 648     return reinterpret_cast<sk_colorspaceprimaries_t&>(p);
 649 }
 650
 651 static inline const sk_colorspaceprimaries_t* ToColorSpacePrimaries(const SkColorSpacePrimaries *p) {
 652     return reinterpret_cast<const sk_colorspaceprimaries_t*>(p);
 653 }
 654
 655 static inline const sk_colorspaceprimaries_t& ToColorSpacePrimaries(const SkColorSpacePrimaries &p) {
 656     return reinterpret_cast<const sk_colorspaceprimaries_t&>(p);
 657 }
 658
 659 static inline const SkColorSpaceTransferFn* AsColorSpaceTransferFn(const sk_colorspace_transfer_fn_t* p) {
 660     return reinterpret_cast<const SkColorSpaceTransferFn*>(p);
 661 }
 662
 663 static inline const SkColorSpaceTransferFn& AsColorSpaceTransferFn(const sk_colorspace_transfer_fn_t& p) {
 664     return reinterpret_cast<const SkColorSpaceTransferFn&>(p);
 665 }
 666
 667 static inline SkColorSpaceTransferFn* AsColorSpaceTransferFn(sk_colorspace_transfer_fn_t* p) {
 668     return reinterpret_cast<SkColorSpaceTransferFn*>(p);
 669 }
 670
 671 static inline SkColorSpaceTransferFn& AsColorSpaceTransferFn(sk_colorspace_transfer_fn_t& p) {
 672     return reinterpret_cast<SkColorSpaceTransferFn&>(p);
 673 }
 674
 675 static inline sk_colorspace_transfer_fn_t* ToColorSpaceTransferFn(SkColorSpaceTransferFn *p) {
 676     return reinterpret_cast<sk_colorspace_transfer_fn_t*>(p);
 677 }
 678
 679 static inline sk_colorspace_transfer_fn_t& ToColorSpaceTransferFn(SkColorSpaceTransferFn &p) {
 680     return reinterpret_cast<sk_colorspace_transfer_fn_t&>(p);
 681 }
 682
 683 static inline const sk_colorspace_transfer_fn_t* ToColorSpaceTransferFn(const SkColorSpaceTransferFn *p) {
 684     return reinterpret_cast<const sk_colorspace_transfer_fn_t*>(p);
 685 }
 686
 687 static inline const sk_colorspace_transfer_fn_t& ToColorSpaceTransferFn(const SkColorSpaceTransferFn &p) {
 688     return reinterpret_cast<const sk_colorspace_transfer_fn_t&>(p);
 689 }
 690
 691 static inline SkCodec::FrameInfo* AsFrameInfo(sk_codec_frameinfo_t *p) {
 692     return reinterpret_cast<SkCodec::FrameInfo*>(p);
 693 }
 694
 695 static inline sk_codec_frameinfo_t* ToFrameInfo(SkCodec::FrameInfo *p) {
 696     return reinterpret_cast<sk_codec_frameinfo_t*>(p);
 697 }
 698
 699 static inline sk_codec_frameinfo_t& ToFrameInfo(SkCodec::FrameInfo &p) {
 700     return reinterpret_cast<sk_codec_frameinfo_t&>(p);
 701 }
 702
 703 static inline const sk_codec_frameinfo_t* ToFrameInfo(const SkCodec::FrameInfo *p) {
 704     return reinterpret_cast<const sk_codec_frameinfo_t*>(p);
 705 }
 706
 707 static inline const sk_codec_frameinfo_t& ToFrameInfo(const SkCodec::FrameInfo &p) {
 708     return reinterpret_cast<const sk_codec_frameinfo_t&>(p);
 709 }
 710
 711 static inline const SkXMLStreamWriter* AsXMLStreamWriter(const sk_xmlstreamwriter_t* p) {
 712     return reinterpret_cast<const SkXMLStreamWriter*>(p);
 713 }
 714
 715 static inline SkXMLStreamWriter* AsXMLStreamWriter(sk_xmlstreamwriter_t* p) {
 716     return reinterpret_cast<SkXMLStreamWriter*>(p);
 717 }
 718
 719 static inline sk_xmlstreamwriter_t* ToXMLStreamWriter(SkXMLStreamWriter* p) {
 720     return reinterpret_cast<sk_xmlstreamwriter_t*>(p);
 721 }
 722
 723 static inline const sk_xmlstreamwriter_t* ToXMLStreamWriter(const SkXMLStreamWriter* p) {
 724     return reinterpret_cast<const sk_xmlstreamwriter_t*>(p);
 725 }
 726
 727 static inline const SkXMLWriter* AsXMLWriter(const sk_xmlwriter_t* p) {
 728     return reinterpret_cast<const SkXMLWriter*>(p);
 729 }
 730
 731 static inline SkXMLWriter* AsXMLWriter(sk_xmlwriter_t* p) {
 732     return reinterpret_cast<SkXMLWriter*>(p);
 733 }
 734
 735 static inline sk_xmlwriter_t* ToXMLWriter(SkXMLWriter* p) {
 736     return reinterpret_cast<sk_xmlwriter_t*>(p);
 737 }
 738
 739 static inline const sk_xmlwriter_t* ToXMLWriter(const SkXMLWriter* p) {
 740     return reinterpret_cast<const sk_xmlwriter_t*>(p);
 741 }
 742
 743 static inline const Sk3DView* As3DView(const sk_3dview_t* p) {
 744     return reinterpret_cast<const Sk3DView*>(p);
 745 }
 746
 747 static inline Sk3DView* As3DView(sk_3dview_t* p) {
 748     return reinterpret_cast<Sk3DView*>(p);
 749 }
 750
 751 static inline sk_3dview_t* To3DView(Sk3DView* p) {
 752     return reinterpret_cast<sk_3dview_t*>(p);
 753 }
 754
 755 static inline const sk_3dview_t* To3DView(const Sk3DView* p) {
 756     return reinterpret_cast<const sk_3dview_t*>(p);
 757 }
 758
 759 static inline const SkMatrix44& AsMatrix44(const sk_matrix44_t& p) {
 760     return reinterpret_cast<const SkMatrix44&>(p);
 761 }
 762
 763 static inline SkMatrix44& AsMatrix44(sk_matrix44_t& p) {
 764     return reinterpret_cast<SkMatrix44&>(p);
 765 }
 766
 767 static inline const SkMatrix44* AsMatrix44(const sk_matrix44_t* p) {
 768     return reinterpret_cast<const SkMatrix44*>(p);
 769 }
 770
 771 static inline SkMatrix44* AsMatrix44(sk_matrix44_t* p) {
 772     return reinterpret_cast<SkMatrix44*>(p);
 773 }
 774
 775 static inline sk_matrix44_t* ToMatrix44(SkMatrix44* p) {
 776     return reinterpret_cast<sk_matrix44_t*>(p);
 777 }
 778
 779 static inline const sk_matrix44_t* ToMatrix44(const SkMatrix44* p) {
 780     return reinterpret_cast<const sk_matrix44_t*>(p);
 781 }
 782
 783 static inline const SkHighContrastConfig* AsHighContrastConfig(const sk_highcontrastconfig_t* p) {
 784     return reinterpret_cast<const SkHighContrastConfig*>(p);
 785 }
 786
 787 static inline const SkHighContrastConfig& AsHighContrastConfig(const sk_highcontrastconfig_t& p) {
 788     return reinterpret_cast<const SkHighContrastConfig&>(p);
 789 }
 790
 791 static inline SkHighContrastConfig* AsHighContrastConfig(sk_highcontrastconfig_t* p) {
 792     return reinterpret_cast<SkHighContrastConfig*>(p);
 793 }
 794
 795 static inline SkHighContrastConfig& AsHighContrastConfig(sk_highcontrastconfig_t& p) {
 796     return reinterpret_cast<SkHighContrastConfig&>(p);
 797 }
 798
 799 static inline sk_highcontrastconfig_t* ToHighContrastConfig(SkHighContrastConfig *p) {
 800     return reinterpret_cast<sk_highcontrastconfig_t*>(p);
 801 }
 802
 803 static inline sk_highcontrastconfig_t& ToHighContrastConfig(SkHighContrastConfig &p) {
 804     return reinterpret_cast<sk_highcontrastconfig_t&>(p);
 805 }
 806
 807 static inline const sk_highcontrastconfig_t* ToHighContrastConfig(const SkHighContrastConfig *p) {
 808     return reinterpret_cast<const sk_highcontrastconfig_t*>(p);
 809 }
 810
 811 static inline const sk_highcontrastconfig_t& ToHighContrastConfig(const SkHighContrastConfig &p) {
 812     return reinterpret_cast<const sk_highcontrastconfig_t&>(p);
 813 }
 814
 815 static inline const SkVertices* AsVertices(const sk_vertices_t* p) {
 816     return reinterpret_cast<const SkVertices*>(p);
 817 }
 818
 819 static inline SkVertices* AsVertices(sk_vertices_t* p) {
 820     return reinterpret_cast<SkVertices*>(p);
 821 }
 822
 823 static inline sk_vertices_t* ToVertices(SkVertices* p) {
 824     return reinterpret_cast<sk_vertices_t*>(p);
 825 }
 826
 827 static inline const sk_vertices_t* ToVertices(const SkVertices* p) {
 828     return reinterpret_cast<const sk_vertices_t*>(p);
 829 }
 830
 831 static inline void from_c(const sk_matrix_t* cmatrix, SkMatrix* matrix) {
 832     matrix->setAll(
 833         cmatrix->mat[0], cmatrix->mat[1], cmatrix->mat[2],
 834         cmatrix->mat[3], cmatrix->mat[4], cmatrix->mat[5],
 835         cmatrix->mat[6], cmatrix->mat[7], cmatrix->mat[8]);
 836 }
 837
 838 static inline void from_sk(const SkMatrix* matrix, sk_matrix_t* cmatrix) {
 839     matrix->get9(cmatrix->mat);
 840 }
 841
 842 static inline void from_c(const sk_imageinfo_t& cinfo, SkImageInfo* info) {
 843     if (info) {
 844         *info = SkImageInfo::Make(
 845             cinfo.width,
 846             cinfo.height,
 847             (SkColorType)cinfo.colorType,
 848             (SkAlphaType)cinfo.alphaType,
 849             sk_ref_sp(AsColorSpace(cinfo.colorspace)));
 850     }
 851 }
 852
 853 static inline void from_sk(const SkImageInfo& info, sk_imageinfo_t* cinfo) {
 854     if (cinfo) {
 855         *cinfo = {
 856             ToColorSpace(info.refColorSpace().release()),
 857             info.width(),
 858             info.height(),
 859             (sk_colortype_t)info.colorType(),
 860             (sk_alphatype_t)info.alphaType(),
 861         };
 862     }
 863 }
 864
 865 static inline void from_c(const sk_document_pdf_metadata_t& cmetadata, SkDocument::PDFMetadata* metadata) {
 866     if (metadata) {
 867         SkDocument::PDFMetadata md;
 868         if (cmetadata.fTitle) md.fTitle = AsString(*cmetadata.fTitle);
 869         if (cmetadata.fAuthor) md.fAuthor = AsString(*cmetadata.fAuthor);
 870         if (cmetadata.fSubject) md.fSubject = AsString(*cmetadata.fSubject);
 871         if (cmetadata.fKeywords) md.fKeywords = AsString(*cmetadata.fKeywords);
 872         if (cmetadata.fCreator) md.fCreator = AsString(*cmetadata.fCreator);
 873         if (cmetadata.fProducer) md.fProducer = AsString(*cmetadata.fProducer);
 874         if (cmetadata.fCreation) {
 875             md.fCreation.fEnabled = true;
 876             md.fCreation.fDateTime = AsTimeDateTime(*cmetadata.fCreation);
 877         }
 878         if (cmetadata.fModified) {
 879             md.fModified.fEnabled = true;
 880             md.fModified.fDateTime = AsTimeDateTime(*cmetadata.fModified);
 881         }
 882         *metadata = md;
 883     }
 884 }
 885
 886 static inline void from_c(const sk_surfaceprops_t* cprops, SkSurfaceProps* props) {
 887     *props = SkSurfaceProps(cprops->flags, (SkPixelGeometry)cprops->pixelGeometry);
 888 }
 889
 890 static inline void from_sk(const SkSurfaceProps* props, sk_surfaceprops_t* cprops) {
 891     *cprops = {
 892         (sk_pixelgeometry_t)props->pixelGeometry(),
 893         (sk_surfaceprops_flags_t)props->flags()
 894     };
 895 }
 896
 897 #endif