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