The Tor Browser / file comparison

comparison: gfx/skia/trunk/include/core/SkMask.h

gfx/skia/trunk/include/core/SkMask.h

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:a6a4ef547e49
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 */
40 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 */
58 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 */
69 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 */
81 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 */
94 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 * Return the address of the specified 32bit mask. In the debug build,
104 * this asserts that the mask's format is 32bits, and that (x,y)
105 * are contained in the mask's fBounds.
106 */
107 uint32_t* getAddr32(int x, int y) const {
108 SkASSERT(kLCD32_Format == fFormat || kARGB32_Format == fFormat);
109 SkASSERT(fBounds.contains(x, y));
110 SkASSERT(fImage != NULL);
111 uint32_t* row = (uint32_t*)(fImage + (y - fBounds.fTop) * fRowBytes);
112 return row + (x - fBounds.fLeft);
113 }
114
115 /**
116 * Returns the address of the specified pixel, computing the pixel-size
117 * at runtime based on the mask format. This will be slightly slower than
118 * using one of the routines where the format is implied by the name
119 * e.g. getAddr8 or getAddrLCD32.
120 *
121 * x,y must be contained by the mask's bounds (this is asserted in the
122 * debug build, but not checked in the release build.)
123 *
124 * This should not be called with kBW_Format, as it will give unspecified
125 * results (and assert in the debug build).
126 */
127 void* getAddr(int x, int y) const;
128
129 static uint8_t* AllocImage(size_t bytes);
130 static void FreeImage(void* image);
131
132 enum CreateMode {
133 kJustComputeBounds_CreateMode, //!< compute bounds and return
134 kJustRenderImage_CreateMode, //!< render into preallocate mask
135 kComputeBoundsAndRenderImage_CreateMode //!< compute bounds, alloc image and render into it
136 };
137 };
138
139 ///////////////////////////////////////////////////////////////////////////////
140
141 /**
142 * \class SkAutoMaskImage
143 *
144 * Stack class used to manage the fImage buffer in a SkMask.
145 * When this object loses scope, the buffer is freed with SkMask::FreeImage().
146 */
147 class SkAutoMaskFreeImage {
148 public:
149 SkAutoMaskFreeImage(uint8_t* maskImage) {
150 fImage = maskImage;
151 }
152
153 ~SkAutoMaskFreeImage() {
154 SkMask::FreeImage(fImage);
155 }
156
157 private:
158 uint8_t* fImage;
159 };
160 #define SkAutoMaskFreeImage(...) SK_REQUIRE_LOCAL_VAR(SkAutoMaskFreeImage)
161
162 #endif

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial