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