1 2 /* 3 * Copyright 2006 The Android Open Source Project 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 #ifndef SkMask_DEFINED 11 #define SkMask_DEFINED 12 13 #include "SkRect.h" 14 15 /** \class SkMask 16 SkMask is used to describe alpha bitmaps, either 1bit, 8bit, or 17 the 3-channel 3D format. These are passed to SkMaskFilter objects. 18 */ 19 struct SkMask { 20 enum Format { 21 kBW_Format, //!< 1bit per pixel mask (e.g. monochrome) 22 kA8_Format, //!< 8bits per pixel mask (e.g. antialiasing) 23 k3D_Format, //!< 3 8bit per pixl planes: alpha, mul, add 24 kARGB32_Format, //!< SkPMColor 25 kLCD16_Format, //!< 565 alpha for r/g/b 26 kLCD32_Format //!< 888 alpha for r/g/b 27 }; 28 29 enum { 30 kCountMaskFormats = kLCD32_Format + 1 31 }; 32 33 uint8_t* fImage; 34 SkIRect fBounds; 35 uint32_t fRowBytes; 36 Format fFormat; 37 38 /** Returns true if the mask is empty: i.e. it has an empty bounds. 39 */ isEmptySkMask40 bool isEmpty() const { return fBounds.isEmpty(); } 41 42 /** Return the byte size of the mask, assuming only 1 plane. 43 Does not account for k3D_Format. For that, use computeTotalImageSize(). 44 If there is an overflow of 32bits, then returns 0. 45 */ 46 size_t computeImageSize() const; 47 48 /** Return the byte size of the mask, taking into account 49 any extra planes (e.g. k3D_Format). 50 If there is an overflow of 32bits, then returns 0. 51 */ 52 size_t computeTotalImageSize() const; 53 54 /** Returns the address of the byte that holds the specified bit. 55 Asserts that the mask is kBW_Format, and that x,y are in range. 56 x,y are in the same coordiate space as fBounds. 57 */ getAddr1SkMask58 uint8_t* getAddr1(int x, int y) const { 59 SkASSERT(kBW_Format == fFormat); 60 SkASSERT(fBounds.contains(x, y)); 61 SkASSERT(fImage != NULL); 62 return fImage + ((x - fBounds.fLeft) >> 3) + (y - fBounds.fTop) * fRowBytes; 63 } 64 65 /** Returns the address of the specified byte. 66 Asserts that the mask is kA8_Format, and that x,y are in range. 67 x,y are in the same coordiate space as fBounds. 68 */ getAddr8SkMask69 uint8_t* getAddr8(int x, int y) const { 70 SkASSERT(kA8_Format == fFormat); 71 SkASSERT(fBounds.contains(x, y)); 72 SkASSERT(fImage != NULL); 73 return fImage + x - fBounds.fLeft + (y - fBounds.fTop) * fRowBytes; 74 } 75 76 /** 77 * Return the address of the specified 16bit mask. In the debug build, 78 * this asserts that the mask's format is kLCD16_Format, and that (x,y) 79 * are contained in the mask's fBounds. 80 */ getAddrLCD16SkMask81 uint16_t* getAddrLCD16(int x, int y) const { 82 SkASSERT(kLCD16_Format == fFormat); 83 SkASSERT(fBounds.contains(x, y)); 84 SkASSERT(fImage != NULL); 85 uint16_t* row = (uint16_t*)(fImage + (y - fBounds.fTop) * fRowBytes); 86 return row + (x - fBounds.fLeft); 87 } 88 89 /** 90 * Return the address of the specified 32bit mask. In the debug build, 91 * this asserts that the mask's format is kLCD32_Format, and that (x,y) 92 * are contained in the mask's fBounds. 93 */ getAddrLCD32SkMask94 uint32_t* getAddrLCD32(int x, int y) const { 95 SkASSERT(kLCD32_Format == fFormat); 96 SkASSERT(fBounds.contains(x, y)); 97 SkASSERT(fImage != NULL); 98 uint32_t* row = (uint32_t*)(fImage + (y - fBounds.fTop) * fRowBytes); 99 return row + (x - fBounds.fLeft); 100 } 101 102 /** 103 * Returns the address of the specified pixel, computing the pixel-size 104 * at runtime based on the mask format. This will be slightly slower than 105 * using one of the routines where the format is implied by the name 106 * e.g. getAddr8 or getAddrLCD32. 107 * 108 * x,y must be contained by the mask's bounds (this is asserted in the 109 * debug build, but not checked in the release build.) 110 * 111 * This should not be called with kBW_Format, as it will give unspecified 112 * results (and assert in the debug build). 113 */ 114 void* getAddr(int x, int y) const; 115 116 static uint8_t* AllocImage(size_t bytes); 117 static void FreeImage(void* image); 118 119 enum CreateMode { 120 kJustComputeBounds_CreateMode, //!< compute bounds and return 121 kJustRenderImage_CreateMode, //!< render into preallocate mask 122 kComputeBoundsAndRenderImage_CreateMode //!< compute bounds, alloc image and render into it 123 }; 124 }; 125 126 /////////////////////////////////////////////////////////////////////////////// 127 128 /** 129 * \class SkAutoMaskImage 130 * 131 * Stack class used to manage the fImage buffer in a SkMask. 132 * When this object loses scope, the buffer is freed with SkMask::FreeImage(). 133 */ 134 class SkAutoMaskFreeImage { 135 public: SkAutoMaskFreeImage(uint8_t * maskImage)136 SkAutoMaskFreeImage(uint8_t* maskImage) { 137 fImage = maskImage; 138 } 139 ~SkAutoMaskFreeImage()140 ~SkAutoMaskFreeImage() { 141 SkMask::FreeImage(fImage); 142 } 143 144 private: 145 uint8_t* fImage; 146 }; 147 148 #endif 149 150