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