wip pixmap docs

wip pixmap docs

Docs-Preview: https://skia.org/?cl=42522
Bug: skia: 6898
Change-Id: I85947bc36ea057ed008b87d7bef2efa82d7c89ad
Reviewed-on: https://skia-review.googlesource.com/42522
Reviewed-by: Cary Clark <caryclark@skia.org>
Commit-Queue: Cary Clark <caryclark@skia.org>

1 files changed, 2040 insertions, 0 deletions

diff --git a/docs/SkPixmap_Reference.bmh b/docs/SkPixmap_Reference.bmh
new file mode 100644
index 0000000000..83f350252c
--- /dev/null
+++ b/docs/SkPixmap_Reference.bmh
@@ -0,0 +1,2040 @@
+#Topic Pixmap
+ 
+#Class SkPixmap
+
+Pixmap provides a utility to pair SkImageInfo with pixels and row bytes. 
+Pixmap is a low level class which provides convenience functions to access
+raster destinations. Canvas can not draw Pixmap, nor does Pixmap provide
+a direct drawing destination.
+
+Use Bitmap to draw pixels referenced by Pixmap; use Surface to draw into
+pixels referenced by Pixmap.
+
+Pixmap does not try to manage the lifetime of the pixel memory. Use PixelRef
+to manage pixel memory; PixelRef is safe across threads.
+
+#Topic Overview
+
+#Subtopic Subtopics
+#Table
+#Legend
+# topics                 # description                                  ##
+#Legend ##
+# Image_Info_Access      # Returns all or part of Image_Info.           ##
+# Initialization         # Sets fields for use.                         ##
+# Reader                 # Examine pixel value.                         ##
+# Writer                 # Copy to pixel values.                        ##
+# Readable_Address       # Returns read only pixels.                    ##
+# Writable_Address       # Returns writable pixels.                     ##
+#Table ##
+#Subtopic ##
+
+#Subtopic Constructors
+#Table
+#Legend
+#                                                                      # description                         ##
+#Legend ##
+# SkPixmap()                                                           # Constructs with default values.     ##
+# SkPixmap(const SkImageInfo& info, const void* addr, size_t rowBytes) # Constructs from Image_Info, pixels. ##
+#Table ##
+#Subtopic ##
+
+#Subtopic Member_Functions
+#Table
+#Legend
+# function         # description   ##
+#Legend ##
+# addr()           # Returns readable pixel address as void pointer. ##
+# addr16           # Returns readable pixel address as 16-bit pointer. ##
+# addr32           # Returns readable pixel address as 32-bit pointer. ##
+# addr64           # Returns readable pixel address as 64-bit pointer. ##
+# addr8            # Returns readable pixel address as 8-bit pointer. ##
+# addrF16          # Returns readable pixel component address as 16-bit pointer. ##
+# alphaType        # Returns Image_Info Alpha_Type. ##
+# bounds()         # Returns width and height as Rectangle. ##
+# colorSpace       # Returns Image_Info Color_Space. ##
+# colorType        # Returns Image_Info Color_Type. ##
+# computeIsOpaque  # Returns true if all pixels are opaque. ##
+# erase()          # Writes Color to pixels. ##
+# extractSubset    # Sets pointer to portion of original. ##
+# getColor         # Returns one pixel as Unpremultiplied Color. ##
+# getSafeSize      # Returns minimum size required for pixels in 32 bits. ##
+# getSafeSize64    # Returns minimum size required for pixels in 64 bits. ##
+# getSize64        # Returns conservative size required for pixels. ##
+# height()         # Returns pixel row count. ##
+# info()           # Returns Image_Info. ##
+# isOpaque         # Returns true if Image_Info describes opaque pixels. ##
+# readPixels       # Copies and converts pixels. ##
+# reset()          # Reuses existing Pixmap with replacement values. ##
+# rowBytes         # Returns interval between rows in bytes. ##
+# rowBytesAsPixels # Returns interval between rows in pixels. ##
+# scalePixels      # Scales and converts pixels. ##
+# setColorSpace    # Sets Image_Info Color_Space. ##
+# shiftPerPixel    # Returns bit shift from pixels to bytes. ##
+# width()          # Returns pixel column count. ##
+# writable_addr    # Returns writable pixel address as void pointer. ##
+# writable_addr16  # Returns writable pixel address as 16-bit pointer. ##
+# writable_addr32  # Returns writable pixel address as 32-bit pointer. ##
+# writable_addr64  # Returns writable pixel address as 64-bit pointer. ##
+# writable_addr8   # Returns writable pixel address as 8-bit pointer. ##
+# writable_addrF16 # Returns writable pixel component address as 16-bit pointer. ##
+#Table ##
+#Subtopic ##
+
+#Topic Overview ##
+
+#Subtopic Initialization
+
+# ------------------------------------------------------------------------------
+
+#Method SkPixmap()
+
+Creates an empty Pixmap without pixels, with kUnknown_SkColorType, with
+kUnknown_SkAlphaType, and with a width and height of zero. Use
+reset() to associate pixels, SkColorType, SkAlphaType, width, and height
+after Pixmap has been created.
+
+#Return empty Pixmap ##
+
+#Example
+void draw(SkCanvas* canvas) {

+    const char* alphas[] = {"Unknown", "Opaque", "Premul", "Unpremul"};

+    const char* colors[] = {"Unknown", "Alpha", "RGB_565", "ARGB_4444", "RGBA_8888", "BGRA_8888",

+                            "Gray_8", "RGBA_F16"};

+    SkPixmap pixmap;

+    for (int i = 0; i < 2; ++i) {

+       SkDebugf("width: %2d  height: %2d", pixmap.width(), pixmap.height());

+       SkDebugf("  color: k%s_SkColorType", colors[pixmap.colorType()]);

+       SkDebugf("  alpha: k%s_SkAlphaType\n", alphas[pixmap.alphaType()]);

+       pixmap.reset(SkImageInfo::Make(25, 35, kRGBA_8888_SkColorType, kOpaque_SkAlphaType),

+                    nullptr, 0);

+    }

+}
+#StdOut
+width:  0  height:  0  color: kUnknown_SkColorType  alpha: kUnknown_SkAlphaType

+width: 25  height: 35  color: kRGBA_8888_SkColorType  alpha: kOpaque_SkAlphaType
+##
+##
+
+#SeeAlso SkPixmap(const SkImageInfo& info, const void* addr, size_t rowBytes) reset() SkAlphaType SkColorType
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method SkPixmap(const SkImageInfo& info, const void* addr, size_t rowBytes)
+        
+Creates Pixmap from info width, height, SkAlphaType, and SkColorType.
+addr points to pixels, or nullptr. rowBytes should be
+#Formula
+info.width() * info.bytesPerPixel()
+##
+or larger.
+
+No parameter checking is performed; it is up to the caller to ensure that
+addr and rowBytes agree with info.  
+
+The memory lifetime pixels are managed by the caller. When Pixmap goes
+out of scope, addr is unaffected.
+
+Pixmap may be later modified by reset() to change its size, pixel type, or
+storage.
+
+#Param info  width, height, SkAlphaType, SkColorType of Image_Info ##
+#Param addr  pointer to pixels allocated by caller; may be nullptr ##
+#Param rowBytes  size of one row of addr; width times pixel size, or larger ##
+
+#Return initialized Pixmap ##
+
+#Example
+#Image 3
+#Description
+SkImage::MakeRasterCopy takes const SkPixmap& as an argument. The example 
+constructs a SkPixmap from the brace-delimited parameters.
+##
+    SkDebugf("image alpha only = %s\n", image->isAlphaOnly() ? "true" : "false");

+    SkPMColor pmColors = 0;

+    sk_sp<SkImage> copy = SkImage::MakeRasterCopy({SkImageInfo::MakeA8(1, 1),

+                                                  (uint8_t*)&pmColors,

+                                                  1});

+    SkDebugf("copy alpha only = %s\n", copy->isAlphaOnly() ? "true" : "false");
+#StdOut
+image alpha only = false

+copy alpha only = true
+##
+##
+
+#SeeAlso SkPixmap() reset() SkAlphaType SkColorType
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method void reset()
+
+Sets width, height, row bytes to zero; pixel address to nullptr; SkColorType to 
+kUnknown_SkColorType; and SkAlphaType to kUnknown_SkAlphaType.
+
+The prior pixels are unaffected; it is up to the caller to release pixels
+memory if desired.
+
+#Example
+void draw(SkCanvas* canvas) {

+    const char* alphas[] = {"Unknown", "Opaque", "Premul", "Unpremul"};

+    const char* colors[] = {"Unknown", "Alpha", "RGB_565", "ARGB_4444", "RGBA_8888", "BGRA_8888",

+                            "Gray_8", "RGBA_F16"};

+    SkPixmap pixmap(SkImageInfo::Make(25, 35, kRGBA_8888_SkColorType, kOpaque_SkAlphaType),

+                    nullptr, 0);

+    for (int i = 0; i < 2; ++i) {

+       SkDebugf("width: %2d  height: %2d", pixmap.width(), pixmap.height());

+       SkDebugf("  color: k%s_SkColorType", colors[pixmap.colorType()]);

+       SkDebugf("  alpha: k%s_SkAlphaType\n", alphas[pixmap.alphaType()]);

+       pixmap.reset();

+    }

+}

+#StdOut
+width: 25  height: 35  color: kRGBA_8888_SkColorType  alpha: kOpaque_SkAlphaType
+width:  0  height:  0  color: kUnknown_SkColorType  alpha: kUnknown_SkAlphaType

