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