diff -r 000000000000 -r 6474c204b198 gfx/skia/trunk/include/core/SkBitmap.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gfx/skia/trunk/include/core/SkBitmap.h Wed Dec 31 06:09:35 2014 +0100 @@ -0,0 +1,927 @@ +/* + * Copyright 2006 The Android Open Source Project + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +#ifndef SkBitmap_DEFINED +#define SkBitmap_DEFINED + +#include "SkColor.h" +#include "SkColorTable.h" +#include "SkImageInfo.h" +#include "SkPoint.h" +#include "SkRefCnt.h" + +struct SkMask; +struct SkIRect; +struct SkRect; +class SkPaint; +class SkPixelRef; +class SkPixelRefFactory; +class SkRegion; +class SkString; +class GrTexture; + +/** \class SkBitmap + + The SkBitmap class specifies a raster bitmap. A bitmap has an integer width + and height, and a format (config), and a pointer to the actual pixels. + Bitmaps can be drawn into a SkCanvas, but they are also used to specify the + target of a SkCanvas' drawing operations. + A const SkBitmap exposes getAddr(), which lets a caller write its pixels; + the constness is considered to apply to the bitmap's configuration, not + its contents. +*/ +class SK_API SkBitmap { +public: + class SK_API Allocator; + + enum Config { + kNo_Config, //!< bitmap has not been configured + kA8_Config, //!< 8-bits per pixel, with only alpha specified (0 is transparent, 0xFF is opaque) + kIndex8_Config, //!< 8-bits per pixel, using SkColorTable to specify the colors + kRGB_565_Config, //!< 16-bits per pixel, (see SkColorPriv.h for packing) + kARGB_4444_Config, //!< 16-bits per pixel, (see SkColorPriv.h for packing) + kARGB_8888_Config, //!< 32-bits per pixel, (see SkColorPriv.h for packing) + }; + + // do not add this to the Config enum, otherwise the compiler will let us + // pass this as a valid parameter for Config. + enum { + kConfigCount = kARGB_8888_Config + 1 + }; + + /** + * Default construct creates a bitmap with zero width and height, and no pixels. + * Its config is set to kNo_Config. + */ + SkBitmap(); + + /** + * Copy the settings from the src into this bitmap. If the src has pixels + * allocated, they will be shared, not copied, so that the two bitmaps will + * reference the same memory for the pixels. If a deep copy is needed, + * where the new bitmap has its own separate copy of the pixels, use + * deepCopyTo(). + */ + SkBitmap(const SkBitmap& src); + + ~SkBitmap(); + + /** Copies the src bitmap into this bitmap. Ownership of the src bitmap's pixels remains + with the src bitmap. + */ + SkBitmap& operator=(const SkBitmap& src); + /** Swap the fields of the two bitmaps. This routine is guaranteed to never fail or throw. + */ + // This method is not exported to java. + void swap(SkBitmap& other); + + /////////////////////////////////////////////////////////////////////////// + + const SkImageInfo& info() const { return fInfo; } + + int width() const { return fInfo.fWidth; } + int height() const { return fInfo.fHeight; } + SkColorType colorType() const { return fInfo.fColorType; } + SkAlphaType alphaType() const { return fInfo.fAlphaType; } + + /** Return the number of bytes per pixel based on the config. If the config + does not have at least 1 byte per (e.g. kA1_Config) then 0 is returned. + */ + int bytesPerPixel() const { return fInfo.bytesPerPixel(); } + + /** Return the rowbytes expressed as a number of pixels (like width and + height). Note, for 1-byte per pixel configs like kA8_Config, this will + return the same as rowBytes(). Is undefined for configs that are less + than 1-byte per pixel (e.g. kA1_Config) + */ + int rowBytesAsPixels() const { + return fRowBytes >> this->shiftPerPixel(); + } + + /** Return the shift amount per pixel (i.e. 0 for 1-byte per pixel, 1 for + 2-bytes per pixel configs, 2 for 4-bytes per pixel configs). Return 0 + for configs that are not at least 1-byte per pixel (e.g. kA1_Config + or kNo_Config) + */ + int shiftPerPixel() const { return this->bytesPerPixel() >> 1; } + + /////////////////////////////////////////////////////////////////////////// + + /** Return true iff the bitmap has empty dimensions. + * Hey! Before you use this, see if you really want to know drawsNothing() instead. + */ + bool empty() const { return fInfo.isEmpty(); } + + /** Return true iff the bitmap has no pixelref. Note: this can return true even if the + * dimensions of the bitmap are > 0 (see empty()). + * Hey! Before you use this, see if you really want to know drawsNothing() instead. + */ + bool isNull() const { return NULL == fPixelRef; } + + /** Return true iff drawing this bitmap has no effect. + */ + bool drawsNothing() const { return this->empty() || this->isNull(); } + + /** Return the config for the bitmap. */ + Config config() const; + + SK_ATTR_DEPRECATED("use config()") + Config getConfig() const { return this->config(); } + + /** Return the number of bytes between subsequent rows of the bitmap. */ + size_t rowBytes() const { return fRowBytes; } + + /** + * Set the bitmap's alphaType, returning true on success. If false is + * returned, then the specified new alphaType is incompatible with the + * Config, and the current alphaType is unchanged. + * + * Note: this changes the alphatype for the underlying pixels, which means + * that all bitmaps that might be sharing (subsets of) the pixels will + * be affected. + */ + bool setAlphaType(SkAlphaType); + + /** Return the address of the pixels for this SkBitmap. + */ + void* getPixels() const { return fPixels; } + + /** Return the byte size of the pixels, based on the height and rowBytes. + Note this truncates the result to 32bits. Call getSize64() to detect + if the real size exceeds 32bits. + */ + size_t getSize() const { return fInfo.fHeight * fRowBytes; } + + /** Return the number of bytes from the pointer returned by getPixels() + to the end of the allocated space in the buffer. Required in + cases where extractSubset has been called. + */ + size_t getSafeSize() const { return fInfo.getSafeSize(fRowBytes); } + + /** + * Return the full size of the bitmap, in bytes. + */ + int64_t computeSize64() const { + return sk_64_mul(fInfo.fHeight, fRowBytes); + } + + /** + * Return the number of bytes from the pointer returned by getPixels() + * to the end of the allocated space in the buffer. This may be smaller + * than computeSize64() if there is any rowbytes padding beyond the width. + */ + int64_t computeSafeSize64() const { + return fInfo.getSafeSize64(fRowBytes); + } + + /** Returns true if this bitmap is marked as immutable, meaning that the + contents of its pixels will not change for the lifetime of the bitmap. + */ + bool isImmutable() const; + + /** Marks this bitmap as immutable, meaning that the contents of its + pixels will not change for the lifetime of the bitmap and of the + underlying pixelref. This state can be set, but it cannot be + cleared once it is set. This state propagates to all other bitmaps + that share the same pixelref. + */ + void setImmutable(); + + /** Returns true if the bitmap is opaque (has no translucent/transparent pixels). + */ + bool isOpaque() const { + return SkAlphaTypeIsOpaque(this->alphaType()); + } + + /** Returns true if the bitmap is volatile (i.e. should not be cached by devices.) + */ + bool isVolatile() const; + + /** Specify whether this bitmap is volatile. Bitmaps are not volatile by + default. Temporary bitmaps that are discarded after use should be + marked as volatile. This provides a hint to the device that the bitmap + should not be cached. Providing this hint when appropriate can + improve performance by avoiding unnecessary overhead and resource + consumption on the device. + */ + void setIsVolatile(bool); + + /** Reset the bitmap to its initial state (see default constructor). If we are a (shared) + owner of the pixels, that ownership is decremented. + */ + void reset(); + + /** Given a config and a width, this computes the optimal rowBytes value. This is called automatically + if you pass 0 for rowBytes to setConfig(). + */ + static size_t ComputeRowBytes(Config c, int width); + + /** Return the bytes-per-pixel for the specified config. If the config is + not at least 1-byte per pixel, return 0, including for kNo_Config. + */ + static int ComputeBytesPerPixel(Config c); + + /** Return the shift-per-pixel for the specified config. If the config is + not at least 1-byte per pixel, return 0, including for kNo_Config. + */ + static int ComputeShiftPerPixel(Config c) { + return ComputeBytesPerPixel(c) >> 1; + } + + static int64_t ComputeSize64(Config, int width, int height); + static size_t ComputeSize(Config, int width, int height); + + /** + * This will brute-force return true if all of the pixels in the bitmap + * are opaque. If it fails to read the pixels, or encounters an error, + * it will return false. + * + * Since this can be an expensive operation, the bitmap stores a flag for + * this (isOpaque). Only call this if you need to compute this value from + * "unknown" pixels. + */ + static bool ComputeIsOpaque(const SkBitmap&); + + /** + * Return the bitmap's bounds [0, 0, width, height] as an SkRect + */ + void getBounds(SkRect* bounds) const; + void getBounds(SkIRect* bounds) const; + + /** Set the bitmap's config and dimensions. If rowBytes is 0, then + ComputeRowBytes() is called to compute the optimal value. This resets + any pixel/colortable ownership, just like reset(). + */ + bool setConfig(Config, int width, int height, size_t rowBytes, SkAlphaType); + + bool setConfig(Config config, int width, int height, size_t rowBytes = 0) { + return this->setConfig(config, width, height, rowBytes, + kPremul_SkAlphaType); + } + + bool setConfig(const SkImageInfo& info, size_t rowBytes = 0); + + /** + * Allocate a pixelref to match the specified image info. If the Factory + * is non-null, call it to allcoate the pixelref. If the ImageInfo requires + * a colortable, then ColorTable must be non-null, and will be ref'd. + * On failure, the bitmap will be set to empty and return false. + */ + bool allocPixels(const SkImageInfo&, SkPixelRefFactory*, SkColorTable*); + + /** + * Allocate a pixelref to match the specified image info, using the default + * allocator. + * On success, the bitmap's pixels will be "locked", and return true. + * On failure, the bitmap will be set to empty and return false. + */ + bool allocPixels(const SkImageInfo& info) { + return this->allocPixels(info, NULL, NULL); + } + + /** + * Legacy helper function, which creates an SkImageInfo from the specified + * config and then calls allocPixels(info). + */ + bool allocConfigPixels(Config, int width, int height, bool isOpaque = false); + + bool allocN32Pixels(int width, int height, bool isOpaque = false) { + SkImageInfo info = SkImageInfo::MakeN32Premul(width, height); + if (isOpaque) { + info.fAlphaType = kOpaque_SkAlphaType; + } + return this->allocPixels(info); + } + + /** + * Install a pixelref that wraps the specified pixels and rowBytes, and + * optional ReleaseProc and context. When the pixels are no longer + * referenced, if ReleaseProc is not null, it will be called with the + * pixels and context as parameters. + * On failure, the bitmap will be set to empty and return false. + */ + bool installPixels(const SkImageInfo&, void* pixels, size_t rowBytes, + void (*ReleaseProc)(void* addr, void* context), + void* context); + + /** + * Call installPixels with no ReleaseProc specified. This means that the + * caller must ensure that the specified pixels are valid for the lifetime + * of the created bitmap (and its pixelRef). + */ + bool installPixels(const SkImageInfo& info, void* pixels, size_t rowBytes) { + return this->installPixels(info, pixels, rowBytes, NULL, NULL); + } + + /** + * Calls installPixels() with the value in the SkMask. The caller must + * ensure that the specified mask pixels are valid for the lifetime + * of the created bitmap (and its pixelRef). + */ + bool installMaskPixels(const SkMask&); + + /** + * DEPRECATED: call info(). + */ + bool asImageInfo(SkImageInfo* info) const { + // compatibility: return false for kUnknown + if (kUnknown_SkColorType == this->colorType()) { + return false; + } + if (info) { + *info = this->info(); + } + return true; + } + + /** Use this to assign a new pixel address for an existing bitmap. This + will automatically release any pixelref previously installed. Only call + this if you are handling ownership/lifetime of the pixel memory. + + If the bitmap retains a reference to the colortable (assuming it is + not null) it will take care of incrementing the reference count. + + @param pixels Address for the pixels, managed by the caller. + @param ctable ColorTable (or null) that matches the specified pixels + */ + void setPixels(void* p, SkColorTable* ctable = NULL); + + /** Copies the bitmap's pixels to the location pointed at by dst and returns + true if possible, returns false otherwise. + + In the case when the dstRowBytes matches the bitmap's rowBytes, the copy + may be made faster by copying over the dst's per-row padding (for all + rows but the last). By setting preserveDstPad to true the caller can + disable this optimization and ensure that pixels in the padding are not + overwritten. + + Always returns false for RLE formats. + + @param dst Location of destination buffer. + @param dstSize Size of destination buffer. Must be large enough to hold + pixels using indicated stride. + @param dstRowBytes Width of each line in the buffer. If 0, uses + bitmap's internal stride. + @param preserveDstPad Must we preserve padding in the dst + */ + bool copyPixelsTo(void* const dst, size_t dstSize, size_t dstRowBytes = 0, + bool preserveDstPad = false) const; + + /** Use the standard HeapAllocator to create the pixelref that manages the + pixel memory. It will be sized based on the current width/height/config. + If this is called multiple times, a new pixelref object will be created + each time. + + If the bitmap retains a reference to the colortable (assuming it is + not null) it will take care of incrementing the reference count. + + @param ctable ColorTable (or null) to use with the pixels that will + be allocated. Only used if config == Index8_Config + @return true if the allocation succeeds. If not the pixelref field of + the bitmap will be unchanged. + */ + bool allocPixels(SkColorTable* ctable = NULL) { + return this->allocPixels(NULL, ctable); + } + + /** Use the specified Allocator to create the pixelref that manages the + pixel memory. It will be sized based on the current width/height/config. + If this is called multiple times, a new pixelref object will be created + each time. + + If the bitmap retains a reference to the colortable (assuming it is + not null) it will take care of incrementing the reference count. + + @param allocator The Allocator to use to create a pixelref that can + manage the pixel memory for the current + width/height/config. If allocator is NULL, the standard + HeapAllocator will be used. + @param ctable ColorTable (or null) to use with the pixels that will + be allocated. Only used if config == Index8_Config. + If it is non-null and the config is not Index8, it will + be ignored. + @return true if the allocation succeeds. If not the pixelref field of + the bitmap will be unchanged. + */ + bool allocPixels(Allocator* allocator, SkColorTable* ctable); + + /** + * Return the current pixelref object or NULL if there is none. This does + * not affect the refcount of the pixelref. + */ + SkPixelRef* pixelRef() const { return fPixelRef; } + + /** + * A bitmap can reference a subset of a pixelref's pixels. That means the + * bitmap's width/height can be <= the dimensions of the pixelref. The + * pixelref origin is the x,y location within the pixelref's pixels for + * the bitmap's top/left corner. To be valid the following must be true: + * + * origin_x + bitmap_width <= pixelref_width + * origin_y + bitmap_height <= pixelref_height + * + * pixelRefOrigin() returns this origin, or (0,0) if there is no pixelRef. + */ + SkIPoint pixelRefOrigin() const { return fPixelRefOrigin; } + + /** + * Assign a pixelref and origin to the bitmap. Pixelrefs are reference, + * so the existing one (if any) will be unref'd and the new one will be + * ref'd. (x,y) specify the offset within the pixelref's pixels for the + * top/left corner of the bitmap. For a bitmap that encompases the entire + * pixels of the pixelref, these will be (0,0). + */ + SkPixelRef* setPixelRef(SkPixelRef* pr, int dx, int dy); + + SkPixelRef* setPixelRef(SkPixelRef* pr, const SkIPoint& origin) { + return this->setPixelRef(pr, origin.fX, origin.fY); + } + + SkPixelRef* setPixelRef(SkPixelRef* pr) { + return this->setPixelRef(pr, 0, 0); + } + + /** Call this to ensure that the bitmap points to the current pixel address + in the pixelref. Balance it with a call to unlockPixels(). These calls + are harmless if there is no pixelref. + */ + void lockPixels() const; + /** When you are finished access the pixel memory, call this to balance a + previous call to lockPixels(). This allows pixelrefs that implement + cached/deferred image decoding to know when there are active clients of + a given image. + */ + void unlockPixels() const; + + /** + * Some bitmaps can return a copy of their pixels for lockPixels(), but + * that copy, if modified, will not be pushed back. These bitmaps should + * not be used as targets for a raster device/canvas (since all pixels + * modifications will be lost when unlockPixels() is called.) + */ + bool lockPixelsAreWritable() const; + + /** Call this to be sure that the bitmap is valid enough to be drawn (i.e. + it has non-null pixels, and if required by its config, it has a + non-null colortable. Returns true if all of the above are met. + */ + bool readyToDraw() const { + return this->getPixels() != NULL && + (this->colorType() != kIndex_8_SkColorType || NULL != fColorTable); + } + + /** Returns the pixelRef's texture, or NULL + */ + GrTexture* getTexture() const; + + /** Return the bitmap's colortable, if it uses one (i.e. colorType is + Index_8) and the pixels are locked. + Otherwise returns NULL. Does not affect the colortable's + reference count. + */ + SkColorTable* getColorTable() const { return fColorTable; } + + /** Returns a non-zero, unique value corresponding to the pixels in our + pixelref. Each time the pixels are changed (and notifyPixelsChanged + is called), a different generation ID will be returned. Finally, if + their is no pixelRef then zero is returned. + */ + uint32_t getGenerationID() const; + + /** Call this if you have changed the contents of the pixels. This will in- + turn cause a different generation ID value to be returned from + getGenerationID(). + */ + void notifyPixelsChanged() const; + + /** + * Fill the entire bitmap with the specified color. + * If the bitmap's config does not support alpha (e.g. 565) then the alpha + * of the color is ignored (treated as opaque). If the config only supports + * alpha (e.g. A1 or A8) then the color's r,g,b components are ignored. + */ + void eraseColor(SkColor c) const { + this->eraseARGB(SkColorGetA(c), SkColorGetR(c), SkColorGetG(c), + SkColorGetB(c)); + } + + /** + * Fill the entire bitmap with the specified color. + * If the bitmap's config does not support alpha (e.g. 565) then the alpha + * of the color is ignored (treated as opaque). If the config only supports + * alpha (e.g. A1 or A8) then the color's r,g,b components are ignored. + */ + void eraseARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b) const; + + SK_ATTR_DEPRECATED("use eraseARGB or eraseColor") + void eraseRGB(U8CPU r, U8CPU g, U8CPU b) const { + this->eraseARGB(0xFF, r, g, b); + } + + /** + * Fill the specified area of this bitmap with the specified color. + * If the bitmap's config does not support alpha (e.g. 565) then the alpha + * of the color is ignored (treated as opaque). If the config only supports + * alpha (e.g. A1 or A8) then the color's r,g,b components are ignored. + */ + void eraseArea(const SkIRect& area, SkColor c) const; + + /** Scroll (a subset of) the contents of this bitmap by dx/dy. If there are + no pixels allocated (i.e. getPixels() returns null) the method will + still update the inval region (if present). If the bitmap is immutable, + do nothing and return false. + + @param subset The subset of the bitmap to scroll/move. To scroll the + entire contents, specify [0, 0, width, height] or just + pass null. + @param dx The amount to scroll in X + @param dy The amount to scroll in Y + @param inval Optional (may be null). Returns the area of the bitmap that + was scrolled away. E.g. if dx = dy = 0, then inval would + be set to empty. If dx >= width or dy >= height, then + inval would be set to the entire bounds of the bitmap. + @return true if the scroll was doable. Will return false if the bitmap + uses an unsupported config for scrolling (only kA8, + kIndex8, kRGB_565, kARGB_4444, kARGB_8888 are supported). + If no pixels are present (i.e. getPixels() returns false) + inval will still be updated, and true will be returned. + */ + bool scrollRect(const SkIRect* subset, int dx, int dy, + SkRegion* inval = NULL) const; + + /** + * Return the SkColor of the specified pixel. In most cases this will + * require un-premultiplying the color. Alpha only configs (A1 and A8) + * return black with the appropriate alpha set. The value is undefined + * for kNone_Config or if x or y are out of bounds, or if the bitmap + * does not have any pixels (or has not be locked with lockPixels()). + */ + SkColor getColor(int x, int y) const; + + /** Returns the address of the specified pixel. This performs a runtime + check to know the size of the pixels, and will return the same answer + as the corresponding size-specific method (e.g. getAddr16). Since the + check happens at runtime, it is much slower than using a size-specific + version. Unlike the size-specific methods, this routine also checks if + getPixels() returns null, and returns that. The size-specific routines + perform a debugging assert that getPixels() is not null, but they do + not do any runtime checks. + */ + void* getAddr(int x, int y) const; + + /** Returns the address of the pixel specified by x,y for 32bit pixels. + * In debug build, this asserts that the pixels are allocated and locked, + * and that the config is 32-bit, however none of these checks are performed + * in the release build. + */ + inline uint32_t* getAddr32(int x, int y) const; + + /** Returns the address of the pixel specified by x,y for 16bit pixels. + * In debug build, this asserts that the pixels are allocated and locked, + * and that the config is 16-bit, however none of these checks are performed + * in the release build. + */ + inline uint16_t* getAddr16(int x, int y) const; + + /** Returns the address of the pixel specified by x,y for 8bit pixels. + * In debug build, this asserts that the pixels are allocated and locked, + * and that the config is 8-bit, however none of these checks are performed + * in the release build. + */ + inline uint8_t* getAddr8(int x, int y) const; + + /** Returns the color corresponding to the pixel specified by x,y for + * colortable based bitmaps. + * In debug build, this asserts that the pixels are allocated and locked, + * that the config is kIndex8, and that the colortable is allocated, + * however none of these checks are performed in the release build. + */ + inline SkPMColor getIndex8Color(int x, int y) const; + + /** Set dst to be a setset of this bitmap. If possible, it will share the + pixel memory, and just point into a subset of it. However, if the config + does not support this, a local copy will be made and associated with + the dst bitmap. If the subset rectangle, intersected with the bitmap's + dimensions is empty, or if there is an unsupported config, false will be + returned and dst will be untouched. + @param dst The bitmap that will be set to a subset of this bitmap + @param subset The rectangle of pixels in this bitmap that dst will + reference. + @return true if the subset copy was successfully made. + */ + bool extractSubset(SkBitmap* dst, const SkIRect& subset) const; + + /** Makes a deep copy of this bitmap, respecting the requested colorType, + * and allocating the dst pixels on the cpu. + * Returns false if either there is an error (i.e. the src does not have + * pixels) or the request cannot be satisfied (e.g. the src has per-pixel + * alpha, and the requested config does not support alpha). + * @param dst The bitmap to be sized and allocated + * @param ct The desired colorType for dst + * @param allocator Allocator used to allocate the pixelref for the dst + * bitmap. If this is null, the standard HeapAllocator + * will be used. + * @return true if the copy was made. + */ + bool copyTo(SkBitmap* dst, SkColorType ct, Allocator* = NULL) const; + + bool copyTo(SkBitmap* dst, Allocator* allocator = NULL) const { + return this->copyTo(dst, this->colorType(), allocator); + } + + /** + * Returns true if this bitmap's pixels can be converted into the requested + * colorType, such that copyTo() could succeed. + */ + bool canCopyTo(SkColorType colorType) const; + + /** Makes a deep copy of this bitmap, keeping the copied pixels + * in the same domain as the source: If the src pixels are allocated for + * the cpu, then so will the dst. If the src pixels are allocated on the + * gpu (typically as a texture), the it will do the same for the dst. + * If the request cannot be fulfilled, returns false and dst is unmodified. + */ + bool deepCopyTo(SkBitmap* dst) const; + + SK_ATTR_DEPRECATED("use setFilterLevel on SkPaint") + void buildMipMap(bool forceRebuild = false); + +#ifdef SK_BUILD_FOR_ANDROID + bool hasHardwareMipMap() const { + return (fFlags & kHasHardwareMipMap_Flag) != 0; + } + + void setHasHardwareMipMap(bool hasHardwareMipMap) { + if (hasHardwareMipMap) { + fFlags |= kHasHardwareMipMap_Flag; + } else { + fFlags &= ~kHasHardwareMipMap_Flag; + } + } +#endif + + bool extractAlpha(SkBitmap* dst) const { + return this->extractAlpha(dst, NULL, NULL, NULL); + } + + bool extractAlpha(SkBitmap* dst, const SkPaint* paint, + SkIPoint* offset) const { + return this->extractAlpha(dst, paint, NULL, offset); + } + + /** Set dst to contain alpha layer of this bitmap. If destination bitmap + fails to be initialized, e.g. because allocator can't allocate pixels + for it, dst will not be modified and false will be returned. + + @param dst The bitmap to be filled with alpha layer + @param paint The paint to draw with + @param allocator Allocator used to allocate the pixelref for the dst + bitmap. If this is null, the standard HeapAllocator + will be used. + @param offset If not null, it is set to top-left coordinate to position + the returned bitmap so that it visually lines up with the + original + */ + bool extractAlpha(SkBitmap* dst, const SkPaint* paint, Allocator* allocator, + SkIPoint* offset) const; + + /** The following two functions provide the means to both flatten and + unflatten the bitmap AND its pixels into the provided buffer. + It is recommended that you do not call these functions directly, + but instead call the write/readBitmap functions on the respective + buffers as they can optimize the recording process and avoid recording + duplicate bitmaps and pixelRefs. + */ + void flatten(SkWriteBuffer&) const; + void unflatten(SkReadBuffer&); + + SkDEBUGCODE(void validate() const;) + + class Allocator : public SkRefCnt { + public: + SK_DECLARE_INST_COUNT(Allocator) + + /** Allocate the pixel memory for the bitmap, given its dimensions and + config. Return true on success, where success means either setPixels + or setPixelRef was called. The pixels need not be locked when this + returns. If the config requires a colortable, it also must be + installed via setColorTable. If false is returned, the bitmap and + colortable should be left unchanged. + */ + virtual bool allocPixelRef(SkBitmap*, SkColorTable*) = 0; + private: + typedef SkRefCnt INHERITED; + }; + + /** Subclass of Allocator that returns a pixelref that allocates its pixel + memory from the heap. This is the default Allocator invoked by + allocPixels(). + */ + class HeapAllocator : public Allocator { + public: + virtual bool allocPixelRef(SkBitmap*, SkColorTable*) SK_OVERRIDE; + }; + + class RLEPixels { + public: + RLEPixels(int width, int height); + virtual ~RLEPixels(); + + uint8_t* packedAtY(int y) const { + SkASSERT((unsigned)y < (unsigned)fHeight); + return fYPtrs[y]; + } + + // called by subclasses during creation + void setPackedAtY(int y, uint8_t* addr) { + SkASSERT((unsigned)y < (unsigned)fHeight); + fYPtrs[y] = addr; + } + + private: + uint8_t** fYPtrs; + int fHeight; + }; + + SK_TO_STRING_NONVIRT() + +private: + struct MipMap; + mutable MipMap* fMipMap; + + mutable SkPixelRef* fPixelRef; + mutable int fPixelLockCount; + // These are just caches from the locked pixelref + mutable void* fPixels; + mutable SkColorTable* fColorTable; // only meaningful for kIndex8 + + SkIPoint fPixelRefOrigin; + + enum Flags { + kImageIsOpaque_Flag = 0x01, + kImageIsVolatile_Flag = 0x02, + kImageIsImmutable_Flag = 0x04, +#ifdef SK_BUILD_FOR_ANDROID + /* A hint for the renderer responsible for drawing this bitmap + * indicating that it should attempt to use mipmaps when this bitmap + * is drawn scaled down. + */ + kHasHardwareMipMap_Flag = 0x08, +#endif + }; + + SkImageInfo fInfo; + + uint32_t fRowBytes; + + uint8_t fFlags; + + void internalErase(const SkIRect&, U8CPU a, U8CPU r, U8CPU g, U8CPU b)const; + + /* Internal computations for safe size. + */ + static int64_t ComputeSafeSize64(Config config, + uint32_t width, + uint32_t height, + size_t rowBytes); + static size_t ComputeSafeSize(Config config, + uint32_t width, + uint32_t height, + size_t rowBytes); + + /* Unreference any pixelrefs or colortables + */ + void freePixels(); + void updatePixelsFromRef() const; + + static SkFixed ComputeMipLevel(SkFixed sx, SkFixed dy); + + /** Given scale factors sx, sy, determine the miplevel available in the + bitmap, and return it (this is the amount to shift matrix iterators + by). If dst is not null, it is set to the correct level. + */ + int extractMipLevel(SkBitmap* dst, SkFixed sx, SkFixed sy); + bool hasMipMap() const; + void freeMipMap(); + + friend struct SkBitmapProcState; +}; + +class SkAutoLockPixels : public SkNoncopyable { +public: + SkAutoLockPixels(const SkBitmap& bm, bool doLock = true) : fBitmap(bm) { + fDidLock = doLock; + if (doLock) { + bm.lockPixels(); + } + } + ~SkAutoLockPixels() { + if (fDidLock) { + fBitmap.unlockPixels(); + } + } + +private: + const SkBitmap& fBitmap; + bool fDidLock; +}; +//TODO(mtklein): uncomment when 71713004 lands and Chromium's fixed. +//#define SkAutoLockPixels(...) SK_REQUIRE_LOCAL_VAR(SkAutoLockPixels) + +/** Helper class that performs the lock/unlockColors calls on a colortable. + The destructor will call unlockColors(false) if it has a bitmap's colortable +*/ +class SkAutoLockColors : public SkNoncopyable { +public: + /** Initialize with no bitmap. Call lockColors(bitmap) to lock bitmap's + colortable + */ + SkAutoLockColors() : fCTable(NULL), fColors(NULL) {} + /** Initialize with bitmap, locking its colortable if present + */ + explicit SkAutoLockColors(const SkBitmap& bm) { + fCTable = bm.getColorTable(); + fColors = fCTable ? fCTable->lockColors() : NULL; + } + /** Initialize with a colortable (may be null) + */ + explicit SkAutoLockColors(SkColorTable* ctable) { + fCTable = ctable; + fColors = ctable ? ctable->lockColors() : NULL; + } + ~SkAutoLockColors() { + if (fCTable) { + fCTable->unlockColors(); + } + } + + /** Return the currently locked colors, or NULL if no bitmap's colortable + is currently locked. + */ + const SkPMColor* colors() const { return fColors; } + + /** Locks the table and returns is colors (assuming ctable is not null) and + unlocks the previous table if one was present + */ + const SkPMColor* lockColors(SkColorTable* ctable) { + if (fCTable) { + fCTable->unlockColors(); + } + fCTable = ctable; + fColors = ctable ? ctable->lockColors() : NULL; + return fColors; + } + + const SkPMColor* lockColors(const SkBitmap& bm) { + return this->lockColors(bm.getColorTable()); + } + +private: + SkColorTable* fCTable; + const SkPMColor* fColors; +}; +#define SkAutoLockColors(...) SK_REQUIRE_LOCAL_VAR(SkAutoLockColors) + +/////////////////////////////////////////////////////////////////////////////// + +inline uint32_t* SkBitmap::getAddr32(int x, int y) const { + SkASSERT(fPixels); + SkASSERT(4 == this->bytesPerPixel()); + SkASSERT((unsigned)x < (unsigned)this->width() && (unsigned)y < (unsigned)this->height()); + return (uint32_t*)((char*)fPixels + y * fRowBytes + (x << 2)); +} + +inline uint16_t* SkBitmap::getAddr16(int x, int y) const { + SkASSERT(fPixels); + SkASSERT(2 == this->bytesPerPixel()); + SkASSERT((unsigned)x < (unsigned)this->width() && (unsigned)y < (unsigned)this->height()); + return (uint16_t*)((char*)fPixels + y * fRowBytes + (x << 1)); +} + +inline uint8_t* SkBitmap::getAddr8(int x, int y) const { + SkASSERT(fPixels); + SkASSERT(1 == this->bytesPerPixel()); + SkASSERT((unsigned)x < (unsigned)this->width() && (unsigned)y < (unsigned)this->height()); + return (uint8_t*)fPixels + y * fRowBytes + x; +} + +inline SkPMColor SkBitmap::getIndex8Color(int x, int y) const { + SkASSERT(fPixels); + SkASSERT(kIndex_8_SkColorType == this->colorType()); + SkASSERT((unsigned)x < (unsigned)this->width() && (unsigned)y < (unsigned)this->height()); + SkASSERT(fColorTable); + return (*fColorTable)[*((const uint8_t*)fPixels + y * fRowBytes + x)]; +} + +/////////////////////////////////////////////////////////////////////////////// +// +// Helpers until we can fully deprecate SkBitmap::Config +// +extern SkBitmap::Config SkColorTypeToBitmapConfig(SkColorType); +extern SkColorType SkBitmapConfigToColorType(SkBitmap::Config); + +#endif