+##
+##
+
+#SeeAlso SkPixmap() SkAlphaType SkColorType
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method void reset(const SkImageInfo& info, const void* addr, size_t rowBytes)
+
+Sets width, height, SkAlphaType, and SkColorType from info.
+Sets pixel address from addr, which may be nullptr. 
+Sets row bytes from rowBytes, which should be
+#Formula
+info.width() * info.bytesPerPixel()
+##
+or larger.
+
+Does not check addr. Asserts if built with SK_DEBUG defined and if rowBytes is
+too small to hold one row of pixels.  
+
+The memory lifetime pixels are managed by the caller. When Pixmap goes
+out of scope, addr is unaffected.
+
+#Param info  width, height, SkAlphaType, SkColorType of Image_Info ##
+#Param addr  pointer to pixels allocated by caller; may be nullptr ##
+#Param rowBytes  size of one row of addr; width times pixel size, or larger ##
+
+#Example
+#Image 4
+#Height 128
+void draw(SkCanvas* canvas) {

+    std::vector<int32_t> pixels;

+    pixels.resize(image->height() * image->width() * 4);

+    SkPixmap pixmap(SkImageInfo::Make(image->width(), image->height(), kN32_SkColorType,

+            image->alphaType()), (const void*) &pixels.front(), image->width() * 4);

+    image->readPixels(pixmap, 0, 0);

+    int x = 0;

+    for (auto colorType : { kRGBA_8888_SkColorType, kBGRA_8888_SkColorType } ) {

+        pixmap.reset(SkImageInfo::Make(image->width(), image->height(), colorType, 

+                image->alphaType()), (const void*) &pixels.front(), image->width() * 4);

+        SkBitmap bitmap;

+        bitmap.installPixels(pixmap);

+        canvas->drawBitmap(bitmap, x, 0);

+        x += 128;

+    }

+}
+##
+
+#SeeAlso SkPixmap(const SkImageInfo& info, const void* addr, size_t rowBytes) reset() SkAlphaType SkColorType
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method void setColorSpace(sk_sp<SkColorSpace> colorSpace)
+
+
+Changes Color_Space in Image_Info; preserves width, height, SkAlphaType, and
+SkColorType in Image, and leaves pixel address and row bytes unchanged.
+colorSpace reference count is incremented.
+
+#Param colorSpace  Color_Space moved to Image_Info ##
+
+#Example
+void draw(SkCanvas* canvas) {

+    SkPixmap pixmap;

+    sk_sp<SkColorSpace> colorSpace1 = SkColorSpace::MakeRGB(SkColorSpace::kLinear_RenderTargetGamma,

+                                                            SkColorSpace::kRec2020_Gamut);

+    SkDebugf("is %sunique\n", colorSpace1->unique() ? "" : "not "); 

+    pixmap.setColorSpace(colorSpace1);

+    SkDebugf("is %sunique\n", colorSpace1->unique() ? "" : "not ");   

+}
+#StdOut
+is unique
+is not unique
+##
+##
+
+#SeeAlso Color_Space SkImageInfo::makeColorSpace
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method bool SK_WARN_UNUSED_RESULT reset(const SkMask& mask)
+
+Sets width, height, pixel address, and row bytes to Mask properties, if Mask
+format is SkMask::kA8_Format; and returns true. Otherwise sets width, height,
+row bytes to zero; pixel address to nullptr; SkColorType to kUnknown_SkColorType;
+and SkAlphaType to kUnknown_SkAlphaType; and returns false.
+
+Failing to read the return value generates a compile time warning.
+
+#Param mask  Mask containing pixels and dimensions ##
+
+#Return  true if set to Mask properties ##
+
+#Example
+    const int width = 2;

+    const int height = 2;

+    uint8_t bytes[] = { 0, 1, 2, 3, 4, 5, 6, 7 };

+    SkMask mask;

+    mask.fFormat = SkMask::kA8_Format;

+    mask.fBounds = {0, 0, width, height};

+    mask.fImage = bytes;

+    mask.fRowBytes = (width + 7) >> 3;

+    SkPixmap pixmap;

+    bool success = pixmap.reset(mask);

+    SkDebugf("success: %s width: %d height: %d\n", success ? "true " : "false",

+                pixmap.width(), pixmap.height()); 

+    mask.fFormat = SkMask::kBW_Format;

+    success = pixmap.reset(mask);

+    SkDebugf("success: %s width: %d height: %d\n", success ? "true " : "false",

+                pixmap.width(), pixmap.height());

+#StdOut

+success: true  width: 2 height: 2

+success: false width: 0 height: 0

+##

+##
+
+#SeeAlso Mask reset()
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method bool SK_WARN_UNUSED_RESULT extractSubset(SkPixmap* subset, const SkIRect& area) const
+
+Sets subset width, height, pixel address to intersection of Pixmap with area,
+if intersection is not empty; and return true. Otherwise, leave subset unchanged
+and return false. 
+
+Failing to read the return value generates a compile time warning.
+
+#Param subset  storage for width, height, pixel address of intersection ##
+#Param area    bounds to intersect with Pixmap ##
+
+#Return true if intersection of Pixmap and area is not empty ##
+
+#Example
+#Image 3
+#Height 128
+void draw(SkCanvas* canvas) {

+    std::vector<int32_t> pixels;

+    pixels.resize(image->height() * image->width() * 4);

+    SkPixmap pixmap(SkImageInfo::Make(image->width(), image->height(), kN32_SkColorType,

+            image->alphaType()), (const void*) &pixels.front(), image->width() * 4);

+    image->readPixels(pixmap, 0, 0);

+    SkPixmap inset;

+    if (pixmap.extractSubset(&inset, {128, 128, 512, 512})) {

+        SkBitmap bitmap;

+        bitmap.installPixels(inset);

+        canvas->drawBitmap(bitmap, 0, 0);

+    }

+}
+##
+
+#SeeAlso reset() SkIRect::intersect
+
+##
+
+#Subtopic Initialization ##
+
+#Subtopic Image_Info_Access
+
+# ------------------------------------------------------------------------------
+
+#Method const SkImageInfo& info() const 
+
+Returns width, height, SkAlphaType, and SkColorType.
+
+#Return reference to ImageInfo  ##
+
+#Example
+#Image 3
+    std::vector<int32_t> pixels;

+    pixels.resize(image->height() * image->width() * 4);

+    SkPixmap pixmap(SkImageInfo::Make(image->width(), image->height(), kN32_SkColorType,

+            image->alphaType()), (const void*) &pixels.front(), image->width() * 4);

+    image->readPixels(pixmap, 0, 0);

+    SkPixmap inset;

+    if (pixmap.extractSubset(&inset, {128, 128, 512, 512})) {

+        const SkImageInfo& info = inset.info();

+        const char* alphas[] = {"Unknown", "Opaque", "Premul", "Unpremul"};

+        const char* colors[] = {"Unknown", "Alpha", "RGB_565", "ARGB_4444",

+                                "RGBA_8888", "BGRA_8888", "Gray_8", "RGBA_F16"};

+        SkDebugf("width: %d height: %d color: %s alpha: %s\n", info.width(), info.height(),

+                 colors[info.colorType()], alphas[info.alphaType()]);

+    }

+#StdOut

+width: 384 height: 384 color: BGRA_8888 alpha: Opaque

+##

+##
+
+#SeeAlso Image_Info
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method size_t rowBytes() const 
+
+Returns row bytes, the interval from one pixel row to the next. Row bytes
+is at least as large as 
+#Formula
+width() * info().bytesPerPixel()
+##
+.
+
+It is up to the Pixmap creator to ensure that row bytes is a useful value.
+
+#Return  byte length of pixel row ##
+
+#Example
+SkPixmap badPixmap = {SkImageInfo::MakeA8(4, 4), nullptr, 2};
+SkPixmap okPixmap = {SkImageInfo::MakeA8(4, 4), nullptr, 8};
+for (auto& pixmap : { badPixmap, okPixmap } ) {
+    SkDebugf("rowBytes: %d minRowBytes: %d\n", pixmap.rowBytes(), 
+       pixmap.info().minRowBytes());
+}
+#StdOut
+rowBytes: 2 minRowBytes: 4

+rowBytes: 8 minRowBytes: 4
+##
+##
+
+#SeeAlso addr() info() SkImageInfo::minRowBytes
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method const void* addr() const 
+
+Returns pixel address, the base corresponding the pixel origin.
+
+It is up to the Pixmap creator to ensure that pixel address is a useful value.
+
+#Return  pixel address ##
+
+#Example
+#Image 3
+    std::vector<int32_t> pixels;

+    pixels.resize(image->height() * image->width() * 4);

+    SkPixmap pixmap(SkImageInfo::Make(image->width(), image->height(), kN32_SkColorType,

+            image->alphaType()), (const void*) &pixels.front(), image->width() * 4);

+    image->readPixels(pixmap, 0, 0);

+    SkDebugf("pixels address: 0x%llx\n", pixmap.addr());

+    SkPixmap inset;

+    if (pixmap.extractSubset(&inset, {128, 128, 512, 512})) {

+         SkDebugf("inset address:  0x%llx\n", inset.addr());

+    }

+#StdOut

+#Volatile

+pixels address: 0x7f2a440bb010

+inset address:  0x7f2a440fb210

+##

+##
+
+#SeeAlso addr(int x, int y) addr8 addr16 addr32 addr64 info() rowBytes()
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method int width() const 
+
+Returns pixel count in each pixel row. Should be equal or less than:
+#Formula
+rowBytes() / info.bytesPerPixel()
+##
+. 
+
+#Return  pixel width in Image_Info ##
+
+#Example
+    SkImageInfo info = SkImageInfo::MakeA8(16, 32);
+    SkPixmap pixmap(info, nullptr, 64);

+    SkDebugf("pixmap width: %d  info width: %d\n", pixmap.width(), info.width());

+#StdOut

+pixmap width: 16  info width: 16

+##

+##
+
+#SeeAlso height()
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method int height() const 
+
+Returns pixel row count.
+
+#Return  pixel height in Image_Info ##
+
+#Example
+    SkImageInfo info = SkImageInfo::MakeA8(16, 32);
+    SkPixmap pixmap(info, nullptr, 64);

+    SkDebugf("pixmap height: %d  info height: %d\n", pixmap.height(), info.height());

+#StdOut

+pixmap height: 32  info height: 32

+##

+##
+
+#SeeAlso width()
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method SkColorType colorType() const 
+
+Returns Color_Type, one of: kUnknown_SkColorType, kAlpha_8_SkColorType,
+kRGB_565_SkColorType, kARGB_4444_SkColorType, kRGBA_8888_SkColorType,
+kBGRA_8888_SkColorType, kGray_8_SkColorType, kRGBA_F16_SkColorType.
+
+#Return  Color_Type in Image_Info ##
+
+#Example
+    const char* colors[] = {"Unknown", "Alpha", "RGB_565", "ARGB_4444",

+                            "RGBA_8888", "BGRA_8888", "Gray_8", "RGBA_F16"};

+    SkPixmap pixmap(SkImageInfo::MakeA8(16, 32), nullptr, 64);

