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>

5 files changed, 2195 insertions, 54 deletions

diff --git a/docs/SkCanvas_Reference.bmh b/docs/SkCanvas_Reference.bmh
index 632c7c1260..ae351421a5 100644
--- a/docs/SkCanvas_Reference.bmh
+++ b/docs/SkCanvas_Reference.bmh
@@ -95,7 +95,7 @@ when no Surface is required, and some helpers implicitly create Raster_Surface.
 # drawArc                          # Draws Arc using Clip, Matrix, and Paint.##
 # drawAtlas                        # Draws sprites using Clip, Matrix, and Paint.##
 # drawBitmap                       # Draws Bitmap at (x, y) position. ##
-# drawBitmapLattice                # Draws differentially stretched Bitmap. ##
+# drawBitmapLattice                # Draws proportionally stretched Bitmap. ##
 # drawBitmapNine                   # Draws Nine_Patch Bitmap. ##
 # drawBitmapRect                   # Draws Bitmap, source Rect to destination Rect. ##
 # drawCircle                       # Draws Circle using Clip, Matrix, and Paint. ##
@@ -104,7 +104,7 @@ when no Surface is required, and some helpers implicitly create Raster_Surface.
 # drawDrawable                     # Draws Drawable, encapsulated drawing commands. ##
 # drawIRect                        # Draws IRect using Clip, Matrix, and Paint. ##
 # drawImage                        # Draws Image at (x, y) position. ##
-# drawImageLattice                 # Draws differentially stretched Image. ##
+# drawImageLattice                 # Draws proportionally stretched Image. ##
 # drawImageNine                    # Draws Nine_Patch Image. ##
 # drawImageRect                    # Draws Image, source Rect to destination Rect. ##
 # drawLine                         # Draws line segment between two points.##
