src/third_party/skia/include/gpu/GrTypes.h

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