+    SkDebugf("color type: k" "%s" "_SkColorType\n", colors[pixmap.colorType()]);

+#StdOut

+color type: kAlpha_SkColorType
+##

+##
+
+#SeeAlso alphaType()
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method SkAlphaType alphaType() const 
+
+Returns Alpha_Type, one of: kUnknown_SkAlphaType, kOpaque_SkAlphaType,
+kPremul_SkAlphaType, kUnpremul_SkAlphaType.
+
+#Return  Alpha_Type in Image_Info ##
+
+#Example
+    const char* alphas[] = {"Unknown", "Opaque", "Premul", "Unpremul"};

+    SkPixmap pixmap(SkImageInfo::MakeA8(16, 32), nullptr, 64);

+    SkDebugf("alpha type: k" "%s" "_SkAlphaType\n", alphas[pixmap.alphaType()]);

+#StdOut
+alpha type: kPremul_SkAlphaType
+##
+##
+
+#SeeAlso colorType()
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method SkColorSpace* colorSpace() const 
+
+Returns Color_Space associated with Image_Info.
+
+#Return Color_Space in Image_Info ##
+
+#Example
+#Description
+SkColorSpace::MakeSRGBLinear creates Color_Space with linear gamma
+and an sRGB gamut. This Color_Space gamma is not close to sRGB gamma.
+##
+    SkPixmap pixmap(SkImageInfo::MakeN32(16, 32, kPremul_SkAlphaType, 

+            SkColorSpace::MakeSRGBLinear()), nullptr, 64);

+    SkColorSpace* colorSpace = pixmap.colorSpace();

+    SkDebugf("gammaCloseToSRGB: %s  gammaIsLinear: %s  isSRGB: %s\n",

+            colorSpace->gammaCloseToSRGB() ? "true" : "false",

+            colorSpace->gammaIsLinear() ? "true" : "false",

+            colorSpace->isSRGB() ? "true" : "false");

+#StdOut

+gammaCloseToSRGB: false  gammaIsLinear: true  isSRGB: false

+##

+##
+
+#SeeAlso Color_Space
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method bool isOpaque() const 
+
+Returns true if Alpha_Type is kOpaque_SkAlphaType.
+Does not check if Color_Type allows Alpha, or Alpha in pixel values.
+
+#Return true if Image_Info has opaque Alpha_Type ##
+
+#Example
+#Description
+    isOpaque ignores whether all pixels are opaque or not.
+##
+    std::vector<uint32_t> pixels;

+    const int height = 2;

+    const int width = 2;

+    pixels.resize(height * width * 4);

+    SkPixmap pixmap(SkImageInfo::Make(width, height, kN32_SkColorType,

+            kPremul_SkAlphaType), (const void*) &pixels.front(), width * 4);

+    for (int index = 0; index < 2; ++index) {

+        pixmap.erase(0x00000000);

+        SkDebugf("isOpaque: %s\n", pixmap.isOpaque() ? "true" : "false");

+        pixmap.erase(0xFFFFFFFF);

+        SkDebugf("isOpaque: %s\n", pixmap.isOpaque() ? "true" : "false");

+        pixmap.reset(pixmap.info().makeAlphaType(kOpaque_SkAlphaType),

+                     (const void*) &pixels.front(), width * 4);

+    }

+#StdOut
+isOpaque: false

+isOpaque: false

+isOpaque: true

+isOpaque: true
+##
+##
+
+#SeeAlso computeIsOpaque SkImageInfo::isOpaque
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method SkIRect bounds() const 
+
+Returns IRect
+#Formula
+{ 0, 0, width(), height() }
+##
+.
+
+#Return  integral rectangle from origin to width() and height() ##
+
+#Example
+    for (int width : { 0, 2 } ) {
+        for (int height : { 0, 2 } ) {
+             SkPixmap pixmap(SkImageInfo::MakeA8(width, height), nullptr, width);

+             SkDebugf("width: %d height: %d empty: %s\n", width, height,
+                      pixmap.bounds().isEmpty() ? "true" : "false");
+        }
+    }
+#StdOut
+width: 0 height: 0 empty: true

+width: 0 height: 2 empty: true

+width: 2 height: 0 empty: true

+width: 2 height: 2 empty: false
+##
+##
+
+#SeeAlso height() width() IRect 
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method int rowBytesAsPixels() const 
+
+
+Returns number of pixels that fit on row. Should be greater than or equal to
+width().
+
+#Return  maximum pixels per row ##
+
+#Example
+    for (int rowBytes : { 4, 5, 6, 7, 8} ) {

+        SkPixmap pixmap(SkImageInfo::MakeN32(1, 1, kPremul_SkAlphaType), nullptr, rowBytes);

+        SkDebugf("rowBytes: %d rowBytesAsPixels: %d\n", rowBytes, pixmap.rowBytesAsPixels());

+    }

+#StdOut
+rowBytes: 4 rowBytesAsPixels: 1

+rowBytes: 5 rowBytesAsPixels: 1

+rowBytes: 6 rowBytesAsPixels: 1

+rowBytes: 7 rowBytesAsPixels: 1

+rowBytes: 8 rowBytesAsPixels: 2
+##
+##
+
+#SeeAlso rowBytes shiftPerPixel width SkImageInfo::bytesPerPixel
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method int shiftPerPixel() const 
+
+Returns bit shift converting row bytes to row pixels.
+Returns zero for kUnknown_SkColorType.
+
+#Return one of: 0, 1, 2, 3; left shift to convert pixels to bytes ##
+
+#Example
+    const char* colors[] = {"Unknown", "Alpha", "RGB_565", "ARGB_4444",

+                            "RGBA_8888", "BGRA_8888", "Gray_8", "RGBA_F16"};

+    SkImageInfo info = SkImageInfo::MakeA8(1, 1);

+    for (SkColorType colorType : { kUnknown_SkColorType,   kAlpha_8_SkColorType,

+                                   kRGB_565_SkColorType,   kARGB_4444_SkColorType, 

+                                   kRGBA_8888_SkColorType, kBGRA_8888_SkColorType,

+                                   kGray_8_SkColorType,    kRGBA_F16_SkColorType } ) {

+        SkPixmap pixmap(info.makeColorType(colorType), nullptr, 4);

+        SkDebugf("color: k" "%s" "_SkColorType" "%*s" "bytesPerPixel: %d shiftPerPixel: %d\n",

+                colors[colorType], 10 - strlen(colors[colorType]), " ",

+                pixmap.info().bytesPerPixel(), pixmap.shiftPerPixel());

+    }

+#StdOut
+color: kUnknown_SkColorType   bytesPerPixel: 0 shiftPerPixel: 0

+color: kAlpha_SkColorType     bytesPerPixel: 1 shiftPerPixel: 0

+color: kRGB_565_SkColorType   bytesPerPixel: 2 shiftPerPixel: 1

+color: kARGB_4444_SkColorType bytesPerPixel: 2 shiftPerPixel: 1

+color: kRGBA_8888_SkColorType bytesPerPixel: 4 shiftPerPixel: 2

+color: kBGRA_8888_SkColorType bytesPerPixel: 4 shiftPerPixel: 2

+color: kGray_8_SkColorType    bytesPerPixel: 1 shiftPerPixel: 0

+color: kRGBA_F16_SkColorType  bytesPerPixel: 8 shiftPerPixel: 3
+##
+##
+
+#SeeAlso rowBytes rowBytesAsPixels width SkImageInfo::bytesPerPixel
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method uint64_t getSize64() const 
+
+Returns conservative memory required for pixel storage.
+Includes unused memory on last row when rowBytesAsPixels exceeds width().
+
+#Return  conservative pixel storage size ##
+
+#Example
+    SkPixmap pixmap;

+    for (int width : { 1, 1000, 1000000 } ) {

+        for (int height: { 1, 1000, 1000000 } ) {

+            SkImageInfo imageInfo = SkImageInfo::MakeN32(width, height, kPremul_SkAlphaType);

+            pixmap.reset(imageInfo , nullptr, width * 5);

+            SkDebugf("width: %7d height: %7d getSize64: %13lld\n", width, height, pixmap.getSize64());

+        }

+    }

+#StdOut

+width:       1 height:       1 getSize64:             5

+width:       1 height:    1000 getSize64:          5000

+width:       1 height: 1000000 getSize64:       5000000

+width:    1000 height:       1 getSize64:          5000

+width:    1000 height:    1000 getSize64:       5000000

+width:    1000 height: 1000000 getSize64:    5000000000

+width: 1000000 height:       1 getSize64:       5000000

+width: 1000000 height:    1000 getSize64:    5000000000

+width: 1000000 height: 1000000 getSize64: 5000000000000

+##

+##
+
+#SeeAlso getSafeSize64 getSafeSize height() rowBytes width() SkImageInfo::bytesPerPixel
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method uint64_t getSafeSize64() const 
+
+Returns minimum memory required for pixel storage.
+Does not include unused memory on last row when rowBytesAsPixels exceeds width().
+
+#Return  exact pixel storage size ##
+
+#Example
+    SkPixmap pixmap;

+    for (int width : { 1, 1000, 1000000 } ) {

+        for (int height: { 1, 1000, 1000000 } ) {

+            SkImageInfo imageInfo = SkImageInfo::MakeN32(width, height, kPremul_SkAlphaType);

+            pixmap.reset(imageInfo , nullptr, width * 5);

+            SkDebugf("width: %7d height: %7d getSafeSize64: %13lld\n", width, height,

+                     pixmap.getSafeSize64());

+        }

+    }

+#StdOut

+width:       1 height:       1 getSafeSize64:             4

+width:       1 height:    1000 getSafeSize64:          4999

+width:       1 height: 1000000 getSafeSize64:       4999999

+width:    1000 height:       1 getSafeSize64:          4000

+width:    1000 height:    1000 getSafeSize64:       4999000

+width:    1000 height: 1000000 getSafeSize64:    4999999000

+width: 1000000 height:       1 getSafeSize64:       4000000

+width: 1000000 height:    1000 getSafeSize64:    4999000000