@@ -314,10 +314,10 @@ void draw(SkCanvas* ) {
 
 #Method SkCanvas()
 
-Creates an empty canvas with no backing device or pixels, with 
+Creates an empty Canvas with no backing device or pixels, with 
 a width and height of zero.
 
-#Return  empty canvas ##
+#Return  empty Canvas ##
 
 #Example
 
@@ -369,11 +369,11 @@ void draw(SkCanvas* canvas) {
 Creates Canvas of the specified dimensions without a Surface.
 Used by Subclasses with custom implementations for draw methods.
 
-If props equals nullptr, Surface_Properties are created with Surface_Properties_Legacy_Font_Host settings,
-which choose the pixel striping direction and order. Since a platform may dynamically
-change its direction when the device is rotated, and since a platform may have
-multiple monitors with different characteristics, it's best not to rely on this
-legacy behavior.
+If props equals nullptr, Surface_Properties are created with
+Surface_Properties_Legacy_Font_Host settings, which choose the pixel striping 
+direction and order. Since a platform may dynamically change its direction when
+the device is rotated, and since a platform may have multiple monitors with
+different characteristics, it is best not to rely on this legacy behavior.
 
 #Param width  zero or greater ##
 #Param height zero or greater ##
@@ -465,16 +465,16 @@ The actual output depends on the installed fonts.
     }
 
     #StdOut
-    -----

-    ---x-

-    ---x-

-    ---x-

-    ---x-

-    ---x-

-    ---x-

-    -----

-    ---x-

-    ---x-

+    -----
+    ---x-
+    ---x-
+    ---x-
+    ---x-
+    ---x-
+    ---x-
+    -----
+    ---x-
+    ---x-
     -----
     #StdOut ##
 ##
@@ -1252,7 +1252,7 @@ this->imageInfo.alphaType()
 
 #Param info  width, height, Image_Color_Type, and Image_Alpha_Type of pixels ##
 #Param pixels  pixels to copy, of size info.height() times rowBytes, or larger ##
-#Param rowBytes  size of one pixels row; info.width() times pixel size, or larger ##
+#Param rowBytes  size of one row of pixels; info.width() times pixel size, or larger ##
 #Param x  offset into Canvas writable pixels in x; may be negative ##
 #Param y  offset into Canvas writable pixels in y; may be negative ##
 
@@ -1551,6 +1551,7 @@ depth = 1
 # ------------------------------------------------------------------------------
 
 #Topic Layer
+#Substitute layer
 #Alias Layers
 
 Layer allocates a temporary Bitmap to draw into. When the drawing is
@@ -3118,7 +3119,7 @@ void draw(SkCanvas* canvas) {
     enum PointMode {
         kPoints_PointMode,
         kLines_PointMode,
-        kPolygon_PointMode 
+        kPolygon_PointMode,
     };
 ##
 
@@ -4284,7 +4285,7 @@ void draw(SkCanvas* canvas) {
 #Method void drawImageNine(const SkImage* image, const SkIRect& center, const SkRect& dst,
                        const SkPaint* paint = nullptr)
 
-Draw Image image stretched differentially to fit into Rect dst.
+Draw Image image stretched proportionally to fit into Rect dst.
 IRect center divides the image into nine sections: four sides, four corners, and
 the center. Corners are unmodified or scaled down proportionately if their sides
 are larger than dst; center and four sides are scaled to fit remaining space, if any.
@@ -4350,7 +4351,7 @@ void draw(SkCanvas* canvas) {
 #Method void drawImageNine(const sk_sp<SkImage>& image, const SkIRect& center, const SkRect& dst,
                        const SkPaint* paint = nullptr) 
 
-Draw Image image stretched differentially to fit into Rect dst.
+Draw Image image stretched proportionally to fit into Rect dst.
 IRect center divides the image into nine sections: four sides, four corners, and
 the center. Corners are not scaled, or scaled down proportionately if their sides
 are larger than dst; center and four sides are scaled to fit remaining space, if any.
@@ -4635,7 +4636,7 @@ void draw(SkCanvas* canvas) {
 #Method void drawBitmapNine(const SkBitmap& bitmap, const SkIRect& center, const SkRect& dst,
                         const SkPaint* paint = nullptr)
 
-Draw Bitmap bitmap stretched differentially to fit into Rect dst.
+Draw Bitmap bitmap stretched proportionally to fit into Rect dst.
 IRect center divides the bitmap into nine sections: four sides, four corners,
 and the center. Corners are not scaled, or scaled down proportionately if their
 sides are larger than dst; center and four sides are scaled to fit remaining
@@ -4783,7 +4784,7 @@ void draw(SkCanvas* canvas) {
 #Method void drawBitmapLattice(const SkBitmap& bitmap, const Lattice& lattice, const SkRect& dst,
                            const SkPaint* paint = nullptr)
 
-Draw Bitmap bitmap stretched differentially to fit into Rect dst.
+Draw Bitmap bitmap stretched proportionally to fit into Rect dst.
 
 Lattice lattice divides bitmap into a rectangular grid.
 Each intersection of an even-numbered row and column is fixed; like the corners
@@ -4860,7 +4861,7 @@ void draw(SkCanvas* canvas) {
 #Method void drawImageLattice(const SkImage* image, const Lattice& lattice, const SkRect& dst,
                           const SkPaint* paint = nullptr)
 
-Draw Image image stretched differentially to fit into Rect dst.
+Draw Image image stretched proportionally to fit into Rect dst.
 
 Lattice lattice divides image into a rectangular grid.
 Each intersection of an even-numbered row and column is fixed; like the corners
diff --git a/docs/SkPaint_Reference.bmh b/docs/SkPaint_Reference.bmh
index 30007f185a..0b80bf7e07 100644
--- a/docs/SkPaint_Reference.bmh
+++ b/docs/SkPaint_Reference.bmh
@@ -348,7 +348,7 @@ This prevents objects with Reference_Count from being modified once Paint refers
 
 #Method SkPaint(SkPaint&& paint)
 
-    Implements a move constructor to avoid incrementing the reference counts
+    Implements a move constructor to avoid increasing the reference counts
     of objects referenced by the paint.
 
     After the call, paint is undefined, and can be safely destructed.
@@ -443,7 +443,7 @@ are increased by one. paint is unmodified.
 
 #Method SkPaint& operator=(SkPaint&& paint)
 
-Moves the paint to avoid incrementing the reference counts
+Moves the paint to avoid increasing the reference counts
 of objects referenced by the paint parameter. Objects containing Reference_Count in the
 prior destination are decreased by one; those objects are deleted if the resulting count
 is zero.
@@ -1178,7 +1178,7 @@ kLCDRenderText_Flag or kSubpixelText_Flag (or both) at compile time.
 
 Linear_Text selects whether text is rendered as a Glyph or as a Path.
 If kLinearText_Flag is set, it has the same effect as setting Hinting to kNormal_Hinting.
-If kLinearText_Flag is clear, it's the same as setting Hinting to kNo_Hinting.
+If kLinearText_Flag is clear, it is the same as setting Hinting to kNo_Hinting.
 
 #Method bool isLinearText() const
 
@@ -2838,7 +2838,7 @@ void draw(SkCanvas* canvas) {
 
     Optional colors used when filling a path, such as a gradient.
 
-    Sets Shader to shader, decrementing Reference_Count of the previous Shader.
+    Sets Shader to shader, decreasing Reference_Count of the previous Shader.
     Does not alter shader Reference_Count.
 
     #Param shader  how geometry is filled with color; if nullptr, Color is used instead ##
@@ -2930,7 +2930,7 @@ void draw(SkCanvas* canvas) {
 
 #Method void setColorFilter(sk_sp<SkColorFilter> colorFilter)
 
-    Sets Color_Filter to filter, decrementing Reference_Count of the previous Color_Filter. 
+    Sets Color_Filter to filter, decreasing Reference_Count of the previous Color_Filter. 
     Pass nullptr to clear Color_Filter.
     Does not alter filter Reference_Count.
 
@@ -3120,7 +3120,7 @@ If Paint has no Path_Effect, the path geometry is unaltered when filled or strok
 #Method void setPathEffect(sk_sp<SkPathEffect> pathEffect)
 
     Sets Path_Effect to pathEffect, 
-    decrementing Reference_Count of the previous Path_Effect. 
+    decreasing Reference_Count of the previous Path_Effect. 
     Pass nullptr to leave the path geometry unaltered.
     Does not alter pathEffect Reference_Count.
 
@@ -3204,7 +3204,7 @@ Set Mask_Filter to nullptr to prevent Mask_Filter from modifying the draw.
 #Method void setMaskFilter(sk_sp<SkMaskFilter> maskFilter)
 
     Sets Mask_Filter to maskFilter,
-    decrementing Reference_Count of the previous Mask_Filter. 
+    decreasing Reference_Count of the previous Mask_Filter. 
     Pass nullptr to clear Mask_Filter and leave Mask_Filter effect on Mask_Alpha unaltered.
     Does not affect Rasterizer.
     Does not alter maskFilter Reference_Count.
@@ -3299,7 +3299,7 @@ implementation.
 #Method void setTypeface(sk_sp<SkTypeface> typeface)
 
     Sets Typeface to typeface,
-    decrementing Reference_Count of the previous Typeface. 
+    decreasing Reference_Count of the previous Typeface. 
     Pass nullptr to clear Typeface and use the default typeface.
     Does not alter typeface Reference_Count.
 
@@ -3416,7 +3416,7 @@ Path, and Text.
 #Method void setRasterizer(sk_sp<SkRasterizer> rasterizer)
 
     Sets Rasterizer to rasterizer,
-    decrementing Reference_Count of the previous Rasterizer. 
+    decreasing Reference_Count of the previous Rasterizer. 
     Pass nullptr to clear Rasterizer and leave Rasterizer effect on Mask_Alpha unaltered.
     Does not affect Mask_Filter.
     Does not alter rasterizer Reference_Count.
@@ -3521,7 +3521,7 @@ Mask_Filter and Rasterizer.
 #Method void setImageFilter(sk_sp<SkImageFilter> imageFilter)
 
     Sets Image_Filter to imageFilter,
-    decrementing Reference_Count of the previous Image_Filter. 
+    decreasing Reference_Count of the previous Image_Filter. 
     Pass nullptr to clear Image_Filter, and remove Image_Filter effect
     on drawing.
     Does not affect Rasterizer or Mask_Filter.
@@ -3642,7 +3642,7 @@ Deprecated.
 #Method void setDrawLooper(sk_sp<SkDrawLooper> drawLooper)
 
     Sets Draw_Looper to drawLooper,
-    decrementing Reference_Count of the previous drawLooper. 
+    decreasing Reference_Count of the previous drawLooper. 
     Pass nullptr to clear Draw_Looper and leave Draw_Looper effect on drawing unaltered.
     Does not alter drawLooper Reference_Count.
 
@@ -4000,11 +4000,11 @@ All character encoding are able to represent all of Unicode, differing only
 in the total storage required.
 
 #A UTF-8 (RFC 3629) # https://tools.ietf.org/html/rfc3629 ## is made up of 8-bit bytes, 
-and is a superset of ASCII.
-#A UTF-16 (RFC 2781) # https://tools.ietf.org/html/rfc2781 ## is made up of 16-bit words, 
-and is a superset of Unicode ranges 0x0000 to 0xD7FF and 0xE000 to 0xFFFF.
-#A UTF-32 # http://www.unicode.org/versions/Unicode5.0.0/ch03.pdf ## is
-made up of 32-bit words, and is a superset of Unicode.
+and encodes ASCII in one byte, and all valid code points in Unicode in multiple bytes.
+#A UTF-16 (RFC 2781) # https://tools.ietf.org/html/rfc2781 ## uses one or two 16-bit words, 
+and encodes Unicode ranges 0x0000 to 0xD7FF and 0xE000 to 0xFFFF in one word.
+#A UTF-32 # http://www.unicode.org/versions/Unicode5.0.0/ch03.pdf ## describes
+a 32-bit word, which encodes all code points in Unicode.
 
 Font_Manager uses font data to convert character code points into glyph indices. 
 A glyph index is a 16-bit word.
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 ##
diff --git a/docs/undocumented.bmh b/docs/undocumented.bmh
index 9a7c488d67..ad7233f2b6 100644
--- a/docs/undocumented.bmh
+++ b/docs/undocumented.bmh
@@ -14,7 +14,10 @@
  SaveLayerFlags # not external; need to add typedef support
  SkUserConfig  # not external, but still thinking about how markup refers to this
  SkXXX.h        # ditto
+ SkXXX_Reference # ditto
  Skia           # ditto
+ SK_DEBUG       # ditto
+ SK_RELEASE     # ditto
  SK_USE_FREETYPE_EMBOLDEN # ditto
  SK_SUPPORT_LEGACY_PAINT_TEXTDECORATION # ditto
  SK_BUILD_FOR_ANDROID_FRAMEWORK # ditto
@@ -53,6 +56,13 @@ FT_Load_Glyph
 #Class SkBitmap
     #Subtopic Row_Bytes
     ##
+    #Method void erase(SkColor c, const SkIRect& area) const
+    ##
+    #Method bool installPixels(const SkImageInfo& info, void* pixels, size_t rowBytes)
+    ##
+    #Method bool readPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes,
+                    int srcX, int srcY, SkTransferFunctionBehavior behavior) const
+    ##
 #Class ##
 ##
 
@@ -141,6 +151,16 @@ FT_Load_Glyph
 #Topic ##
 
 #Topic Color_Space
+#Class SkColorSpace
+    #Method static sk_sp<SkColorSpace> MakeSRGBLinear()
+    ##
+##
+#EnumClass SkTransferFunctionBehavior
+#Const kRespect 0
+##
+#Const kIgnore 1
+##
+#EnumClass ##
 ##
 
 #Topic Core_Graphics
@@ -209,6 +229,18 @@ FT_Load_Glyph
     #Const kHigh_SkFilterQuality 3
     ##
 #Enum ##
+#Subtopic Nearest_Neighbor
+#Substitute nearest neighbor filter
+##
+#Subtopic Bilerp
+#Substitute bilerp filter
+##
+#Subtopic MipMap
+#Substitute mip-map filter
+##
+#Subtopic BiCubic
+#Substitute bicubic filter
+##
 #Topic ##
 
 #Topic Font
@@ -242,12 +274,21 @@ FT_Load_Glyph
 
 #Topic Image
     #Subtopic Alpha_Type
+    #Alias Alpha_Type
         #Enum SkAlphaType
+            #Const kUnknown_SkAlphaType 0
+            ##
+            #Const kOpaque_SkAlphaType 1
+            ##
             #Const kPremul_SkAlphaType 2
             ##
+            #Const kUnpremul_SkAlphaType 3
+            ##
         ##
     #Subtopic ##
-    #Subtopic Color_Type 
+    #Subtopic Color_Type
+    #Alias Color_Type
+    #Alias Color_Types
         #Enum SkColorType
             #Const kUnknown_SkColorType 0
             ##
@@ -276,12 +317,27 @@ FT_Load_Glyph
         #Struct SkImageInfo
             #Method SkImageInfo()
             ##
+            #Method SkImageInfo makeColorSpace(sk_sp<SkColorSpace> cs) const
+            ##
+            #Method size_t minRowBytes() const
+            ##
+            #Method bool isOpaque() const
+            ##
+            #Method int bytesPerPixel() const
+            ##
         ## 
     #Subtopic ##
     #Class SkImage
         #Method sk_sp<SkShader> makeShader(SkShader::TileMode, SkShader::TileMode,
                                    const SkMatrix* localMatrix = nullptr) const
         ##
+        #Method static sk_sp<SkImage> MakeRasterCopy(const SkPixmap&)
+        ##
+        #Method bool readPixels(const SkPixmap& dst, int srcX, int srcY,
+                    CachingHint = kAllow_CachingHint) const
+        ##
+        #Method bool scalePixels(const SkPixmap& dst, SkFilterQuality, CachingHint = kAllow_CachingHint) const
+        ##
     ##
 #Topic ##
 
@@ -297,6 +353,8 @@ FT_Load_Glyph
 
 #Topic IRect
 #Struct SkIRect
+    #Method bool intersect(const SkIRect& r)
+    ##
 ##
 ##
 
@@ -308,6 +366,20 @@ FT_Load_Glyph
 #Topic ##
 
 #Topic Mask
+#Class SkMask
+    #Enum Format
+        #Const kBW_Format 0
+        ##
+        #Const kA8_Format 1
+        ##
+        #Const k3D_Format 2
+        ##
+        #Const kARGB32_Format 3
+        ##
+        k#Const LCD16_Format 4
+        ##
+    ##
+##
 #Topic ##
 
 #Topic Mask_Alpha
@@ -318,6 +390,11 @@ FT_Load_Glyph
 #Class ##
 #Topic ##
 
+#Topic Math
+    #Method static inline bool sk_64_isS32(int64_t value)
+    ##
+##
+
 #Topic Matrix
 #Struct SkMatrix
 #Struct ##
@@ -405,12 +482,12 @@ FT_Load_Glyph
 ##
 ##
 
-#Enum SkPixelGeometry
+#Topic PixelRef
+#Class SkPixelRef
 ##
-
-#Topic Pixmap
-#Class SkPixmap
 ##
+
+#Enum SkPixelGeometry
 ##
 
 #Topic Point
@@ -533,6 +610,8 @@ FT_Load_Glyph
     #Method static sk_sp<SkSurface> MakeRasterDirect(const SkImageInfo&, void* pixels, size_t rowBytes,
                                              const SkSurfaceProps* = nullptr)
     ##
