06c20f356d
fix a couple of fiddles with changed output rewrite some SkSurface image makers move towards replacing SkImageInfo.h R=caryclark@google.com Docs-Preview: https://skia.org/?cl=115163 Bug: skia:6898 Change-Id: Id9895b051cd457336c30250a69cf95359d1d34d7 Reviewed-on: https://skia-review.googlesource.com/115163 Commit-Queue: Cary Clark <caryclark@skia.org> Reviewed-by: Cary Clark <caryclark@skia.org>
2262 lines
77 KiB
Plaintext
2262 lines
77 KiB
Plaintext
#Topic Image_Info
|
|
#Alias Image_Info_Reference
|
|
|
|
Image_Info specifies the dimensions and encoding of the pixels in a Bitmap.
|
|
The dimensions are integral width and height. The encoding is how pixel
|
|
bits describe Color_Alpha, transparency; Color components red, blue,
|
|
and green; and Color_Space, the range and linearity of colors.
|
|
|
|
Image_Info describes an uncompressed raster pixels. In contrast, Image
|
|
additionally describes compressed pixels like PNG, and Surface describes
|
|
destinations on the GPU. Image and Surface may be specified by Image_Info,
|
|
but Image and Surface may not contain Image_Info.
|
|
|
|
#Subtopic Overview
|
|
#Subtopic Subtopic
|
|
#Populate
|
|
##
|
|
##
|
|
|
|
#Subtopic Constant
|
|
#Populate
|
|
##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
#Subtopic Alpha_Type
|
|
#Line # encoding for pixel transparency ##
|
|
#Alias Alpha_Type
|
|
#Alias Alpha_Types
|
|
|
|
#PhraseDef list_of_alpha_types
|
|
kUnknown_SkAlphaType, kOpaque_SkAlphaType, kPremul_SkAlphaType,
|
|
kUnpremul_SkAlphaType
|
|
##
|
|
|
|
#Enum SkAlphaType
|
|
#Line # encoding for pixel transparency ##
|
|
|
|
#Code
|
|
enum SkAlphaType {
|
|
kUnknown_SkAlphaType,
|
|
kOpaque_SkAlphaType,
|
|
kPremul_SkAlphaType,
|
|
kUnpremul_SkAlphaType,
|
|
kLastEnum_SkAlphaType = kUnpremul_SkAlphaType,
|
|
};
|
|
##
|
|
|
|
Describes how to interpret the alpha component of a pixel. A pixel may
|
|
be opaque, or Color_Alpha, describing multiple levels of transparency.
|
|
|
|
In simple blending, Color_Alpha weights the draw color and the destination
|
|
color to create a new color. If alpha describes a weight from zero to one:
|
|
|
|
#Formula
|
|
new color = draw color * alpha + destination color * (1 - alpha)
|
|
##
|
|
|
|
In practice alpha is encoded in two or more bits, where 1.0 equals all bits set.
|
|
|
|
Color_RGB may have Color_Alpha included in each component value; the stored
|
|
value is the original Color_RGB multiplied by Color_Alpha. Premultiplied color
|
|
components improve performance.
|
|
|
|
#Const kUnknown_SkAlphaType 0
|
|
Alpha_Type is uninitialized.
|
|
##
|
|
#Const kOpaque_SkAlphaType 1
|
|
Pixels are opaque. The Color_Type must have no explicit alpha
|
|
component, or all alpha components must be set to their maximum value.
|
|
##
|
|
#Const kPremul_SkAlphaType 2
|
|
Pixels have alpha premultiplied into color components.
|
|
Surface pixels must be premultiplied.
|
|
##
|
|
#Const kUnpremul_SkAlphaType 3
|
|
Pixel color component values are independent of alpha value.
|
|
Images generated from encoded data like PNG do not premultiply pixel color
|
|
components. kUnpremul_SkAlphaType is supported for Image pixels, but not for
|
|
Surface pixels.
|
|
##
|
|
|
|
#NoExample
|
|
##
|
|
|
|
#SeeAlso SkColorType SkColorSpace
|
|
|
|
#Enum SkAlphaType ##
|
|
|
|
#Subtopic Opaque
|
|
|
|
Use Opaque as a hint to optimize drawing when alpha component
|
|
of all pixel is set to its maximum value of 1.0; all alpha component bits are set.
|
|
If Image_Info is set to Opaque but all alpha values are not 1.0, results are
|
|
undefined.
|
|
|
|
#Example
|
|
#Height 64
|
|
#Description
|
|
SkPreMultiplyARGB parameter a is set to 255, its maximum value, and is interpreted
|
|
as Color_Alpha of 1.0. kOpaque_SkAlphaType may be set to improve performance.
|
|
If SkPreMultiplyARGB parameter a is set to a value smaller than 255,
|
|
kPremul_SkAlphaType must be used instead to avoid undefined results.
|
|
The four displayed values are the original component values, though not necessarily
|
|
in the same order.
|
|
##
|
|
SkPMColor color = SkPreMultiplyARGB(255, 50, 100, 150);
|
|
SkString s;
|
|
s.printf("%u %u %u %u", SkColorGetA(color), SkColorGetR(color),
|
|
SkColorGetG(color), SkColorGetB(color));
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
canvas->drawString(s, 10, 62, paint);
|
|
canvas->scale(50, 50);
|
|
SkBitmap bitmap;
|
|
SkImageInfo imageInfo = SkImageInfo::Make(1, 1, kN32_SkColorType, kOpaque_SkAlphaType);
|
|
if (bitmap.installPixels(imageInfo, (void*) &color, imageInfo.minRowBytes())) {
|
|
canvas->drawBitmap(bitmap, 0, 0);
|
|
}
|
|
##
|
|
|
|
#Subtopic Opaque ##
|
|
|
|
#Subtopic Premul
|
|
|
|
Use Premul when stored color components are the original color multiplied by the
|
|
alpha component. The alpha component range of 0.0 to 1.0 is achieved by dividing
|
|
the integer bit value by the maximum bit value.
|
|
|
|
#Formula
|
|
stored color = original color * alpha / max alpha
|
|
##
|
|
|
|
The color component must be equal to or smaller than the alpha component,
|
|
or the results are undefined.
|
|
|
|
#Example
|
|
#Description
|
|
SkPreMultiplyARGB parameter a is set to 150, less than its maximum value, and is
|
|
interpreted as Color_Alpha of about 0.6. kPremul_SkAlphaType must be set, since
|
|
SkPreMultiplyARGB parameter a is set to a value smaller than 255,
|
|
to avoid undefined results.
|
|
The four displayed values reflect that the alpha component has been multiplied
|
|
by the original color.
|
|
##
|
|
#Height 64
|
|
SkPMColor color = SkPreMultiplyARGB(150, 50, 100, 150);
|
|
SkString s;
|
|
s.printf("%u %u %u %u", SkColorGetA(color), SkColorGetR(color),
|
|
SkColorGetG(color), SkColorGetB(color));
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
canvas->drawString(s, 10, 62, paint);
|
|
canvas->scale(50, 50);
|
|
SkBitmap bitmap;
|
|
SkImageInfo imageInfo = SkImageInfo::Make(1, 1, kN32_SkColorType, kPremul_SkAlphaType);
|
|
if (bitmap.installPixels(imageInfo, (void*) &color, imageInfo.minRowBytes())) {
|
|
canvas->drawBitmap(bitmap, 0, 0);
|
|
}
|
|
##
|
|
|
|
#Subtopic Premul ##
|
|
|
|
#Subtopic Unpremul
|
|
|
|
Use Unpremul if stored color components are not divided by the alpha component.
|
|
Some drawing destinations may not support Unpremul.
|
|
|
|
#Bug 7079
|
|
#Example
|
|
#Height 64
|
|
#Description
|
|
SkColorSetARGB parameter a is set to 150, less than its maximum value, and is
|
|
interpreted as Color_Alpha of about 0.6. color is not premultiplied;
|
|
color components may have values greater than color alpha.
|
|
The four displayed values are the original component values, though not necessarily
|
|
in the same order.
|
|
##
|
|
SkColor color = SkColorSetARGB(150, 50, 100, 255);
|
|
SkString s;
|
|
s.printf("%u %u %u %u", SkColorGetA(color), SkColorGetR(color),
|
|
SkColorGetG(color), SkColorGetB(color));
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
canvas->drawString(s, 10, 62, paint);
|
|
canvas->scale(50, 50);
|
|
SkBitmap bitmap;
|
|
SkImageInfo imageInfo = SkImageInfo::Make(1, 1, kN32_SkColorType, kUnpremul_SkAlphaType);
|
|
if (bitmap.installPixels(imageInfo, (void*) &color, imageInfo.minRowBytes())) {
|
|
canvas->drawBitmap(bitmap, 0, 0);
|
|
}
|
|
##
|
|
|
|
#Subtopic Unpremul ##
|
|
|
|
#Method static inline bool SkAlphaTypeIsOpaque(SkAlphaType at)
|
|
#In Property
|
|
#Line # returns if Alpha_Type equals kOpaque_SkAlphaType ##
|
|
|
|
#Param at one of: #list_of_alpha_types#
|
|
##
|
|
#Return true if at equals kOpaque_SkAlphaType ##
|
|
#NoExample
|
|
##
|
|
##
|
|
|
|
#Subtopic Alpha_Type ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
#Subtopic Color_Type
|
|
#Line # encoding for pixel color ##
|
|
#Alias Color_Type
|
|
#Alias Color_Types
|
|
|
|
#PhraseDef list_of_color_types
|
|
kUnknown_SkColorType, kAlpha_8_SkColorType, kRGB_565_SkColorType,
|
|
kARGB_4444_SkColorType, kRGBA_8888_SkColorType, kRGB_888x_SkColorType,
|
|
kBGRA_8888_SkColorType, kRGBA_1010102_SkColorType, kRGB_101010x_SkColorType,
|
|
kGray_8_SkColorType, kRGBA_F16_SkColorType
|
|
##
|
|
|
|
#Subtopic Native
|
|
#Alias Native_Color_Type
|
|
#Substitute native SkColorType
|
|
##
|
|
|
|
#Enum SkColorType
|
|
#Line # encoding for pixel color ##
|
|
|
|
#Code
|
|
###$
|
|
enum SkColorType {
|
|
kUnknown_SkColorType,
|
|
kAlpha_8_SkColorType,
|
|
kRGB_565_SkColorType,
|
|
kARGB_4444_SkColorType,
|
|
kRGBA_8888_SkColorType,
|
|
kRGB_888x_SkColorType,
|
|
kBGRA_8888_SkColorType,
|
|
kRGBA_1010102_SkColorType,
|
|
kRGB_101010x_SkColorType,
|
|
kGray_8_SkColorType,
|
|
kRGBA_F16_SkColorType,
|
|
|
|
kLastEnum_SkColorType = kRGBA_F16_SkColorType,
|
|
|
|
#if SK_PMCOLOR_BYTE_ORDER(B,G,R,A)
|
|
kN32_SkColorType = kBGRA_8888_SkColorType,
|
|
#elif SK_PMCOLOR_BYTE_ORDER(R,G,B,A)
|
|
kN32_SkColorType = kRGBA_8888_SkColorType,
|
|
#else
|
|
#error "SK_*32_SHIFT values must correspond to BGRA or RGBA byte order"
|
|
#endif
|
|
};
|
|
$$$#
|
|
##
|
|
|
|
Describes how pixel bits encode color. A pixel may be an alpha mask, a
|
|
gray level, Color_RGB, or Color_ARGB.
|
|
|
|
kN32_SkColorType selects the native 32-bit Color_ARGB format. On Little_Endian
|
|
processors, pixels containing 8-bit Color_ARGB components pack into 32-bit
|
|
kBGRA_8888_SkColorType. On Big_Endian processors, pixels pack into 32-bit
|
|
kRGBA_8888_SkColorType.
|
|
|
|
#Const kUnknown_SkColorType 0
|
|
|
|
##
|
|
#Const kAlpha_8_SkColorType 1
|
|
Encodes Color_Alpha as Alpha_8 pixel in an 8-bit byte.
|
|
##
|
|
#Const kRGB_565_SkColorType 2
|
|
Encodes Color_RGB as BGR_565 pixel in a 16-bit word.
|
|
##
|
|
#Const kARGB_4444_SkColorType 3
|
|
Encodes Color_ARGB as ABGR_4444 pixel in a 16-bit word.
|
|
##
|
|
#Const kRGBA_8888_SkColorType 4
|
|
Encodes Color_ARGB as RGBA_8888 pixel in a 32-bit word.
|
|
##
|
|
#Const kRGB_888x_SkColorType 5
|
|
Encodes Color_RGB as RGB_888x pixel in a 32-bit word.
|
|
##
|
|
#Const kBGRA_8888_SkColorType 6
|
|
Encodes Color_ARGB as BGRA_8888 pixel in a 32-bit word.
|
|
##
|
|
#Const kRGBA_1010102_SkColorType 7
|
|
Encodes Color_ARGB as RGBA_1010102 pixel in a 32-bit word.
|
|
##
|
|
#Const kRGB_101010x_SkColorType 8
|
|
Encodes Color_RGB as RGB_101010x pixel in a 32-bit word.
|
|
##
|
|
#Const kGray_8_SkColorType 9
|
|
Encodes Color_Gray as Gray_8 in an 8-bit byte.
|
|
##
|
|
#Const kRGBA_F16_SkColorType 10
|
|
Encodes Color_ARGB as RGBA_F16 in a 64-bit word.
|
|
##
|
|
|
|
#ToDo can be 4 or 6; how to document? ##
|
|
#Const kN32_SkColorType 4
|
|
Encodes Color_ARGB as either RGBA_8888 or BGRA_8888, whichever
|
|
is native to the platform.
|
|
##
|
|
|
|
#NoExample
|
|
##
|
|
|
|
#SeeAlso SkAlphaType SkColorSpace
|
|
|
|
#Enum SkColorType ##
|
|
|
|
#Subtopic Alpha_8
|
|
|
|
Alpha_8 is an 8-bit byte pixel encoding that represents transparency. A value of zero is
|
|
completely transparent; a value of 255 is completely opaque. Bitmap with Alpha_8
|
|
pixels does not visibly draw, because its pixels have no color information.
|
|
The paired SkAlphaType is ignored.
|
|
|
|
#Example
|
|
#Description
|
|
Alpha_8 pixels can modify another draw. orangePaint fills the bounds of bitmap,
|
|
with its transparency set to alpha8 pixel value.
|
|
##
|
|
#Height 64
|
|
canvas->scale(16, 16);
|
|
SkBitmap bitmap;
|
|
SkImageInfo imageInfo = SkImageInfo::Make(2, 2, kAlpha_8_SkColorType, kOpaque_SkAlphaType);
|
|
bitmap.allocPixels(imageInfo);
|
|
SkCanvas offscreen(bitmap);
|
|
offscreen.clear(SK_ColorGREEN);
|
|
SkPaint orangePaint;
|
|
orangePaint.setARGB(0xFF, 0xFF, 0xA5, 0x00);
|
|
canvas->drawBitmap(bitmap, 0, 0, &orangePaint);
|
|
uint8_t alpha8[] = { 0xFF, 0xBB, 0x77, 0x33 };
|
|
SkPixmap alphaPixmap(imageInfo, &alpha8, imageInfo.minRowBytes());
|
|
if (bitmap.writePixels(alphaPixmap, 0, 0)) {
|
|
canvas->drawBitmap(bitmap, 2, 2, &orangePaint);
|
|
}
|
|
##
|
|
##
|
|
|
|
#Subtopic BGR_565
|
|
|
|
BGR_565 is a 16-bit word pixel encoding that contains five bits of blue,
|
|
six bits of green, and five bits of red. BGR_565 is fully opaque as if its
|
|
Color_Alpha was set to one, and should always be paired with kOpaque_SkAlphaType.
|
|
|
|
#Illustration
|
|
|
|
#Example
|
|
#Height 96
|
|
canvas->scale(16, 16);
|
|
SkBitmap bitmap;
|
|
SkImageInfo imageInfo = SkImageInfo::Make(2, 2, kRGB_565_SkColorType, kOpaque_SkAlphaType);
|
|
bitmap.allocPixels(imageInfo);
|
|
SkCanvas offscreen(bitmap);
|
|
offscreen.clear(SK_ColorGREEN);
|
|
canvas->drawBitmap(bitmap, 0, 0);
|
|
auto pack565 = [](unsigned r, unsigned g, unsigned b) -> uint16_t {
|
|
return (b << 0) | (g << 5) | (r << 11);
|
|
};
|
|
uint16_t red565[] = { pack565(0x1F, 0x00, 0x00), pack565(0x17, 0x00, 0x00),
|
|
pack565(0x0F, 0x00, 0x00), pack565(0x07, 0x00, 0x00) };
|
|
uint16_t blue565[] = { pack565(0x00, 0x00, 0x1F), pack565(0x00, 0x00, 0x17),
|
|
pack565(0x00, 0x00, 0x0F), pack565(0x00, 0x00, 0x07) };
|
|
SkPixmap redPixmap(imageInfo, &red565, imageInfo.minRowBytes());
|
|
if (bitmap.writePixels(redPixmap, 0, 0)) {
|
|
canvas->drawBitmap(bitmap, 2, 2);
|
|
}
|
|
SkPixmap bluePixmap(imageInfo, &blue565, imageInfo.minRowBytes());
|
|
if (bitmap.writePixels(bluePixmap, 0, 0)) {
|
|
canvas->drawBitmap(bitmap, 4, 4);
|
|
}
|
|
##
|
|
##
|
|
|
|
#Subtopic ABGR_4444
|
|
|
|
ABGR_4444 is a 16-bit word pixel encoding that contains four bits of alpha,
|
|
four bits of blue, four bits of green, and four bits of red.
|
|
|
|
#Illustration
|
|
|
|
If paired with kPremul_SkAlphaType: blue, green, and red components are
|
|
premultiplied by the alpha value. If blue, green, or red is greater than alpha,
|
|
the drawn result is undefined.
|
|
|
|
If paired with kUnpremul_SkAlphaType: alpha, blue, green, and red components
|
|
may have any value. There may be a performance penalty with unpremultipled
|
|
pixels.
|
|
|
|
If paired with kOpaque_SkAlphaType: all alpha component values are at the maximum;
|
|
blue, green, and red components are fully opaque. If any alpha component is
|
|
less than 15, the drawn result is undefined.
|
|
|
|
#Bug 7648
|
|
|
|
#Example
|
|
#Height 96
|
|
canvas->scale(16, 16);
|
|
SkBitmap bitmap;
|
|
SkImageInfo imageInfo = SkImageInfo::Make(2, 2, kARGB_4444_SkColorType, kPremul_SkAlphaType);
|
|
bitmap.allocPixels(imageInfo);
|
|
SkCanvas offscreen(bitmap);
|
|
offscreen.clear(SK_ColorGREEN);
|
|
canvas->drawBitmap(bitmap, 0, 0);
|
|
auto pack4444 = [](unsigned a, unsigned r, unsigned g, unsigned b) -> uint16_t {
|
|
return (a << 0) | (b << 4) | (g << 8) | (r << 12);
|
|
};
|
|
uint16_t red4444[] = { pack4444(0xF, 0xF, 0x0, 0x0), pack4444(0xF, 0xb, 0x0, 0x0),
|
|
pack4444(0xF, 0x7, 0x0, 0x0), pack4444(0xF, 0x3, 0x0, 0x0) };
|
|
uint16_t blue4444[] = { pack4444(0xF, 0x0, 0x0, 0xF), pack4444(0xF, 0x0, 0x0, 0xb),
|
|
pack4444(0xF, 0x0, 0x0, 0x7), pack4444(0xF, 0x0, 0x0, 0x3) };
|
|
SkPixmap redPixmap(imageInfo, &red4444, imageInfo.minRowBytes());
|
|
if (bitmap.writePixels(redPixmap, 0, 0)) {
|
|
canvas->drawBitmap(bitmap, 2, 2);
|
|
}
|
|
SkPixmap bluePixmap(imageInfo, &blue4444, imageInfo.minRowBytes());
|
|
if (bitmap.writePixels(bluePixmap, 0, 0)) {
|
|
canvas->drawBitmap(bitmap, 4, 4);
|
|
}
|
|
##
|
|
##
|
|
|
|
#Subtopic RGBA_8888
|
|
|
|
RGBA_8888 is a 32-bit word pixel encoding that contains eight bits of red,
|
|
eight bits of green, eight bits of blue, and eight bits of alpha.
|
|
|
|
#Illustration
|
|
|
|
If paired with kPremul_SkAlphaType: red, green, and blue components are
|
|
premultiplied by the alpha value. If red, green, or blue is greater than alpha,
|
|
the drawn result is undefined.
|
|
|
|
If paired with kUnpremul_SkAlphaType: alpha, red, green, and blue components
|
|
may have any value. There may be a performance penalty with unpremultipled
|
|
pixels.
|
|
|
|
If paired with kOpaque_SkAlphaType: all alpha component values are at the maximum;
|
|
red, green, and blue components are fully opaque. If any alpha component is
|
|
less than 255, the drawn result is undefined.
|
|
|
|
On Big_Endian platforms, RGBA_8888 is the native Color_Type, and will have
|
|
the best performance. Use kN32_SkColorType to choose the best Color_Type for
|
|
the platform at compile time.
|
|
|
|
#Example
|
|
#Height 96
|
|
canvas->scale(16, 16);
|
|
SkBitmap bitmap;
|
|
SkImageInfo imageInfo = SkImageInfo::Make(2, 2, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
|
|
bitmap.allocPixels(imageInfo);
|
|
SkCanvas offscreen(bitmap);
|
|
offscreen.clear(SK_ColorGREEN);
|
|
canvas->drawBitmap(bitmap, 0, 0);
|
|
auto pack8888 = [](unsigned a, unsigned r, unsigned g, unsigned b) -> uint32_t {
|
|
return (r << 0) | (g << 8) | (b << 16) | (a << 24);
|
|
};
|
|
uint32_t red8888[] = { pack8888(0xFF, 0xFF, 0x0, 0x0), pack8888(0xFF, 0xbb, 0x0, 0x0),
|
|
pack8888(0xFF, 0x77, 0x0, 0x0), pack8888(0xFF, 0x33, 0x0, 0x0) };
|
|
uint32_t blue8888[] = { pack8888(0xFF, 0x0, 0x0, 0x0FF), pack8888(0xFF, 0x0, 0x0, 0x0bb),
|
|
pack8888(0xFF, 0x0, 0x0, 0x077), pack8888(0xFF, 0x0, 0x0, 0x033) };
|
|
SkPixmap redPixmap(imageInfo, &red8888, imageInfo.minRowBytes());
|
|
if (bitmap.writePixels(redPixmap, 0, 0)) {
|
|
canvas->drawBitmap(bitmap, 2, 2);
|
|
}
|
|
SkPixmap bluePixmap(imageInfo, &blue8888, imageInfo.minRowBytes());
|
|
if (bitmap.writePixels(bluePixmap, 0, 0)) {
|
|
canvas->drawBitmap(bitmap, 4, 4);
|
|
}
|
|
##
|
|
##
|
|
|
|
#Subtopic RGB_888x
|
|
|
|
RGB_888x is a 32-bit word pixel encoding that contains eight bits of red,
|
|
eight bits of green, eight bits of blue, and eight unused bits. RGB_888x is fully
|
|
opaque as if its Color_Alpha was set to one, and should always be paired with
|
|
kOpaque_SkAlphaType.
|
|
|
|
#Illustration
|
|
|
|
#Example
|
|
#Bug 7645
|
|
#Height 96
|
|
#Platform cpu
|
|
canvas->scale(16, 16);
|
|
SkBitmap bitmap;
|
|
SkImageInfo imageInfo = SkImageInfo::Make(2, 2, kRGB_888x_SkColorType, kOpaque_SkAlphaType);
|
|
bitmap.allocPixels(imageInfo);
|
|
SkCanvas offscreen(bitmap);
|
|
offscreen.clear(SK_ColorGREEN);
|
|
canvas->drawBitmap(bitmap, 0, 0);
|
|
auto pack888 = [](unsigned r, unsigned g, unsigned b) -> uint32_t {
|
|
return (r << 0) | (g << 8) | (b << 16);
|
|
};
|
|
uint32_t red888[] = { pack888(0xFF, 0x00, 0x00), pack888(0xbb, 0x00, 0x00),
|
|
pack888(0x77, 0x00, 0x00), pack888(0x33, 0x00, 0x00) };
|
|
uint32_t blue888[] = { pack888(0x00, 0x00, 0xFF), pack888(0x00, 0x00, 0xbb),
|
|
pack888(0x00, 0x00, 0x77), pack888(0x00, 0x00, 0x33) };
|
|
if (bitmap.installPixels(imageInfo, (void*) red888, imageInfo.minRowBytes())) {
|
|
canvas->drawBitmap(bitmap, 2, 2);
|
|
}
|
|
if (bitmap.installPixels(imageInfo, (void*) blue888, imageInfo.minRowBytes())) {
|
|
canvas->drawBitmap(bitmap, 4, 4);
|
|
}
|
|
##
|
|
##
|
|
|
|
#Subtopic BGRA_8888
|
|
|
|
BGRA_8888 is a 32-bit word pixel encoding that contains eight bits of blue,
|
|
eight bits of green, eight bits of red, and eight bits of alpha.
|
|
|
|
#Illustration
|
|
|
|
If paired with kPremul_SkAlphaType: blue, green, and red components are
|
|
premultiplied by the alpha value. If blue, green, or red is greater than alpha,
|
|
the drawn result is undefined.
|
|
|
|
If paired with kUnpremul_SkAlphaType: blue, green, red, and alpha components
|
|
may have any value. There may be a performance penalty with unpremultipled
|
|
pixels.
|
|
|
|
If paired with kOpaque_SkAlphaType: all alpha component values are at the maximum;
|
|
blue, green, and red components are fully opaque. If any alpha component is
|
|
less than 255, the drawn result is undefined.
|
|
|
|
On Little_Endian platforms, BGRA_8888 is the native Color_Type, and will have
|
|
the best performance. Use kN32_SkColorType to choose the best Color_Type for
|
|
the platform at compile time.
|
|
|
|
#Example
|
|
#Height 96
|
|
canvas->scale(16, 16);
|
|
SkBitmap bitmap;
|
|
SkImageInfo imageInfo = SkImageInfo::Make(2, 2, kBGRA_8888_SkColorType, kPremul_SkAlphaType);
|
|
bitmap.allocPixels(imageInfo);
|
|
SkCanvas offscreen(bitmap);
|
|
offscreen.clear(SK_ColorGREEN);
|
|
canvas->drawBitmap(bitmap, 0, 0);
|
|
auto pack8888 = [](unsigned a, unsigned r, unsigned g, unsigned b) -> uint32_t {
|
|
return (b << 0) | (g << 8) | (r << 16) | (a << 24);
|
|
};
|
|
uint32_t red8888[] = { pack8888(0xFF, 0xFF, 0x0, 0x0), pack8888(0xFF, 0xbb, 0x0, 0x0),
|
|
pack8888(0xFF, 0x99, 0x0, 0x0), pack8888(0xFF, 0x55, 0x0, 0x0) };
|
|
uint32_t blue8888[] = { pack8888(0xFF, 0x0, 0x0, 0x0FF), pack8888(0xFF, 0x0, 0x0, 0x0bb),
|
|
pack8888(0xFF, 0x0, 0x0, 0x099), pack8888(0xFF, 0x0, 0x0, 0x055) };
|
|
SkPixmap redPixmap(imageInfo, &red8888, imageInfo.minRowBytes());
|
|
if (bitmap.writePixels(redPixmap, 0, 0)) {
|
|
canvas->drawBitmap(bitmap, 2, 2);
|
|
}
|
|
SkPixmap bluePixmap(imageInfo, &blue8888, imageInfo.minRowBytes());
|
|
if (bitmap.writePixels(bluePixmap, 0, 0)) {
|
|
canvas->drawBitmap(bitmap, 4, 4);
|
|
}
|
|
##
|
|
##
|
|
|
|
#Subtopic RGBA_1010102
|
|
|
|
RGBA_1010102 is a 32-bit word pixel encoding that contains ten bits of red,
|
|
ten bits of green, ten bits of blue, and two bits of alpha. Possible alpha
|
|
values are zero: fully transparent; one: 33% opaque; two: 67% opaque;
|
|
three: fully opaque.
|
|
|
|
#Illustration
|
|
|
|
If paired with kPremul_SkAlphaType: red, green, and blue components are
|
|
premultiplied by the alpha value. If red, green, or blue is greater than the
|
|
alpha replicated to ten bits, the drawn result is undefined.
|
|
|
|
If paired with kUnpremul_SkAlphaType: alpha, red, green, and blue components
|
|
may have any value. There may be a performance penalty with unpremultipled
|
|
pixels.
|
|
|
|
If paired with kOpaque_SkAlphaType: all alpha component values are at the maximum;
|
|
red, green, and blue components are fully opaque. If any alpha component is
|
|
less than 3, the drawn result is undefined.
|
|
|
|
#Example
|
|
#Bug 7645
|
|
#Height 96
|
|
#Platform cpu
|
|
canvas->scale(16, 16);
|
|
SkBitmap bitmap;
|
|
SkImageInfo imageInfo = SkImageInfo::Make(2, 2, kRGBA_1010102_SkColorType, kOpaque_SkAlphaType);
|
|
bitmap.allocPixels(imageInfo);
|
|
SkCanvas offscreen(bitmap);
|
|
offscreen.clear(SK_ColorGREEN);
|
|
canvas->drawBitmap(bitmap, 0, 0);
|
|
auto pack1010102 = [](unsigned r, unsigned g, unsigned b, unsigned a) -> uint32_t {
|
|
return (r << 0) | (g << 10) | (b << 20) | (a << 30);
|
|
};
|
|
uint32_t redBits[] = { pack1010102(0x3FF, 0x000, 0x000, 0x3),
|
|
pack1010102(0x2ff, 0x000, 0x000, 0x3),
|
|
pack1010102(0x1ff, 0x000, 0x000, 0x3),
|
|
pack1010102(0x0ff, 0x000, 0x000, 0x3) };
|
|
uint32_t blueBits[] = { pack1010102(0x000, 0x000, 0x3FF, 0x3),
|
|
pack1010102(0x000, 0x000, 0x2ff, 0x3),
|
|
pack1010102(0x000, 0x000, 0x1ff, 0x3),
|
|
pack1010102(0x000, 0x000, 0x0ff, 0x3) };
|
|
if (bitmap.installPixels(imageInfo, (void*) redBits, imageInfo.minRowBytes())) {
|
|
canvas->drawBitmap(bitmap, 2, 2);
|
|
}
|
|
SkPixmap bluePixmap(imageInfo, &blueBits, imageInfo.minRowBytes());
|
|
if (bitmap.installPixels(imageInfo, (void*) blueBits, imageInfo.minRowBytes())) {
|
|
canvas->drawBitmap(bitmap, 4, 4);
|
|
}
|
|
##
|
|
##
|
|
|
|
#Subtopic RGB_101010x
|
|
|
|
RGB_101010x is a 32-bit word pixel encoding that contains ten bits of red,
|
|
ten bits of green, ten bits of blue, and two unused bits. RGB_101010x is fully
|
|
opaque as if its Color_Alpha was set to one, and should always be paired with
|
|
kOpaque_SkAlphaType.
|
|
|
|
#Illustration
|
|
|
|
#Example
|
|
#Bug 7645
|
|
#Height 96
|
|
#Platform cpu
|
|
canvas->scale(16, 16);
|
|
SkBitmap bitmap;
|
|
SkImageInfo imageInfo = SkImageInfo::Make(2, 2, kRGB_101010x_SkColorType, kOpaque_SkAlphaType);
|
|
bitmap.allocPixels(imageInfo);
|
|
SkCanvas offscreen(bitmap);
|
|
offscreen.clear(SK_ColorGREEN);
|
|
canvas->drawBitmap(bitmap, 0, 0);
|
|
auto pack101010x = [](unsigned r, unsigned g, unsigned b) -> uint32_t {
|
|
return (r << 0) | (g << 10) | (b << 20);
|
|
};
|
|
uint32_t redBits[] = { pack101010x(0x3FF, 0x000, 0x000), pack101010x(0x2ff, 0x000, 0x000),
|
|
pack101010x(0x1ff, 0x000, 0x000), pack101010x(0x0ff, 0x000, 0x000) };
|
|
uint32_t blueBits[] = { pack101010x(0x000, 0x000, 0x3FF), pack101010x(0x000, 0x000, 0x2ff),
|
|
pack101010x(0x000, 0x000, 0x1ff), pack101010x(0x000, 0x000, 0x0ff) };
|
|
if (bitmap.installPixels(imageInfo, (void*) redBits, imageInfo.minRowBytes())) {
|
|
canvas->drawBitmap(bitmap, 2, 2);
|
|
}
|
|
SkPixmap bluePixmap(imageInfo, &blueBits, imageInfo.minRowBytes());
|
|
if (bitmap.installPixels(imageInfo, (void*) blueBits, imageInfo.minRowBytes())) {
|
|
canvas->drawBitmap(bitmap, 4, 4);
|
|
}
|
|
##
|
|
##
|
|
|
|
#Subtopic Gray_8
|
|
|
|
Gray_8 is an 8-bit byte pixel encoding that represents equal values for red,
|
|
blue, and green, reprsenting colors from black to white. Gray_8 is fully
|
|
opaque as if its Color_Alpha was set to one, and should always be paired with
|
|
kOpaque_SkAlphaType.
|
|
|
|
#Example
|
|
#Height 64
|
|
canvas->scale(16, 16);
|
|
SkBitmap bitmap;
|
|
SkImageInfo imageInfo = SkImageInfo::Make(2, 2, kGray_8_SkColorType, kOpaque_SkAlphaType);
|
|
bitmap.allocPixels(imageInfo);
|
|
SkCanvas offscreen(bitmap);
|
|
offscreen.clear(SK_ColorGREEN);
|
|
canvas->drawBitmap(bitmap, 0, 0);
|
|
uint8_t gray8[] = { 0xFF, 0xBB, 0x77, 0x33 };
|
|
SkPixmap grayPixmap(imageInfo, &gray8, imageInfo.minRowBytes());
|
|
if (bitmap.writePixels(grayPixmap, 0, 0)) {
|
|
canvas->drawBitmap(bitmap, 2, 2);
|
|
}
|
|
##
|
|
##
|
|
|
|
#Subtopic RGBA_F16
|
|
|
|
RGBA_F16 is a 64-bit word pixel encoding that contains sixteen bits of blue,
|
|
sixteen bits of green, sixteen bits of red, and sixteen bits of alpha.
|
|
|
|
Each component encodes a floating point value using
|
|
#A Half floats # https://www.khronos.org/opengl/wiki/Small_Float_Formats ##
|
|
. Meaningful colors are represented by the range 0.0 to 1.0, although smaller
|
|
and larger values may be useful when used in combination with Transfer_Mode.
|
|
|
|
#Illustration
|
|
|
|
If paired with kPremul_SkAlphaType: blue, green, and red components are
|
|
premultiplied by the alpha value. If blue, green, or red is greater than alpha,
|
|
the drawn result is undefined.
|
|
|
|
If paired with kUnpremul_SkAlphaType: blue, green, red, and alpha components
|
|
may have any value. There may be a performance penalty with unpremultipled
|
|
pixels.
|
|
|
|
If paired with kOpaque_SkAlphaType: all alpha component values are at the maximum;
|
|
blue, green, and red components are fully opaque. If any alpha component is
|
|
less than 255, the drawn result is undefined.
|
|
|
|
#ToDo
|
|
FloatToHalf should be replaced with SkFloatToHalf if/when that's made public
|
|
##
|
|
|
|
#Example
|
|
#Height 96
|
|
#Function
|
|
union FloatUIntUnion {
|
|
uint32_t fUInt;
|
|
float fFloat;
|
|
};
|
|
|
|
uint16_t FloatToHalf(float f) {
|
|
static const FloatUIntUnion magic = { 15 << 23 };
|
|
static const uint32_t round_mask = ~0xfffu;
|
|
FloatUIntUnion floatUnion;
|
|
floatUnion.fFloat = f;
|
|
uint32_t sign = floatUnion.fUInt & 0x80000000u;
|
|
floatUnion.fUInt ^= sign;
|
|
floatUnion.fUInt &= round_mask;
|
|
floatUnion.fFloat *= magic.fFloat;
|
|
floatUnion.fUInt -= round_mask;
|
|
return (floatUnion.fUInt >> 13) | (sign >> 16);
|
|
}
|
|
##
|
|
|
|
void draw(SkCanvas* canvas) {
|
|
canvas->scale(16, 16);
|
|
SkBitmap bitmap;
|
|
SkImageInfo imageInfo = SkImageInfo::Make(2, 2, kRGBA_F16_SkColorType, kPremul_SkAlphaType);
|
|
bitmap.allocPixels(imageInfo);
|
|
SkCanvas offscreen(bitmap);
|
|
offscreen.clear(SK_ColorGREEN);
|
|
canvas->drawBitmap(bitmap, 0, 0);
|
|
auto H = [](float c) -> uint16_t {
|
|
return FloatToHalf(c);
|
|
};
|
|
// R G B A
|
|
uint16_t red_f16[][4] = { { H(1.0f), H(0.0f), H(0.0f), H(1.0f) },
|
|
{ H(.75f), H(0.0f), H(0.0f), H(1.0f) },
|
|
{ H(.50f), H(0.0f), H(0.0f), H(1.0f) },
|
|
{ H(.25f), H(0.0f), H(0.0f), H(1.0f) } };
|
|
uint16_t blue_f16[][4] = { { H(0.0f), H(0.0f), H(1.0f), H(1.0f) },
|
|
{ H(0.0f), H(0.0f), H(.75f), H(1.0f) },
|
|
{ H(0.0f), H(0.0f), H(.50f), H(1.0f) },
|
|
{ H(0.0f), H(0.0f), H(.25f), H(1.0f) } };
|
|
SkPixmap redPixmap(imageInfo, red_f16, imageInfo.minRowBytes());
|
|
if (bitmap.writePixels(redPixmap, 0, 0)) {
|
|
canvas->drawBitmap(bitmap, 2, 2);
|
|
}
|
|
SkPixmap bluePixmap(imageInfo, blue_f16, imageInfo.minRowBytes());
|
|
if (bitmap.writePixels(bluePixmap, 0, 0)) {
|
|
canvas->drawBitmap(bitmap, 4, 4);
|
|
}
|
|
}
|
|
##
|
|
##
|
|
|
|
#Subtopic Color_Type ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method int SkColorTypeBytesPerPixel(SkColorType ct)
|
|
#In Property
|
|
#Line # returns Color_Type byte size ##
|
|
|
|
Returns the number of bytes required to store a pixel, including unused padding.
|
|
Returns zero if ct is kUnknown_SkColorType or invalid.
|
|
|
|
#Param ct one of: #list_of_color_types#
|
|
##
|
|
|
|
#Return bytes per pixel ##
|
|
|
|
#Example
|
|
#Height 192
|
|
const char* colors[] = { "Unknown", "Alpha_8", "RGB_565", "ARGB_4444", "RGBA_8888", "RGB_888x",
|
|
"BGRA_8888", "RGBA_1010102", "RGB_101010x", "Gray_8", "RGBA_F16" };
|
|
SkPaint paint;
|
|
paint.setTypeface(SkTypeface::MakeFromName("monospace", SkFontStyle()));
|
|
paint.setAntiAlias(true);
|
|
paint.setTextSize(10);
|
|
int y = 15;
|
|
canvas->drawString(" colorType bytes", 10, y, paint);
|
|
for (SkColorType colorType : { #list_of_color_types#
|
|
} ) {
|
|
int result = SkColorTypeBytesPerPixel(colorType);
|
|
SkString string;
|
|
string.printf("%13s %4d", colors[(int) colorType], result);
|
|
canvas->drawString(string, 10, y += 14, paint);
|
|
}
|
|
##
|
|
#SeeAlso SkImageInfo::bytesPerPixel
|
|
##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method bool SkColorTypeIsAlwaysOpaque(SkColorType ct)
|
|
#In Property
|
|
#Line # returns if Color_Type includes Color_Alpha ##
|
|
|
|
Returns true if Color_Type always decodes Color_Alpha to 1.0, making the pixel
|
|
fully opaque. If true, Color_Type does not reserve bits to encode Color_Alpha.
|
|
|
|
#Param ct one of: #list_of_color_types#
|
|
##
|
|
|
|
#Return true if Color_Alpha is always set to 1.0 ##
|
|
|
|
#Example
|
|
#Height 192
|
|
const char* colors[] = { "Unknown", "Alpha_8", "RGB_565", "ARGB_4444", "RGBA_8888", "RGB_888x",
|
|
"BGRA_8888", "RGBA_1010102", "RGB_101010x", "Gray_8", "RGBA_F16" };
|
|
SkPaint paint;
|
|
paint.setTypeface(SkTypeface::MakeFromName("monospace", SkFontStyle()));
|
|
paint.setAntiAlias(true);
|
|
paint.setTextSize(10);
|
|
int y = 15;
|
|
canvas->drawString(" colorType bytes", 10, y, paint);
|
|
for (SkColorType colorType : { #list_of_color_types#
|
|
} ) {
|
|
bool result = SkColorTypeIsAlwaysOpaque(colorType);
|
|
SkString string;
|
|
string.printf("%13s %6s", colors[(int) colorType], result ? "true" : "false");
|
|
canvas->drawString(string, 10, y += 14, paint);
|
|
}
|
|
##
|
|
#SeeAlso SkColorTypeValidateAlphaType
|
|
##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method bool SkColorTypeValidateAlphaType(SkColorType colorType, SkAlphaType alphaType,
|
|
SkAlphaType* canonical = nullptr)
|
|
#In Property
|
|
#Line # returns if Alpha_Type is valid ##
|
|
|
|
Returns true if canonical can be set to a valid Alpha_Type for colorType. If
|
|
there is more than one valid canonical Alpha_Type, set to alphaType, if valid.
|
|
If true is returned and canonical is not nullptr, store valid Alpha_Type.
|
|
|
|
Returns false only if alphaType is kUnknown_SkAlphaType, color type is not
|
|
kUnknown_SkColorType, and Color_Type is not always opaque. If false is returned,
|
|
canonical is ignored.
|
|
|
|
For kUnknown_SkColorType: set canonical to kUnknown_SkAlphaType and return true.
|
|
For kAlpha_8_SkColorType: set canonical to kPremul_SkAlphaType or
|
|
kOpaque_SkAlphaType and return true if alphaType is not kUnknown_SkAlphaType.
|
|
For kRGB_565_SkColorType, kRGB_888x_SkColorType, kRGB_101010x_SkColorType, and
|
|
kGray_8_SkColorType: set canonical to kOpaque_SkAlphaType and return true.
|
|
For kARGB_4444_SkColorType, kRGBA_8888_SkColorType, kBGRA_8888_SkColorType,
|
|
kRGBA_1010102_SkColorType, and kRGBA_F16_SkColorType: set canonical to alphaType
|
|
and return true if alphaType is not kUnknown_SkAlphaType.
|
|
|
|
#Param colorType one of: #list_of_color_types#
|
|
##
|
|
#Param alphaType one of: #list_of_alpha_types#
|
|
##
|
|
#Param canonical storage for Alpha_Type ##
|
|
|
|
#Return true if valid Alpha_Type can be associated with colorType ##
|
|
|
|
#Example
|
|
#Height 640
|
|
const char* colors[] = { "Unknown", "Alpha_8", "RGB_565", "ARGB_4444", "RGBA_8888", "RGB_888x",
|
|
"BGRA_8888", "RGBA_1010102", "RGB_101010x", "Gray_8", "RGBA_F16" };
|
|
const char* alphas[] = {"Unknown ", "Opaque ", "Premul ", "Unpremul"};
|
|
SkAlphaType alphaTypes[] = { #list_of_alpha_types#
|
|
};
|
|
SkPaint paint;
|
|
paint.setTypeface(SkTypeface::MakeFromName("monospace", SkFontStyle()));
|
|
paint.setAntiAlias(true);
|
|
paint.setTextSize(10);
|
|
int y = 15;
|
|
canvas->drawString(" colorType alphaType canonical", 10, y, paint);
|
|
for (SkColorType colorType : { #list_of_color_types#
|
|
} ) {
|
|
for (SkAlphaType alphaType : alphaTypes) {
|
|
SkAlphaType canonicalAlphaType = kUnknown_SkAlphaType;
|
|
bool result = SkColorTypeValidateAlphaType(colorType, alphaType, &canonicalAlphaType);
|
|
SkString string;
|
|
string.printf("%13s %10s %10s", colors[(int) colorType], alphas[(int) alphaType],
|
|
result ? alphas[(int) canonicalAlphaType] : "------ ");
|
|
canvas->drawString(string, 10, y += 14, paint);
|
|
}
|
|
}
|
|
##
|
|
#SeeAlso SkColorTypeIsAlwaysOpaque
|
|
##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
#Subtopic YUV_ColorSpace
|
|
#Alias YUV_ColorSpace
|
|
#Enum SkYUVColorSpace
|
|
#Line # color range of YUV pixels ##
|
|
|
|
#Code
|
|
enum SkYUVColorSpace {
|
|
kJPEG_SkYUVColorSpace,
|
|
kRec601_SkYUVColorSpace,
|
|
kRec709_SkYUVColorSpace,
|
|
kLastEnum_SkYUVColorSpace = kRec709_SkYUVColorSpace,
|
|
};
|
|
##
|
|
|
|
Describes color range of YUV pixels. The color mapping from YUV to RGB varies
|
|
depending on the source. YUV pixels may be generated by JPEG images, standard
|
|
video streams, or high definition video streams. Each has its own mapping from
|
|
YUV and RGB.
|
|
|
|
JPEG YUV values encode the full range of 0 to 255 for all three components.
|
|
Video YUV values range from 16 to 235 for all three components. Details of
|
|
encoding and conversion to RGB are described in
|
|
#A YCbCr color space # https://en.wikipedia.org/wiki/YCbCr ##
|
|
.
|
|
|
|
#Const kJPEG_SkYUVColorSpace 0
|
|
Describes standard JPEG color space;
|
|
#A CCIR 601 # https://en.wikipedia.org/wiki/Rec._601 ##
|
|
with full range of 0 to 255 for components.
|
|
##
|
|
#Const kRec601_SkYUVColorSpace 1
|
|
Describes standard used by SDTV;
|
|
#A CCIR 601 # https://en.wikipedia.org/wiki/Rec._601 ##
|
|
with studio range of 16 to 235 range for components.
|
|
##
|
|
#Const kRec709_SkYUVColorSpace 2
|
|
Describes standard used by HDTV;
|
|
#A Rec. 709 # http://en.wikipedia.org/wiki/Rec._709 ##
|
|
with studio range of 16 to 235 range for components.
|
|
##
|
|
|
|
#NoExample
|
|
##
|
|
|
|
#SeeAlso SkImage::MakeFromYUVTexturesCopy SkImage::MakeFromNV12TexturesCopy
|
|
|
|
#Enum SkYUVColorSpace ##
|
|
#Subtopic YUV_ColorSpace ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Struct SkImageInfo
|
|
|
|
Describes pixel dimensions and encoding. Bitmap, Image, PixMap, and Surface
|
|
can be created from Image_Info. Image_Info can be retrieved from Bitmap and
|
|
Pixmap, but not from Image and Surface. For example, Image and Surface
|
|
implementations may defer pixel depth, so may not completely specify Image_Info.
|
|
|
|
Image_Info contains dimensions, the pixel integral width and height. It encodes
|
|
how pixel bits describe Color_Alpha, transparency; Color components red, blue,
|
|
and green; and Color_Space, the range and linearity of colors.
|
|
|
|
#Subtopic Member_Function
|
|
#Populate
|
|
##
|
|
|
|
#Subtopic Related_Function
|
|
#Populate
|
|
##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
#Subtopic Constructor
|
|
#Populate
|
|
##
|
|
|
|
#Method SkImageInfo()
|
|
|
|
#In Constructor
|
|
#Line # creates with zero dimensions, kUnknown_SkColorType, kUnknown_SkAlphaType ##
|
|
Creates an empty Image_Info with kUnknown_SkColorType, kUnknown_SkAlphaType,
|
|
a width and height of zero, and no Color_Space.
|
|
|
|
#Return empty Image_Info ##
|
|
|
|
#Example
|
|
#Height 32
|
|
#Description
|
|
An empty Image_Info may be passed to SkCanvas::accessTopLayerPixels as storage
|
|
for the Canvas actual Image_Info.
|
|
##
|
|
SkImageInfo imageInfo;
|
|
size_t rowBytes;
|
|
SkIPoint origin;
|
|
(void) canvas->accessTopLayerPixels(&imageInfo, &rowBytes, &origin);
|
|
const char* alphaType[] = { "Unknown", "Opaque", "Premul", "Unpremul" };
|
|
SkString string;
|
|
string.printf("k%s_SkAlphaType", alphaType[(int) imageInfo.alphaType()]);
|
|
SkPaint paint;
|
|
canvas->drawString(string, 20, 20, paint);
|
|
##
|
|
|
|
#SeeAlso Make MakeN32 MakeS32 MakeA8
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method static SkImageInfo Make(int width, int height, SkColorType ct, SkAlphaType at,
|
|
sk_sp<SkColorSpace> cs = nullptr)
|
|
#In Constructor
|
|
#Line # creates Image_Info from dimensions, Color_Type, Alpha_Type, Color_Space ##
|
|
Creates Image_Info from integral dimensions width and height, Color_Type ct,
|
|
Alpha_Type at, and optionally Color_Space cs.
|
|
|
|
If Color_Space cs is nullptr and Image_Info is part of drawing source: Color_Space
|
|
defaults to sRGB, mapping into Surface Color_Space.
|
|
|
|
Parameters are not validated to see if their values are legal, or that the
|
|
combination is supported.
|
|
|
|
#Param width pixel column count; must be zero or greater ##
|
|
#Param height pixel row count; must be zero or greater ##
|
|
#Param ct one of: #list_of_color_types#
|
|
##
|
|
#Param at one of: #list_of_alpha_types#
|
|
##
|
|
#Param cs range of colors; may be nullptr ##
|
|
|
|
#Return created Image_Info ##
|
|
|
|
#Example
|
|
#Height 48
|
|
uint8_t storage[][5] = {{ 0xCA, 0xDA, 0xCA, 0xC9, 0xA3 },
|
|
{ 0xAC, 0xA8, 0x89, 0xA7, 0x87 },
|
|
{ 0x9B, 0xB5, 0xE5, 0x95, 0x46 },
|
|
{ 0x90, 0x81, 0xC5, 0x71, 0x33 },
|
|
{ 0x75, 0x55, 0x44, 0x40, 0x30 }};
|
|
SkImageInfo imageInfo = SkImageInfo::Make(5, 5, kGray_8_SkColorType, kOpaque_SkAlphaType);
|
|
SkPixmap pixmap(imageInfo, storage[0], sizeof(storage) / 5);
|
|
SkBitmap bitmap;
|
|
bitmap.installPixels(pixmap);
|
|
canvas->scale(8, 8);
|
|
canvas->drawBitmap(bitmap, 0, 0);
|
|
##
|
|
|
|
#SeeAlso MakeN32 MakeN32Premul MakeS32 MakeA8
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method static SkImageInfo MakeN32(int width, int height, SkAlphaType at,
|
|
sk_sp<SkColorSpace> cs = nullptr)
|
|
#In Constructor
|
|
#Line # creates Image_Info with Native_Color_Type ##
|
|
Creates Image_Info from integral dimensions width and height, kN32_SkColorType,
|
|
Alpha_Type at, and optionally Color_Space cs. kN32_SkColorType will equal either
|
|
kBGRA_8888_SkColorType or kRGBA_8888_SkColorType, whichever is optimal.
|
|
|
|
If Color_Space cs is nullptr and Image_Info is part of drawing source: Color_Space
|
|
defaults to sRGB, mapping into Surface Color_Space.
|
|
|
|
Parameters are not validated to see if their values are legal, or that the
|
|
combination is supported.
|
|
|
|
#Param width pixel column count; must be zero or greater ##
|
|
#Param height pixel row count; must be zero or greater ##
|
|
#Param at one of: #list_of_alpha_types#
|
|
##
|
|
#Param cs range of colors; may be nullptr ##
|
|
|
|
#Return created Image_Info ##
|
|
|
|
#Example
|
|
#Height 128
|
|
SkBitmap bitmap;
|
|
bitmap.allocPixels(SkImageInfo::MakeN32(16, 16, kPremul_SkAlphaType));
|
|
SkCanvas offscreen(bitmap);
|
|
offscreen.clear(SK_ColorWHITE);
|
|
SkPaint paint;
|
|
offscreen.drawString("g", 0, 10, paint);
|
|
canvas->scale(8, 8);
|
|
canvas->drawBitmap(bitmap, 0, 0);
|
|
##
|
|
|
|
#SeeAlso Make MakeN32Premul MakeS32 MakeA8
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method static SkImageInfo MakeS32(int width, int height, SkAlphaType at)
|
|
|
|
#In Constructor
|
|
#Line # creates Image_Info with Native_Color_Type, sRGB Color_Space ##
|
|
Creates Image_Info from integral dimensions width and height, kN32_SkColorType,
|
|
Alpha_Type at, with sRGB Color_Space.
|
|
|
|
Parameters are not validated to see if their values are legal, or that the
|
|
combination is supported.
|
|
|
|
#Param width pixel column count; must be zero or greater ##
|
|
#Param height pixel row count; must be zero or greater ##
|
|
#Param at one of: #list_of_alpha_types#
|
|
##
|
|
|
|
#Return created Image_Info ##
|
|
|
|
#Example
|
|
#Set sRGB
|
|
#Height 128
|
|
#Description
|
|
Top gradient is drawn to offscreen without Color_Space. It is darker than middle
|
|
gradient, drawn to offscreen with sRGB Color_Space. Bottom gradient shares bits
|
|
with middle, but does not specify the Color_Space in noColorSpaceBitmap. A source
|
|
without Color_Space is treated as sRGB; the bottom gradient is identical to the
|
|
middle gradient.
|
|
##
|
|
const int width = 256;
|
|
const int height = 32;
|
|
SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
|
|
SkColor gradColors[] = { 0xFFAA0055, 0xFF11CC88 };
|
|
SkPoint gradPoints[] = { { 0, 0 }, { width, 0 } };
|
|
SkPaint gradPaint;
|
|
gradPaint.setShader(SkGradientShader::MakeLinear(gradPoints, gradColors, nullptr,
|
|
SK_ARRAY_COUNT(gradColors), SkShader::kClamp_TileMode));
|
|
SkBitmap bitmap;
|
|
bitmap.allocPixels(SkImageInfo::MakeN32(width, height, kPremul_SkAlphaType));
|
|
SkCanvas offscreen(bitmap);
|
|
offscreen.drawRect(SkRect::MakeWH(width, height), gradPaint);
|
|
canvas->drawBitmap(bitmap, 0, 0);
|
|
bitmap.allocPixels(SkImageInfo::MakeS32(width, height, kPremul_SkAlphaType));
|
|
SkCanvas sRGBOffscreen(bitmap);
|
|
sRGBOffscreen.drawRect(SkRect::MakeWH(width, height), gradPaint);
|
|
canvas->drawBitmap(bitmap, 0, 48);
|
|
SkBitmap noColorSpaceBitmap;
|
|
noColorSpaceBitmap.setInfo(SkImageInfo::MakeN32(width, height, kPremul_SkAlphaType));
|
|
noColorSpaceBitmap.setPixels(bitmap.getAddr(0, 0));
|
|
canvas->drawBitmap(noColorSpaceBitmap, 0, 96);
|
|
##
|
|
|
|
#SeeAlso Make MakeN32 MakeN32Premul MakeA8
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method static SkImageInfo MakeN32Premul(int width, int height, sk_sp<SkColorSpace> cs = nullptr)
|
|
|
|
#In Constructor
|
|
#Line # creates Image_Info with Native_Color_Type, kPremul_SkAlphaType ##
|
|
Creates Image_Info from integral dimensions width and height, kN32_SkColorType,
|
|
kPremul_SkAlphaType, with optional Color_Space.
|
|
|
|
If Color_Space cs is nullptr and Image_Info is part of drawing source: Color_Space
|
|
defaults to sRGB, mapping into Surface Color_Space.
|
|
|
|
Parameters are not validated to see if their values are legal, or that the
|
|
combination is supported.
|
|
|
|
#Param width pixel column count; must be zero or greater ##
|
|
#Param height pixel row count; must be zero or greater ##
|
|
#Param cs range of colors; may be nullptr ##
|
|
|
|
#Return created Image_Info ##
|
|
|
|
#Example
|
|
#Height 128
|
|
SkBitmap bitmap;
|
|
bitmap.allocPixels(SkImageInfo::MakeN32Premul(18, 18));
|
|
SkCanvas offscreen(bitmap);
|
|
offscreen.clear(SK_ColorWHITE);
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
paint.setTextSize(15);
|
|
offscreen.drawString("\xF0\x9F\x98\xB8", 1, 15, paint);
|
|
canvas->scale(6, 6);
|
|
canvas->drawBitmap(bitmap, 0, 0);
|
|
##
|
|
|
|
#SeeAlso MakeN32 MakeS32 MakeA8 Make
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method static SkImageInfo MakeN32Premul(const SkISize& size)
|
|
|
|
#In Constructor
|
|
Creates Image_Info from integral dimensions width and height, kN32_SkColorType,
|
|
kPremul_SkAlphaType, with Color_Space set to nullptr.
|
|
|
|
If Image_Info is part of drawing source: Color_Space defaults to sRGB, mapping
|
|
into Surface Color_Space.
|
|
|
|
Parameters are not validated to see if their values are legal, or that the
|
|
combination is supported.
|
|
|
|
#Param size width and height, each must be zero or greater ##
|
|
|
|
#Return created Image_Info ##
|
|
|
|
#Example
|
|
#Height 128
|
|
SkBitmap bitmap;
|
|
bitmap.allocPixels(SkImageInfo::MakeN32Premul({18, 18}));
|
|
SkCanvas offscreen(bitmap);
|
|
offscreen.clear(SK_ColorWHITE);
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
paint.setTextSize(15);
|
|
offscreen.drawString("\xF0\x9F\x98\xB9", 1, 15, paint);
|
|
canvas->scale(6, 6);
|
|
canvas->drawBitmap(bitmap, 0, 0);
|
|
##
|
|
|
|
#SeeAlso MakeN32 MakeS32 MakeA8 Make
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method static SkImageInfo MakeA8(int width, int height)
|
|
|
|
#In Constructor
|
|
#Line # creates Image_Info with kAlpha_8_SkColorType, kPremul_SkAlphaType ##
|
|
Creates Image_Info from integral dimensions width and height, kAlpha_8_SkColorType,
|
|
kPremul_SkAlphaType, with Color_Space set to nullptr.
|
|
|
|
#Param width pixel column count; must be zero or greater ##
|
|
#Param height pixel row count; must be zero or greater ##
|
|
|
|
#Return created Image_Info ##
|
|
|
|
#Example
|
|
#Height 64
|
|
uint8_t pixels[][8] = { { 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00},
|
|
{ 0x00, 0x7f, 0xff, 0x3f, 0x3f, 0x7f, 0x3f, 0x00},
|
|
{ 0x3f, 0xff, 0x7f, 0x00, 0x7f, 0xff, 0x7f, 0x00},
|
|
{ 0x00, 0x3f, 0x00, 0x00, 0x3f, 0x7f, 0x3f, 0x00},
|
|
{ 0x3f, 0x7f, 0x7f, 0x3f, 0x00, 0x00, 0x00, 0x00},
|
|
{ 0x7f, 0xff, 0xff, 0x7f, 0x00, 0x3f, 0x7f, 0x3f},
|
|
{ 0x7f, 0xff, 0xff, 0x7f, 0x00, 0x7f, 0xff, 0x7f},
|
|
{ 0x3f, 0x7f, 0x7f, 0x3f, 0x00, 0x3f, 0x7f, 0x3f} };
|
|
SkBitmap bitmap;
|
|
bitmap.installPixels(SkImageInfo::MakeA8(8, 8),
|
|
(void*) pixels, sizeof(pixels[0]));
|
|
SkPaint paint;
|
|
canvas->scale(4, 4);
|
|
for (auto color : { SK_ColorRED, SK_ColorBLUE, 0xFF007F00} ) {
|
|
paint.setColor(color);
|
|
canvas->drawBitmap(bitmap, 0, 0, &paint);
|
|
canvas->translate(12, 0);
|
|
}
|
|
##
|
|
|
|
#SeeAlso MakeN32 MakeS32 Make
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method static SkImageInfo MakeUnknown(int width, int height)
|
|
|
|
#In Constructor
|
|
#Line # creates Image_Info with kUnknown_SkColorType, kUnknown_SkAlphaType ##
|
|
Creates Image_Info from integral dimensions width and height, kUnknown_SkColorType,
|
|
kUnknown_SkAlphaType, with Color_Space set to nullptr.
|
|
|
|
Returned Image_Info as part of source does not draw, and as part of destination
|
|
can not be drawn to.
|
|
|
|
#Param width pixel column count; must be zero or greater ##
|
|
#Param height pixel row count; must be zero or greater ##
|
|
|
|
#Return created Image_Info ##
|
|
|
|
#Example
|
|
#Height 32
|
|
#Width 384
|
|
SkImageInfo info; // default constructor
|
|
SkString string;
|
|
string.printf("SkImageInfo() %c= SkImageInfo::MakeUnknown(0, 0)",
|
|
info == SkImageInfo::MakeUnknown(0, 0) ? '=' : '!');
|
|
SkPaint paint;
|
|
canvas->drawString(string, 0, 12, paint);
|
|
##
|
|
|
|
#SeeAlso SkImageInfo() MakeN32 MakeS32 Make
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method static SkImageInfo MakeUnknown()
|
|
|
|
#In Constructor
|
|
Creates Image_Info from integral dimensions width and height set to zero,
|
|
kUnknown_SkColorType, kUnknown_SkAlphaType, with Color_Space set to nullptr.
|
|
|
|
Returned Image_Info as part of source does not draw, and as part of destination
|
|
can not be drawn to.
|
|
|
|
#Return created Image_Info ##
|
|
|
|
#Example
|
|
#Height 32
|
|
#Width 384
|
|
SkImageInfo info; // default constructor
|
|
SkString string;
|
|
string.printf("SkImageInfo() %c= SkImageInfo::MakeUnknown()",
|
|
info == SkImageInfo::MakeUnknown() ? '=' : '!');
|
|
SkPaint paint;
|
|
canvas->drawString(string, 0, 12, paint);
|
|
##
|
|
|
|
#SeeAlso SkImageInfo() MakeN32 MakeS32 Make
|
|
|
|
#Method ##
|
|
|
|
|
|
# ------------------------------------------------------------------------------
|
|
#Subtopic Property
|
|
#Populate
|
|
#Line # metrics and attributes ##
|
|
##
|
|
|
|
#Method int width() const
|
|
#In Property
|
|
#Line # returns pixel column count ##
|
|
Returns pixel count in each row.
|
|
|
|
#Return pixel width ##
|
|
|
|
#Example
|
|
#Image 4
|
|
#Height 96
|
|
canvas->translate(10, 10);
|
|
canvas->drawBitmap(source, 0, 0);
|
|
SkImageInfo imageInfo = source.info();
|
|
canvas->translate(0, imageInfo.height());
|
|
SkPaint paint;
|
|
paint.setTextAlign(SkPaint::kCenter_Align);
|
|
canvas->drawLine(0, 10, imageInfo.width(), 10, paint);
|
|
canvas->drawString("width", imageInfo.width() / 2, 25, paint);
|
|
##
|
|
|
|
#SeeAlso height SkBitmap::width SkPixelRef::width SkImage::width SkSurface::width
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method int height() const
|
|
#In Property
|
|
#Line # returns pixel row count ##
|
|
Returns pixel row count.
|
|
|
|
#Return pixel height ##
|
|
|
|
#Example
|
|
#Image 4
|
|
#Height 96
|
|
canvas->translate(10, 20);
|
|
canvas->drawBitmap(source, 0, 0);
|
|
SkImageInfo imageInfo = source.info();
|
|
SkPaint paint;
|
|
paint.setTextAlign(SkPaint::kCenter_Align);
|
|
paint.setVerticalText(true);
|
|
canvas->drawLine(imageInfo.width() + 10, 0, imageInfo.width() + 10, imageInfo.height(), paint);
|
|
canvas->drawString("height", imageInfo.width() + 25, imageInfo.height() / 2, paint);
|
|
##
|
|
|
|
#SeeAlso width SkBitmap::height SkPixelRef::height SkImage::height SkSurface::height
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method SkColorType colorType() const
|
|
#In Property
|
|
#Line # returns Color_Type ##
|
|
Returns Color_Type, one of: #list_of_color_types#.
|
|
|
|
#Return Color_Type ##
|
|
|
|
#Example
|
|
const char* colors[] = {"Unknown", "Alpha_8", "RGB_565", "ARGB_4444", "RGBA_8888", "RGB_888x",
|
|
"BGRA_8888", "RGBA_1010102", "RGB_101010x", "Gray_8", "RGBA_F16"};
|
|
SkImageInfo info = SkImageInfo::MakeA8(16, 32);
|
|
SkDebugf("color type: k" "%s" "_SkColorType\n", colors[info.colorType()]);
|
|
#StdOut
|
|
color type: kAlpha_8_SkColorType
|
|
##
|
|
##
|
|
|
|
#SeeAlso alphaType SkPixmap::colorType SkBitmap::colorType
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method SkAlphaType alphaType() const
|
|
#In Property
|
|
#Line # Returns Alpha_Type ##
|
|
Returns Alpha_Type, one of: #list_of_alpha_types#.
|
|
|
|
#Return Alpha_Type ##
|
|
|
|
#Example
|
|
const char* alphas[] = {"Unknown", "Opaque", "Premul", "Unpremul"};
|
|
SkImageInfo info = SkImageInfo::MakeA8(16, 32);
|
|
SkDebugf("alpha type: k" "%s" "_SkAlphaType\n", alphas[info.alphaType()]);
|
|
#StdOut
|
|
alpha type: kPremul_SkAlphaType
|
|
##
|
|
##
|
|
|
|
#SeeAlso colorType SkPixmap::alphaType SkBitmap::alphaType
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method SkColorSpace* colorSpace() const
|
|
#In Property
|
|
#Line # returns Color_Space ##
|
|
Returns Color_Space, the range of colors. The reference count of
|
|
Color_Space is unchanged. The returned Color_Space is immutable.
|
|
|
|
#Return Color_Space, or nullptr ##
|
|
|
|
#Example
|
|
#Description
|
|
SkColorSpace::MakeSRGBLinear creates Color_Space with linear gamma
|
|
and an sRGB gamut. This Color_Space gamma is not close to sRGB gamma.
|
|
##
|
|
SkImageInfo info = SkImageInfo::MakeN32(16, 32, kPremul_SkAlphaType,
|
|
SkColorSpace::MakeSRGBLinear());
|
|
SkColorSpace* colorSpace = info.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 SkPixmap::colorSpace SkBitmap::colorSpace
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method sk_sp<SkColorSpace> refColorSpace() const
|
|
#In Property
|
|
#Line # returns Color_Space ##
|
|
Returns smart pointer to Color_Space, the range of colors. The smart pointer
|
|
tracks the number of objects sharing this Color_Space reference so the memory
|
|
is released when the owners destruct.
|
|
|
|
The returned Color_Space is immutable.
|
|
|
|
#Return Color_Space wrapped in a smart pointer ##
|
|
|
|
#Example
|
|
SkImageInfo info1 = SkImageInfo::MakeN32(16, 32, kPremul_SkAlphaType,
|
|
SkColorSpace::MakeSRGBLinear());
|
|
SkImageInfo info2 = SkImageInfo::MakeN32(16, 32, kPremul_SkAlphaType,
|
|
info1.refColorSpace());
|
|
SkColorSpace* colorSpace = info2.colorSpace();
|
|
SkDebugf("gammaCloseToSRGB: %s gammaIsLinear: %s isSRGB: %s\n",
|
|
colorSpace->gammaCloseToSRGB() ? "true" : "false",
|
|
colorSpace->gammaIsLinear() ? "true" : "false",
|
|
colorSpace->isSRGB() ? "true" : "false");
|
|
##
|
|
|
|
#SeeAlso Color_Space SkBitmap::refColorSpace
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method bool isEmpty() const
|
|
#In Property
|
|
#Line # returns if dimensions contain pixels ##
|
|
|
|
Returns if Image_Info describes an empty area of pixels by checking if either
|
|
width or height is zero or smaller.
|
|
|
|
#Return true if either dimension is zero or smaller ##
|
|
|
|
#Example
|
|
for (int width : { 0, 2 } ) {
|
|
for (int height : { 0, 2 } ) {
|
|
SkImageInfo imageInfo= SkImageInfo::MakeA8(width, height);
|
|
SkDebugf("width: %d height: %d empty: %s\n", width, height,
|
|
imageInfo.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 dimensions bounds SkBitmap::empty SkPixmap::bounds
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method bool isOpaque() const
|
|
#In Property
|
|
#Line # returns if Alpha_Type is kOpaque_SkAlphaType ##
|
|
|
|
Returns true if Alpha_Type is set to hint that all pixels are opaque; their
|
|
Color_Alpha value is implicitly or explicitly 1.0. If true, and all pixels are
|
|
not opaque, Skia may draw incorrectly.
|
|
|
|
Does not check if Color_Type allows Alpha, or if any pixel value has
|
|
transparency.
|
|
|
|
#Return true if Alpha_Type is kOpaque_SkAlphaType ##
|
|
|
|
#Example
|
|
const int height = 2;
|
|
const int width = 2;
|
|
SkBitmap bitmap;
|
|
SkImageInfo imageInfo = SkImageInfo::Make(width, height, kN32_SkColorType, kPremul_SkAlphaType);
|
|
bitmap.setInfo(imageInfo);
|
|
for (int index = 0; index < 2; ++index) {
|
|
bitmap.allocPixels();
|
|
bitmap.eraseColor(0x00000000);
|
|
SkDebugf("isOpaque: %s\n", imageInfo.isOpaque() ? "true" : "false");
|
|
bitmap.eraseColor(0xFFFFFFFF);
|
|
SkDebugf("isOpaque: %s\n", imageInfo.isOpaque() ? "true" : "false");
|
|
imageInfo = imageInfo.makeAlphaType(kOpaque_SkAlphaType);
|
|
bitmap.setInfo(imageInfo);
|
|
}
|
|
#StdOut
|
|
isOpaque: false
|
|
isOpaque: false
|
|
isOpaque: true
|
|
isOpaque: true
|
|
##
|
|
##
|
|
|
|
#SeeAlso Color_Alpha SkColorTypeValidateAlphaType SkBitmap::isOpaque SkImage::isOpaque SkPixmap::isOpaque
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method SkISize dimensions() const
|
|
#In Property
|
|
#Line # returns width() and height() ##
|
|
|
|
Returns ISize { width(), height() }.
|
|
|
|
#Return integral size of width() and height() ##
|
|
|
|
#Example
|
|
const int height = 2;
|
|
const int width = 2;
|
|
SkImageInfo imageInfo = SkImageInfo::Make(width, height, kN32_SkColorType, kPremul_SkAlphaType);
|
|
SkISize dimensions = imageInfo.dimensions();
|
|
SkIRect bounds = imageInfo.bounds();
|
|
SkIRect dimensionsAsBounds = SkIRect::MakeSize(dimensions);
|
|
SkDebugf("dimensionsAsBounds %c= bounds\n", dimensionsAsBounds == bounds ? '=' : '!');
|
|
#StdOut
|
|
dimensionsAsBounds == bounds
|
|
##
|
|
##
|
|
|
|
#SeeAlso width height bounds SkBitmap::dimensions
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method SkIRect bounds() const
|
|
#In Property
|
|
#Line # returns width() and height() as Rectangle ##
|
|
Returns IRect { 0, 0, width(), height() }.
|
|
|
|
#Return integral rectangle from origin to width() and height() ##
|
|
|
|
#Example
|
|
#Height 64
|
|
#Image 4
|
|
canvas->scale(.5f, .5f);
|
|
SkImageInfo imageInfo = source.info();
|
|
SkIRect bounds = imageInfo.bounds();
|
|
for (int x : { 0, bounds.width() } ) {
|
|
for (int y : { 0, bounds.height() } ) {
|
|
canvas->drawBitmap(source, x, y);
|
|
}
|
|
}
|
|
##
|
|
|
|
#SeeAlso width height dimensions
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method bool gammaCloseToSRGB() const
|
|
#In Property
|
|
#Line # Returns if Color_Space gamma is approximately the same as sRGB ##
|
|
|
|
Returns true if associated Color_Space is not nullptr, and Color_Space gamma
|
|
is approximately the same as sRGB.
|
|
This includes the
|
|
###$
|
|
$A sRGB transfer function $ https://en.wikipedia.org/wiki/SRGB#The_sRGB_transfer_function_(%22gamma%22) $$
|
|
$$$#
|
|
as well as a gamma curve described by a 2.2 exponent.
|
|
|
|
#Return true if Color_Space gamma is approximately the same as sRGB ##
|
|
|
|
#Example
|
|
#Height 144
|
|
const int width = 256;
|
|
const int height = 64;
|
|
auto drawLabel = [=](const char* what, bool closeToSRGB) -> void {
|
|
SkString string;
|
|
string.printf("%s gamma is %s" "close to sRGB", what, closeToSRGB ? "" : "not ");
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
paint.setTextAlign(SkPaint::kCenter_Align);
|
|
canvas->drawString(string, width / 2, 56, paint);
|
|
};
|
|
SkColor gradColors[] = { 0xFFFF7F00, 0xFF00FF7F, 0xFF0000FF, 0xFF7F7FFF };
|
|
SkPoint gradPoints[] = { { 0, 0 }, { width, 0 }, { width * 2, 0 }, { width * 3, 0 } };
|
|
SkPaint gradPaint;
|
|
gradPaint.setShader(SkGradientShader::MakeLinear(gradPoints, gradColors, nullptr,
|
|
SK_ARRAY_COUNT(gradColors), SkShader::kClamp_TileMode));
|
|
canvas->drawRect(SkRect::MakeWH(width, height), gradPaint);
|
|
drawLabel("canvas", canvas->imageInfo().gammaCloseToSRGB());
|
|
SkBitmap bitmap;
|
|
SkImageInfo offscreenInfo = SkImageInfo::MakeS32(width, height, kPremul_SkAlphaType);
|
|
bitmap.allocPixels(offscreenInfo);
|
|
SkCanvas sRGBOffscreen(bitmap);
|
|
sRGBOffscreen.drawRect(SkRect::MakeWH(width, height), gradPaint);
|
|
canvas->translate(0, 80);
|
|
canvas->drawBitmap(bitmap, 0, 0);
|
|
drawLabel("offscreen", offscreenInfo.gammaCloseToSRGB());
|
|
##
|
|
|
|
#SeeAlso SkColorSpace::gammaCloseToSRGB
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method SkImageInfo makeWH(int newWidth, int newHeight) const
|
|
#In Constructor
|
|
#Line # creates Image_Info with changed dimensions ##
|
|
Creates Image_Info with the same Color_Type, Color_Space, and Alpha_Type,
|
|
with dimensions set to width and height.
|
|
|
|
#Param newWidth pixel column count; must be zero or greater ##
|
|
#Param newHeight pixel row count; must be zero or greater ##
|
|
|
|
#Return created Image_Info ##
|
|
|
|
#Example
|
|
#Height 144
|
|
#Image 3
|
|
SkImageInfo canvasImageInfo = canvas->imageInfo();
|
|
SkRect canvasBounds = SkRect::Make(canvasImageInfo.bounds());
|
|
canvas->drawBitmapRect(source, source.bounds(), canvasBounds, nullptr);
|
|
SkImageInfo insetImageInfo =
|
|
canvasImageInfo.makeWH(canvasBounds.width() / 2, canvasBounds.height() / 2);
|
|
SkBitmap inset;
|
|
inset.allocPixels(insetImageInfo);
|
|
SkCanvas offscreen(inset);
|
|
offscreen.drawBitmapRect(source, source.bounds(), SkRect::Make(inset.bounds()), nullptr);
|
|
canvas->drawBitmap(inset, canvasBounds.width() / 4, canvasBounds.height() / 4);
|
|
##
|
|
|
|
#SeeAlso Make makeAlphaType makeColorSpace makeColorType
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method SkImageInfo makeAlphaType(SkAlphaType newAlphaType) const
|
|
#In Constructor
|
|
#Line # creates Image_Info with changed Alpha_Type ##
|
|
Creates Image_Info with same Color_Type, Color_Space, width, and height,
|
|
with Alpha_Type set to newAlphaType.
|
|
|
|
Created Image_Info contains newAlphaType even if it is incompatible with
|
|
Color_Type, in which case Alpha_Type in Image_Info is ignored.
|
|
|
|
#Param newAlphaType one of: #list_of_alpha_types#
|
|
##
|
|
|
|
#Return created Image_Info ##
|
|
|
|
#Example
|
|
#Image 3
|
|
const int width = 256;
|
|
const int height = 128;
|
|
SkColor pixels[height][width];
|
|
for (int y = 0; y < height; ++y) {
|
|
for (int x = 0; x < width; ++x) {
|
|
int red = SkScalarRoundToInt(255 * SkScalarAbs(SkScalarSin((x * 4 + y) * 0.03f)));
|
|
int blue = SkScalarRoundToInt(255 * SkScalarAbs(SkScalarCos((x * 3 + y) * 0.04f)));
|
|
int green = SkScalarRoundToInt(255 * SkScalarAbs(SkScalarSin((x * 2 + y) * 0.05f)));
|
|
int alpha = SkScalarRoundToInt(255 * SkScalarAbs(SkScalarCos((x * 1 + y) * 0.006f)));
|
|
pixels[y][x] =
|
|
SkColorSetARGB(alpha, red * alpha / 255, green * alpha / 255, blue * alpha / 255);
|
|
}
|
|
}
|
|
SkBitmap bitmap;
|
|
SkImageInfo info = SkImageInfo::Make(width, height, kBGRA_8888_SkColorType, kPremul_SkAlphaType);
|
|
bitmap.installPixels(info, (void*) pixels, sizeof(SkColor) * width);
|
|
canvas->drawBitmap(source, 0, 0);
|
|
canvas->drawBitmap(bitmap, 0, 0);
|
|
SkImageInfo unpremulInfo = info.makeAlphaType(kUnpremul_SkAlphaType);
|
|
bitmap.installPixels(unpremulInfo, (void*) pixels, sizeof(SkColor) * width);
|
|
canvas->drawBitmap(bitmap, 0, 128);
|
|
##
|
|
|
|
#SeeAlso Make MakeA8 makeColorType makeColorSpace
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method SkImageInfo makeColorType(SkColorType newColorType) const
|
|
#In Constructor
|
|
#Line # creates Image_Info with changed Color_Type ##
|
|
Creates Image_Info with same Alpha_Type, Color_Space, width, and height,
|
|
with Color_Type set to newColorType.
|
|
|
|
#Param newColorType one of: #list_of_color_types#
|
|
##
|
|
|
|
#Return created Image_Info ##
|
|
|
|
#Example
|
|
const int width = 256;
|
|
const int height = 128;
|
|
SkColor pixels[height][width];
|
|
for (int y = 0; y < height; ++y) {
|
|
for (int x = 0; x < width; ++x) {
|
|
int red = SkScalarRoundToInt(255 * SkScalarAbs(SkScalarSin((x * 4 + y) * 0.03f)));
|
|
int blue = SkScalarRoundToInt(255 * SkScalarAbs(SkScalarCos((x * 3 + y) * 0.04f)));
|
|
int green = SkScalarRoundToInt(255 * SkScalarAbs(SkScalarSin((x * 2 + y) * 0.05f)));
|
|
int alpha = SkScalarRoundToInt(255 * SkScalarAbs(SkScalarCos((x * 1 + y) * 0.006f)));
|
|
pixels[y][x] =
|
|
SkColorSetARGB(alpha, red * alpha / 255, green * alpha / 255, blue * alpha / 255);
|
|
}
|
|
}
|
|
SkBitmap bitmap;
|
|
SkImageInfo info = SkImageInfo::Make(width, height, kBGRA_8888_SkColorType, kPremul_SkAlphaType);
|
|
bitmap.installPixels(info, (void*) pixels, sizeof(SkColor) * width);
|
|
canvas->drawBitmap(source, 0, 0);
|
|
canvas->drawBitmap(bitmap, 0, 0);
|
|
SkImageInfo rgbaInfo = info.makeColorType(kRGBA_8888_SkColorType);
|
|
bitmap.installPixels(rgbaInfo, (void*) pixels, sizeof(SkColor) * width);
|
|
canvas->drawBitmap(bitmap, 0, 128);
|
|
##
|
|
|
|
#SeeAlso Make makeAlphaType makeColorSpace
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method SkImageInfo makeColorSpace(sk_sp<SkColorSpace> cs) const
|
|
#In Constructor
|
|
#Line # creates Image_Info with changed Color_Space ##
|
|
Creates Image_Info with same Alpha_Type, Color_Type, width, and height,
|
|
with Color_Space set to cs.
|
|
|
|
#Param cs range of colors; may be nullptr ##
|
|
|
|
#Return created Image_Info ##
|
|
|
|
#Example
|
|
#Height 224
|
|
const int width = 256;
|
|
const int height = 64;
|
|
auto drawLabel = [=](const char* what, bool closeToSRGB) -> void {
|
|
SkString string;
|
|
string.printf("%s gamma is %s" "close to sRGB", what, closeToSRGB ? "" : "not ");
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
paint.setTextAlign(SkPaint::kCenter_Align);
|
|
canvas->drawString(string, width / 2, 56, paint);
|
|
};
|
|
SkColor gradColors[] = { 0xFFFF7F00, 0xFF00FF7F, 0xFF0000FF, 0xFF7F7FFF };
|
|
SkPoint gradPoints[] = { { 0, 0 }, { width, 0 }, { width * 2, 0 }, { width * 3, 0 } };
|
|
SkPaint gradPaint;
|
|
gradPaint.setShader(SkGradientShader::MakeLinear(gradPoints, gradColors, nullptr,
|
|
SK_ARRAY_COUNT(gradColors), SkShader::kClamp_TileMode));
|
|
canvas->drawRect(SkRect::MakeWH(width, height), gradPaint);
|
|
drawLabel("canvas", canvas->imageInfo().gammaCloseToSRGB());
|
|
SkBitmap bitmap;
|
|
SkImageInfo offscreenInfo = SkImageInfo::MakeS32(width, height, kPremul_SkAlphaType);
|
|
bitmap.allocPixels(offscreenInfo);
|
|
SkCanvas sRGBOffscreen(bitmap);
|
|
sRGBOffscreen.drawRect(SkRect::MakeWH(width, height), gradPaint);
|
|
canvas->translate(0, 80);
|
|
canvas->drawBitmap(bitmap, 0, 0);
|
|
drawLabel("offscreen", offscreenInfo.gammaCloseToSRGB());
|
|
SkImageInfo linearGamma =
|
|
offscreenInfo.makeColorSpace(offscreenInfo.colorSpace()->makeLinearGamma());
|
|
bitmap.allocPixels(linearGamma);
|
|
SkCanvas lgOffscreen(bitmap);
|
|
lgOffscreen.drawRect(SkRect::MakeWH(width, height), gradPaint);
|
|
canvas->translate(0, 80);
|
|
canvas->drawBitmap(bitmap, 0, 0);
|
|
drawLabel("linear", linearGamma.gammaCloseToSRGB());
|
|
##
|
|
|
|
#SeeAlso Make MakeS32 makeAlphaType makeColorType
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method int bytesPerPixel() const
|
|
#In Property
|
|
#Line # returns number of bytes in pixel based on Color_Type ##
|
|
Returns number of bytes per pixel required by Color_Type.
|
|
Returns zero if colorType( is kUnknown_SkColorType.
|
|
|
|
#Return bytes in pixel ##
|
|
|
|
#Example
|
|
const char* colors[] = {"Unknown", "Alpha_8", "RGB_565", "ARGB_4444", "RGBA_8888", "RGB_888x",
|
|
"BGRA_8888", "RGBA_1010102", "RGB_101010x", "Gray_8", "RGBA_F16"};
|
|
for (SkColorType colorType : { #list_of_color_types#
|
|
} ) {
|
|
SkImageInfo info = SkImageInfo::Make(1, 1, colorType, kOpaque_SkAlphaType);
|
|
SkDebugf("color: k" "%s" "_SkColorType" "%*s" "bytesPerPixel: %d\n",
|
|
colors[colorType], 13 - strlen(colors[colorType]), " ",
|
|
info.bytesPerPixel());
|
|
}
|
|
#StdOut
|
|
color: kUnknown_SkColorType bytesPerPixel: 0
|
|
color: kAlpha_8_SkColorType bytesPerPixel: 1
|
|
color: kRGB_565_SkColorType bytesPerPixel: 2
|
|
color: kARGB_4444_SkColorType bytesPerPixel: 2
|
|
color: kRGBA_8888_SkColorType bytesPerPixel: 4
|
|
color: kRGB_888x_SkColorType bytesPerPixel: 4
|
|
color: kBGRA_8888_SkColorType bytesPerPixel: 4
|
|
color: kRGBA_1010102_SkColorType bytesPerPixel: 4
|
|
color: kRGB_101010x_SkColorType bytesPerPixel: 4
|
|
color: kGray_8_SkColorType bytesPerPixel: 1
|
|
color: kRGBA_F16_SkColorType bytesPerPixel: 8
|
|
##
|
|
##
|
|
|
|
#SeeAlso width shiftPerPixel SkBitmap::bytesPerPixel
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method int shiftPerPixel() const
|
|
#In Property
|
|
#Line # returns bit shift from pixels to bytes ##
|
|
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_8", "RGB_565", "ARGB_4444", "RGBA_8888", "RGB_888x",
|
|
"BGRA_8888", "RGBA_1010102", "RGB_101010x", "Gray_8", "RGBA_F16"};
|
|
for (SkColorType colorType : { #list_of_color_types#
|
|
} ) {
|
|
SkImageInfo info = SkImageInfo::Make(1, 1, colorType, kOpaque_SkAlphaType);
|
|
SkDebugf("color: k" "%s" "_SkColorType" "%*s" "shiftPerPixel: %d\n",
|
|
colors[colorType], 14 - strlen(colors[colorType]), " ",
|
|
info.shiftPerPixel());
|
|
}
|
|
#StdOut
|
|
color: kUnknown_SkColorType shiftPerPixel: 0
|
|
color: kAlpha_8_SkColorType shiftPerPixel: 0
|
|
color: kRGB_565_SkColorType shiftPerPixel: 1
|
|
color: kARGB_4444_SkColorType shiftPerPixel: 1
|
|
color: kRGBA_8888_SkColorType shiftPerPixel: 2
|
|
color: kRGB_888x_SkColorType shiftPerPixel: 2
|
|
color: kBGRA_8888_SkColorType shiftPerPixel: 2
|
|
color: kRGBA_1010102_SkColorType shiftPerPixel: 2
|
|
color: kRGB_101010x_SkColorType shiftPerPixel: 2
|
|
color: kGray_8_SkColorType shiftPerPixel: 0
|
|
color: kRGBA_F16_SkColorType shiftPerPixel: 3
|
|
##
|
|
##
|
|
|
|
#SeeAlso bytesPerPixel minRowBytes SkBitmap::shiftPerPixel SkPixmap::shiftPerPixel
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method uint64_t minRowBytes64() const
|
|
#In Property
|
|
#Line # returns width() times bytesPerPixel in 64 bits ##
|
|
|
|
Returns minimum bytes per row, computed from pixel width() and Color_Type, which
|
|
specifies bytesPerPixel(). Bitmap maximum value for row bytes must be representable
|
|
as a positive value in a 32-bit signed integer.
|
|
|
|
#Return width() times bytesPerPixel as unsigned 64-bit integer ##
|
|
|
|
#Example
|
|
for (int shift = 24; shift < 32; ++shift) {
|
|
int width = 1 << shift;
|
|
SkImageInfo imageInfo =
|
|
SkImageInfo::Make(width, 1, kRGBA_F16_SkColorType, kPremul_SkAlphaType);
|
|
uint64_t minRowBytes = imageInfo.minRowBytes64();
|
|
bool widthTooLarge = (uint64_t) (int32_t) minRowBytes != minRowBytes;
|
|
SkDebugf("RGBA_F16 width %d (0x%08x) %s\n",
|
|
width, width, widthTooLarge ? "too large" : "OK");
|
|
}
|
|
#StdOut
|
|
RGBA_F16 width 16777216 (0x01000000) OK
|
|
RGBA_F16 width 33554432 (0x02000000) OK
|
|
RGBA_F16 width 67108864 (0x04000000) OK
|
|
RGBA_F16 width 134217728 (0x08000000) OK
|
|
RGBA_F16 width 268435456 (0x10000000) too large
|
|
RGBA_F16 width 536870912 (0x20000000) too large
|
|
RGBA_F16 width 1073741824 (0x40000000) too large
|
|
RGBA_F16 width -2147483648 (0x80000000) too large
|
|
##
|
|
##
|
|
|
|
#SeeAlso minRowBytes computeByteSize computeMinByteSize validRowBytes
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method size_t minRowBytes() const
|
|
#In Property
|
|
#Line # returns width() times bytesPerPixel in 32 bits ##
|
|
|
|
Returns minimum bytes per row, computed from pixel width() and Color_Type, which
|
|
specifies bytesPerPixel(). Bitmap maximum value for row bytes must be representable
|
|
as a positive value in a 32-bit signed integer.
|
|
|
|
#Return width() times bytesPerPixel as signed 32-bit integer ##
|
|
|
|
#Example
|
|
for (int shift = 24; shift < 32; ++shift) {
|
|
int width = 1 << shift;
|
|
SkImageInfo imageInfo =
|
|
SkImageInfo::Make(width, 1, kRGBA_F16_SkColorType, kPremul_SkAlphaType);
|
|
size_t minRowBytes = imageInfo.minRowBytes();
|
|
bool widthTooLarge = !minRowBytes;
|
|
SkDebugf("RGBA_F16 width %d (0x%08x) %s\n",
|
|
width, width, widthTooLarge ? "too large" : "OK");
|
|
}
|
|
#StdOut
|
|
RGBA_F16 width 16777216 (0x01000000) OK
|
|
RGBA_F16 width 33554432 (0x02000000) OK
|
|
RGBA_F16 width 67108864 (0x04000000) OK
|
|
RGBA_F16 width 134217728 (0x08000000) OK
|
|
RGBA_F16 width 268435456 (0x10000000) too large
|
|
RGBA_F16 width 536870912 (0x20000000) too large
|
|
RGBA_F16 width 1073741824 (0x40000000) too large
|
|
RGBA_F16 width -2147483648 (0x80000000) too large
|
|
##
|
|
##
|
|
|
|
#SeeAlso minRowBytes64 computeByteSize computeMinByteSize validRowBytes
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method size_t computeOffset(int x, int y, size_t rowBytes) const
|
|
#In Utility
|
|
#Line # returns byte offset within pixel array ##
|
|
|
|
Returns byte offset of pixel from pixel base address.
|
|
|
|
Asserts in debug build if x or y is outside of bounds. Does not assert if
|
|
rowBytes is smaller than minRowBytes, even though result may be incorrect.
|
|
|
|
#Param x column index, zero or greater, and less than width() ##
|
|
#Param y row index, zero or greater, and less than height() ##
|
|
#Param rowBytes size of pixel row or larger ##
|
|
|
|
#Return offset within pixel array ##
|
|
|
|
#Example
|
|
#Height 128
|
|
uint8_t pixels[][12] = { { 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00},
|
|
{ 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00},
|
|
{ 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00},
|
|
{ 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0xFF},
|
|
{ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
|
|
{ 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00},
|
|
{ 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00},
|
|
{ 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00} };
|
|
SkImageInfo imageInfo = SkImageInfo::MakeA8(8, 8);
|
|
SkBitmap bitmap;
|
|
bitmap.installPixels(imageInfo, (void*) pixels, sizeof(pixels[0]));
|
|
SkPaint paint;
|
|
paint.setColor(SK_ColorRED);
|
|
canvas->drawBitmapRect(bitmap, SkRect::MakeWH(8, 8), SkRect::MakeWH(32, 32), &paint);
|
|
size_t offset = imageInfo.computeOffset(2, 3, sizeof(pixels[0]));
|
|
pixels[0][offset] = 0x7F;
|
|
offset = imageInfo.computeOffset(5, 3, sizeof(pixels[0]));
|
|
pixels[0][offset] = 0x7F;
|
|
bitmap.installPixels(imageInfo, (void*) pixels, sizeof(pixels[0]));
|
|
canvas->drawBitmapRect(bitmap, SkRect::MakeWH(8, 8), SkRect::MakeWH(128, 128), &paint);
|
|
##
|
|
|
|
#SeeAlso height width minRowBytes computeByteSize
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
#Subtopic Operator
|
|
#Populate
|
|
##
|
|
|
|
#Method bool operator==(const SkImageInfo& other)_const
|
|
#Line # compares Image_Info for equality ##
|
|
|
|
Compares Image_Info with other, and returns true if width, height, Color_Type,
|
|
Alpha_Type, and Color_Space are equivalent.
|
|
|
|
#Param other Image_Info to compare ##
|
|
|
|
#Return true if Image_Info equals other ##
|
|
|
|
#Example
|
|
SkImageInfo info1 = SkImageInfo::Make(10, 20, kGray_8_SkColorType, kPremul_SkAlphaType);
|
|
SkImageInfo info2 = SkImageInfo::Make(20, 10, kAlpha_8_SkColorType, kUnpremul_SkAlphaType);
|
|
SkDebugf("info1 %c= info2\n", info1 == info2 ? '=' : '!');
|
|
info2 = info2.makeWH(10, 20);
|
|
SkDebugf("info1 %c= info2\n", info1 == info2 ? '=' : '!');
|
|
info2 = info2.makeColorType(kGray_8_SkColorType);
|
|
SkDebugf("info1 %c= info2\n", info1 == info2 ? '=' : '!');
|
|
info2 = info2.makeAlphaType(kPremul_SkAlphaType);
|
|
SkDebugf("info1 %c= info2\n", info1 == info2 ? '=' : '!');
|
|
#StdOut
|
|
info1 != info2
|
|
info1 != info2
|
|
info1 != info2
|
|
info1 == info2
|
|
##
|
|
##
|
|
|
|
#SeeAlso operator!=(const SkImageInfo& other)_const SkColorSpace::Equals
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method bool operator!=(const SkImageInfo& other)_const
|
|
#Line # compares Image_Info for inequality ##
|
|
|
|
Compares Image_Info with other, and returns true if width, height, Color_Type,
|
|
Alpha_Type, and Color_Space are equivalent.
|
|
|
|
#Param other Image_Info to compare ##
|
|
|
|
#Return true if Image_Info is not equal to other ##
|
|
|
|
#Example
|
|
SkImageInfo info1 = SkImageInfo::Make(10, 20, kGray_8_SkColorType, kPremul_SkAlphaType);
|
|
SkImageInfo info2 = SkImageInfo::Make(20, 10, kAlpha_8_SkColorType, kUnpremul_SkAlphaType);
|
|
SkDebugf("info1 %c= info2\n", info1 != info2 ? '!' : '=');
|
|
info2 = info2.makeWH(10, 20);
|
|
SkDebugf("info1 %c= info2\n", info1 != info2 ? '!' : '=');
|
|
info2 = info2.makeColorType(kGray_8_SkColorType);
|
|
SkDebugf("info1 %c= info2\n", info1 != info2 ? '!' : '=');
|
|
info2 = info2.makeAlphaType(kPremul_SkAlphaType);
|
|
SkDebugf("info1 %c= info2\n", info1 != info2 ? '!' : '=');
|
|
#StdOut
|
|
info1 != info2
|
|
info1 != info2
|
|
info1 != info2
|
|
info1 == info2
|
|
##
|
|
##
|
|
|
|
#SeeAlso operator==(const SkImageInfo& other)_const SkColorSpace::Equals
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method size_t computeByteSize(size_t rowBytes) const
|
|
#In Utility
|
|
#Line # memory required by pixel buffer with given row bytes ##
|
|
Returns storage required by pixel array, given Image_Info dimensions, Color_Type,
|
|
and rowBytes. rowBytes is assumed to be at least as large as minRowBytes().
|
|
|
|
Returns zero if height is zero.
|
|
Returns SK_MaxSizeT if answer exceeds the range of size_t.
|
|
|
|
#Param rowBytes size of pixel row or larger ##
|
|
|
|
#Return memory required by pixel buffer ##
|
|
|
|
#Example
|
|
#Height 130
|
|
SkImageInfo info = SkImageInfo::MakeN32Premul(2, 2);
|
|
const size_t size = info.computeByteSize(100000);
|
|
SkAutoTMalloc<SkPMColor> storage(size);
|
|
SkPMColor* pixels = storage.get();
|
|
SkBitmap bitmap;
|
|
bitmap.setInfo(info);
|
|
bitmap.setPixels(pixels);
|
|
bitmap.eraseColor(SK_ColorRED);
|
|
canvas->scale(50, 50);
|
|
canvas->rotate(8);
|
|
canvas->drawBitmap(bitmap, 2, 0);
|
|
##
|
|
|
|
#SeeAlso computeMinByteSize validRowBytes
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method size_t computeMinByteSize() const
|
|
#In Utility
|
|
#Line # least memory required by pixel buffer ##
|
|
Returns storage required by pixel array, given Image_Info dimensions, and
|
|
Color_Type. Uses minRowBytes() to compute bytes for pixel row.
|
|
|
|
Returns zero if height is zero.
|
|
Returns SK_MaxSizeT if answer exceeds the range of size_t.
|
|
|
|
#Return least memory required by pixel buffer ##
|
|
|
|
#Example
|
|
#Height 130
|
|
SkImageInfo info = SkImageInfo::MakeN32Premul(2, 2);
|
|
const size_t size = info.computeMinByteSize();
|
|
SkAutoTMalloc<SkPMColor> storage(size);
|
|
SkPMColor* pixels = storage.get();
|
|
SkBitmap bitmap;
|
|
bitmap.setInfo(info);
|
|
bitmap.setPixels(pixels);
|
|
bitmap.eraseColor(SK_ColorRED);
|
|
canvas->scale(50, 50);
|
|
canvas->rotate(8);
|
|
canvas->drawBitmap(bitmap, 2, 0);
|
|
##
|
|
|
|
#SeeAlso computeByteSize validRowBytes
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method static bool ByteSizeOverflowed(size_t byteSize)
|
|
#In Utility
|
|
#Line # checks result of computeByteSize and computeMinByteSize ##
|
|
Returns true if byteSize equals SK_MaxSizeT. computeByteSize and
|
|
computeMinByteSize return SK_MaxSizeT if size_t can not hold buffer size.
|
|
|
|
#Param byteSize result of computeByteSize or computeMinByteSize ##
|
|
|
|
#Return true if computeByteSize or computeMinByteSize result exceeds size_t ##
|
|
|
|
#Example
|
|
SkImageInfo info = SkImageInfo::MakeN32Premul(2, 1000000000);
|
|
for (size_t rowBytes = 100000000; rowBytes < 10000000000000LL; rowBytes *= 10) {
|
|
const size_t size = info.computeByteSize(rowBytes);
|
|
SkDebugf("rowBytes:%llu size:%llu overflowed:%s\n", rowBytes, size,
|
|
SkImageInfo::ByteSizeOverflowed(size) ? "true" : "false");
|
|
}
|
|
#StdOut
|
|
rowBytes:100000000 size:99999999900000008 overflowed:false
|
|
rowBytes:1000000000 size:999999999000000008 overflowed:false
|
|
rowBytes:10000000000 size:9999999990000000008 overflowed:false
|
|
rowBytes:100000000000 size:18446744073709551615 overflowed:true
|
|
rowBytes:1000000000000 size:18446744073709551615 overflowed:true
|
|
##
|
|
##
|
|
|
|
#SeeAlso computeByteSize computeMinByteSize validRowBytes
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method bool validRowBytes(size_t rowBytes) const
|
|
#In Utility
|
|
#Line # checks if row bytes is large enough to contain pixel row ##
|
|
Returns true if rowBytes is smaller than width times pixel size.
|
|
|
|
#Param rowBytes size of pixel row or larger ##
|
|
|
|
#Return true if rowBytes is large enough to contain pixel row ##
|
|
|
|
#Example
|
|
SkImageInfo info = SkImageInfo::MakeN32Premul(16, 8);
|
|
for (size_t rowBytes = 60; rowBytes < 72; rowBytes += sizeof(SkPMColor)) {
|
|
SkDebugf("validRowBytes(%llu): %s\n", rowBytes, info.validRowBytes(rowBytes) ?
|
|
"true" : "false");
|
|
}
|
|
#StdOut
|
|
validRowBytes(60): false
|
|
validRowBytes(64): true
|
|
validRowBytes(68): true
|
|
##
|
|
##
|
|
|
|
#SeeAlso ByteSizeOverflowed computeByteSize computeMinByteSize
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method void reset()
|
|
#In Constructor
|
|
#Line # sets zero dimensions, kUnknown_SkColorType, kUnknown_SkAlphaType ##
|
|
Creates an empty Image_Info with kUnknown_SkColorType, kUnknown_SkAlphaType,
|
|
a width and height of zero, and no Color_Space.
|
|
|
|
#Example
|
|
SkImageInfo info = SkImageInfo::MakeN32Premul(16, 8);
|
|
SkImageInfo copy = info;
|
|
SkDebugf("info %c= copy\n", info == copy ? '=' : '!');
|
|
copy.reset();
|
|
SkDebugf("info %c= reset copy\n", info == copy ? '=' : '!');
|
|
SkDebugf("SkImageInfo() %c= reset copy\n", SkImageInfo() == copy ? '=' : '!');
|
|
#StdOut
|
|
info == copy
|
|
info != reset copy
|
|
SkImageInfo() == reset copy
|
|
##
|
|
##
|
|
|
|
#SeeAlso SkImageInfo()
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
#Subtopic Utility
|
|
#Populate
|
|
#Line # rarely called management functions ##
|
|
##
|
|
|
|
#Method void validate() const
|
|
#In Utility
|
|
#Line # asserts if Image_Info is invalid (debug only) ##
|
|
Asserts if internal values are illegal or inconsistent. Only available if
|
|
SK_DEBUG is defined at compile time.
|
|
|
|
#NoExample
|
|
##
|
|
|
|
#SeeAlso validRowBytes SkBitmap::validate
|
|
|
|
#Method ##
|
|
|
|
#Struct SkImageInfo ##
|
|
|
|
#Topic Image_Info ##
|