+width: 1000000 height: 1000000 getSafeSize64: 4999999000000
+##
+##
+
+#SeeAlso getSize64 getSafeSize height() rowBytes width() SkImageInfo::bytesPerPixel
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method size_t getSafeSize() const 
+
+Returns minimum memory required for pixel storage.
+Does not include unused memory on last row when rowBytesAsPixels exceeds width().
+Returns zero if value is does not fit in a signed 32-bit integer.
+The largest value than can be returned is 2,147,483,647.
+
+#Return  exact pixel storage size if size fits in signed 32 bits ##
+
+#Example
+void draw(SkCanvas* canvas) {

+    SkPixmap pixmap;

+    for (int width : { 1, 1000, 1000000 } ) {

+        for (int height: { 1, 1000, 1000000 } ) {

+            SkImageInfo imageInfo = SkImageInfo::MakeN32(width, height, kPremul_SkAlphaType);

+            pixmap.reset(imageInfo , nullptr, width * 5);

+            SkDebugf("width: %7d height: %7d getSafeSize: %7d\n", width, height, pixmap.getSafeSize());

+        }

+    }

+}
+#StdOut

+width:       1 height:       1 getSafeSize:       4

+width:       1 height:    1000 getSafeSize:    4999

+width:       1 height: 1000000 getSafeSize: 4999999

+width:    1000 height:       1 getSafeSize:    4000

+width:    1000 height:    1000 getSafeSize: 4999000

+width:    1000 height: 1000000 getSafeSize:       0

+width: 1000000 height:       1 getSafeSize: 4000000

+width: 1000000 height:    1000 getSafeSize:       0

+width: 1000000 height: 1000000 getSafeSize:       0

+##
+##
+
+#SeeAlso getSize64 getSafeSize64 height() rowBytes width() SkImageInfo::bytesPerPixel sk_64_isS32
+
+##
+
+#Subtopic Image_Info_Access ##
+
+#Subtopic Reader
+
+# ------------------------------------------------------------------------------
+
+#Method bool computeIsOpaque() const
+
+Returns true if all pixels are opaque. Color_Type determines how pixels
+are encoded, and whether pixel describes Alpha. Returns true for Color_Types
+without alpha for each pixel; for other Color_Types, returns true if all
+pixels have alpha values equivalent to 1.0 or greater.
+
+For Color_Types kRGB_565_SkColorType or kGray_8_SkColorType: always
+returns true. For Color_Types kAlpha_8_SkColorType, kBGRA_8888_SkColorType,
+kRGBA_8888_SkColorType: returns true if all pixel Alpha values are 255.
+For Color_Type kARGB_4444_SkColorType: returns true if all pixel Alpha values are 15.
+For kRGBA_F16_SkColorType: returns true if all pixel Alpha values are 1.0 or
+greater.
+
+Returns false for any other Color_Type. 
+
+#Return true all pixels have opaque values or Color_Type is opaque  ##
+
+#Example
+    std::vector<uint32_t> pixels;

+    const int height = 2;

+    const int width = 2;

+    pixels.resize(height * width * 4);

+    SkPixmap pixmap(SkImageInfo::Make(width, height, kN32_SkColorType,

+            kPremul_SkAlphaType), (const void*) &pixels.front(), width * 4);

+    for (int index = 0; index < 2; ++index) {

+        pixmap.erase(0x00000000);

+        SkDebugf("computeIsOpaque: %s\n", pixmap.computeIsOpaque() ? "true" : "false");

+        pixmap.erase(0xFFFFFFFF);

+        SkDebugf("computeIsOpaque: %s\n", pixmap.computeIsOpaque() ? "true" : "false");

+        pixmap.reset(pixmap.info().makeAlphaType(kOpaque_SkAlphaType),

+                     (const void*) &pixels.front(), width * 4);

+    }
+#StdOut
+computeIsOpaque: false

+computeIsOpaque: true

+computeIsOpaque: false

+computeIsOpaque: true
+##
+##
+
+#SeeAlso isOpaque Color_Type Alpha
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method SkColor getColor(int x, int y) const
+
+Returns pixel at (x, y) as Unpremultiplied Color.
+Returns black with Alpha if Color_Type is kAlpha_8_SkColorType.
+
+Input is not validated: out of bounds values of x or y trigger an assert() if
+built with SK_DEBUG defined; and returns undefined values or may crash if
+SK_RELEASE is defined. Fails if Color_Type is kUnknown_SkColorType or
+pixel address is nullptr.
+
+Color_Space in Image_Info is ignored. Some Color precision may be lost in the
+conversion to Unpremultiplied Color; original pixel data may have additional 
+precision.
+
+#Param x  positive column index less than width() ##
+#Param y  positive row index less than height() ##
+
+#Return  pixel converted to Unpremultiplied Color ##
+
+#Example
+    const int w = 4;

+    const int h = 4;

+    std::vector<SkPMColor> storage;

+    storage.resize(w * h);

+    SkDebugf("Premultiplied:\n");

+    for (int y = 0; y < h; ++y) {

+        SkDebugf("(0, %d) ", y);

+        for (int x = 0; x < w; ++x) {

+            int a = 0xFF * (x + y) / (w - 1 + h - 1);

+            storage[x + y * w] = SkPackARGB32(a, a * x / (w - 1), a * y / (h - 1), a);

+            SkDebugf("0x%08x%c", storage[x + y * w], x == w - 1 ? '\n' : ' ');

+        }

+    }

+    SkPixmap pixmap(SkImageInfo::MakeN32(w, h, kPremul_SkAlphaType), &storage.front(), w * 4);

+    SkDebugf("Unpremultiplied:\n");

+    for (int y = 0; y < h; ++y) {

+        SkDebugf("(0, %d) ", y);

+        for (int x = 0; x < w; ++x) {

+            SkDebugf("0x%08x%c", pixmap.getColor(x, y), x == w - 1 ? '\n' : ' ');

+        }

+    }

+#StdOut
+Premultiplied:

+(0, 0) 0x00000000 0x2a0e002a 0x55380055 0x7f7f007f 

+(0, 1) 0x2a000e2a 0x551c1c55 0x7f542a7f 0xaaaa38aa 

+(0, 2) 0x55003855 0x7f2a547f 0xaa7171aa 0xd4d48dd4 

+(0, 3) 0x7f007f7f 0xaa38aaaa 0xd48dd4d4 0xffffffff 

+Unpremultiplied:

+(0, 0) 0x00000000 0x2a5500ff 0x55a800ff 0x7fff00ff 

+(0, 1) 0x2a0055ff 0x555454ff 0x7fa954ff 0xaaff54ff 

+(0, 2) 0x5500a8ff 0x7f54a9ff 0xaaaaaaff 0xd4ffaaff 

+(0, 3) 0x7f00ffff 0xaa54ffff 0xd4aaffff 0xffffffff 
+##
+##
+
+#SeeAlso addr() readPixels
+
+##
+
+#Subtopic Reader ##
+
+#Subtopic Readable_Address
+
+# ------------------------------------------------------------------------------
+
+#Method const void* addr(int x, int y) const
+
+Returns readable pixel address at (x, y).
+
+Input is not validated: out of bounds values of x or y trigger an assert() if
+built with SK_DEBUG defined. Returns zero if Color_Type is kUnknown_SkColorType.
+
+#Param x  positive column index less than width() ##
+#Param y  positive row index less than height() ##
+
+#Return  readable generic pointer to pixel ##
+
+#Example
+    const int w = 4;

+    const int h = 4;

+    std::vector<SkPMColor> storage;

+    storage.resize(w * h);

+    SkPixmap pixmap(SkImageInfo::MakeN32(w, h, kPremul_SkAlphaType), &storage.front(), w * 4);

+    SkDebugf("pixmap.addr(1, 2) %c= &storage[1 + 2 * w]\n",
+              pixmap.addr(1, 2)  == &storage[1 + 2 * w] ? '=' : '!');
+#StdOut
+pixmap.addr(1, 2) == &storage[1 + 2 * w]
+##
+##
+
+#SeeAlso addr8 addr16 addr32 addr64 addrF16 getColor writable_addr
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method const uint8_t* addr8() const 
+
+Returns readable base pixel address. Result is addressable as unsigned 8-bit bytes.
+Will trigger an assert() if Color_Type is not kAlpha_8_SkColorType or
+kGray_8_SkColorType, and is built with SK_DEBUG defined.
+
+One byte corresponds to one pixel.
+
+#Return  readable unsigned 8-bit pointer to pixels ##
+
+#Example
+    const int w = 4;

+    const int h = 4;

+    uint8_t storage[w * h];

+    SkPixmap pixmap(SkImageInfo::Make(w, h, kGray_8_SkColorType, kPremul_SkAlphaType),

+                    storage, w * sizeof(storage[0]));

+    SkDebugf("pixmap.addr8() %c= storage\n",
+              pixmap.addr8()  == storage ? '=' : '!');
+#StdOut
+pixmap.addr8() == storage
+##
+##
+
+#SeeAlso addr() addr16 addr32 addr64 addrF16 getColor writable_addr writable_addr8
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method const uint16_t* addr16() const 
+
+Returns readable base pixel address. Result is addressable as unsigned 16-bit words.
+Will trigger an assert() if Color_Type is not kRGB_565_SkColorType or
+kARGB_4444_SkColorType, and is built with SK_DEBUG defined.
+
+One word corresponds to one pixel.
+
+#Return  readable unsigned 16-bit pointer to pixels ##
+
+#Example
+    const int w = 4;

+    const int h = 4;

+    uint16_t storage[w * h];

+    SkPixmap pixmap(SkImageInfo::Make(w, h, kARGB_4444_SkColorType, kPremul_SkAlphaType),

+                    storage, w * sizeof(storage[0]));

+    SkDebugf("pixmap.addr16() %c= storage\n",
+              pixmap.addr16()  == storage ? '=' : '!');
+#StdOut
+pixmap.addr16() == storage
+##
+##
+
+#SeeAlso addr() addr8 addr32 addr64 addrF16 getColor writable_addr writable_addr16
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method const uint32_t* addr32() const 
+
+Returns readable base pixel address. Result is addressable as unsigned 32-bit words.
+Will trigger an assert() if Color_Type is not kRGBA_8888_SkColorType or
+kBGRA_8888_SkColorType, and is built with SK_DEBUG defined.
+
+One word corresponds to one pixel.
+
+#Return  readable unsigned 32-bit pointer to pixels ##
+
+#Example
+    const int w = 4;

+    const int h = 4;

+    uint32_t storage[w * h];

+    SkPixmap pixmap(SkImageInfo::MakeN32(w, h, kPremul_SkAlphaType),

+                    storage, w * sizeof(storage[0]));

+    SkDebugf("pixmap.addr32() %c= storage\n",
+              pixmap.addr32()  == storage ? '=' : '!');
+#StdOut
+pixmap.addr32() == storage
+##
+##
+
+#SeeAlso addr() addr8 addr16 addr64 addrF16 getColor writable_addr writable_addr32
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method const uint64_t* addr64() const 
+
+Returns readable base pixel address. Result is addressable as unsigned 64-bit words.
+Will trigger an assert() if Color_Type is not kRGBA_F16_SkColorType and is built
+with SK_DEBUG defined.
+
+One word corresponds to one pixel.
+
+#Return  readable unsigned 64-bit pointer to pixels ##
+
+#Example
+    const int w = 4;

+    const int h = 4;

+    uint64_t storage[w * h];

+    SkPixmap pixmap(SkImageInfo::Make(w, h, kRGBA_F16_SkColorType, kPremul_SkAlphaType),

+                    storage, w * sizeof(storage[0]));

+    SkDebugf("pixmap.addr64() %c= storage\n",
+              pixmap.addr64()  == storage ? '=' : '!');
+#StdOut
+pixmap.addr64() == storage
+##
+##
+
+#SeeAlso addr() addr8 addr16 addr32 addrF16 getColor writable_addr writable_addr64
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method const uint16_t* addrF16() const 
+
+Returns readable base pixel address. Result is addressable as unsigned 16-bit words.
+Will trigger an assert() if Color_Type is not kRGBA_F16_SkColorType and is built
+with SK_DEBUG defined.
+
+Each word represents one color component encoded as a half float.
+Four words correspond to one pixel.
+
+#Return  readable unsigned 16-bit pointer to first component of pixels ##
+
+#Example
+    const int w = 4;

+    const int h = 4;

+    uint16_t storage[w * h * 4];

+    SkPixmap pixmap(SkImageInfo::Make(w, h, kRGBA_F16_SkColorType, kPremul_SkAlphaType),

+                    storage, w * 4 * sizeof(storage[0]));

+    SkDebugf("pixmap.addrF16() %c= storage\n",
+              pixmap.addrF16()  == storage ? '=' : '!');
+#StdOut
+pixmap.addrF16() == storage
+##
+##
+
+#SeeAlso addr() addr8 addr16 addr32 addr64 getColor writable_addr writable_addrF16
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method const uint8_t* addr8(int x, int y) const 
+
+Returns readable pixel address at (x, y).
+
+Input is not validated: out of bounds values of x or y trigger an assert() if
+built with SK_DEBUG defined.
+
+Will trigger an assert() if Color_Type is not kAlpha_8_SkColorType or
+kGray_8_SkColorType, and is built with SK_DEBUG defined.
+
+#Param x  positive column index less than width() ##
+#Param y  positive row index less than height() ##
+
+#Return  readable unsigned 8-bit pointer to pixel at (x, y) ##
+
+#Example
+    const int w = 4;

+    const int h = 4;

+    uint8_t storage[w * h];

+    SkPixmap pixmap(SkImageInfo::Make(w, h, kGray_8_SkColorType, kPremul_SkAlphaType),

+                    storage, w * sizeof(storage[0]));

+    SkDebugf("pixmap.addr8(1, 2) %c= &storage[1 + 2 * w]\n",

+              pixmap.addr8(1, 2)  == &storage[1 + 2 * w] ? '=' : '!');

+#StdOut
+pixmap.addr8(1, 2) == &storage[1 + 2 * w]
+##
+##
+
+#SeeAlso addr() addr16 addr32 addr64 addrF16 getColor writable_addr writable_addr8
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method const uint16_t* addr16(int x, int y) const 
+
+Returns readable pixel address at (x, y).
+
+Input is not validated: out of bounds values of x or y trigger an assert() if
+built with SK_DEBUG defined.
+
+Will trigger an assert() if Color_Type is not kRGB_565_SkColorType or
+kARGB_4444_SkColorType, and is built with SK_DEBUG defined.
+
+#Param x  positive column index less than width() ##
+#Param y  positive row index less than height() ##
+
+#Return  readable unsigned 16-bit pointer to pixel at (x, y) ##
+
+#Example
+    const int w = 4;

+    const int h = 4;

+    uint16_t storage[w * h];

+    SkPixmap pixmap(SkImageInfo::Make(w, h, kARGB_4444_SkColorType, kPremul_SkAlphaType),

+                    storage, w * sizeof(storage[0]));

+    SkDebugf("pixmap.addr16(1, 2) %c= &storage[1 + 2 * w]\n",
+              pixmap.addr16(1, 2)  == &storage[1 + 2 * w] ? '=' : '!');
+#StdOut
+pixmap.addr16(1, 2) == &storage[1 + 2 * w]
+##
+##
+
+#SeeAlso addr() addr8 addr32 addr64 addrF16 getColor writable_addr writable_addr16
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method const uint32_t* addr32(int x, int y) const 
+
+Returns readable pixel address at (x, y).
+
+Input is not validated: out of bounds values of x or y trigger an assert() if
+built with SK_DEBUG defined.
+
+Will trigger an assert() if Color_Type is not kRGBA_8888_SkColorType or
+kBGRA_8888_SkColorType, and is built with SK_DEBUG defined.
+
+#Param x  positive column index less than width() ##
+#Param y  positive row index less than height() ##
+
+#Return  readable unsigned 32-bit pointer to pixel at (x, y) ##
+
+#Example
+    const int w = 4;

+    const int h = 4;

+    uint32_t storage[w * h];

+    SkPixmap pixmap(SkImageInfo::Make(w, h, kRGBA_8888_SkColorType, kPremul_SkAlphaType),

+                    storage, w * sizeof(storage[0]));

+    SkDebugf("pixmap.addr32(1, 2) %c= &storage[1 + 2 * w]\n",
+              pixmap.addr32(1, 2)  == &storage[1 + 2 * w] ? '=' : '!');
+#StdOut
+pixmap.addr32(1, 2) == &storage[1 + 2 * w]
+##
+##
+
+#ToDo incomplete ##
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method const uint64_t* addr64(int x, int y) const 
+
+Returns readable pixel address at (x, y).
+
+Input is not validated: out of bounds values of x or y trigger an assert() if
+built with SK_DEBUG defined.
+
+Will trigger an assert() if Color_Type is not kRGBA_F16_SkColorType and is built
+with SK_DEBUG defined.
+
+#Param x  positive column index less than width() ##
+#Param y  positive row index less than height() ##
+
+#Return  readable unsigned 64-bit pointer to pixel at (x, y) ##
+
+#Example
+    const int w = 4;

+    const int h = 4;

+    uint64_t storage[w * h];

+    SkPixmap pixmap(SkImageInfo::Make(w, h, kRGBA_F16_SkColorType, kPremul_SkAlphaType),

+                    storage, w * sizeof(storage[0]));

+    SkDebugf("pixmap.addr64(1, 2) %c= &storage[1 + 2 * w]\n",
+              pixmap.addr64(1, 2)  == &storage[1 + 2 * w] ? '=' : '!');
+#StdOut
+pixmap.addr64(1, 2) == &storage[1 + 2 * w]
+##
+##
+
+#SeeAlso addr() addr8 addr16 addr32 addrF16 getColor writable_addr writable_addr64
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method const uint16_t* addrF16(int x, int y) const 
+
+Returns readable pixel address at (x, y).
+
+Input is not validated: out of bounds values of x or y trigger an assert() if
+built with SK_DEBUG defined.
+
+Will trigger an assert() if Color_Type is not kRGBA_F16_SkColorType and is built
+with SK_DEBUG defined.
+
+Each unsigned 16-bit word represents one color component encoded as a half float.
+Four words correspond to one pixel.
+
+#Param x  positive column index less than width() ##
+#Param y  positive row index less than height() ##
+
+#Return  readable unsigned 16-bit pointer to pixel component at (x, y) ##
+
+#Example
+    const int w = 4;

+    const int h = 4;

+    const int wordsPerPixel = 4;

+    const int rowWords = w * wordsPerPixel;

+    uint16_t storage[rowWords * h];

+    SkPixmap pixmap(SkImageInfo::Make(w, h, kRGBA_F16_SkColorType, kPremul_SkAlphaType),

+                    storage, rowWords * sizeof(storage[0]));

+    SkDebugf("pixmap.addrF16(1, 2) %c= &storage[1 * wordsPerPixel + 2 * rowWords]\n",

+              pixmap.addrF16(1, 2)  == &storage[1 * wordsPerPixel + 2 * rowWords] ? '=' : '!');

+#StdOut
+pixmap.addrF16(1, 2) == &storage[1 * wordsPerPixel + 2 * rowWords]
+##
+##
+
+#SeeAlso addr() addr8 addr16 addr32 addr64 getColor writable_addr writable_addrF16
+
+##
+
+#Subtopic Readable_Address ##
+
+#Subtopic Writable_Address
+
+# ------------------------------------------------------------------------------
+
+#Method void* writable_addr() const 
+
+Returns writable base pixel address.
+
+#Return  writable generic base pointer to pixels ##
+
+#Example
+    const int w = 4;

+    const int h = 4;

+    SkPMColor storage[w * h * 4];

+    SkPixmap pixmap(SkImageInfo::MakeN32(w, h, kPremul_SkAlphaType), storage, w * 4);

+    SkDebugf("pixmap.writable_addr() %c= (void *)storage\n",

+              pixmap.writable_addr()  == (void *)storage ? '=' : '!');

+    pixmap.erase(0x00000000);

+    *(SkPMColor*)pixmap.writable_addr() = 0xFFFFFFFF;

+    SkDebugf("pixmap.getColor(0, 1) %c= 0x00000000\n",

+              pixmap.getColor(0, 1)  == 0x00000000 ? '=' : '!');

+    SkDebugf("pixmap.getColor(0, 0) %c= 0xFFFFFFFF\n",

+              pixmap.getColor(0, 0)  == 0xFFFFFFFF ? '=' : '!');
+#StdOut
+pixmap.writable_addr() == (void *)storage

+pixmap.getColor(0, 1) == 0x00000000