+    #Method bool readPixels(const SkPixmap& dst, int srcX, int srcY);
+    ##
 ##
 #Subtopic Properties
     #Class SkSurfaceProps
diff --git a/docs/usingBookmaker.bmh b/docs/usingBookmaker.bmh
index 60505ca279..16775c5716 100644
--- a/docs/usingBookmaker.bmh
+++ b/docs/usingBookmaker.bmh
@@ -25,15 +25,35 @@ $ ninja -C out/dir bookmaker
 ##

 

 Generate an starter Bookmaker file from an existing include.

-This writes SkXXX.bmh in the current directory, which is

-out/dir/obj/ from an IDE.

 

 #Code

-$ ./out/dir/bookmaker -t -i include/core/SkXXX.h

+$ ./out/dir/bookmaker -i include/core/SkXXX.h -t docs

 ##

 

-Copy SkXXX.bmh to docs.

-Use your favorite editor to fill out docs/SkXXX.bmh.

+If a method or function has an unnamed parameter, bookmaker generates an error:

+

+#Code

+###$

+C:/puregit/include/core/SkPixmap.h(208): error: #Method missing param name

+bool erase(const SkColor4f&, const SkIRect* subset = nullptr) const

+           ^

+$$$#

+##

+

+All parameters require names to allow markdown and doxygen documents to refer to

+them. After naming all parameters, check in the include before continuing.

+

+A successful run generates

+#Code

+docs/SkXXX_Reference.bmh

+##

+.

+

+Next, use your favorite editor to fill out

+#Code

+docs/SkXXX_Reference.bmh

+##

+.

 

 #Subtopic Style

 

@@ -102,13 +122,14 @@ This reports if a method no longer exists or its parameters have changed.
 $ ./out/dir/bookmaker -x -b docs/SkXXX.bmh -i include/core/SkXXX.h

 ##

 

-Generate an updated include header.

-This writes the updated SkXXX.h to the current directory.

+Generate an updated include header. Run:

 

 #Code

 $ ./out/dir/bookmaker -p -b docs -i include/core/SkXXX.h

 ##

 

+to write the updated SkXXX.h to the current directory.

+

 #Subtopic Bugs

 

 Bookmaker bugs are tracked #A here # bug.skia.org/6898 ##.