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 SkBitmap_DEFINED
11 : #define SkBitmap_DEFINED
12 :
13 : #include "Sk64.h"
14 : #include "SkColor.h"
15 : #include "SkPoint.h"
16 : #include "SkRefCnt.h"
17 :
18 : struct SkIRect;
19 : class SkColorTable;
20 : class SkPaint;
21 : class SkPixelRef;
22 : class SkRegion;
23 : class SkFlattenableReadBuffer;
24 : class SkFlattenableWriteBuffer;
25 :
26 : // This is an opaque class, not interpreted by skia
27 : class SkGpuTexture;
28 :
29 : /** \class SkBitmap
30 :
31 : The SkBitmap class specifies a raster bitmap. A bitmap has an integer width
32 : and height, and a format (config), and a pointer to the actual pixels.
33 : Bitmaps can be drawn into a SkCanvas, but they are also used to specify the
34 : target of a SkCanvas' drawing operations.
35 : A const SkBitmap exposes getAddr(), which lets a caller write its pixels;
36 : the constness is considered to apply to the bitmap's configuration, not
37 : its contents.
38 : */
39 : class SK_API SkBitmap {
40 : public:
41 : class Allocator;
42 :
43 : enum Config {
44 : kNo_Config, //!< bitmap has not been configured
45 : /**
46 : * 1-bit per pixel, (0 is transparent, 1 is opaque)
47 : * Valid as a destination (target of a canvas), but not valid as a src.
48 : * i.e. you can draw into a 1-bit bitmap, but you cannot draw from one.
49 : */
50 : kA1_Config,
51 : kA8_Config, //!< 8-bits per pixel, with only alpha specified (0 is transparent, 0xFF is opaque)
52 : kIndex8_Config, //!< 8-bits per pixel, using SkColorTable to specify the colors
53 : kRGB_565_Config, //!< 16-bits per pixel, (see SkColorPriv.h for packing)
54 : kARGB_4444_Config, //!< 16-bits per pixel, (see SkColorPriv.h for packing)
55 : kARGB_8888_Config, //!< 32-bits per pixel, (see SkColorPriv.h for packing)
56 : /**
57 : * Custom compressed format, not supported on all platforms.
58 : * Cannot be used as a destination (target of a canvas).
59 : * i.e. you may be able to draw from one, but you cannot draw into one.
60 : */
61 : kRLE_Index8_Config,
62 :
63 : kConfigCount
64 : };
65 :
66 : /** Default construct creates a bitmap with zero width and height, and no pixels.
67 : Its config is set to kNo_Config.
68 : */
69 : SkBitmap();
70 : /** Constructor initializes the new bitmap by copying the src bitmap. All fields are copied,
71 : but ownership of the pixels remains with the src bitmap.
72 : */
73 : SkBitmap(const SkBitmap& src);
74 : /** Decrements our (shared) pixel ownership if needed.
75 : */
76 : ~SkBitmap();
77 :
78 : /** Copies the src bitmap into this bitmap. Ownership of the src bitmap's pixels remains
79 : with the src bitmap.
80 : */
81 : SkBitmap& operator=(const SkBitmap& src);
82 : /** Swap the fields of the two bitmaps. This routine is guaranteed to never fail or throw.
83 : */
84 : // This method is not exported to java.
85 : void swap(SkBitmap& other);
86 :
87 : /** Return true iff the bitmap has empty dimensions.
88 : */
89 : bool empty() const { return 0 == fWidth || 0 == fHeight; }
90 :
91 : /** Return true iff the bitmap has no pixels nor a pixelref. Note: this can
92 : return true even if the dimensions of the bitmap are > 0 (see empty()).
93 : */
94 : bool isNull() const { return NULL == fPixels && NULL == fPixelRef; }
95 :
96 : /** Return the config for the bitmap.
97 : */
98 0 : Config config() const { return (Config)fConfig; }
99 : /** DEPRECATED, use config()
100 : */
101 0 : Config getConfig() const { return this->config(); }
102 : /** Return the bitmap's width, in pixels.
103 : */
104 0 : int width() const { return fWidth; }
105 : /** Return the bitmap's height, in pixels.
106 : */
107 0 : int height() const { return fHeight; }
108 : /** Return the number of bytes between subsequent rows of the bitmap.
109 : */
110 0 : int rowBytes() const { return fRowBytes; }
111 :
112 : /** Return the shift amount per pixel (i.e. 0 for 1-byte per pixel, 1 for
113 : 2-bytes per pixel configs, 2 for 4-bytes per pixel configs). Return 0
114 : for configs that are not at least 1-byte per pixel (e.g. kA1_Config
115 : or kNo_Config)
116 : */
117 : int shiftPerPixel() const { return fBytesPerPixel >> 1; }
118 :
119 : /** Return the number of bytes per pixel based on the config. If the config
120 : does not have at least 1 byte per (e.g. kA1_Config) then 0 is returned.
121 : */
122 : int bytesPerPixel() const { return fBytesPerPixel; }
123 :
124 : /** Return the rowbytes expressed as a number of pixels (like width and
125 : height). Note, for 1-byte per pixel configs like kA8_Config, this will
126 : return the same as rowBytes(). Is undefined for configs that are less
127 : than 1-byte per pixel (e.g. kA1_Config)
128 : */
129 : int rowBytesAsPixels() const { return fRowBytes >> (fBytesPerPixel >> 1); }
130 :
131 : /** Return the address of the pixels for this SkBitmap.
132 : */
133 0 : void* getPixels() const { return fPixels; }
134 :
135 : /** Return the byte size of the pixels, based on the height and rowBytes.
136 : Note this truncates the result to 32bits. Call getSize64() to detect
137 : if the real size exceeds 32bits.
138 : */
139 : size_t getSize() const { return fHeight * fRowBytes; }
140 :
141 : /** Return the number of bytes from the pointer returned by getPixels()
142 : to the end of the allocated space in the buffer. Required in
143 : cases where extractBitmap has been called.
144 : */
145 : size_t getSafeSize() const ;
146 :
147 : /** Return the byte size of the pixels, based on the height and rowBytes.
148 : This routine is slightly slower than getSize(), but does not truncate
149 : the answer to 32bits.
150 : */
151 : Sk64 getSize64() const {
152 : Sk64 size;
153 : size.setMul(fHeight, fRowBytes);
154 : return size;
155 : }
156 :
157 : /** Same as getSafeSize(), but does not truncate the answer to 32bits.
158 : */
159 : Sk64 getSafeSize64() const ;
160 :
161 : /** Returns true if this bitmap is marked as immutable, meaning that the
162 : contents of its pixels will not change for the lifetime of the bitmap.
163 : */
164 : bool isImmutable() const;
165 :
166 : /** Marks this bitmap as immutable, meaning that the contents of its
167 : pixels will not change for the lifetime of the bitmap and of the
168 : underlying pixelref. This state can be set, but it cannot be
169 : cleared once it is set. This state propagates to all other bitmaps
170 : that share the same pixelref.
171 : */
172 : void setImmutable();
173 :
174 : /** Returns true if the bitmap is opaque (has no translucent/transparent pixels).
175 : */
176 : bool isOpaque() const;
177 :
178 : /** Specify if this bitmap's pixels are all opaque or not. Is only meaningful for configs
179 : that support per-pixel alpha (RGB32, A1, A8).
180 : */
181 : void setIsOpaque(bool);
182 :
183 : /** Returns true if the bitmap is volatile (i.e. should not be cached by devices.)
184 : */
185 : bool isVolatile() const;
186 :
187 : /** Specify whether this bitmap is volatile. Bitmaps are not volatile by
188 : default. Temporary bitmaps that are discarded after use should be
189 : marked as volatile. This provides a hint to the device that the bitmap
190 : should not be cached. Providing this hint when appropriate can
191 : improve performance by avoiding unnecessary overhead and resource
192 : consumption on the device.
193 : */
194 : void setIsVolatile(bool);
195 :
196 : /** Reset the bitmap to its initial state (see default constructor). If we are a (shared)
197 : owner of the pixels, that ownership is decremented.
198 : */
199 : void reset();
200 :
201 : /** Given a config and a width, this computes the optimal rowBytes value. This is called automatically
202 : if you pass 0 for rowBytes to setConfig().
203 : */
204 : static int ComputeRowBytes(Config c, int width);
205 :
206 : /** Return the bytes-per-pixel for the specified config. If the config is
207 : not at least 1-byte per pixel, return 0, including for kNo_Config.
208 : */
209 : static int ComputeBytesPerPixel(Config c);
210 :
211 : /** Return the shift-per-pixel for the specified config. If the config is
212 : not at least 1-byte per pixel, return 0, including for kNo_Config.
213 : */
214 : static int ComputeShiftPerPixel(Config c) {
215 : return ComputeBytesPerPixel(c) >> 1;
216 : }
217 :
218 : static Sk64 ComputeSize64(Config, int width, int height);
219 : static size_t ComputeSize(Config, int width, int height);
220 :
221 : /** Set the bitmap's config and dimensions. If rowBytes is 0, then
222 : ComputeRowBytes() is called to compute the optimal value. This resets
223 : any pixel/colortable ownership, just like reset().
224 : */
225 : void setConfig(Config, int width, int height, int rowBytes = 0);
226 : /** Use this to assign a new pixel address for an existing bitmap. This
227 : will automatically release any pixelref previously installed. Only call
228 : this if you are handling ownership/lifetime of the pixel memory.
229 :
230 : If the bitmap retains a reference to the colortable (assuming it is
231 : not null) it will take care of incrementing the reference count.
232 :
233 : @param pixels Address for the pixels, managed by the caller.
234 : @param ctable ColorTable (or null) that matches the specified pixels
235 : */
236 : void setPixels(void* p, SkColorTable* ctable = NULL);
237 :
238 : /** Copies the bitmap's pixels to the location pointed at by dst and returns
239 : true if possible, returns false otherwise.
240 :
241 : In the case when the dstRowBytes matches the bitmap's rowBytes, the copy
242 : may be made faster by copying over the dst's per-row padding (for all
243 : rows but the last). By setting preserveDstPad to true the caller can
244 : disable this optimization and ensure that pixels in the padding are not
245 : overwritten.
246 :
247 : Always returns false for RLE formats.
248 :
249 : @param dst Location of destination buffer.
250 : @param dstSize Size of destination buffer. Must be large enough to hold
251 : pixels using indicated stride.
252 : @param dstRowBytes Width of each line in the buffer. If -1, uses
253 : bitmap's internal stride.
254 : @param preserveDstPad Must we preserve padding in the dst
255 : */
256 : bool copyPixelsTo(void* const dst, size_t dstSize, int dstRowBytes = -1,
257 : bool preserveDstPad = false)
258 : const;
259 :
260 : /** Use the standard HeapAllocator to create the pixelref that manages the
261 : pixel memory. It will be sized based on the current width/height/config.
262 : If this is called multiple times, a new pixelref object will be created
263 : each time.
264 :
265 : If the bitmap retains a reference to the colortable (assuming it is
266 : not null) it will take care of incrementing the reference count.
267 :
268 : @param ctable ColorTable (or null) to use with the pixels that will
269 : be allocated. Only used if config == Index8_Config
270 : @return true if the allocation succeeds. If not the pixelref field of
271 : the bitmap will be unchanged.
272 : */
273 0 : bool allocPixels(SkColorTable* ctable = NULL) {
274 0 : return this->allocPixels(NULL, ctable);
275 : }
276 :
277 : /** Use the specified Allocator to create the pixelref that manages the
278 : pixel memory. It will be sized based on the current width/height/config.
279 : If this is called multiple times, a new pixelref object will be created
280 : each time.
281 :
282 : If the bitmap retains a reference to the colortable (assuming it is
283 : not null) it will take care of incrementing the reference count.
284 :
285 : @param allocator The Allocator to use to create a pixelref that can
286 : manage the pixel memory for the current
287 : width/height/config. If allocator is NULL, the standard
288 : HeapAllocator will be used.
289 : @param ctable ColorTable (or null) to use with the pixels that will
290 : be allocated. Only used if config == Index8_Config.
291 : If it is non-null and the config is not Index8, it will
292 : be ignored.
293 : @return true if the allocation succeeds. If not the pixelref field of
294 : the bitmap will be unchanged.
295 : */
296 : bool allocPixels(Allocator* allocator, SkColorTable* ctable);
297 :
298 : /** Return the current pixelref object, if any
299 : */
300 : SkPixelRef* pixelRef() const { return fPixelRef; }
301 : /** Return the offset into the pixelref, if any. Will return 0 if there is
302 : no pixelref installed.
303 : */
304 : size_t pixelRefOffset() const { return fPixelRefOffset; }
305 : /** Assign a pixelref and optional offset. Pixelrefs are reference counted,
306 : so the existing one (if any) will be unref'd and the new one will be
307 : ref'd.
308 : */
309 : SkPixelRef* setPixelRef(SkPixelRef* pr, size_t offset = 0);
310 :
311 : /** Call this to ensure that the bitmap points to the current pixel address
312 : in the pixelref. Balance it with a call to unlockPixels(). These calls
313 : are harmless if there is no pixelref.
314 : */
315 : void lockPixels() const;
316 : /** When you are finished access the pixel memory, call this to balance a
317 : previous call to lockPixels(). This allows pixelrefs that implement
318 : cached/deferred image decoding to know when there are active clients of
319 : a given image.
320 : */
321 : void unlockPixels() const;
322 :
323 : /**
324 : * Some bitmaps can return a copy of their pixels for lockPixels(), but
325 : * that copy, if modified, will not be pushed back. These bitmaps should
326 : * not be used as targets for a raster device/canvas (since all pixels
327 : * modifications will be lost when unlockPixels() is called.)
328 : */
329 : bool lockPixelsAreWritable() const;
330 :
331 : /** Call this to be sure that the bitmap is valid enough to be drawn (i.e.
332 : it has non-null pixels, and if required by its config, it has a
333 : non-null colortable. Returns true if all of the above are met.
334 : */
335 : bool readyToDraw() const {
336 : return this->getPixels() != NULL &&
337 : ((this->config() != kIndex8_Config &&
338 : this->config() != kRLE_Index8_Config) ||
339 : fColorTable != NULL);
340 : }
341 :
342 : /** Returns the pixelRef's texture, or NULL
343 : */
344 : SkGpuTexture* getTexture() const;
345 :
346 : /** Return the bitmap's colortable (if any). Does not affect the colortable's
347 : reference count.
348 : */
349 : SkColorTable* getColorTable() const { return fColorTable; }
350 :
351 : /** Returns a non-zero, unique value corresponding to the pixels in our
352 : pixelref (or raw pixels set via setPixels). Each time the pixels are
353 : changed (and notifyPixelsChanged is called), a different generation ID
354 : will be returned.
355 : */
356 : uint32_t getGenerationID() const;
357 :
358 : /** Call this if you have changed the contents of the pixels. This will in-
359 : turn cause a different generation ID value to be returned from
360 : getGenerationID().
361 : */
362 : void notifyPixelsChanged() const;
363 :
364 : /** Initialize the bitmap's pixels with the specified color+alpha, automatically converting into the correct format
365 : for the bitmap's config. If the config is kRGB_565_Config, then the alpha value is ignored.
366 : If the config is kA8_Config, then the r,g,b parameters are ignored.
367 : */
368 : void eraseARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b) const;
369 : /** Initialize the bitmap's pixels with the specified color+alpha, automatically converting into the correct format
370 : for the bitmap's config. If the config is kRGB_565_Config, then the alpha value is presumed
371 : to be 0xFF. If the config is kA8_Config, then the r,g,b parameters are ignored and the
372 : pixels are all set to 0xFF.
373 : */
374 : void eraseRGB(U8CPU r, U8CPU g, U8CPU b) const {
375 : this->eraseARGB(0xFF, r, g, b);
376 : }
377 : /** Initialize the bitmap's pixels with the specified color, automatically converting into the correct format
378 : for the bitmap's config. If the config is kRGB_565_Config, then the color's alpha value is presumed
379 : to be 0xFF. If the config is kA8_Config, then only the color's alpha value is used.
380 : */
381 : void eraseColor(SkColor c) const {
382 : this->eraseARGB(SkColorGetA(c), SkColorGetR(c), SkColorGetG(c),
383 : SkColorGetB(c));
384 : }
385 :
386 : /** Scroll (a subset of) the contents of this bitmap by dx/dy. If there are
387 : no pixels allocated (i.e. getPixels() returns null) the method will
388 : still update the inval region (if present).
389 :
390 : @param subset The subset of the bitmap to scroll/move. To scroll the
391 : entire contents, specify [0, 0, width, height] or just
392 : pass null.
393 : @param dx The amount to scroll in X
394 : @param dy The amount to scroll in Y
395 : @param inval Optional (may be null). Returns the area of the bitmap that
396 : was scrolled away. E.g. if dx = dy = 0, then inval would
397 : be set to empty. If dx >= width or dy >= height, then
398 : inval would be set to the entire bounds of the bitmap.
399 : @return true if the scroll was doable. Will return false if the bitmap
400 : uses an unsupported config for scrolling (only kA8,
401 : kIndex8, kRGB_565, kARGB_4444, kARGB_8888 are supported).
402 : If no pixels are present (i.e. getPixels() returns false)
403 : inval will still be updated, and true will be returned.
404 : */
405 : bool scrollRect(const SkIRect* subset, int dx, int dy,
406 : SkRegion* inval = NULL) const;
407 :
408 : /**
409 : * Return the SkColor of the specified pixel. In most cases this will
410 : * require un-premultiplying the color. Alpha only configs (A1 and A8)
411 : * return black with the appropriate alpha set. The value is undefined
412 : * for kNone_Config or if x or y are out of bounds, or if the bitmap
413 : * does not have any pixels (or has not be locked with lockPixels()).
414 : */
415 : SkColor getColor(int x, int y) const;
416 :
417 : /** Returns the address of the specified pixel. This performs a runtime
418 : check to know the size of the pixels, and will return the same answer
419 : as the corresponding size-specific method (e.g. getAddr16). Since the
420 : check happens at runtime, it is much slower than using a size-specific
421 : version. Unlike the size-specific methods, this routine also checks if
422 : getPixels() returns null, and returns that. The size-specific routines
423 : perform a debugging assert that getPixels() is not null, but they do
424 : not do any runtime checks.
425 : */
426 : void* getAddr(int x, int y) const;
427 :
428 : /** Returns the address of the pixel specified by x,y for 32bit pixels.
429 : * In debug build, this asserts that the pixels are allocated and locked,
430 : * and that the config is 32-bit, however none of these checks are performed
431 : * in the release build.
432 : */
433 : inline uint32_t* getAddr32(int x, int y) const;
434 :
435 : /** Returns the address of the pixel specified by x,y for 16bit pixels.
436 : * In debug build, this asserts that the pixels are allocated and locked,
437 : * and that the config is 16-bit, however none of these checks are performed
438 : * in the release build.
439 : */
440 : inline uint16_t* getAddr16(int x, int y) const;
441 :
442 : /** Returns the address of the pixel specified by x,y for 8bit pixels.
443 : * In debug build, this asserts that the pixels are allocated and locked,
444 : * and that the config is 8-bit, however none of these checks are performed
445 : * in the release build.
446 : */
447 : inline uint8_t* getAddr8(int x, int y) const;
448 :
449 : /** Returns the address of the byte containing the pixel specified by x,y
450 : * for 1bit pixels.
451 : * In debug build, this asserts that the pixels are allocated and locked,
452 : * and that the config is 1-bit, however none of these checks are performed
453 : * in the release build.
454 : */
455 : inline uint8_t* getAddr1(int x, int y) const;
456 :
457 : /** Returns the color corresponding to the pixel specified by x,y for
458 : * colortable based bitmaps.
459 : * In debug build, this asserts that the pixels are allocated and locked,
460 : * that the config is kIndex8, and that the colortable is allocated,
461 : * however none of these checks are performed in the release build.
462 : */
463 : inline SkPMColor getIndex8Color(int x, int y) const;
464 :
465 : /** Set dst to be a setset of this bitmap. If possible, it will share the
466 : pixel memory, and just point into a subset of it. However, if the config
467 : does not support this, a local copy will be made and associated with
468 : the dst bitmap. If the subset rectangle, intersected with the bitmap's
469 : dimensions is empty, or if there is an unsupported config, false will be
470 : returned and dst will be untouched.
471 : @param dst The bitmap that will be set to a subset of this bitmap
472 : @param subset The rectangle of pixels in this bitmap that dst will
473 : reference.
474 : @return true if the subset copy was successfully made.
475 : */
476 : bool extractSubset(SkBitmap* dst, const SkIRect& subset) const;
477 :
478 : /** Makes a deep copy of this bitmap, respecting the requested config,
479 : * and allocating the dst pixels on the cpu.
480 : * Returns false if either there is an error (i.e. the src does not have
481 : * pixels) or the request cannot be satisfied (e.g. the src has per-pixel
482 : * alpha, and the requested config does not support alpha).
483 : * @param dst The bitmap to be sized and allocated
484 : * @param c The desired config for dst
485 : * @param allocator Allocator used to allocate the pixelref for the dst
486 : * bitmap. If this is null, the standard HeapAllocator
487 : * will be used.
488 : * @return true if the copy could be made.
489 : */
490 : bool copyTo(SkBitmap* dst, Config c, Allocator* allocator = NULL) const;
491 :
492 : /** Makes a deep copy of this bitmap, respecting the requested config, and
493 : * with custom allocation logic that will keep the copied pixels
494 : * in the same domain as the source: If the src pixels are allocated for
495 : * the cpu, then so will the dst. If the src pixels are allocated on the
496 : * gpu (typically as a texture), the it will do the same for the dst.
497 : * If the request cannot be fulfilled, returns false and dst is unmodified.
498 : */
499 : bool deepCopyTo(SkBitmap* dst, Config c) const;
500 :
501 : /** Returns true if this bitmap can be deep copied into the requested config
502 : by calling copyTo().
503 : */
504 : bool canCopyTo(Config newConfig) const;
505 :
506 : bool hasMipMap() const;
507 : void buildMipMap(bool forceRebuild = false);
508 : void freeMipMap();
509 :
510 : /** Given scale factors sx, sy, determine the miplevel available in the
511 : bitmap, and return it (this is the amount to shift matrix iterators
512 : by). If dst is not null, it is set to the correct level.
513 : */
514 : int extractMipLevel(SkBitmap* dst, SkFixed sx, SkFixed sy);
515 :
516 : bool extractAlpha(SkBitmap* dst) const {
517 : return this->extractAlpha(dst, NULL, NULL, NULL);
518 : }
519 :
520 : bool extractAlpha(SkBitmap* dst, const SkPaint* paint,
521 : SkIPoint* offset) const {
522 : return this->extractAlpha(dst, paint, NULL, offset);
523 : }
524 :
525 : /** Set dst to contain alpha layer of this bitmap. If destination bitmap
526 : fails to be initialized, e.g. because allocator can't allocate pixels
527 : for it, dst will not be modified and false will be returned.
528 :
529 : @param dst The bitmap to be filled with alpha layer
530 : @param paint The paint to draw with
531 : @param allocator Allocator used to allocate the pixelref for the dst
532 : bitmap. If this is null, the standard HeapAllocator
533 : will be used.
534 : @param offset If not null, it is set to top-left coordinate to position
535 : the returned bitmap so that it visually lines up with the
536 : original
537 : */
538 : bool extractAlpha(SkBitmap* dst, const SkPaint* paint, Allocator* allocator,
539 : SkIPoint* offset) const;
540 :
541 : void flatten(SkFlattenableWriteBuffer&) const;
542 : void unflatten(SkFlattenableReadBuffer&);
543 :
544 : SkDEBUGCODE(void validate() const;)
545 :
546 : class Allocator : public SkRefCnt {
547 : public:
548 : /** Allocate the pixel memory for the bitmap, given its dimensions and
549 : config. Return true on success, where success means either setPixels
550 : or setPixelRef was called. The pixels need not be locked when this
551 : returns. If the config requires a colortable, it also must be
552 : installed via setColorTable. If false is returned, the bitmap and
553 : colortable should be left unchanged.
554 : */
555 : virtual bool allocPixelRef(SkBitmap*, SkColorTable*) = 0;
556 : };
557 :
558 : /** Subclass of Allocator that returns a pixelref that allocates its pixel
559 : memory from the heap. This is the default Allocator invoked by
560 : allocPixels().
561 : */
562 : class HeapAllocator : public Allocator {
563 : public:
564 : virtual bool allocPixelRef(SkBitmap*, SkColorTable*);
565 : };
566 :
567 : class RLEPixels {
568 : public:
569 : RLEPixels(int width, int height);
570 : virtual ~RLEPixels();
571 :
572 : uint8_t* packedAtY(int y) const {
573 : SkASSERT((unsigned)y < (unsigned)fHeight);
574 : return fYPtrs[y];
575 : }
576 :
577 : // called by subclasses during creation
578 : void setPackedAtY(int y, uint8_t* addr) {
579 : SkASSERT((unsigned)y < (unsigned)fHeight);
580 : fYPtrs[y] = addr;
581 : }
582 :
583 : private:
584 : uint8_t** fYPtrs;
585 : int fHeight;
586 : };
587 :
588 : private:
589 : struct MipMap;
590 : mutable MipMap* fMipMap;
591 :
592 : mutable SkPixelRef* fPixelRef;
593 : mutable size_t fPixelRefOffset;
594 : mutable int fPixelLockCount;
595 : // either user-specified (in which case it is not treated as mutable)
596 : // or a cache of the returned value from fPixelRef->lockPixels()
597 : mutable void* fPixels;
598 : mutable SkColorTable* fColorTable; // only meaningful for kIndex8
599 : // When there is no pixel ref (setPixels was called) we still need a
600 : // gen id for SkDevice implementations that may cache a copy of the
601 : // pixels (e.g. as a gpu texture)
602 : mutable int fRawPixelGenerationID;
603 :
604 : enum Flags {
605 : kImageIsOpaque_Flag = 0x01,
606 : kImageIsVolatile_Flag = 0x02,
607 : kImageIsImmutable_Flag = 0x04
608 : };
609 :
610 : uint32_t fRowBytes;
611 : uint32_t fWidth;
612 : uint32_t fHeight;
613 : uint8_t fConfig;
614 : uint8_t fFlags;
615 : uint8_t fBytesPerPixel; // based on config
616 :
617 : /* Internal computations for safe size.
618 : */
619 : static Sk64 ComputeSafeSize64(Config config,
620 : uint32_t width,
621 : uint32_t height,
622 : uint32_t rowBytes);
623 : static size_t ComputeSafeSize(Config config,
624 : uint32_t width,
625 : uint32_t height,
626 : uint32_t rowBytes);
627 :
628 : /* Unreference any pixelrefs or colortables
629 : */
630 : void freePixels();
631 : void updatePixelsFromRef() const;
632 :
633 : static SkFixed ComputeMipLevel(SkFixed sx, SkFixed dy);
634 : };
635 :
636 : /** \class SkColorTable
637 :
638 : SkColorTable holds an array SkPMColors (premultiplied 32-bit colors) used by
639 : 8-bit bitmaps, where the bitmap bytes are interpreted as indices into the colortable.
640 : */
641 : class SkColorTable : public SkRefCnt {
642 : public:
643 : /** Makes a deep copy of colors.
644 : */
645 : SkColorTable(const SkColorTable& src);
646 : /** Preallocates the colortable to have 'count' colors, which
647 : * are initially set to 0.
648 : */
649 : explicit SkColorTable(int count);
650 : explicit SkColorTable(SkFlattenableReadBuffer&);
651 : SkColorTable(const SkPMColor colors[], int count);
652 : virtual ~SkColorTable();
653 :
654 : enum Flags {
655 : kColorsAreOpaque_Flag = 0x01 //!< if set, all of the colors in the table are opaque (alpha==0xFF)
656 : };
657 : /** Returns the flag bits for the color table. These can be changed with setFlags().
658 : */
659 : unsigned getFlags() const { return fFlags; }
660 : /** Set the flags for the color table. See the Flags enum for possible values.
661 : */
662 : void setFlags(unsigned flags);
663 :
664 : bool isOpaque() const { return (fFlags & kColorsAreOpaque_Flag) != 0; }
665 : void setIsOpaque(bool isOpaque);
666 :
667 : /** Returns the number of colors in the table.
668 : */
669 : int count() const { return fCount; }
670 :
671 : /** Returns the specified color from the table. In the debug build, this asserts that
672 : the index is in range (0 <= index < count).
673 : */
674 : SkPMColor operator[](int index) const {
675 : SkASSERT(fColors != NULL && (unsigned)index < fCount);
676 : return fColors[index];
677 : }
678 :
679 : /** Specify the number of colors in the color table. This does not initialize the colors
680 : to any value, just allocates memory for them. To initialize the values, either call
681 : setColors(array, count), or follow setCount(count) with a call to
682 : lockColors()/{set the values}/unlockColors(true).
683 : */
684 : // void setColors(int count) { this->setColors(NULL, count); }
685 : // void setColors(const SkPMColor[], int count);
686 :
687 : /** Return the array of colors for reading and/or writing. This must be
688 : balanced by a call to unlockColors(changed?), telling the colortable if
689 : the colors were changed during the lock.
690 : */
691 : SkPMColor* lockColors() {
692 : SkDEBUGCODE(fColorLockCount += 1;)
693 : return fColors;
694 : }
695 : /** Balancing call to lockColors(). If the colors have been changed, pass true.
696 : */
697 : void unlockColors(bool changed);
698 :
699 : /** Similar to lockColors(), lock16BitCache() returns the array of
700 : RGB16 colors that mirror the 32bit colors. However, this function
701 : will return null if kColorsAreOpaque_Flag is not set.
702 : Also, unlike lockColors(), the returned array here cannot be modified.
703 : */
704 : const uint16_t* lock16BitCache();
705 : /** Balancing call to lock16BitCache().
706 : */
707 : void unlock16BitCache() {
708 : SkASSERT(f16BitCacheLockCount > 0);
709 : SkDEBUGCODE(f16BitCacheLockCount -= 1);
710 : }
711 :
712 : void flatten(SkFlattenableWriteBuffer&) const;
713 :
714 : private:
715 : SkPMColor* fColors;
716 : uint16_t* f16BitCache;
717 : uint16_t fCount;
718 : uint8_t fFlags;
719 : SkDEBUGCODE(int fColorLockCount;)
720 : SkDEBUGCODE(int f16BitCacheLockCount;)
721 :
722 : void inval16BitCache();
723 : };
724 :
725 : class SkAutoLockPixels : public SkNoncopyable {
726 : public:
727 : SkAutoLockPixels(const SkBitmap& bm, bool doLock = true) : fBitmap(bm) {
728 : fDidLock = doLock;
729 : if (doLock) {
730 : bm.lockPixels();
731 : }
732 : }
733 : ~SkAutoLockPixels() {
734 : if (fDidLock) {
735 : fBitmap.unlockPixels();
736 : }
737 : }
738 :
739 : private:
740 : const SkBitmap& fBitmap;
741 : bool fDidLock;
742 : };
743 :
744 : /** Helper class that performs the lock/unlockColors calls on a colortable.
745 : The destructor will call unlockColors(false) if it has a bitmap's colortable
746 : */
747 : class SkAutoLockColors : public SkNoncopyable {
748 : public:
749 : /** Initialize with no bitmap. Call lockColors(bitmap) to lock bitmap's
750 : colortable
751 : */
752 : SkAutoLockColors() : fCTable(NULL), fColors(NULL) {}
753 : /** Initialize with bitmap, locking its colortable if present
754 : */
755 : explicit SkAutoLockColors(const SkBitmap& bm) {
756 : fCTable = bm.getColorTable();
757 : fColors = fCTable ? fCTable->lockColors() : NULL;
758 : }
759 : /** Initialize with a colortable (may be null)
760 : */
761 : explicit SkAutoLockColors(SkColorTable* ctable) {
762 : fCTable = ctable;
763 : fColors = ctable ? ctable->lockColors() : NULL;
764 : }
765 : ~SkAutoLockColors() {
766 : if (fCTable) {
767 : fCTable->unlockColors(false);
768 : }
769 : }
770 :
771 : /** Return the currently locked colors, or NULL if no bitmap's colortable
772 : is currently locked.
773 : */
774 : const SkPMColor* colors() const { return fColors; }
775 :
776 : /** Locks the table and returns is colors (assuming ctable is not null) and
777 : unlocks the previous table if one was present
778 : */
779 : const SkPMColor* lockColors(SkColorTable* ctable) {
780 : if (fCTable) {
781 : fCTable->unlockColors(false);
782 : }
783 : fCTable = ctable;
784 : fColors = ctable ? ctable->lockColors() : NULL;
785 : return fColors;
786 : }
787 :
788 : const SkPMColor* lockColors(const SkBitmap& bm) {
789 : return this->lockColors(bm.getColorTable());
790 : }
791 :
792 : private:
793 : SkColorTable* fCTable;
794 : const SkPMColor* fColors;
795 : };
796 :
797 : ///////////////////////////////////////////////////////////////////////////////
798 :
799 : inline uint32_t* SkBitmap::getAddr32(int x, int y) const {
800 : SkASSERT(fPixels);
801 : SkASSERT(fConfig == kARGB_8888_Config);
802 : SkASSERT((unsigned)x < fWidth && (unsigned)y < fHeight);
803 : return (uint32_t*)((char*)fPixels + y * fRowBytes + (x << 2));
804 : }
805 :
806 : inline uint16_t* SkBitmap::getAddr16(int x, int y) const {
807 : SkASSERT(fPixels);
808 : SkASSERT(fConfig == kRGB_565_Config || fConfig == kARGB_4444_Config);
809 : SkASSERT((unsigned)x < fWidth && (unsigned)y < fHeight);
810 : return (uint16_t*)((char*)fPixels + y * fRowBytes + (x << 1));
811 : }
812 :
813 : inline uint8_t* SkBitmap::getAddr8(int x, int y) const {
814 : SkASSERT(fPixels);
815 : SkASSERT(fConfig == kA8_Config || fConfig == kIndex8_Config);
816 : SkASSERT((unsigned)x < fWidth && (unsigned)y < fHeight);
817 : return (uint8_t*)fPixels + y * fRowBytes + x;
818 : }
819 :
820 : inline SkPMColor SkBitmap::getIndex8Color(int x, int y) const {
821 : SkASSERT(fPixels);
822 : SkASSERT(fConfig == kIndex8_Config);
823 : SkASSERT((unsigned)x < fWidth && (unsigned)y < fHeight);
824 : SkASSERT(fColorTable);
825 : return (*fColorTable)[*((const uint8_t*)fPixels + y * fRowBytes + x)];
826 : }
827 :
828 : // returns the address of the byte that contains the x coordinate
829 : inline uint8_t* SkBitmap::getAddr1(int x, int y) const {
830 : SkASSERT(fPixels);
831 : SkASSERT(fConfig == kA1_Config);
832 : SkASSERT((unsigned)x < fWidth && (unsigned)y < fHeight);
833 : return (uint8_t*)fPixels + y * fRowBytes + (x >> 3);
834 : }
835 :
836 : #endif
|