+pixmap.getColor(0, 0) == 0xFFFFFFFF
+##
+##
+
+#SeeAlso writable_addr8 writable_addr16 writable_addr32 writable_addr64 writable_addrF16 addr()
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method void* writable_addr(int x, int y) const 
+
+Returns writable pixel address at (x, y).
+
+Input is not validated: out of bounds values of x or y trigger an assert() if
+built with SK_DEBUG defined. Returns zero if Color_Type is kUnknown_SkColorType.
+
+#Param x  positive column index less than width() ##
+#Param y  positive row index less than height() ##
+
+#Return  writable generic pointer to pixel ##
+
+#Example
+    const int w = 4;

+    const int h = 4;

+    SkPMColor storage[w * h * 4];

+    SkPixmap pixmap(SkImageInfo::MakeN32(w, h, kPremul_SkAlphaType), storage, w * 4);

+    SkDebugf("pixmap.writable_addr() %c= (void *)storage\n",

+              pixmap.writable_addr()  == (void *)storage ? '=' : '!');

+    pixmap.erase(0x00000000);

+    *(SkPMColor*)pixmap.writable_addr(1, 2) = 0xFFFFFFFF;

+    SkDebugf("pixmap.getColor(0, 0) %c= 0x00000000\n",

+              pixmap.getColor(0, 0)  == 0x00000000 ? '=' : '!');

+    SkDebugf("pixmap.getColor(1, 2) %c= 0xFFFFFFFF\n",

+              pixmap.getColor(1, 2)  == 0xFFFFFFFF ? '=' : '!');
+#StdOut
+pixmap.writable_addr() == (void *)storage

+pixmap.getColor(0, 0) == 0x00000000

+pixmap.getColor(1, 2) == 0xFFFFFFFF
+##
+##
+
+#SeeAlso writable_addr8 writable_addr16 writable_addr32 writable_addr64 writable_addrF16 addr()
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method uint8_t* writable_addr8(int x, int y) const 
+
+Returns writable base pixel address. Result is addressable as unsigned 8-bit bytes.
+Will trigger an assert() if Color_Type is not kAlpha_8_SkColorType or
+kGray_8_SkColorType, and is built with SK_DEBUG defined.
+
+One byte corresponds to one pixel.
+
+#Param x  positive column index less than width() ##
+#Param y  positive row index less than height() ##
+
+#Return  writable unsigned 8-bit pointer to pixels ##
+
+#Example
+#Height 64
+#Description
+Altering pixels after drawing Bitmap is not guaranteed to affect subsequent
+drawing on all platforms. Adding a second SkBitmap::installPixels after editing
+pixel memory is safer.
+##
+void draw(SkCanvas* canvas) {

+    uint8_t storage[][5] = {{ 0,   0,  64,   0,  0},

+                            { 0, 128, 255, 128,  0},

+                            {64, 255, 255, 255, 64},

+                            { 0, 128, 255, 128,  0},

+                            { 0,   0,  64,   0,  0}};

+    SkImageInfo imageInfo = SkImageInfo::Make(5, 5, kGray_8_SkColorType, kPremul_SkAlphaType);

+    SkPixmap pixmap(imageInfo, storage[0], 5);

+    SkBitmap bitmap;

+    bitmap.installPixels(pixmap);

+    canvas->scale(10, 10);

+    canvas->drawBitmap(bitmap, 0, 0);

+    *pixmap.writable_addr8(2, 2) = 0;

+//  bitmap.installPixels(pixmap);      // uncomment to fix on GPU

+    canvas->drawBitmap(bitmap, 10, 0);

+}
+##
+
+#SeeAlso writable_addr writable_addr16 writable_addr32 writable_addr64 writable_addrF16 addr() addr8
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method uint16_t* writable_addr16(int x, int y) const 
+
+Returns writable_addr base pixel address. Result is addressable as unsigned 16-bit words.
+Will trigger an assert() if Color_Type is not kRGB_565_SkColorType or
+kARGB_4444_SkColorType, and is built with SK_DEBUG defined.
+
+One word corresponds to one pixel.
+
+#Param x  positive column index less than width() ##
+#Param y  positive row index less than height() ##
+
+#Return  writable unsigned 16-bit pointer to pixel ##
+
+#Example
+#Description
+Draw a five by five bitmap, and draw it again with a center black pixel.
+The low nibble of the 16-bit word is Alpha.
+##
+#Height 64
+    uint16_t storage[][5] = {{ 0xCABF, 0xDABE, 0xCA9D, 0xC96C, 0xA39B },

+                             { 0xACEE, 0xA87C, 0x893A, 0x4779, 0x8708 },

+                             { 0x4B7C, 0x255B, 0x2559, 0x2557, 0x4656 },

+                             { 0x9099, 0x8128, 0x2557, 0x4124, 0x3323 },

+                             { 0x7547, 0x5505, 0x4434, 0x2012, 0x0000 }};

+    SkImageInfo imageInfo = SkImageInfo::Make(5, 5, kARGB_4444_SkColorType, kPremul_SkAlphaType);

+    SkPixmap pixmap(imageInfo, storage[0], sizeof(storage) / 5);

+    SkBitmap bitmap;

+    bitmap.installPixels(pixmap);

+    canvas->scale(10, 10);

+    canvas->drawBitmap(bitmap, 0, 0);

+    *pixmap.writable_addr16(2, 2) = 0x000F;

+    bitmap.installPixels(pixmap);

+    canvas->drawBitmap(bitmap, 10, 0);
+##
+
+#SeeAlso writable_addr writable_addr8 writable_addr32 writable_addr64 writable_addrF16 addr() addr16
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method uint32_t* writable_addr32(int x, int y) const 
+
+Returns writable base pixel address. Result is addressable as unsigned 32-bit words.
+Will trigger an assert() if Color_Type is not kRGBA_8888_SkColorType or
+kBGRA_8888_SkColorType, and is built with SK_DEBUG defined.
+
+One word corresponds to one pixel.
+
+#Param x  positive column index less than width() ##
+#Param y  positive row index less than height() ##
+
+#Return  writable unsigned 32-bit pointer to pixel ##
+
+#Example
+#Image 4
+#Height 72
+    std::vector<int32_t> pixels;

+    pixels.resize(image->height() * image->width() * 4);

+    SkPixmap pixmap(SkImageInfo::Make(image->width(), image->height(), kN32_SkColorType,

+            image->alphaType()), (const void*) &pixels.front(), image->width() * 4);

+    image->readPixels(pixmap, 0, 0);

+    for (int y = 0; y < pixmap.height() / 2; ++y) {

+        for (int x = 0; x < pixmap.width(); ++x) {

+            if ((x & 4) == (y & 4)) {

+                SkTSwap(*pixmap.writable_addr32(x, y), 

+                        *pixmap.writable_addr32(pixmap.width() - x, pixmap.height() - y));

+            }

+        }

+    }

+    SkBitmap bitmap;

+    bitmap.installPixels(pixmap);

+    canvas->drawBitmap(bitmap, 0, 0);
+##
+
+#SeeAlso writable_addr writable_addr8 writable_addr16 writable_addr64 writable_addrF16 addr() addr32
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method uint64_t* writable_addr64(int x, int y) const 
+
+Returns writable base pixel address. Result is addressable as unsigned 64-bit words.
+Will trigger an assert() if Color_Type is not kRGBA_F16_SkColorType and is built
+with SK_DEBUG defined.
+
+One word corresponds to one pixel.
+
+#Param x  positive column index less than width() ##
+#Param y  positive row index less than height() ##
+
+#Return  writable unsigned 64-bit pointer to pixel ##
+
+#Example
+    SkImageInfo info = SkImageInfo::Make(3, 3, kRGBA_F16_SkColorType, kPremul_SkAlphaType);

+    uint64_t storage[9];

+    SkPixmap pixmap(info, storage, 3 * sizeof(uint64_t));

+    SkColor4f c4 { 1, 0.45f, 0.25f, 0.65f };

+    pixmap.erase(c4);

+    SkBitmap bitmap;

+    canvas->scale(10, 10);

+    bitmap.installPixels(pixmap);

+    canvas->drawBitmap(bitmap, 0, 0);

+    *pixmap.writable_addr64(1, 1) |= 0x00ff000000000000LL;

+    bitmap.installPixels(pixmap);

+    canvas->drawBitmap(bitmap, 10, 0);
+##
+
+#SeeAlso writable_addr writable_addr8 writable_addr16 writable_addr32 writable_addrF16 addr() addr64
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method uint16_t* writable_addrF16(int x, int y) const 
+
+Returns writable base pixel address. Result is addressable as unsigned 16-bit words.
+Will trigger an assert() if Color_Type is not kRGBA_F16_SkColorType and is built
+with SK_DEBUG defined.
+
+Each word represents one color component encoded as a half float.
+Four words correspond to one pixel.
+
+#Param x  positive column index less than width() ##
+#Param y  positive row index less than height() ##
+
+#Return  writable unsigned 16-bit pointer to first component of pixel ##
+
+#Example
+#Height 64
+#Description
+Left bitmap is drawn with two pixels defined in half float format. Right bitmap
+is drawn after overwriting bottom half float color with top half float color. 
+##
+    SkImageInfo info = SkImageInfo::Make(1, 2, kRGBA_F16_SkColorType, kPremul_SkAlphaType);

+    uint16_t storage[2][4];

+    SkPixmap pixmap(info, storage[0], sizeof(uint64_t));

+    SkIRect topPixelBounds = {0, 0, 1, 1};

+    pixmap.erase({ 0.65f, 0.45f, 0.25f, 1 }, &topPixelBounds);

+    SkIRect bottomPixelBounds = {0, 1, 1, 2};

+    pixmap.erase({ 0.25f, 0.65f, 0.45f, 1 }, &bottomPixelBounds);

+    SkBitmap bitmap;

+    canvas->scale(20, 20);

+    bitmap.installPixels(pixmap);

+    canvas->drawBitmap(bitmap, 0, 0);

+    uint16_t* pixel2 = pixmap.writable_addrF16(0, 1);

+    for (int i = 0; i < 4; ++i) {

+        pixel2[i] = storage[0][i];

+    }

+    bitmap.installPixels(pixmap);

+    canvas->drawBitmap(bitmap, 4, 0);

