1 /* 2 * Copyright 2010 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 GrTypes_DEFINED 9 #define GrTypes_DEFINED 10 11 #include "SkTypes.h" 12 #include "GrConfig.h" 13 #include "SkMath.h" 14 15 //////////////////////////////////////////////////////////////////////////////// 16 17 /** 18 * Defines overloaded bitwise operators to make it easier to use an enum as a 19 * bitfield. 20 */ 21 #define GR_MAKE_BITFIELD_OPS(X) \ 22 inline X operator | (X a, X b) { \ 23 return (X) (+a | +b); \ 24 } \ 25 inline X& operator |= (X& a, X b) { \ 26 return (a = a | b); \ 27 } \ 28 \ 29 inline X operator & (X a, X b) { \ 30 return (X) (+a & +b); \ 31 } \ 32 template <typename T> \ 33 inline X operator & (T a, X b) { \ 34 return (X) (+a & +b); \ 35 } \ 36 template <typename T> \ 37 inline X operator & (X a, T b) { \ 38 return (X) (+a & +b); \ 39 } \ 40 41 #define GR_DECL_BITFIELD_OPS_FRIENDS(X) \ 42 friend X operator | (X a, X b); \ 43 friend X& operator |= (X& a, X b); \ 44 \ 45 friend X operator & (X a, X b); \ 46 \ 47 template <typename T> \ 48 friend X operator & (T a, X b); \ 49 \ 50 template <typename T> \ 51 friend X operator & (X a, T b); \ 52 //////////////////////////////////////////////////////////////////////////////// 53 54 // compile time versions of min/max 55 #define GR_CT_MAX(a, b) (((b) < (a)) ? (a) : (b)) 56 #define GR_CT_MIN(a, b) (((b) < (a)) ? (b) : (a)) 57 58 /** 59 * divide, rounding up 60 */ 61 static inline int32_t GrIDivRoundUp(int x, int y) { 62 SkASSERT(y > 0); 63 return (x + (y-1)) / y; 64 } 65 static inline uint32_t GrUIDivRoundUp(uint32_t x, uint32_t y) { 66 return (x + (y-1)) / y; 67 } 68 static inline size_t GrSizeDivRoundUp(size_t x, size_t y) { 69 return (x + (y-1)) / y; 70 } 71 72 // compile time, evaluates Y multiple times 73 #define GR_CT_DIV_ROUND_UP(X, Y) (((X) + ((Y)-1)) / (Y)) 74 75 /** 76 * align up 77 */ 78 static inline uint32_t GrUIAlignUp(uint32_t x, uint32_t alignment) { 79 return GrUIDivRoundUp(x, alignment) * alignment; 80 } 81 static inline size_t GrSizeAlignUp(size_t x, size_t alignment) { 82 return GrSizeDivRoundUp(x, alignment) * alignment; 83 } 84 85 // compile time, evaluates A multiple times 86 #define GR_CT_ALIGN_UP(X, A) (GR_CT_DIV_ROUND_UP((X),(A)) * (A)) 87 88 /** 89 * amount of pad needed to align up 90 */ 91 static inline uint32_t GrUIAlignUpPad(uint32_t x, uint32_t alignment) { 92 return (alignment - x % alignment) % alignment; 93 } 94 static inline size_t GrSizeAlignUpPad(size_t x, size_t alignment) { 95 return (alignment - x % alignment) % alignment; 96 } 97 98 /** 99 * align down 100 */ 101 static inline uint32_t GrUIAlignDown(uint32_t x, uint32_t alignment) { 102 return (x / alignment) * alignment; 103 } 104 static inline size_t GrSizeAlignDown(size_t x, uint32_t alignment) { 105 return (x / alignment) * alignment; 106 } 107 108 /////////////////////////////////////////////////////////////////////////////// 109 110 /** 111 * Return the next power of 2 >= n. 112 */ 113 static inline uint32_t GrNextPow2(uint32_t n) { 114 return n ? (1 << (32 - SkCLZ(n - 1))) : 1; 115 } 116 117 static inline int GrNextPow2(int n) { 118 SkASSERT(n >= 0); // this impl only works for non-neg. 119 return n ? (1 << (32 - SkCLZ(n - 1))) : 1; 120 } 121 122 /////////////////////////////////////////////////////////////////////////////// 123 124 /** 125 * Possible 3D APIs that may be used by Ganesh. 126 */ 127 enum GrBackend { 128 kOpenGL_GrBackend, 129 kVulkan_GrBackend, 130 131 kLast_GrBackend = kVulkan_GrBackend 132 }; 133 const int kBackendCount = kLast_GrBackend + 1; 134 135 /** 136 * Backend-specific 3D context handle 137 * GrGLInterface* for OpenGL. If NULL will use the default GL interface. 138 */ 139 typedef intptr_t GrBackendContext; 140 141 /////////////////////////////////////////////////////////////////////////////// 142 143 /** 144 * Geometric primitives used for drawing. 145 */ 146 enum GrPrimitiveType { 147 kTriangles_GrPrimitiveType, 148 kTriangleStrip_GrPrimitiveType, 149 kTriangleFan_GrPrimitiveType, 150 kPoints_GrPrimitiveType, 151 kLines_GrPrimitiveType, // 1 pix wide only 152 kLineStrip_GrPrimitiveType, // 1 pix wide only 153 kLast_GrPrimitiveType = kLineStrip_GrPrimitiveType 154 }; 155 156 static inline bool GrIsPrimTypeLines(GrPrimitiveType type) { 157 return kLines_GrPrimitiveType == type || kLineStrip_GrPrimitiveType == type; 158 } 159 160 static inline bool GrIsPrimTypeTris(GrPrimitiveType type) { 161 return kTriangles_GrPrimitiveType == type || 162 kTriangleStrip_GrPrimitiveType == type || 163 kTriangleFan_GrPrimitiveType == type; 164 } 165 166 /** 167 * Formats for masks, used by the font cache. 168 * Important that these are 0-based. 169 */ 170 enum GrMaskFormat { 171 kA8_GrMaskFormat, //!< 1-byte per pixel 172 kA565_GrMaskFormat, //!< 2-bytes per pixel, RGB represent 3-channel LCD coverage 173 kARGB_GrMaskFormat, //!< 4-bytes per pixel, color format 174 175 kLast_GrMaskFormat = kARGB_GrMaskFormat 176 }; 177 static const int kMaskFormatCount = kLast_GrMaskFormat + 1; 178 179 /** 180 * Return the number of bytes-per-pixel for the specified mask format. 181 */ 182 static inline int GrMaskFormatBytesPerPixel(GrMaskFormat format) { 183 SkASSERT(format < kMaskFormatCount); 184 // kA8 (0) -> 1 185 // kA565 (1) -> 2 186 // kARGB (2) -> 4 187 static const int sBytesPerPixel[] = { 1, 2, 4 }; 188 static_assert(SK_ARRAY_COUNT(sBytesPerPixel) == kMaskFormatCount, "array_size_mismatch"); 189 static_assert(kA8_GrMaskFormat == 0, "enum_order_dependency"); 190 static_assert(kA565_GrMaskFormat == 1, "enum_order_dependency"); 191 static_assert(kARGB_GrMaskFormat == 2, "enum_order_dependency"); 192 193 return sBytesPerPixel[(int) format]; 194 } 195 196 /** 197 * Pixel configurations. 198 */ 199 enum GrPixelConfig { 200 kUnknown_GrPixelConfig, 201 kAlpha_8_GrPixelConfig, 202 kIndex_8_GrPixelConfig, 203 kRGB_565_GrPixelConfig, 204 /** 205 * Premultiplied 206 */ 207 kRGBA_4444_GrPixelConfig, 208 /** 209 * Premultiplied. Byte order is r,g,b,a. 210 */ 211 kRGBA_8888_GrPixelConfig, 212 /** 213 * Premultiplied. Byte order is b,g,r,a. 214 */ 215 kBGRA_8888_GrPixelConfig, 216 /** 217 * Premultiplied and sRGB. Byte order is r,g,b,a. 218 */ 219 kSRGBA_8888_GrPixelConfig, 220 /** 221 * ETC1 Compressed Data 222 */ 223 kETC1_GrPixelConfig, 224 /** 225 * LATC/RGTC/3Dc/BC4 Compressed Data 226 */ 227 kLATC_GrPixelConfig, 228 /** 229 * R11 EAC Compressed Data 230 * (Corresponds to section C.3.5 of the OpenGL 4.4 core profile spec) 231 */ 232 kR11_EAC_GrPixelConfig, 233 234 /** 235 * 12x12 ASTC Compressed Data 236 * ASTC stands for Adaptive Scalable Texture Compression. It is a technique 237 * that allows for a lot of customization in the compressed representataion 238 * of a block. The only thing fixed in the representation is the block size, 239 * which means that a texture that contains ASTC data must be treated as 240 * having RGBA values. However, there are single-channel encodings which set 241 * the alpha to opaque and all three RGB channels equal effectively making the 242 * compression format a single channel such as R11 EAC and LATC. 243 */ 244 kASTC_12x12_GrPixelConfig, 245 246 /** 247 * Byte order is r, g, b, a. This color format is 32 bits per channel 248 */ 249 kRGBA_float_GrPixelConfig, 250 251 /** 252 * This color format is a single 16 bit float channel 253 */ 254 kAlpha_half_GrPixelConfig, 255 256 /** 257 * Byte order is r, g, b, a. This color format is 16 bits per channel 258 */ 259 kRGBA_half_GrPixelConfig, 260 261 kLast_GrPixelConfig = kRGBA_half_GrPixelConfig 262 }; 263 static const int kGrPixelConfigCnt = kLast_GrPixelConfig + 1; 264 265 // Aliases for pixel configs that match skia's byte order. 266 #ifndef SK_CPU_LENDIAN 267 #error "Skia gpu currently assumes little endian" 268 #endif 269 #if SK_PMCOLOR_BYTE_ORDER(B,G,R,A) 270 static const GrPixelConfig kSkia8888_GrPixelConfig = kBGRA_8888_GrPixelConfig; 271 #elif SK_PMCOLOR_BYTE_ORDER(R,G,B,A) 272 static const GrPixelConfig kSkia8888_GrPixelConfig = kRGBA_8888_GrPixelConfig; 273 #else 274 #error "SK_*32_SHIFT values must correspond to GL_BGRA or GL_RGBA format." 275 #endif 276 277 // Returns true if the pixel config is a GPU-specific compressed format 278 // representation. 279 static inline bool GrPixelConfigIsCompressed(GrPixelConfig config) { 280 switch (config) { 281 case kIndex_8_GrPixelConfig: 282 case kETC1_GrPixelConfig: 283 case kLATC_GrPixelConfig: 284 case kR11_EAC_GrPixelConfig: 285 case kASTC_12x12_GrPixelConfig: 286 return true; 287 default: 288 return false; 289 } 290 } 291 292 /** If the pixel config is compressed, return an equivalent uncompressed format. */ 293 static inline GrPixelConfig GrMakePixelConfigUncompressed(GrPixelConfig config) { 294 switch (config) { 295 case kIndex_8_GrPixelConfig: 296 case kETC1_GrPixelConfig: 297 case kASTC_12x12_GrPixelConfig: 298 return kRGBA_8888_GrPixelConfig; 299 case kLATC_GrPixelConfig: 300 case kR11_EAC_GrPixelConfig: 301 return kAlpha_8_GrPixelConfig; 302 default: 303 SkASSERT(!GrPixelConfigIsCompressed(config)); 304 return config; 305 } 306 } 307 308 // Returns true if the pixel config is 32 bits per pixel 309 static inline bool GrPixelConfigIs8888(GrPixelConfig config) { 310 switch (config) { 311 case kRGBA_8888_GrPixelConfig: 312 case kBGRA_8888_GrPixelConfig: 313 case kSRGBA_8888_GrPixelConfig: 314 return true; 315 default: 316 return false; 317 } 318 } 319 320 // Returns true if the color (non-alpha) components represent sRGB values. It does NOT indicate that 321 // all three color components are present in the config or anything about their order. 322 static inline bool GrPixelConfigIsSRGB(GrPixelConfig config) { 323 switch (config) { 324 case kSRGBA_8888_GrPixelConfig: 325 return true; 326 default: 327 return false; 328 } 329 } 330 331 // Takes a config and returns the equivalent config with the R and B order 332 // swapped if such a config exists. Otherwise, kUnknown_GrPixelConfig 333 static inline GrPixelConfig GrPixelConfigSwapRAndB(GrPixelConfig config) { 334 switch (config) { 335 case kBGRA_8888_GrPixelConfig: 336 return kRGBA_8888_GrPixelConfig; 337 case kRGBA_8888_GrPixelConfig: 338 return kBGRA_8888_GrPixelConfig; 339 default: 340 return kUnknown_GrPixelConfig; 341 } 342 } 343 344 static inline size_t GrBytesPerPixel(GrPixelConfig config) { 345 SkASSERT(!GrPixelConfigIsCompressed(config)); 346 switch (config) { 347 case kAlpha_8_GrPixelConfig: 348 return 1; 349 case kRGB_565_GrPixelConfig: 350 case kRGBA_4444_GrPixelConfig: 351 case kAlpha_half_GrPixelConfig: 352 return 2; 353 case kRGBA_8888_GrPixelConfig: 354 case kBGRA_8888_GrPixelConfig: 355 case kSRGBA_8888_GrPixelConfig: 356 return 4; 357 case kRGBA_half_GrPixelConfig: 358 return 8; 359 case kRGBA_float_GrPixelConfig: 360 return 16; 361 default: 362 return 0; 363 } 364 } 365 366 static inline bool GrPixelConfigIsOpaque(GrPixelConfig config) { 367 switch (config) { 368 case kETC1_GrPixelConfig: 369 case kRGB_565_GrPixelConfig: 370 return true; 371 default: 372 return false; 373 } 374 } 375 376 static inline bool GrPixelConfigIsAlphaOnly(GrPixelConfig config) { 377 switch (config) { 378 case kR11_EAC_GrPixelConfig: 379 case kLATC_GrPixelConfig: 380 case kASTC_12x12_GrPixelConfig: 381 case kAlpha_8_GrPixelConfig: 382 case kAlpha_half_GrPixelConfig: 383 return true; 384 default: 385 return false; 386 } 387 } 388 389 /** 390 * Optional bitfield flags that can be set on GrSurfaceDesc (below). 391 */ 392 enum GrSurfaceFlags { 393 kNone_GrSurfaceFlags = 0x0, 394 /** 395 * Creates a texture that can be rendered to as a GrRenderTarget. Use 396 * GrTexture::asRenderTarget() to access. 397 */ 398 kRenderTarget_GrSurfaceFlag = 0x1, 399 /** 400 * Placeholder for managing zero-copy textures 401 */ 402 kZeroCopy_GrSurfaceFlag = 0x2, 403 /** 404 * Indicates that all allocations (color buffer, FBO completeness, etc) 405 * should be verified. 406 */ 407 kCheckAllocation_GrSurfaceFlag = 0x4, 408 }; 409 410 GR_MAKE_BITFIELD_OPS(GrSurfaceFlags) 411 412 // opaque type for 3D API object handles 413 typedef intptr_t GrBackendObject; 414 415 /** 416 * Some textures will be stored such that the upper and left edges of the content meet at the 417 * the origin (in texture coord space) and for other textures the lower and left edges meet at 418 * the origin. kDefault_GrSurfaceOrigin sets textures to TopLeft, and render targets 419 * to BottomLeft. 420 */ 421 422 enum GrSurfaceOrigin { 423 kDefault_GrSurfaceOrigin, // DEPRECATED; to be removed 424 kTopLeft_GrSurfaceOrigin, 425 kBottomLeft_GrSurfaceOrigin, 426 }; 427 428 /** 429 * An container of function pointers which consumers of Skia can fill in and 430 * pass to Skia. Skia will use these function pointers in place of its backend 431 * API texture creation function. Either all of the function pointers should be 432 * filled in, or they should all be nullptr. 433 */ 434 struct GrTextureStorageAllocator { 435 GrTextureStorageAllocator() 436 : fAllocateTextureStorage(nullptr) 437 , fDeallocateTextureStorage(nullptr) { 438 } 439 440 enum class Result { 441 kSucceededAndUploaded, 442 kSucceededWithoutUpload, 443 kFailed 444 }; 445 typedef Result (*AllocateTextureStorageProc)( 446 void* ctx, GrBackendObject texture, unsigned width, 447 unsigned height, GrPixelConfig config, const void* srcData, GrSurfaceOrigin); 448 typedef void (*DeallocateTextureStorageProc)(void* ctx, GrBackendObject texture); 449 450 /* 451 * Generates and binds a texture to |textureStorageTarget()|. Allocates 452 * storage for the texture. 453 * 454 * In OpenGL, the MIN and MAX filters for the created texture must be 455 * GL_LINEAR. The WRAP_S and WRAP_T must be GL_CLAMP_TO_EDGE. 456 * 457 * If |srcData| is not nullptr, then the implementation of this function 458 * may attempt to upload the data into the texture. On successful upload, 459 * or if |srcData| is nullptr, returns kSucceededAndUploaded. 460 */ 461 AllocateTextureStorageProc fAllocateTextureStorage; 462 463 /* 464 * Deallocate the storage for the given texture. 465 * 466 * Skia does not always destroy its outstanding textures. See 467 * GrContext::abandonContext() for more details. The consumer of Skia is 468 * responsible for making sure that all textures are destroyed, even if this 469 * callback is not invoked. 470 */ 471 DeallocateTextureStorageProc fDeallocateTextureStorage; 472 473 /* 474 * The context to use when invoking fAllocateTextureStorage and 475 * fDeallocateTextureStorage. 476 */ 477 void* fCtx; 478 }; 479 480 /** 481 * Describes a surface to be created. 482 */ 483 struct GrSurfaceDesc { 484 GrSurfaceDesc() 485 : fFlags(kNone_GrSurfaceFlags) 486 , fOrigin(kDefault_GrSurfaceOrigin) 487 , fWidth(0) 488 , fHeight(0) 489 , fConfig(kUnknown_GrPixelConfig) 490 , fSampleCnt(0) { 491 } 492 493 GrSurfaceFlags fFlags; //!< bitfield of TextureFlags 494 GrSurfaceOrigin fOrigin; //!< origin of the texture 495 int fWidth; //!< Width of the texture 496 int fHeight; //!< Height of the texture 497 498 /** 499 * Format of source data of the texture. Not guaranteed to be the same as 500 * internal format used by 3D API. 501 */ 502 GrPixelConfig fConfig; 503 504 /** 505 * The number of samples per pixel or 0 to disable full scene AA. This only 506 * applies if the kRenderTarget_GrSurfaceFlag is set. The actual number 507 * of samples may not exactly match the request. The request will be rounded 508 * up to the next supported sample count, or down if it is larger than the 509 * max supported count. 510 */ 511 int fSampleCnt; 512 513 /** 514 * A custom platform-specific allocator to use in place of the backend APIs 515 * usual texture creation method (e.g. TexImage2D in OpenGL). 516 */ 517 GrTextureStorageAllocator fTextureStorageAllocator; 518 }; 519 520 // Legacy alias 521 typedef GrSurfaceDesc GrTextureDesc; 522 523 /** 524 * Clips are composed from these objects. 525 */ 526 enum GrClipType { 527 kRect_ClipType, 528 kPath_ClipType 529 }; 530 531 /////////////////////////////////////////////////////////////////////////////// 532 533 534 /** Ownership rules for external GPU resources imported into Skia. */ 535 enum GrWrapOwnership { 536 /** Skia will assume the client will keep the resource alive and Skia will not free it. */ 537 kBorrow_GrWrapOwnership, 538 539 /** Skia will assume ownership of the resource and free it. */ 540 kAdopt_GrWrapOwnership, 541 }; 542 543 /** 544 * Gr can wrap an existing texture created by the client with a GrTexture 545 * object. The client is responsible for ensuring that the texture lives at 546 * least as long as the GrTexture object wrapping it. We require the client to 547 * explicitly provide information about the texture, such as width, height, 548 * and pixel config, rather than querying the 3D APIfor these values. We expect 549 * these to be immutable even if the 3D API doesn't require this (OpenGL). 550 * 551 * Textures that are also render targets are supported as well. Gr will manage 552 * any ancillary 3D API (stencil buffer, FBO id, etc) objects necessary for 553 * Gr to draw into the render target. To access the render target object 554 * call GrTexture::asRenderTarget(). 555 * 556 * If in addition to the render target flag, the caller also specifies a sample 557 * count Gr will create an MSAA buffer that resolves into the texture. Gr auto- 558 * resolves when it reads from the texture. The client can explictly resolve 559 * using the GrRenderTarget interface. 560 * 561 * Note: These flags currently form a subset of GrTexture's flags. 562 */ 563 564 enum GrBackendTextureFlags { 565 /** 566 * No flags enabled 567 */ 568 kNone_GrBackendTextureFlag = 0, 569 /** 570 * Indicates that the texture is also a render target, and thus should have 571 * a GrRenderTarget object. 572 */ 573 kRenderTarget_GrBackendTextureFlag = kRenderTarget_GrSurfaceFlag, 574 }; 575 GR_MAKE_BITFIELD_OPS(GrBackendTextureFlags) 576 577 struct GrBackendTextureDesc { 578 GrBackendTextureDesc() { memset(this, 0, sizeof(*this)); } 579 GrBackendTextureFlags fFlags; 580 GrSurfaceOrigin fOrigin; 581 int fWidth; //<! width in pixels 582 int fHeight; //<! height in pixels 583 GrPixelConfig fConfig; //<! color format 584 /** 585 * If the render target flag is set and sample count is greater than 0 586 * then Gr will create an MSAA buffer that resolves to the texture. 587 */ 588 int fSampleCnt; 589 /** 590 * Handle to the 3D API object. 591 * OpenGL: Texture ID. 592 */ 593 GrBackendObject fTextureHandle; 594 }; 595 596 /////////////////////////////////////////////////////////////////////////////// 597 598 /** 599 * Gr can wrap an existing render target created by the client in the 3D API 600 * with a GrRenderTarget object. The client is responsible for ensuring that the 601 * underlying 3D API object lives at least as long as the GrRenderTarget object 602 * wrapping it. We require the client to explicitly provide information about 603 * the target, such as width, height, and pixel config rather than querying the 604 * 3D API for these values. We expect these properties to be immutable even if 605 * the 3D API doesn't require this (OpenGL). 606 */ 607 608 struct GrBackendRenderTargetDesc { 609 GrBackendRenderTargetDesc() { memset(this, 0, sizeof(*this)); } 610 int fWidth; //<! width in pixels 611 int fHeight; //<! height in pixels 612 GrPixelConfig fConfig; //<! color format 613 GrSurfaceOrigin fOrigin; //<! pixel origin 614 /** 615 * The number of samples per pixel. Gr uses this to influence decisions 616 * about applying other forms of anti-aliasing. 617 */ 618 int fSampleCnt; 619 /** 620 * Number of bits of stencil per-pixel. 621 */ 622 int fStencilBits; 623 /** 624 * Handle to the 3D API object. 625 * OpenGL: FBO ID 626 */ 627 GrBackendObject fRenderTargetHandle; 628 }; 629 630 /** 631 * The GrContext's cache of backend context state can be partially invalidated. 632 * These enums are specific to the GL backend and we'd add a new set for an alternative backend. 633 */ 634 enum GrGLBackendState { 635 kRenderTarget_GrGLBackendState = 1 << 0, 636 kTextureBinding_GrGLBackendState = 1 << 1, 637 // View state stands for scissor and viewport 638 kView_GrGLBackendState = 1 << 2, 639 kBlend_GrGLBackendState = 1 << 3, 640 kMSAAEnable_GrGLBackendState = 1 << 4, 641 kVertex_GrGLBackendState = 1 << 5, 642 kStencil_GrGLBackendState = 1 << 6, 643 kPixelStore_GrGLBackendState = 1 << 7, 644 kProgram_GrGLBackendState = 1 << 8, 645 kFixedFunction_GrGLBackendState = 1 << 9, 646 kMisc_GrGLBackendState = 1 << 10, 647 kPathRendering_GrGLBackendState = 1 << 11, 648 kALL_GrGLBackendState = 0xffff 649 }; 650 651 /** 652 * Returns the data size for the given compressed pixel config 653 */ 654 static inline size_t GrCompressedFormatDataSize(GrPixelConfig config, 655 int width, int height) { 656 SkASSERT(GrPixelConfigIsCompressed(config)); 657 static const int kGrIndex8TableSize = 256 * 4; // 4 == sizeof(GrColor) 658 659 switch (config) { 660 case kIndex_8_GrPixelConfig: 661 return width * height + kGrIndex8TableSize; 662 case kR11_EAC_GrPixelConfig: 663 case kLATC_GrPixelConfig: 664 case kETC1_GrPixelConfig: 665 SkASSERT((width & 3) == 0); 666 SkASSERT((height & 3) == 0); 667 return (width >> 2) * (height >> 2) * 8; 668 669 case kASTC_12x12_GrPixelConfig: 670 SkASSERT((width % 12) == 0); 671 SkASSERT((height % 12) == 0); 672 return (width / 12) * (height / 12) * 16; 673 674 default: 675 SkFAIL("Unknown compressed pixel config"); 676 return 4 * width * height; 677 } 678 } 679 680 /** 681 * This value translates to reseting all the context state for any backend. 682 */ 683 static const uint32_t kAll_GrBackendState = 0xffffffff; 684 685 #endif 686