+##
+
+#SeeAlso writable_addr writable_addr8 writable_addr16 writable_addr32 writable_addr64 addr() addrF16
+
+##
+
+#Subtopic Writable_Address ##
+
+#Subtopic Writer
+
+# ------------------------------------------------------------------------------
+
+#Method bool readPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes,
+                    int srcX, int srcY, SkTransferFunctionBehavior behavior) const
+
+Copies a Rect of pixels to dstPixels. Copy starts at (srcX, srcY), and does not
+exceed
+#Formula
+(this->width(), this->height())
+##
+. dstInfo specifies width, height, Color_Type, Alpha_Type, and 
+Color_Space of destination. dstRowBytes specifics the gap from one destination
+row to the next. Returns true if pixels are copied. Returns false if
+dstInfo.addr() equals nullptr, or dstRowBytes is less than dstInfo.minRowBytes.
+
+Pixels are copied only if pixel conversion is possible. If this->colorType is
+kGray_8_SkColorType, or kAlpha_8_SkColorType; dstInfo.colorType must match.
+If this->colorType is kGray_8_SkColorType, dstInfo.colorSpace must match.
+If this->alphaType is kOpaque_SkAlphaType, dstInfo.alphaType must
+match. If this->colorSpace is nullptr, dstInfo.colorSpace must match. Returns
+false if pixel conversion is not possible.
+ 
+srcX and srcY may be negative to copy only top or left of source. Returns
+false if width() or height() is zero or negative. Returns false if 
+#Formula
+abs(srcX) >= this->width() || abs(scrY) >= this->height()
+##
+.
+
+If behavior is SkTransferFunctionBehavior::kRespect: converts source
+pixels to a linear space before converting to dstInfo.
+If behavior is SkTransferFunctionBehavior::kIgnore: source
+pixels are treated as if they are linear, regardless of their encoding.
+
+#Param dstInfo  destination width, height, Color_Type, Alpha_Type, Color_Space ##
+#Param dstPixels  destination pixel storage ##
+#Param dstRowBytes  destination row length ##
+#Param srcX  column index whose absolute value is less than width() ##
+#Param srcY  row index whose absolute value is less than height() ##
+#Param behavior  one of: SkTransferFunctionBehavior::kRespect,
+                         SkTransferFunctionBehavior::kIgnore 
+##
+
+#Return  true if pixels are copied to dstPixels ##
+
+#Example
+#Image 3
+void draw(SkCanvas* canvas) {
+    SkImageInfo info = SkImageInfo::MakeN32Premul(image->width(), image->height(),
+            canvas->imageInfo().colorSpace() ? SkColorSpace::MakeSRGB() : nullptr);
+    std::vector<int32_t> srcPixels;

+    srcPixels.resize(image->height() * image->width() * 4);

+    SkPixmap pixmap(info, (const void*) &srcPixels.front(), image->width() * 4);

+    image->readPixels(pixmap, 0, 0);

+    SkTransferFunctionBehavior behavior = canvas->imageInfo().colorSpace() ?
+            SkTransferFunctionBehavior::kRespect : SkTransferFunctionBehavior::kIgnore;
+    std::vector<int32_t> dstPixels;

+    dstPixels.resize(image->height() * image->width() * 4);

+    int offset = 0;

+    for (auto behavior : { SkTransferFunctionBehavior::kRespect,

+                           SkTransferFunctionBehavior::kIgnore} ) {

+        pixmap.readPixels(info, &dstPixels.front(), image->width() * 4, offset, 0, behavior);
+        offset += 128;
+    }
+    SkBitmap bitmap;
+    SkPixmap dstmap(info, &dstPixels.front(), image->width() * 4);
+    bitmap.installPixels(dstmap);
+    canvas->drawBitmap(bitmap, 0, 0);
+}
+##
+
+#SeeAlso erase SkBitmap::readPixels SkCanvas::drawBitmap SkCanvas::readPixels SkImage::readPixels SkSurface::readPixels
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method bool readPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes) const 
+
+Copies a Rect of pixels to dstPixels. Copy starts at (0, 0), and does not
+exceed
+#Formula
+(this->width(), this->height())
+##
+. dstInfo specifies width, height, Color_Type, Alpha_Type, and 
+Color_Space of destination. dstRowBytes specifics the gap from one destination
+row to the next. Returns true if pixels are copied. Returns false if
+dstInfo.addr() equals nullptr, or dstRowBytes is less than dstInfo.minRowBytes.
+
+Pixels are copied only if pixel conversion is possible. If this->colorType is
+kGray_8_SkColorType, or kAlpha_8_SkColorType; dstInfo.colorType must match.
+If this->colorType is kGray_8_SkColorType, dstInfo.colorSpace must match.
+If this->alphaType is kOpaque_SkAlphaType, dstInfo.alphaType must
+match. If this->colorSpace is nullptr, dstInfo.colorSpace must match. Returns
+false if pixel conversion is not possible.
+
+Returns false if this->width() or this->height() is zero or negative.
+
+#Param dstInfo  destination width, height, Color_Type, Alpha_Type, Color_Space ##
+#Param dstPixels  destination pixel storage ##
+#Param dstRowBytes  destination row length ##
+
+#Return  true if pixels are copied to dstPixels ##
+
+#Example
+#Height 128
+#Description
+Transferring the gradient from 8 bits per component to 4 bits per component
+creates visible banding.
+##
+    std::vector<int32_t> pixels;

+    const int width = 256;

+    const int height = 64;

+    pixels.resize(height * width * 4);

+    SkImageInfo srcInfo = SkImageInfo::MakeN32Premul(width, height);

+    SkPixmap srcPixmap(srcInfo, (const void*) &pixels.front(), width * 4);

+    SkColor  gradColors[] = { 0xFFAA3300, 0x7F881122 };

+    SkPoint  gradPoints[] = { { 0, 0 }, { 256, 0 } };

+    SkPaint paint;

+    paint.setShader(SkGradientShader::MakeLinear(gradPoints, gradColors, nullptr,

+                    SK_ARRAY_COUNT(gradColors), SkShader::kClamp_TileMode));

+    SkBitmap bitmap;

+    bitmap.installPixels(srcPixmap);

+    SkCanvas srcCanvas(bitmap);

+    srcCanvas.drawRect(SkRect::MakeWH(width, height), paint);

+    canvas->drawBitmap(bitmap, 0, 0);

+    std::vector<int32_t> dstPixels;

+    dstPixels.resize(height * width * 2);

+    SkImageInfo dstInfo = srcInfo.makeColorType(kARGB_4444_SkColorType);

+    srcPixmap.readPixels(dstInfo, &dstPixels.front(), width * 2);

+    SkPixmap dstPixmap(dstInfo, &dstPixels.front(), width * 2);

+    bitmap.installPixels(dstPixmap);

+    canvas->drawBitmap(bitmap, 0, 128);
+##
+
+#SeeAlso erase SkBitmap::readPixels SkCanvas::drawBitmap SkCanvas::readPixels SkImage::readPixels SkSurface::readPixels
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method bool readPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes, int srcX,
+                    int srcY) const 
+
+Copies a Rect of pixels to dstPixels. Copy starts at (srcX, srcY), and does not
+exceed
+#Formula
+(this->width(), this->height())
+##
+. dstInfo specifies width, height, Color_Type, Alpha_Type, and 
+Color_Space of destination. dstRowBytes specifics the gap from one destination
+row to the next. Returns true if pixels are copied. Returns false if
+dstInfo.addr() equals nullptr, or dstRowBytes is less than dstInfo.minRowBytes.
+
+Pixels are copied only if pixel conversion is possible. If this->colorType is
+kGray_8_SkColorType, or kAlpha_8_SkColorType; dstInfo.colorType must match.
+If this->colorType is kGray_8_SkColorType, dstInfo.colorSpace must match.
+If this->alphaType is kOpaque_SkAlphaType, dstInfo.alphaType must
+match. If this->colorSpace is nullptr, dstInfo.colorSpace must match. Returns
+false if pixel conversion is not possible.
+ 
+srcX and srcY may be negative to copy only top or left of source. Returns
+false if this->width() or this->height() is zero or negative. Returns false if 
+#Formula
+abs(srcX) >= this->width() || abs(scrY) >= this->height()
+##
+.
+
+#Param dstInfo  destination width, height, Color_Type, Alpha_Type, Color_Space ##
+#Param dstPixels  destination pixel storage ##
+#Param dstRowBytes  destination row length ##
+#Param srcX  column index whose absolute value is less than width() ##
+#Param srcY  row index whose absolute value is less than height() ##
+
+#Return  true if pixels are copied to dstPixels ##
+
+#Example
+#Image 3
+void draw(SkCanvas* canvas) {

+    SkImageInfo info = SkImageInfo::MakeN32Premul(image->width(), image->height());

+    std::vector<int32_t> srcPixels;

+    const int rowBytes = image->width() * 4;

+    srcPixels.resize(image->height() * rowBytes);

+    SkPixmap pixmap(info, (const void*) &srcPixels.front(), rowBytes);

+    image->readPixels(pixmap, 0, 0);

+    for (int offset : { 32, 64, 96 } ) {

+        std::vector<int32_t> dstPixels;

+        dstPixels.resize(image->height() * rowBytes);

+        pixmap.readPixels(info, &dstPixels.front(), rowBytes, offset, 0);

+        SkBitmap bitmap;

+        SkPixmap dstmap(info, &dstPixels.front(), rowBytes);

+        bitmap.installPixels(dstmap);

+        canvas->translate(32, 32);

+        canvas->drawBitmap(bitmap, 0, 0);

+    }

+}
+##
+
+#SeeAlso erase SkBitmap::readPixels SkCanvas::drawBitmap SkCanvas::readPixels SkImage::readPixels SkSurface::readPixels
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method bool readPixels(const SkPixmap& dst, int srcX, int srcY) const 
+
+Copies a Rect of pixels to dst. Copy starts at (srcX, srcY), and does not
+exceed (this->width(), this->height()). dst specifies width, height, Color_Type,
+Alpha_Type, and Color_Space of destination.  Returns true if pixels are copied.
+Returns false if dst.addr() equals nullptr, or dst.rowBytes is less than
+dst SkImageInfo::minRowBytes.
+
+Pixels are copied only if pixel conversion is possible. If this->colorType is
+kGray_8_SkColorType, or kAlpha_8_SkColorType; dst.info().colorType must match.
+If this->colorType is kGray_8_SkColorType, dst.info().colorSpace must match.
+If this->alphaType is kOpaque_SkAlphaType, dst.info().alphaType must
+match. If this->colorSpace is nullptr, dst.info().colorSpace must match. Returns
+false if pixel conversion is not possible.
+ 
+srcX and srcY may be negative to copy only top or left of source. Returns
+false this->width() or this->height() is zero or negative. Returns false if 
+#Formula
+abs(srcX) >= this->width() || abs(scrY) >= this->height()
+##
+.
+
+#Param dst  Image_Info and pixel address to write to ##
+#Param srcX  column index whose absolute value is less than width() ##
+#Param srcY  row index whose absolute value is less than height() ##
+
+#Return  true if pixels are copied to dst ##
+
+#Example
+#Image 3
+void draw(SkCanvas* canvas) {

+    SkImageInfo info = SkImageInfo::MakeN32Premul(image->width(), image->height());

+    std::vector<int32_t> srcPixels;

+    const int rowBytes = image->width() * 4;

+    srcPixels.resize(image->height() * rowBytes);

+    SkPixmap pixmap(info, (const void*) &srcPixels.front(), rowBytes);

+    image->readPixels(pixmap, 0, 0);

+    for (int offset : { 32, 64, 96 } ) {

+        std::vector<int32_t> dstPixels;

+        dstPixels.resize(image->height() * rowBytes);

+        SkPixmap dstmap(info, &dstPixels.front(), rowBytes);

+        pixmap.readPixels(dstmap, offset, 0);

+        SkBitmap bitmap;

+        bitmap.installPixels(dstmap);

+        canvas->translate(32, 32);

+        canvas->drawBitmap(bitmap, 0, 0);

+    }

+}
+##
+
+#SeeAlso erase SkBitmap::readPixels SkCanvas::drawBitmap SkCanvas::readPixels SkImage::readPixels SkSurface::readPixels
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method bool readPixels(const SkPixmap& dst) const 
+
+Copies pixels inside bounds() to dst. dst specifies width, height, Color_Type,
+Alpha_Type, and Color_Space of destination.  Returns true if pixels are copied.
+Returns false if dst.addr() equals nullptr, or dst.rowBytes is less than
+dst SkImageInfo::minRowBytes.
+
+Pixels are copied only if pixel conversion is possible. If this->colorType is
+kGray_8_SkColorType, or kAlpha_8_SkColorType; dst Color_Type must match.
+If this->colorType is kGray_8_SkColorType, dst Color_Space must match.
+If this->alphaType is kOpaque_SkAlphaType, dst Alpha_Type must
+match. If this->colorSpace is nullptr, dst Color_Space must match. Returns
+false if pixel conversion is not possible.
+ 
+Returns false if this->width() or this->height() is zero or negative.
+
+#Param dst  Image_Info and pixel address to write to ##
+
+#Return  true if pixels are copied to dst ##
+
+#Example
+#Image 3
+void draw(SkCanvas* canvas) {

+    SkImageInfo info = SkImageInfo::MakeN32Premul(image->width(), image->height());

+    std::vector<int32_t> srcPixels;

+    const int rowBytes = image->width() * 4;

+    srcPixels.resize(image->height() * rowBytes);

+    SkPixmap pixmap(info, (const void*) &srcPixels.front(), rowBytes);

+    image->readPixels(pixmap, 0, 0);

+    for (int index = 0; index < 3; ++index ) {

+        std::vector<int32_t> dstPixels;

+        dstPixels.resize(image->height() * rowBytes);

+        SkPixmap dstmap(info, &dstPixels.front(), rowBytes);

+        pixmap.readPixels(dstmap);

+        SkBitmap bitmap;

+        bitmap.installPixels(dstmap);

+        canvas->translate(32, 32);

+        canvas->drawBitmap(bitmap, 0, 0);

+    }

+}
+##
+
+#SeeAlso erase SkBitmap::readPixels SkCanvas::drawBitmap SkCanvas::readPixels SkImage::readPixels SkSurface::readPixels
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method bool scalePixels(const SkPixmap& dst, SkFilterQuality filterQuality) const
+
+Copies this to dst, scaling pixels to fit dst.width() and dst.height(), and
+converting pixels to match dst.colorType and dst.alphaType. Returns true if
+pixels are copied. Returns false if dst.addr() is nullptr, or dst.rowBytes is
+less than dst SkImageInfo::minRowBytes.
+
+Pixels are copied only if pixel conversion is possible. If this->colorType is
+kGray_8_SkColorType, or kAlpha_8_SkColorType; dst Color_Type must match.
+If this->colorType is kGray_8_SkColorType, dst Color_Space must match.
+If this->alphaType is kOpaque_SkAlphaType, dst Alpha_Type must
+match. If this->colorSpace is nullptr, dst Color_Space must match. Returns
+false if pixel conversion is not possible.
+
+Returns false if this->width() or this->height() is zero or negative.
+
+Scales the image, with filterQuality, to match dst.width() and dst.height().
+filterQuality kNone_SkFilterQuality is fastest, typically implemented with
+Filter_Quality_Nearest_Neighbor. kLow_SkFilterQuality is typically implemented with
+Filter_Quality_Bilerp. kMedium_SkFilterQuality is typically implemented with
+Filter_Quality_Bilerp, and Filter_Quality_MipMap when size is reduced.
+kHigh_SkFilterQuality is slowest, typically implemented with Filter_Quality_BiCubic.
+
+#Param dst  Image_Info and pixel address to write to ##
+#Param filterQuality  one of: kNone_SkFilterQuality, kLow_SkFilterQuality, 
+                      kMedium_SkFilterQuality, kHigh_SkFilterQuality
+##
+
+#Return  true if pixels are copied to dst ##
+
+#Example
+#Image 3
+void draw(SkCanvas* canvas) {

+    SkImageInfo info = SkImageInfo::MakeN32Premul(image->width(), image->height());

+    std::vector<int32_t> srcPixels;

+    int rowBytes = image->width() * 4;

+    srcPixels.resize(image->height() * rowBytes);

+    SkPixmap pixmap(info, (const void*) &srcPixels.front(), rowBytes);

+    image->readPixels(pixmap, 0, 0);

+    for (int offset : { 32, 64, 96 } ) {

+        info = SkImageInfo::MakeN32Premul(image->width() + offset, image->height());

+        rowBytes = info.width() * 4;

+        std::vector<int32_t> dstPixels;

+        dstPixels.resize(image->height() * rowBytes);

+        SkPixmap dstmap(info, &dstPixels.front(), rowBytes);

+        pixmap.scalePixels(dstmap, kMedium_SkFilterQuality);

+        SkBitmap bitmap;

+        bitmap.installPixels(dstmap);

+        canvas->translate(32, 32);

+        canvas->drawBitmap(bitmap, 0, 0);

+    }

+}
+##
+
+#SeeAlso SkCanvas::drawBitmap SkImage::scalePixels
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method bool erase(SkColor color, const SkIRect& subset) const
+
+Writes color to pixels bounded by subset; returns true on success.
+Returns false if colorType is kUnknown_SkColorType, or if subset does
+not intersect bounds().
+  
+#Param color  Unpremultiplied Color to write ##
+#Param subset bounding integer Rect of written pixels ##
+
+#Return  true if pixels are changed ##
+
+#Example
+    uint32_t storage[2];

+    SkImageInfo info = SkImageInfo::MakeN32Premul(1, 2);

+    SkPixmap pixmap(info, storage, info.minRowBytes());

+    pixmap.erase(SK_ColorBLUE, {0, 0, 1, 1});

+    pixmap.erase(SK_ColorRED, {0, 1, 1, 2});

+    SkBitmap bitmap;

+    canvas->scale(20, 20);

+    bitmap.installPixels(pixmap);

+    canvas->drawBitmap(bitmap, 0, 0);

+##
+
+#SeeAlso SkBitmap::erase SkCanvas::clear SkCanvas::drawColor
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method bool erase(SkColor color) const 
+
+Writes color to pixels inside bounds(); returns true on success.
+Returns false if colorType is kUnknown_SkColorType, or if bounds()
+is empty.
+
+#Param color  Unpremultiplied Color to write ##
+
+#Return  true if pixels are changed ##
+
+#Example
+    uint32_t storage[2];

+    SkImageInfo info = SkImageInfo::MakeN32Premul(1, 2);

+    SkPixmap pixmap(info, storage, info.minRowBytes());

+    pixmap.erase(SK_ColorBLUE);

+    SkBitmap bitmap;

+    canvas->scale(20, 20);

+    bitmap.installPixels(pixmap);

+    canvas->drawBitmap(bitmap, 0, 0);

+##
+
+#SeeAlso SkBitmap::erase SkCanvas::clear SkCanvas::drawColor
+
+##
+
+# ------------------------------------------------------------------------------
+
+#Method bool erase(const SkColor4f& color, const SkIRect* subset = nullptr) const
+
+Writes color to pixels bounded by subset; returns true on success.
+if subset is nullptr, writes colors pixels inside bounds(). Returns false if
+colorType is kUnknown_SkColorType, if subset is not nullptr and does
+not intersect bounds(), or if subset is nullptr and bounds() is empty.
+
+#Param color  Unpremultiplied Color to write ##
+#Param subset  bounding integer Rect of pixels to write; may be nullptr ##
+
+#Return  true if pixels are changed ##
+
+#Example
+    uint32_t storage[2];

+    SkImageInfo info = SkImageInfo::MakeN32Premul(1, 2);

+    SkPixmap pixmap(info, storage, info.minRowBytes());

+    SkIRect topPixelBounds = {0, 0, 1, 1};

+    pixmap.erase({ 0.65f, 0.45f, 0.25f, 1 }, &topPixelBounds);

+    SkIRect bottomPixelBounds = {0, 1, 1, 2};

+    pixmap.erase({ 0.25f, 0.65f, 0.45f, 1 }, &bottomPixelBounds);

+    SkBitmap bitmap;

+    canvas->scale(20, 20);

+    bitmap.installPixels(pixmap);

+    canvas->drawBitmap(bitmap, 0, 0);

+##
+
+#SeeAlso SkBitmap::erase SkCanvas::clear SkCanvas::drawColor
+
+##
+
+
+#Subtopic Writer ##
+
+#Class SkPixmap ##
+
+#Topic Pixmap ##