1 #Topic Image_Info 2 #Alias Image_Info_Reference ## 3 4 #Code 5 #Populate 6 ## 7 8 Image_Info specifies the dimensions and encoding of the pixels in a Bitmap. 9 The dimensions are integral width and height. The encoding is how pixel 10 bits describe Color_Alpha, transparency; Color components red, blue, 11 and green; and Color_Space, the range and linearity of colors. 12 13 Image_Info describes an uncompressed raster pixels. In contrast, Image 14 additionally describes compressed pixels like PNG, and Surface describes 15 destinations on the GPU. Image and Surface may be specified by Image_Info, 16 but Image and Surface may not contain Image_Info. 17 18 # ------------------------------------------------------------------------------ 19 #Subtopic Alpha_Type 20 #Line # encoding for pixel transparency ## 21 #Alias Alpha_Type ## 22 #Alias Alpha_Types ## 23 24 #PhraseDef list_of_alpha_types 25 kUnknown_SkAlphaType, kOpaque_SkAlphaType, kPremul_SkAlphaType, 26 kUnpremul_SkAlphaType 27 ## 28 29 #Enum SkAlphaType 30 #Line # encoding for pixel transparency ## 31 32 #Code 33 #Populate 34 ## 35 36 Describes how to interpret the alpha component of a pixel. A pixel may 37 be opaque, or Color_Alpha, describing multiple levels of transparency. 38 39 In simple blending, Color_Alpha weights the draw color and the destination 40 color to create a new color. If alpha describes a weight from zero to one, 41 new color is set to: #Formula # draw color * alpha + destination color * (1 - alpha) ##. 42 43 In practice alpha is encoded in two or more bits, where 1.0 equals all bits set. 44 45 RGB may have Color_Alpha included in each component value; the stored 46 value is the original RGB multiplied by Color_Alpha. Premultiplied color 47 components improve performance. 48 49 #Const kUnknown_SkAlphaType 0 50 #Line # uninitialized ## 51 Alpha_Type is uninitialized. 52 ## 53 #Const kOpaque_SkAlphaType 1 54 #Line # pixel is opaque ## 55 #Details Opaque 56 Pixels are opaque. The Color_Type must have no explicit alpha 57 component, or all alpha components must be set to their maximum value. 58 ## 59 #Const kPremul_SkAlphaType 2 60 #Line # pixel components are Premultiplied by Alpha ## 61 #Details Premul 62 Pixels have Alpha Premultiplied into color components. 63 Surface pixels must be Premultiplied. 64 ## 65 #Const kUnpremul_SkAlphaType 3 66 #Line # pixel components are independent of Alpha ## 67 #Details Unpremul 68 Pixel color component values are independent of alpha value. 69 Images generated from encoded data like PNG do not Premultiply pixel color 70 components. kUnpremul_SkAlphaType is supported for Image pixels, but not for 71 Surface pixels. 72 ## 73 #Const kLastEnum_SkAlphaType 3 74 #Line # last valid value ## 75 Used by tests to iterate through all valid values. 76 ## 77 78 #NoExample 79 ## 80 81 #SeeAlso SkColorType SkColorSpace 82 83 #Enum SkAlphaType ## 84 85 #Subtopic Opaque 86 #Line # hints all pixels are opaque ## 87 Use kOpaque_SkAlphaType as a hint to optimize drawing when Alpha component 88 of all pixel is set to its maximum value of 1.0; all alpha component bits are set. 89 If Image_Info is set to kOpaque_SkAlphaType but all alpha values are not 1.0, 90 results are undefined. 91 92 #Example 93 #Height 64 94 #Description 95 SkPreMultiplyARGB parameter a is set to 255, its maximum value, and is interpreted 96 as Color_Alpha of 1.0. kOpaque_SkAlphaType may be set to improve performance. 97 If SkPreMultiplyARGB parameter a is set to a value smaller than 255, 98 kPremul_SkAlphaType must be used instead to avoid undefined results. 99 The four displayed values are the original component values, though not necessarily 100 in the same order. 101 ## 102 SkPMColor color = SkPreMultiplyARGB(255, 50, 100, 150); 103 SkString s; 104 s.printf("%u %u %u %u", SkColorGetA(color), SkColorGetR(color), 105 SkColorGetG(color), SkColorGetB(color)); 106 SkPaint paint; 107 paint.setAntiAlias(true); 108 canvas->drawString(s, 10, 62, paint); 109 canvas->scale(50, 50); 110 SkBitmap bitmap; 111 SkImageInfo imageInfo = SkImageInfo::Make(1, 1, kN32_SkColorType, kOpaque_SkAlphaType); 112 if (bitmap.installPixels(imageInfo, (void*) &color, imageInfo.minRowBytes())) { 113 canvas->drawBitmap(bitmap, 0, 0); 114 } 115 ## 116 117 #Subtopic Opaque ## 118 119 #Subtopic Premul 120 #Line # stores components scaled by Alpha ## 121 Use kPremul_SkAlphaType when stored color components are the original color 122 multiplied by the alpha component. The alpha component range of 0.0 to 1.0 is 123 achieved by dividing the integer bit value by the maximum bit value. 124 125 #Code 126 stored color = original color * alpha / max alpha 127 ## 128 129 The color component must be equal to or smaller than the alpha component, 130 or the results are undefined. 131 132 #Example 133 #Description 134 SkPreMultiplyARGB parameter a is set to 150, less than its maximum value, and is 135 interpreted as Color_Alpha of about 0.6. kPremul_SkAlphaType must be set, since 136 SkPreMultiplyARGB parameter a is set to a value smaller than 255, 137 to avoid undefined results. 138 The four displayed values reflect that the alpha component has been multiplied 139 by the original color. 140 ## 141 #Height 64 142 SkPMColor color = SkPreMultiplyARGB(150, 50, 100, 150); 143 SkString s; 144 s.printf("%u %u %u %u", SkColorGetA(color), SkColorGetR(color), 145 SkColorGetG(color), SkColorGetB(color)); 146 SkPaint paint; 147 paint.setAntiAlias(true); 148 canvas->drawString(s, 10, 62, paint); 149 canvas->scale(50, 50); 150 SkBitmap bitmap; 151 SkImageInfo imageInfo = SkImageInfo::Make(1, 1, kN32_SkColorType, kPremul_SkAlphaType); 152 if (bitmap.installPixels(imageInfo, (void*) &color, imageInfo.minRowBytes())) { 153 canvas->drawBitmap(bitmap, 0, 0); 154 } 155 ## 156 157 #Subtopic Premul ## 158 159 #Subtopic Unpremul 160 #Line # stores components without Alpha scaling ## 161 Use kUnpremul_SkAlphaType if stored color components are not divided by the 162 alpha component. Some drawing destinations may not support 163 kUnpremul_SkAlphaType. 164 165 #Bug 7079 166 #Example 167 #Height 64 168 #Description 169 SkColorSetARGB parameter a is set to 150, less than its maximum value, and is 170 interpreted as Color_Alpha of about 0.6. color is not Premultiplied; 171 color components may have values greater than color alpha. 172 The four displayed values are the original component values, though not necessarily 173 in the same order. 174 ## 175 SkColor color = SkColorSetARGB(150, 50, 100, 255); 176 SkString s; 177 s.printf("%u %u %u %u", SkColorGetA(color), SkColorGetR(color), 178 SkColorGetG(color), SkColorGetB(color)); 179 SkPaint paint; 180 paint.setAntiAlias(true); 181 canvas->drawString(s, 10, 62, paint); 182 canvas->scale(50, 50); 183 SkBitmap bitmap; 184 SkImageInfo imageInfo = SkImageInfo::Make(1, 1, kN32_SkColorType, kUnpremul_SkAlphaType); 185 if (bitmap.installPixels(imageInfo, (void*) &color, imageInfo.minRowBytes())) { 186 canvas->drawBitmap(bitmap, 0, 0); 187 } 188 ## 189 190 #Subtopic Unpremul ## 191 192 #Method static bool SkAlphaTypeIsOpaque(SkAlphaType at) 193 #In Property 194 #Line # returns if Alpha_Type equals kOpaque_SkAlphaType ## 195 #Populate 196 197 #NoExample 198 ## 199 ## 200 201 #Subtopic Alpha_Type ## 202 203 # ------------------------------------------------------------------------------ 204 #Subtopic Color_Type 205 #Line # encoding for pixel color ## 206 #Alias Color_Type ## 207 #Alias Color_Types ## 208 209 #PhraseDef list_of_color_types 210 kUnknown_SkColorType, kAlpha_8_SkColorType, kRGB_565_SkColorType, 211 kARGB_4444_SkColorType, kRGBA_8888_SkColorType, kRGB_888x_SkColorType, 212 kBGRA_8888_SkColorType, kRGBA_1010102_SkColorType, kRGB_101010x_SkColorType, 213 kGray_8_SkColorType, kRGBA_F16_SkColorType 214 ## 215 216 #Enum SkColorType 217 #Line # encoding for pixel color ## 218 219 #Code 220 #Populate 221 ## 222 223 Describes how pixel bits encode color. A pixel may be an alpha mask, a 224 grayscale, RGB, or ARGB. 225 226 kN32_SkColorType selects the native 32-bit ARGB format. On Little_Endian 227 processors, pixels containing 8-bit ARGB components pack into 32-bit 228 kBGRA_8888_SkColorType. On Big_Endian processors, pixels pack into 32-bit 229 kRGBA_8888_SkColorType. 230 231 #Const kUnknown_SkColorType 0 232 #Line # uninitialized ## 233 Color_Type is set to kUnknown_SkColorType by default. If set, 234 encoding format and size is unknown. 235 ## 236 237 #Const kAlpha_8_SkColorType 1 238 #Line # pixel with Alpha in 8-bit byte ## 239 #Details Alpha_8 240 Stores 8-bit byte pixel encoding that represents transparency. Value of zero 241 is completely transparent; a value of 255 is completely opaque. 242 ## 243 244 #Const kRGB_565_SkColorType 2 245 #Line # pixel with 5 bits red, 6 bits green, 5 bits blue, in 16-bit word ## 246 #Details RGB_565 247 Stores 16-bit word pixel encoding that contains five bits of blue, 248 six bits of green, and five bits of red. 249 ## 250 251 #Const kARGB_4444_SkColorType 3 252 #Line # pixel with 4 bits for alpha, red, green, blue; in 16-bit word ## 253 #Details ARGB_4444 254 Stores 16-bit word pixel encoding that contains four bits of alpha, 255 four bits of blue, four bits of green, and four bits of red. 256 ## 257 258 #Const kRGBA_8888_SkColorType 4 259 #Line # pixel with 8 bits for red, green, blue, alpha; in 32-bit word ## 260 #Details RGBA_8888 261 Stores 32-bit word pixel encoding that contains eight bits of red, 262 eight bits of green, eight bits of blue, and eight bits of alpha. 263 ## 264 265 #Const kRGB_888x_SkColorType 5 266 #Line # pixel with 8 bits each for red, green, blue; in 32-bit word ## 267 #Details RGB_888 268 Stores 32-bit word pixel encoding that contains eight bits of red, 269 eight bits of green, eight bits of blue, and eight unused bits. 270 ## 271 272 #Const kBGRA_8888_SkColorType 6 273 #Line # pixel with 8 bits for blue, green, red, alpha; in 32-bit word ## 274 #Details BGRA_8888 275 Stores 32-bit word pixel encoding that contains eight bits of blue, 276 eight bits of green, eight bits of red, and eight bits of alpha. 277 ## 278 279 #Const kRGBA_1010102_SkColorType 7 280 #Line # 10 bits for red, green, blue; 2 bits for alpha; in 32-bit word ## 281 #Details RGBA_1010102 282 Stores 32-bit word pixel encoding that contains ten bits of red, 283 ten bits of green, ten bits of blue, and two bits of alpha. 284 ## 285 286 #Const kRGB_101010x_SkColorType 8 287 #Line # pixel with 10 bits each for red, green, blue; in 32-bit word ## 288 #Details RGB_101010 289 Stores 32-bit word pixel encoding that contains ten bits of red, 290 ten bits of green, ten bits of blue, and two unused bits. 291 ## 292 293 #Const kGray_8_SkColorType 9 294 #Line # pixel with grayscale level in 8-bit byte ## 295 #Details Gray_8 296 Stores 8-bit byte pixel encoding that equivalent to equal values for red, 297 blue, and green, representing colors from black to white. 298 ## 299 300 #Const kRGBA_F16_SkColorType 10 301 #Line # pixel with half floats for red, green, blue, alpha; in 64-bit word ## 302 #Details RGBA_F16 303 Stores 64-bit word pixel encoding that contains 16 bits of blue, 304 16 bits of green, 16 bits of red, and 16 bits of alpha. Each component 305 is encoded as a half float. 306 ## 307 308 #Const kRGBA_F32_SkColorType 11 309 #Line # pixel using C float for red, green, blue, alpha; in 128-bit word ## 310 #Details RGBA_F32 311 Stores 128-bit word pixel encoding that contains 32 bits of blue, 312 32 bits of green, 32 bits of red, and 32 bits of alpha. Each component 313 is encoded as a single precision float. 314 ## 315 316 #Const kLastEnum_SkColorType 11 317 #NoJustify 318 #Line # last valid value ## 319 Used by tests to iterate through all valid values. 320 ## 321 322 #Const kN32_SkColorType 4 or 6 323 #Alias Native_Color_Type ## 324 #NoJustify 325 #Line # native ARGB 32-bit encoding ## 326 Encodes ARGB as either kRGBA_8888_SkColorType or 327 kBGRA_8888_SkColorType, whichever is native to the platform. 328 ## 329 330 #NoExample 331 ## 332 333 #SeeAlso SkAlphaType SkColorSpace 334 335 #Enum SkColorType ## 336 337 #Subtopic Alpha_8 338 #Line # encodes transparency only ## 339 Alpha pixels encode transparency without color information. Value of zero is 340 completely transparent; a value of 255 is completely opaque. Bitmap 341 pixels do not visibly draw, because its pixels have no color information. 342 When SkColorType is set to kAlpha_8_SkColorType, the paired SkAlphaType is 343 ignored. 344 345 #Example 346 #Description 347 Alpha pixels can modify another draw. orangePaint fills the bounds of bitmap, 348 with its transparency set to alpha8 pixel value. 349 ## 350 #Height 64 351 canvas->scale(16, 16); 352 SkBitmap bitmap; 353 SkImageInfo imageInfo = SkImageInfo::Make(2, 2, kAlpha_8_SkColorType, kOpaque_SkAlphaType); 354 bitmap.allocPixels(imageInfo); 355 SkCanvas offscreen(bitmap); 356 offscreen.clear(SK_ColorGREEN); 357 SkPaint orangePaint; 358 orangePaint.setARGB(0xFF, 0xFF, 0xA5, 0x00); 359 canvas->drawBitmap(bitmap, 0, 0, &orangePaint); 360 uint8_t alpha8[] = { 0xFF, 0xBB, 0x77, 0x33 }; 361 SkPixmap alphaPixmap(imageInfo, &alpha8, imageInfo.minRowBytes()); 362 if (bitmap.writePixels(alphaPixmap, 0, 0)) { 363 canvas->drawBitmap(bitmap, 2, 2, &orangePaint); 364 } 365 ## 366 #SeeAlso Alpha Gray_8 367 ## 368 369 #Subtopic RGB_565 370 #Line # encodes RGB in 16 bits ## 371 kRGB_565_SkColorType encodes RGB to fit in a 16-bit word. Red and blue 372 components use five bits describing 32 levels. Green components, more sensitive 373 to the eye, use six bits describing 64 levels. kRGB_565_SkColorType has no 374 bits for Alpha. 375 376 Pixels are fully opaque as if its Color_Alpha was set to one, and should 377 always be paired with kOpaque_SkAlphaType. 378 379 #Illustration 380 381 #Example 382 #Height 96 383 canvas->scale(16, 16); 384 SkBitmap bitmap; 385 SkImageInfo imageInfo = SkImageInfo::Make(2, 2, kRGB_565_SkColorType, kOpaque_SkAlphaType); 386 bitmap.allocPixels(imageInfo); 387 SkCanvas offscreen(bitmap); 388 offscreen.clear(SK_ColorGREEN); 389 canvas->drawBitmap(bitmap, 0, 0); 390 auto pack565 = [](unsigned r, unsigned g, unsigned b) -> uint16_t { 391 return (b << 0) | (g << 5) | (r << 11); 392 }; 393 uint16_t red565[] = { pack565(0x1F, 0x00, 0x00), pack565(0x17, 0x00, 0x00), 394 pack565(0x0F, 0x00, 0x00), pack565(0x07, 0x00, 0x00) }; 395 uint16_t blue565[] = { pack565(0x00, 0x00, 0x1F), pack565(0x00, 0x00, 0x17), 396 pack565(0x00, 0x00, 0x0F), pack565(0x00, 0x00, 0x07) }; 397 SkPixmap redPixmap(imageInfo, &red565, imageInfo.minRowBytes()); 398 if (bitmap.writePixels(redPixmap, 0, 0)) { 399 canvas->drawBitmap(bitmap, 2, 2); 400 } 401 SkPixmap bluePixmap(imageInfo, &blue565, imageInfo.minRowBytes()); 402 if (bitmap.writePixels(bluePixmap, 0, 0)) { 403 canvas->drawBitmap(bitmap, 4, 4); 404 } 405 ## 406 #SeeAlso ARGB_4444 RGBA_8888 407 ## 408 409 #Subtopic ARGB_4444 410 #Line # encodes ARGB in 16 bits ## 411 kARGB_4444_SkColorType encodes ARGB to fit in 16-bit word. Each 412 component: alpha, blue, green, and red; use four bits, describing 16 levels. 413 Note that kARGB_4444_SkColorType is misnamed; the acronym does not 414 describe the actual component order. 415 416 #Illustration 417 418 If paired with kPremul_SkAlphaType: blue, green, and red components are 419 Premultiplied by the alpha value. If blue, green, or red is greater than alpha, 420 the drawn result is undefined. 421 422 If paired with kUnpremul_SkAlphaType: alpha, blue, green, and red components 423 may have any value. There may be a performance penalty with Unpremultiplied 424 pixels. 425 426 If paired with kOpaque_SkAlphaType: all alpha component values are at the maximum; 427 blue, green, and red components are fully opaque. If any alpha component is 428 less than 15, the drawn result is undefined. 429 430 #Bug 7648 431 432 #Example 433 #Height 96 434 canvas->scale(16, 16); 435 SkBitmap bitmap; 436 SkImageInfo imageInfo = SkImageInfo::Make(2, 2, kARGB_4444_SkColorType, kPremul_SkAlphaType); 437 bitmap.allocPixels(imageInfo); 438 SkCanvas offscreen(bitmap); 439 offscreen.clear(SK_ColorGREEN); 440 canvas->drawBitmap(bitmap, 0, 0); 441 auto pack4444 = [](unsigned a, unsigned r, unsigned g, unsigned b) -> uint16_t { 442 return (a << 0) | (b << 4) | (g << 8) | (r << 12); 443 }; 444 uint16_t red4444[] = { pack4444(0xF, 0xF, 0x0, 0x0), pack4444(0xF, 0xb, 0x0, 0x0), 445 pack4444(0xF, 0x7, 0x0, 0x0), pack4444(0xF, 0x3, 0x0, 0x0) }; 446 uint16_t blue4444[] = { pack4444(0xF, 0x0, 0x0, 0xF), pack4444(0xF, 0x0, 0x0, 0xb), 447 pack4444(0xF, 0x0, 0x0, 0x7), pack4444(0xF, 0x0, 0x0, 0x3) }; 448 SkPixmap redPixmap(imageInfo, &red4444, imageInfo.minRowBytes()); 449 if (bitmap.writePixels(redPixmap, 0, 0)) { 450 canvas->drawBitmap(bitmap, 2, 2); 451 } 452 SkPixmap bluePixmap(imageInfo, &blue4444, imageInfo.minRowBytes()); 453 if (bitmap.writePixels(bluePixmap, 0, 0)) { 454 canvas->drawBitmap(bitmap, 4, 4); 455 } 456 ## 457 #SeeAlso RGBA_8888 458 ## 459 460 #Subtopic RGBA_8888 461 #Line # encodes ARGB Big_Endian in 32 bits ## 462 kRGBA_8888_SkColorType encodes ARGB into a 32-bit word. Each component: 463 red, green, blue, alpha; use eight bits, describing 256 levels. 464 465 #Illustration 466 467 If paired with kPremul_SkAlphaType: red, green, and blue components are 468 Premultiplied by the alpha value. If red, green, or blue is greater than alpha, 469 the drawn result is undefined. 470 471 If paired with kUnpremul_SkAlphaType: alpha, red, green, and blue components 472 may have any value. There may be a performance penalty with Unpremultiplied 473 pixels. 474 475 If paired with kOpaque_SkAlphaType: all alpha component values are at the maximum; 476 red, green, and blue components are fully opaque. If any alpha component is 477 less than 255, the drawn result is undefined. 478 479 On Big_Endian platforms, kRGBA_8888_SkColorType is the native Color_Type, and 480 will have the best performance. Use kN32_SkColorType to choose the best 481 Color_Type for the platform at compile time. 482 483 #Example 484 #Height 96 485 canvas->scale(16, 16); 486 SkBitmap bitmap; 487 SkImageInfo imageInfo = SkImageInfo::Make(2, 2, kRGBA_8888_SkColorType, kPremul_SkAlphaType); 488 bitmap.allocPixels(imageInfo); 489 SkCanvas offscreen(bitmap); 490 offscreen.clear(SK_ColorGREEN); 491 canvas->drawBitmap(bitmap, 0, 0); 492 auto pack8888 = [](unsigned a, unsigned r, unsigned g, unsigned b) -> uint32_t { 493 return (r << 0) | (g << 8) | (b << 16) | (a << 24); 494 }; 495 uint32_t red8888[] = { pack8888(0xFF, 0xFF, 0x0, 0x0), pack8888(0xFF, 0xbb, 0x0, 0x0), 496 pack8888(0xFF, 0x77, 0x0, 0x0), pack8888(0xFF, 0x33, 0x0, 0x0) }; 497 uint32_t blue8888[] = { pack8888(0xFF, 0x0, 0x0, 0x0FF), pack8888(0xFF, 0x0, 0x0, 0x0bb), 498 pack8888(0xFF, 0x0, 0x0, 0x077), pack8888(0xFF, 0x0, 0x0, 0x033) }; 499 SkPixmap redPixmap(imageInfo, &red8888, imageInfo.minRowBytes()); 500 if (bitmap.writePixels(redPixmap, 0, 0)) { 501 canvas->drawBitmap(bitmap, 2, 2); 502 } 503 SkPixmap bluePixmap(imageInfo, &blue8888, imageInfo.minRowBytes()); 504 if (bitmap.writePixels(bluePixmap, 0, 0)) { 505 canvas->drawBitmap(bitmap, 4, 4); 506 } 507 ## 508 #SeeAlso RGB_888 BGRA_8888 509 ## 510 511 #Subtopic RGB_888 512 #Line # encodes RGB in 32 bits ## 513 kRGB_888x_SkColorType encodes RGB into a 32-bit word. Each component: 514 red, green, blue; use eight bits, describing 256 levels. Eight bits are 515 unused. Pixels described by kRGB_888x_SkColorType are fully opaque as if 516 their Color_Alpha was set to one, and should always be paired with 517 kOpaque_SkAlphaType. 518 519 #Illustration 520 521 #Example 522 #Bug 7645 523 #Height 96 524 #Platform cpu 525 canvas->scale(16, 16); 526 SkBitmap bitmap; 527 SkImageInfo imageInfo = SkImageInfo::Make(2, 2, kRGB_888x_SkColorType, kOpaque_SkAlphaType); 528 bitmap.allocPixels(imageInfo); 529 SkCanvas offscreen(bitmap); 530 offscreen.clear(SK_ColorGREEN); 531 canvas->drawBitmap(bitmap, 0, 0); 532 auto pack888 = [](unsigned r, unsigned g, unsigned b) -> uint32_t { 533 return (r << 0) | (g << 8) | (b << 16); 534 }; 535 uint32_t red888[] = { pack888(0xFF, 0x00, 0x00), pack888(0xbb, 0x00, 0x00), 536 pack888(0x77, 0x00, 0x00), pack888(0x33, 0x00, 0x00) }; 537 uint32_t blue888[] = { pack888(0x00, 0x00, 0xFF), pack888(0x00, 0x00, 0xbb), 538 pack888(0x00, 0x00, 0x77), pack888(0x00, 0x00, 0x33) }; 539 if (bitmap.installPixels(imageInfo, (void*) red888, imageInfo.minRowBytes())) { 540 canvas->drawBitmap(bitmap, 2, 2); 541 } 542 if (bitmap.installPixels(imageInfo, (void*) blue888, imageInfo.minRowBytes())) { 543 canvas->drawBitmap(bitmap, 4, 4); 544 } 545 ## 546 #SeeAlso RGBA_8888 BGRA_8888 547 ## 548 549 #Subtopic BGRA_8888 550 #Line # encodes ARGB Little_Endian in 32 bits ## 551 kBGRA_8888_SkColorType encodes ARGB into a 32-bit word. Each component: 552 blue, green, red, and alpha; use eight bits, describing 256 levels. 553 554 #Illustration 555 556 If paired with kPremul_SkAlphaType: blue, green, and red components are 557 Premultiplied by the alpha value. If blue, green, or red is greater than alpha, 558 the drawn result is undefined. 559 560 If paired with kUnpremul_SkAlphaType: blue, green, red, and alpha components 561 may have any value. There may be a performance penalty with Unpremultiplied 562 pixels. 563 564 If paired with kOpaque_SkAlphaType: all alpha component values are at the maximum; 565 blue, green, and red components are fully opaque. If any alpha component is 566 less than 255, the drawn result is undefined. 567 568 On Little_Endian platforms, kBGRA_8888_SkColorType is the native Color_Type, 569 and will have the best performance. Use kN32_SkColorType to choose the best 570 Color_Type for the platform at compile time. 571 572 #Example 573 #Height 96 574 canvas->scale(16, 16); 575 SkBitmap bitmap; 576 SkImageInfo imageInfo = SkImageInfo::Make(2, 2, kBGRA_8888_SkColorType, kPremul_SkAlphaType); 577 bitmap.allocPixels(imageInfo); 578 SkCanvas offscreen(bitmap); 579 offscreen.clear(SK_ColorGREEN); 580 canvas->drawBitmap(bitmap, 0, 0); 581 auto pack8888 = [](unsigned a, unsigned r, unsigned g, unsigned b) -> uint32_t { 582 return (b << 0) | (g << 8) | (r << 16) | (a << 24); 583 }; 584 uint32_t red8888[] = { pack8888(0xFF, 0xFF, 0x0, 0x0), pack8888(0xFF, 0xbb, 0x0, 0x0), 585 pack8888(0xFF, 0x99, 0x0, 0x0), pack8888(0xFF, 0x55, 0x0, 0x0) }; 586 uint32_t blue8888[] = { pack8888(0xFF, 0x0, 0x0, 0x0FF), pack8888(0xFF, 0x0, 0x0, 0x0bb), 587 pack8888(0xFF, 0x0, 0x0, 0x099), pack8888(0xFF, 0x0, 0x0, 0x055) }; 588 SkPixmap redPixmap(imageInfo, &red8888, imageInfo.minRowBytes()); 589 if (bitmap.writePixels(redPixmap, 0, 0)) { 590 canvas->drawBitmap(bitmap, 2, 2); 591 } 592 SkPixmap bluePixmap(imageInfo, &blue8888, imageInfo.minRowBytes()); 593 if (bitmap.writePixels(bluePixmap, 0, 0)) { 594 canvas->drawBitmap(bitmap, 4, 4); 595 } 596 ## 597 #SeeAlso RGBA_8888 598 ## 599 600 #Subtopic RGBA_1010102 601 #Line # encodes ARGB ten bits per color component ## 602 kRGBA_1010102_SkColorType encodes ARGB into a 32-bit word. Each 603 Color component: red, green, and blue; use ten bits, describing 1024 levels. 604 Two bits contain alpha, describing four levels. Possible alpha 605 values are zero: fully transparent; one: 33% opaque; two: 67% opaque; 606 three: fully opaque. 607 608 At present, Color in Paint does not provide enough precision to 609 draw all colors possible to a kRGBA_1010102_SkColorType Surface. 610 611 #Illustration 612 613 If paired with kPremul_SkAlphaType: red, green, and blue components are 614 Premultiplied by the alpha value. If red, green, or blue is greater than the 615 alpha replicated to ten bits, the drawn result is undefined. 616 617 If paired with kUnpremul_SkAlphaType: alpha, red, green, and blue components 618 may have any value. There may be a performance penalty with Unpremultiplied 619 pixels. 620 621 If paired with kOpaque_SkAlphaType: all alpha component values are at the maximum; 622 red, green, and blue components are fully opaque. If any alpha component is 623 less than three, the drawn result is undefined. 624 625 #Example 626 #Bug 7645 627 #Height 96 628 #Platform cpu 629 canvas->scale(16, 16); 630 SkBitmap bitmap; 631 SkImageInfo imageInfo = SkImageInfo::Make(2, 2, kRGBA_1010102_SkColorType, kOpaque_SkAlphaType); 632 bitmap.allocPixels(imageInfo); 633 SkCanvas offscreen(bitmap); 634 offscreen.clear(SK_ColorGREEN); 635 canvas->drawBitmap(bitmap, 0, 0); 636 auto pack1010102 = [](unsigned r, unsigned g, unsigned b, unsigned a) -> uint32_t { 637 return (r << 0) | (g << 10) | (b << 20) | (a << 30); 638 }; 639 uint32_t redBits[] = { pack1010102(0x3FF, 0x000, 0x000, 0x3), 640 pack1010102(0x2ff, 0x000, 0x000, 0x3), 641 pack1010102(0x1ff, 0x000, 0x000, 0x3), 642 pack1010102(0x0ff, 0x000, 0x000, 0x3) }; 643 uint32_t blueBits[] = { pack1010102(0x000, 0x000, 0x3FF, 0x3), 644 pack1010102(0x000, 0x000, 0x2ff, 0x3), 645 pack1010102(0x000, 0x000, 0x1ff, 0x3), 646 pack1010102(0x000, 0x000, 0x0ff, 0x3) }; 647 if (bitmap.installPixels(imageInfo, (void*) redBits, imageInfo.minRowBytes())) { 648 canvas->drawBitmap(bitmap, 2, 2); 649 } 650 SkPixmap bluePixmap(imageInfo, &blueBits, imageInfo.minRowBytes()); 651 if (bitmap.installPixels(imageInfo, (void*) blueBits, imageInfo.minRowBytes())) { 652 canvas->drawBitmap(bitmap, 4, 4); 653 } 654 ## 655 #SeeAlso RGB_101010 RGBA_8888 656 ## 657 658 #Subtopic RGB_101010 659 #Line # encodes RGB ten bits per color component ## 660 kRGB_101010x_SkColorType encodes RGB into a 32-bit word. Each 661 Color component: red, green, and blue; use ten bits, describing 1024 levels. 662 Two bits are unused. Pixels described by kRGB_101010x_SkColorType are fully 663 opaque as if its Color_Alpha was set to one, and should always be paired 664 with kOpaque_SkAlphaType. 665 666 At present, Color in Paint does not provide enough precision to 667 draw all colors possible to a kRGB_101010x_SkColorType Surface. 668 669 #Illustration 670 671 #Example 672 #Bug 7645 673 #Height 96 674 #Platform cpu 675 canvas->scale(16, 16); 676 SkBitmap bitmap; 677 SkImageInfo imageInfo = SkImageInfo::Make(2, 2, kRGB_101010x_SkColorType, kOpaque_SkAlphaType); 678 bitmap.allocPixels(imageInfo); 679 SkCanvas offscreen(bitmap); 680 offscreen.clear(SK_ColorGREEN); 681 canvas->drawBitmap(bitmap, 0, 0); 682 auto pack101010x = [](unsigned r, unsigned g, unsigned b) -> uint32_t { 683 return (r << 0) | (g << 10) | (b << 20); 684 }; 685 uint32_t redBits[] = { pack101010x(0x3FF, 0x000, 0x000), pack101010x(0x2ff, 0x000, 0x000), 686 pack101010x(0x1ff, 0x000, 0x000), pack101010x(0x0ff, 0x000, 0x000) }; 687 uint32_t blueBits[] = { pack101010x(0x000, 0x000, 0x3FF), pack101010x(0x000, 0x000, 0x2ff), 688 pack101010x(0x000, 0x000, 0x1ff), pack101010x(0x000, 0x000, 0x0ff) }; 689 if (bitmap.installPixels(imageInfo, (void*) redBits, imageInfo.minRowBytes())) { 690 canvas->drawBitmap(bitmap, 2, 2); 691 } 692 SkPixmap bluePixmap(imageInfo, &blueBits, imageInfo.minRowBytes()); 693 if (bitmap.installPixels(imageInfo, (void*) blueBits, imageInfo.minRowBytes())) { 694 canvas->drawBitmap(bitmap, 4, 4); 695 } 696 ## 697 #SeeAlso RGBA_1010102 698 ## 699 700 #Subtopic Gray_8 701 #Line # encodes level of grayscale in 8 bits ## 702 kGray_8_SkColorType encodes grayscale level in eight bits that is equivalent 703 to equal values for red, blue, and green, representing colors from black to 704 white. Pixels described by kGray_8_SkColorType are fully 705 opaque as if its Color_Alpha was set to one, and should always be paired with 706 kOpaque_SkAlphaType. 707 708 #Example 709 #Height 64 710 canvas->scale(16, 16); 711 SkBitmap bitmap; 712 SkImageInfo imageInfo = SkImageInfo::Make(2, 2, kGray_8_SkColorType, kOpaque_SkAlphaType); 713 bitmap.allocPixels(imageInfo); 714 SkCanvas offscreen(bitmap); 715 offscreen.clear(SK_ColorGREEN); 716 canvas->drawBitmap(bitmap, 0, 0); 717 uint8_t gray8[] = { 0xFF, 0xBB, 0x77, 0x33 }; 718 SkPixmap grayPixmap(imageInfo, &gray8, imageInfo.minRowBytes()); 719 if (bitmap.writePixels(grayPixmap, 0, 0)) { 720 canvas->drawBitmap(bitmap, 2, 2); 721 } 722 ## 723 #SeeAlso Alpha_8 724 ## 725 726 #Subtopic RGBA_F16 727 #Line # encodes ARGB as half floats ## 728 kRGBA_F16_SkColorType encodes ARGB into a 64-bit word. Each component: 729 blue, green, red, and alpha; use 16 bits, describing a floating point value, 730 from -65500 to 65000 with 3.31 decimal digits of precision. 731 732 At present, Color in Paint does not provide enough precision or range to 733 draw all colors possible to a kRGBA_F16_SkColorType Surface. 734 735 Each component encodes a floating point value using 736 #A Half floats # https://www.khronos.org/opengl/wiki/Small_Float_Formats ## 737 . Meaningful colors are represented by the range 0.0 to 1.0, although smaller 738 and larger values may be useful when used in combination with Transfer_Mode. 739 740 #Illustration 741 742 If paired with kPremul_SkAlphaType: blue, green, and red components are 743 Premultiplied by the alpha value. If blue, green, or red is greater than alpha, 744 the drawn result is undefined. 745 746 If paired with kUnpremul_SkAlphaType: blue, green, red, and alpha components 747 may have any value. There may be a performance penalty with Unpremultiplied 748 pixels. 749 750 If paired with kOpaque_SkAlphaType: all alpha component values are at the maximum; 751 blue, green, and red components are fully opaque. If any alpha component is 752 less than one, the drawn result is undefined. 753 754 #ToDo 755 FloatToHalf should be replaced with SkFloatToHalf if/when that's made public 756 ## 757 758 #Example 759 #Height 96 760 #Function 761 union FloatUIntUnion { 762 uint32_t fUInt; 763 float fFloat; 764 }; 765 766 uint16_t FloatToHalf(float f) { 767 static const FloatUIntUnion magic = { 15 << 23 }; 768 static const uint32_t round_mask = ~0xfffu; 769 FloatUIntUnion floatUnion; 770 floatUnion.fFloat = f; 771 uint32_t sign = floatUnion.fUInt & 0x80000000u; 772 floatUnion.fUInt ^= sign; 773 floatUnion.fUInt &= round_mask; 774 floatUnion.fFloat *= magic.fFloat; 775 floatUnion.fUInt -= round_mask; 776 return (floatUnion.fUInt >> 13) | (sign >> 16); 777 } 778 ## 779 780 void draw(SkCanvas* canvas) { 781 canvas->scale(16, 16); 782 SkBitmap bitmap; 783 SkImageInfo imageInfo = SkImageInfo::Make(2, 2, kRGBA_F16_SkColorType, kPremul_SkAlphaType); 784 bitmap.allocPixels(imageInfo); 785 SkCanvas offscreen(bitmap); 786 offscreen.clear(SK_ColorGREEN); 787 canvas->drawBitmap(bitmap, 0, 0); 788 auto H = [](float c) -> uint16_t { 789 return FloatToHalf(c); 790 }; 791 // R G B A 792 uint16_t red_f16[][4] = { { H(1.0), H(0.0), H(0.0), H(1.0) }, 793 { H(.75), H(0.0), H(0.0), H(1.0) }, 794 { H(.50), H(0.0), H(0.0), H(1.0) }, 795 { H(.25), H(0.0), H(0.0), H(1.0) } }; 796 uint16_t blue_f16[][4] = { { H(0.0), H(0.0), H(1.0), H(1.0) }, 797 { H(0.0), H(0.0), H(.75), H(1.0) }, 798 { H(0.0), H(0.0), H(.50), H(1.0) }, 799 { H(0.0), H(0.0), H(.25), H(1.0) } }; 800 SkPixmap redPixmap(imageInfo, red_f16, imageInfo.minRowBytes()); 801 if (bitmap.writePixels(redPixmap, 0, 0)) { 802 canvas->drawBitmap(bitmap, 2, 2); 803 } 804 SkPixmap bluePixmap(imageInfo, blue_f16, imageInfo.minRowBytes()); 805 if (bitmap.writePixels(bluePixmap, 0, 0)) { 806 canvas->drawBitmap(bitmap, 4, 4); 807 } 808 } 809 ## 810 #SeeAlso SkColor4f 811 ## 812 813 #Subtopic RGBA_F32 814 #Line # encodes ARGB as single precision floats ## 815 kRGBA_F32_SkColorType encodes ARGB into a 128-bit word. Each component: 816 blue, green, red, and alpha; use 32 bits, describing a floating point value, 817 from -3.402823e+38 to 3.402823e+38 with 7.225 decimal digits of precision. 818 819 At present, Color in Paint does not provide enough precision or range to 820 draw all colors possible to a kRGBA_F32_SkColorType Surface. 821 822 Each component encodes a floating point value using 823 #A single-precision floats # https://en.wikipedia.org/wiki/Single-precision_floating-point_format ## 824 . Meaningful colors are represented by the range 0.0 to 1.0, although smaller 825 and larger values may be useful when used in combination with Transfer_Mode. 826 827 #Illustration 828 829 If paired with kPremul_SkAlphaType: blue, green, and red components are 830 Premultiplied by the alpha value. If blue, green, or red is greater than alpha, 831 the drawn result is undefined. 832 833 If paired with kUnpremul_SkAlphaType: blue, green, red, and alpha components 834 may have any value. There may be a performance penalty with Unpremultiplied 835 pixels. 836 837 If paired with kOpaque_SkAlphaType: all alpha component values are at the maximum; 838 blue, green, and red components are fully opaque. If any alpha component is 839 less than one, the drawn result is undefined. 840 841 #NoExample 842 canvas->scale(16, 16); 843 SkBitmap bitmap; 844 SkImageInfo imageInfo = SkImageInfo::Make(2, 2, kRGBA_F32_SkColorType, kPremul_SkAlphaType); 845 bitmap.allocPixels(imageInfo); 846 SkCanvas offscreen(bitmap); 847 offscreen.clear(SK_ColorGREEN); 848 canvas->drawBitmap(bitmap, 0, 0); 849 // R G B A 850 float red_f32[][4] = { { 1.0, 0.0, 0.0, 1.0 }, 851 { .75, 0.0, 0.0, 1.0 }, 852 { .50, 0.0, 0.0, 1.0 }, 853 { .25, 0.0, 0.0, 1.0 } }; 854 float blue_f32[][4] = { { 0.0, 0.0, 1.0, 1.0 }, 855 { 0.0, 0.0, .75, 1.0 }, 856 { 0.0, 0.0, .50, 1.0 }, 857 { 0.0, 0.0, .25, 1.0 } }; 858 SkPixmap redPixmap(imageInfo, red_f32, imageInfo.minRowBytes()); 859 if (bitmap.writePixels(redPixmap, 0, 0)) { 860 canvas->drawBitmap(bitmap, 2, 2); 861 } 862 SkPixmap bluePixmap(imageInfo, blue_f32, imageInfo.minRowBytes()); 863 if (bitmap.writePixels(bluePixmap, 0, 0)) { 864 canvas->drawBitmap(bitmap, 4, 4); 865 } 866 ## 867 #SeeAlso SkColor4f 868 ## 869 870 871 #Subtopic Color_Type ## 872 873 # ------------------------------------------------------------------------------ 874 875 #Method int SkColorTypeBytesPerPixel(SkColorType ct) 876 #In Property 877 #Line # returns Color_Type byte size ## 878 #Populate 879 880 #Example 881 #Height 192 882 const char* colors[] = { "Unknown", "Alpha_8", "RGB_565", "ARGB_4444", "RGBA_8888", "RGB_888x", 883 "BGRA_8888", "RGBA_1010102", "RGB_101010x", "Gray_8", "RGBA_F16" }; 884 SkPaint paint; 885 paint.setTypeface(SkTypeface::MakeFromName("monospace", SkFontStyle())); 886 paint.setAntiAlias(true); 887 paint.setTextSize(10); 888 int y = 15; 889 canvas->drawString(" colorType bytes", 10, y, paint); 890 for (SkColorType colorType : { #list_of_color_types# 891 } ) { 892 int result = SkColorTypeBytesPerPixel(colorType); 893 SkString string; 894 string.printf("%13s %4d", colors[(int) colorType], result); 895 canvas->drawString(string, 10, y += 14, paint); 896 } 897 ## 898 #SeeAlso SkImageInfo::bytesPerPixel 899 ## 900 901 # ------------------------------------------------------------------------------ 902 903 #Method bool SkColorTypeIsAlwaysOpaque(SkColorType ct) 904 #In Property 905 #Line # returns if Color_Type includes Color_Alpha ## 906 #Populate 907 908 #Example 909 #Height 192 910 const char* colors[] = { "Unknown", "Alpha_8", "RGB_565", "ARGB_4444", "RGBA_8888", "RGB_888x", 911 "BGRA_8888", "RGBA_1010102", "RGB_101010x", "Gray_8", "RGBA_F16" }; 912 SkPaint paint; 913 paint.setTypeface(SkTypeface::MakeFromName("monospace", SkFontStyle())); 914 paint.setAntiAlias(true); 915 paint.setTextSize(10); 916 int y = 15; 917 canvas->drawString(" colorType bytes", 10, y, paint); 918 for (SkColorType colorType : { #list_of_color_types# 919 } ) { 920 bool result = SkColorTypeIsAlwaysOpaque(colorType); 921 SkString string; 922 string.printf("%13s %6s", colors[(int) colorType], result ? "true" : "false"); 923 canvas->drawString(string, 10, y += 14, paint); 924 } 925 ## 926 #SeeAlso SkColorTypeValidateAlphaType 927 ## 928 929 # ------------------------------------------------------------------------------ 930 931 #Method bool SkColorTypeValidateAlphaType(SkColorType colorType, SkAlphaType alphaType, 932 SkAlphaType* canonical = nullptr) 933 #In Property 934 #Line # returns if Alpha_Type is valid ## 935 #Populate 936 937 #Example 938 #Height 640 939 const char* colors[] = { "Unknown", "Alpha_8", "RGB_565", "ARGB_4444", "RGBA_8888", "RGB_888x", 940 "BGRA_8888", "RGBA_1010102", "RGB_101010x", "Gray_8", "RGBA_F16" }; 941 const char* alphas[] = {"Unknown ", "Opaque ", "Premul ", "Unpremul"}; 942 SkAlphaType alphaTypes[] = { #list_of_alpha_types# 943 }; 944 SkPaint paint; 945 paint.setTypeface(SkTypeface::MakeFromName("monospace", SkFontStyle())); 946 paint.setAntiAlias(true); 947 paint.setTextSize(10); 948 int y = 15; 949 canvas->drawString(" colorType alphaType canonical", 10, y, paint); 950 for (SkColorType colorType : { #list_of_color_types# 951 } ) { 952 for (SkAlphaType alphaType : alphaTypes) { 953 SkAlphaType canonicalAlphaType = kUnknown_SkAlphaType; 954 bool result = SkColorTypeValidateAlphaType(colorType, alphaType, &canonicalAlphaType); 955 SkString string; 956 string.printf("%13s %10s %10s", colors[(int) colorType], alphas[(int) alphaType], 957 result ? alphas[(int) canonicalAlphaType] : "------ "); 958 canvas->drawString(string, 10, y += 14, paint); 959 } 960 } 961 ## 962 #SeeAlso SkColorTypeIsAlwaysOpaque 963 ## 964 965 # ------------------------------------------------------------------------------ 966 #Subtopic YUV_ColorSpace 967 #Line # color range of YUV pixels ## 968 #Alias YUV_ColorSpace ## 969 970 #Enum SkYUVColorSpace 971 #Line # color range of YUV pixels ## 972 973 #Code 974 #Populate 975 ## 976 977 Describes color range of YUV pixels. The color mapping from YUV to RGB varies 978 depending on the source. YUV pixels may be generated by JPEG images, standard 979 video streams, or high definition video streams. Each has its own mapping from 980 YUV and RGB. 981 982 JPEG YUV values encode the full range of 0 to 255 for all three components. 983 Video YUV values range from 16 to 235 for all three components. Details of 984 encoding and conversion to RGB are described in 985 #A YCbCr color space # https://en.wikipedia.org/wiki/YCbCr ## 986 . 987 988 #Const kJPEG_SkYUVColorSpace 0 989 #Line # describes full range ## 990 Describes standard JPEG color space; 991 #A CCIR 601 # https://en.wikipedia.org/wiki/Rec._601 ## 992 with full range of 0 to 255 for components. 993 ## 994 #Const kRec601_SkYUVColorSpace 1 995 #Line # describes SDTV range ## 996 Describes standard used by standard definition television; 997 #A CCIR 601 # https://en.wikipedia.org/wiki/Rec._601 ## 998 with studio range of 16 to 235 range for components. 999 ## 1000 #Const kRec709_SkYUVColorSpace 2 1001 #Line # describes HDTV range ## 1002 Describes standard used by high definition television; 1003 #A Rec. 709 # https://en.wikipedia.org/wiki/Rec._709 ## 1004 with studio range of 16 to 235 range for components. 1005 ## 1006 #Const kLastEnum_SkYUVColorSpace 2 1007 #Line # last valid value ## 1008 Used by tests to iterate through all valid values. 1009 ## 1010 1011 #NoExample 1012 ## 1013 1014 #SeeAlso SkImage::MakeFromYUVTexturesCopy SkImage::MakeFromNV12TexturesCopy 1015 1016 #Enum SkYUVColorSpace ## 1017 #Subtopic YUV_ColorSpace ## 1018 1019 # ------------------------------------------------------------------------------ 1020 1021 #Struct SkImageInfo 1022 1023 #Code 1024 #Populate 1025 ## 1026 1027 Describes pixel dimensions and encoding. Bitmap, Image, Pixmap, and Surface 1028 can be created from Image_Info. Image_Info can be retrieved from Bitmap and 1029 Pixmap, but not from Image and Surface. For example, Image and Surface 1030 implementations may defer pixel depth, so may not completely specify Image_Info. 1031 1032 Image_Info contains dimensions, the pixel integral width and height. It encodes 1033 how pixel bits describe Color_Alpha, transparency; Color components red, blue, 1034 and green; and Color_Space, the range and linearity of colors. 1035 1036 # ------------------------------------------------------------------------------ 1037 1038 #Method SkImageInfo() 1039 1040 #In Constructors 1041 #Line # creates with zeroed dimensions, kUnknown_SkColorType, kUnknown_SkAlphaType ## 1042 #Populate 1043 1044 #Example 1045 #Height 32 1046 #Description 1047 An empty Image_Info may be passed to SkCanvas::accessTopLayerPixels as storage 1048 for the Canvas actual Image_Info. 1049 ## 1050 SkImageInfo imageInfo; 1051 size_t rowBytes; 1052 SkIPoint origin; 1053 (void) canvas->accessTopLayerPixels(&imageInfo, &rowBytes, &origin); 1054 const char* alphaType[] = { "Unknown", "Opaque", "Premul", "Unpremul" }; 1055 SkString string; 1056 string.printf("k%s_SkAlphaType", alphaType[(int) imageInfo.alphaType()]); 1057 SkPaint paint; 1058 canvas->drawString(string, 20, 20, paint); 1059 ## 1060 1061 #SeeAlso Make MakeN32 MakeS32 MakeA8 1062 1063 #Method ## 1064 1065 # ------------------------------------------------------------------------------ 1066 1067 #Method static SkImageInfo Make(int width, int height, SkColorType ct, SkAlphaType at, 1068 sk_sp<SkColorSpace> cs = nullptr) 1069 #In Constructors 1070 #Line # creates Image_Info from dimensions, Color_Type, Alpha_Type, Color_Space ## 1071 #Populate 1072 1073 #Example 1074 #Height 48 1075 uint8_t storage[][5] = {{ 0xCA, 0xDA, 0xCA, 0xC9, 0xA3 }, 1076 { 0xAC, 0xA8, 0x89, 0xA7, 0x87 }, 1077 { 0x9B, 0xB5, 0xE5, 0x95, 0x46 }, 1078 { 0x90, 0x81, 0xC5, 0x71, 0x33 }, 1079 { 0x75, 0x55, 0x44, 0x40, 0x30 }}; 1080 SkImageInfo imageInfo = SkImageInfo::Make(5, 5, kGray_8_SkColorType, kOpaque_SkAlphaType); 1081 SkPixmap pixmap(imageInfo, storage[0], sizeof(storage) / 5); 1082 SkBitmap bitmap; 1083 bitmap.installPixels(pixmap); 1084 canvas->scale(8, 8); 1085 canvas->drawBitmap(bitmap, 0, 0); 1086 ## 1087 1088 #SeeAlso MakeN32 MakeN32Premul MakeS32 MakeA8 1089 1090 #Method ## 1091 1092 # ------------------------------------------------------------------------------ 1093 1094 #Method static SkImageInfo MakeN32(int width, int height, SkAlphaType at, 1095 sk_sp<SkColorSpace> cs = nullptr) 1096 #In Constructors 1097 #Line # creates Image_Info with Native_Color_Type ## 1098 #Populate 1099 1100 #Example 1101 #Height 128 1102 SkBitmap bitmap; 1103 bitmap.allocPixels(SkImageInfo::MakeN32(16, 16, kPremul_SkAlphaType)); 1104 SkCanvas offscreen(bitmap); 1105 offscreen.clear(SK_ColorWHITE); 1106 SkPaint paint; 1107 offscreen.drawString("g", 0, 10, paint); 1108 canvas->scale(8, 8); 1109 canvas->drawBitmap(bitmap, 0, 0); 1110 ## 1111 1112 #SeeAlso Make MakeN32Premul MakeS32 MakeA8 1113 1114 #Method ## 1115 1116 # ------------------------------------------------------------------------------ 1117 1118 #Method static SkImageInfo MakeS32(int width, int height, SkAlphaType at) 1119 1120 #In Constructors 1121 #Line # creates Image_Info with Native_Color_Type, sRGB Color_Space ## 1122 #Populate 1123 1124 #Example 1125 #Set sRGB 1126 #Height 128 1127 #Description 1128 Top gradient is drawn to offScreen without Color_Space. It is darker than middle 1129 gradient, drawn to offScreen with sRGB Color_Space. Bottom gradient shares bits 1130 with middle, but does not specify the Color_Space in noColorSpaceBitmap. A source 1131 without Color_Space is treated as sRGB; the bottom gradient is identical to the 1132 middle gradient. 1133 ## 1134 const int width = 256; 1135 const int height = 32; 1136 SkImageInfo info = SkImageInfo::MakeN32Premul(width, height); 1137 SkColor gradColors[] = { 0xFFAA0055, 0xFF11CC88 }; 1138 SkPoint gradPoints[] = { { 0, 0 }, { width, 0 } }; 1139 SkPaint gradPaint; 1140 gradPaint.setShader(SkGradientShader::MakeLinear(gradPoints, gradColors, nullptr, 1141 SK_ARRAY_COUNT(gradColors), SkShader::kClamp_TileMode)); 1142 SkBitmap bitmap; 1143 bitmap.allocPixels(SkImageInfo::MakeN32(width, height, kPremul_SkAlphaType)); 1144 SkCanvas offScreen(bitmap); 1145 offScreen.drawRect(SkRect::MakeWH(width, height), gradPaint); 1146 canvas->drawBitmap(bitmap, 0, 0); 1147 bitmap.allocPixels(SkImageInfo::MakeS32(width, height, kPremul_SkAlphaType)); 1148 SkCanvas sRGBOffscreen(bitmap); 1149 sRGBOffscreen.drawRect(SkRect::MakeWH(width, height), gradPaint); 1150 canvas->drawBitmap(bitmap, 0, 48); 1151 SkBitmap noColorSpaceBitmap; 1152 noColorSpaceBitmap.setInfo(SkImageInfo::MakeN32(width, height, kPremul_SkAlphaType)); 1153 noColorSpaceBitmap.setPixels(bitmap.getAddr(0, 0)); 1154 canvas->drawBitmap(noColorSpaceBitmap, 0, 96); 1155 ## 1156 1157 #SeeAlso Make MakeN32 MakeN32Premul MakeA8 1158 1159 #Method ## 1160 1161 # ------------------------------------------------------------------------------ 1162 1163 #Method static SkImageInfo MakeN32Premul(int width, int height, sk_sp<SkColorSpace> cs = nullptr) 1164 1165 #In Constructors 1166 #Line # creates Image_Info with Native_Color_Type, kPremul_SkAlphaType ## 1167 #Populate 1168 1169 #Example 1170 #Height 128 1171 SkBitmap bitmap; 1172 bitmap.allocPixels(SkImageInfo::MakeN32Premul(18, 18)); 1173 SkCanvas offscreen(bitmap); 1174 offscreen.clear(SK_ColorWHITE); 1175 SkPaint paint; 1176 paint.setAntiAlias(true); 1177 paint.setTextSize(15); 1178 offscreen.drawString("\xF0\x9F\x98\xB8", 1, 15, paint); 1179 canvas->scale(6, 6); 1180 canvas->drawBitmap(bitmap, 0, 0); 1181 ## 1182 1183 #SeeAlso MakeN32 MakeS32 MakeA8 Make 1184 1185 #Method ## 1186 1187 # ------------------------------------------------------------------------------ 1188 1189 #Method static SkImageInfo MakeN32Premul(const SkISize& size) 1190 1191 #In Constructors 1192 #Populate 1193 1194 #Example 1195 #Height 128 1196 SkBitmap bitmap; 1197 bitmap.allocPixels(SkImageInfo::MakeN32Premul({18, 18})); 1198 SkCanvas offscreen(bitmap); 1199 offscreen.clear(SK_ColorWHITE); 1200 SkPaint paint; 1201 paint.setAntiAlias(true); 1202 paint.setTextSize(15); 1203 offscreen.drawString("\xF0\x9F\x98\xB9", 1, 15, paint); 1204 canvas->scale(6, 6); 1205 canvas->drawBitmap(bitmap, 0, 0); 1206 ## 1207 1208 #SeeAlso MakeN32 MakeS32 MakeA8 Make 1209 1210 #Method ## 1211 1212 # ------------------------------------------------------------------------------ 1213 1214 #Method static SkImageInfo MakeA8(int width, int height) 1215 1216 #In Constructors 1217 #Line # creates Image_Info with kAlpha_8_SkColorType, kPremul_SkAlphaType ## 1218 #Populate 1219 1220 #Example 1221 #Height 64 1222 uint8_t pixels[][8] = { { 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00}, 1223 { 0x00, 0x7f, 0xff, 0x3f, 0x3f, 0x7f, 0x3f, 0x00}, 1224 { 0x3f, 0xff, 0x7f, 0x00, 0x7f, 0xff, 0x7f, 0x00}, 1225 { 0x00, 0x3f, 0x00, 0x00, 0x3f, 0x7f, 0x3f, 0x00}, 1226 { 0x3f, 0x7f, 0x7f, 0x3f, 0x00, 0x00, 0x00, 0x00}, 1227 { 0x7f, 0xff, 0xff, 0x7f, 0x00, 0x3f, 0x7f, 0x3f}, 1228 { 0x7f, 0xff, 0xff, 0x7f, 0x00, 0x7f, 0xff, 0x7f}, 1229 { 0x3f, 0x7f, 0x7f, 0x3f, 0x00, 0x3f, 0x7f, 0x3f} }; 1230 SkBitmap bitmap; 1231 bitmap.installPixels(SkImageInfo::MakeA8(8, 8), 1232 (void*) pixels, sizeof(pixels[0])); 1233 SkPaint paint; 1234 canvas->scale(4, 4); 1235 for (auto color : { SK_ColorRED, SK_ColorBLUE, 0xFF007F00} ) { 1236 paint.setColor(color); 1237 canvas->drawBitmap(bitmap, 0, 0, &paint); 1238 canvas->translate(12, 0); 1239 } 1240 ## 1241 1242 #SeeAlso MakeN32 MakeS32 Make 1243 1244 #Method ## 1245 1246 # ------------------------------------------------------------------------------ 1247 1248 #Method static SkImageInfo MakeUnknown(int width, int height) 1249 1250 #In Constructors 1251 #Line # creates Image_Info with kUnknown_SkColorType, kUnknown_SkAlphaType ## 1252 #Populate 1253 1254 #Example 1255 #Height 32 1256 #Width 384 1257 SkImageInfo info; // default constructor 1258 SkString string; 1259 string.printf("SkImageInfo() %c= SkImageInfo::MakeUnknown(0, 0)", 1260 info == SkImageInfo::MakeUnknown(0, 0) ? '=' : '!'); 1261 SkPaint paint; 1262 canvas->drawString(string, 0, 12, paint); 1263 ## 1264 1265 #SeeAlso SkImageInfo() MakeN32 MakeS32 Make 1266 1267 #Method ## 1268 1269 # ------------------------------------------------------------------------------ 1270 1271 #Method static SkImageInfo MakeUnknown() 1272 1273 #In Constructors 1274 #Populate 1275 1276 #Example 1277 #Height 32 1278 #Width 384 1279 SkImageInfo info; // default constructor 1280 SkString string; 1281 string.printf("SkImageInfo() %c= SkImageInfo::MakeUnknown()", 1282 info == SkImageInfo::MakeUnknown() ? '=' : '!'); 1283 SkPaint paint; 1284 canvas->drawString(string, 0, 12, paint); 1285 ## 1286 1287 #SeeAlso SkImageInfo() MakeN32 MakeS32 Make 1288 1289 #Method ## 1290 1291 1292 # ------------------------------------------------------------------------------ 1293 #Subtopic Property 1294 #Line # metrics and attributes ## 1295 ## 1296 1297 #Method int width() const 1298 #In Property 1299 #Line # returns pixel column count ## 1300 #Populate 1301 1302 #Example 1303 #Image 4 1304 #Height 96 1305 canvas->translate(10, 10); 1306 canvas->drawBitmap(source, 0, 0); 1307 SkImageInfo imageInfo = source.info(); 1308 canvas->translate(0, imageInfo.height()); 1309 SkPaint paint; 1310 canvas->drawLine(0, 10, imageInfo.width(), 10, paint); 1311 canvas->drawString("width", imageInfo.width() / 2 - 15, 25, paint); 1312 ## 1313 1314 #SeeAlso height SkBitmap::width SkPixelRef::width SkImage::width SkSurface::width 1315 1316 #Method ## 1317 1318 # ------------------------------------------------------------------------------ 1319 1320 #Method int height() const 1321 #In Property 1322 #Line # returns pixel row count ## 1323 #Populate 1324 1325 #Example 1326 #Image 4 1327 #Height 96 1328 canvas->translate(10, 20); 1329 canvas->drawBitmap(source, 0, 0); 1330 SkImageInfo imageInfo = source.info(); 1331 SkPaint paint; 1332 canvas->drawLine(imageInfo.width() + 10, 0, imageInfo.width() + 10, imageInfo.height(), paint); 1333 canvas->drawString("height", imageInfo.width() + 15, imageInfo.height() / 2, paint); 1334 ## 1335 1336 #SeeAlso width SkBitmap::height SkPixelRef::height SkImage::height SkSurface::height 1337 1338 #Method ## 1339 1340 # ------------------------------------------------------------------------------ 1341 1342 #Method SkColorType colorType() const 1343 #In Property 1344 #Line # returns Color_Type ## 1345 Returns Color_Type, one of: #list_of_color_types#. 1346 1347 #Return Color_Type ## 1348 1349 #Example 1350 const char* colors[] = {"Unknown", "Alpha_8", "RGB_565", "ARGB_4444", "RGBA_8888", "RGB_888x", 1351 "BGRA_8888", "RGBA_1010102", "RGB_101010x", "Gray_8", "RGBA_F16"}; 1352 SkImageInfo info = SkImageInfo::MakeA8(16, 32); 1353 SkDebugf("color type: k" "%s" "_SkColorType\n", colors[info.colorType()]); 1354 #StdOut 1355 color type: kAlpha_8_SkColorType 1356 ## 1357 ## 1358 1359 #SeeAlso alphaType SkPixmap::colorType SkBitmap::colorType 1360 1361 #Method ## 1362 1363 # ------------------------------------------------------------------------------ 1364 1365 #Method SkAlphaType alphaType() const 1366 #In Property 1367 #Line # returns Alpha_Type ## 1368 Returns Alpha_Type, one of: #list_of_alpha_types#. 1369 1370 #Return Alpha_Type ## 1371 1372 #Example 1373 const char* alphas[] = {"Unknown", "Opaque", "Premul", "Unpremul"}; 1374 SkImageInfo info = SkImageInfo::MakeA8(16, 32); 1375 SkDebugf("alpha type: k" "%s" "_SkAlphaType\n", alphas[info.alphaType()]); 1376 #StdOut 1377 alpha type: kPremul_SkAlphaType 1378 ## 1379 ## 1380 1381 #SeeAlso colorType SkPixmap::alphaType SkBitmap::alphaType 1382 1383 #Method ## 1384 1385 # ------------------------------------------------------------------------------ 1386 1387 #Method SkColorSpace* colorSpace() const 1388 #In Property 1389 #Line # returns Color_Space ## 1390 #Populate 1391 1392 #Example 1393 #Description 1394 SkColorSpace::MakeSRGBLinear creates Color_Space with linear gamma 1395 and an sRGB gamut. This Color_Space gamma is not close to sRGB gamma. 1396 ## 1397 SkImageInfo info = SkImageInfo::MakeN32(16, 32, kPremul_SkAlphaType, 1398 SkColorSpace::MakeSRGBLinear()); 1399 SkColorSpace* colorSpace = info.colorSpace(); 1400 SkDebugf("gammaCloseToSRGB: %s gammaIsLinear: %s isSRGB: %s\n", 1401 colorSpace->gammaCloseToSRGB() ? "true" : "false", 1402 colorSpace->gammaIsLinear() ? "true" : "false", 1403 colorSpace->isSRGB() ? "true" : "false"); 1404 #StdOut 1405 gammaCloseToSRGB: false gammaIsLinear: true isSRGB: false 1406 ## 1407 ## 1408 1409 #SeeAlso Color_Space SkPixmap::colorSpace SkBitmap::colorSpace 1410 1411 #Method ## 1412 1413 # ------------------------------------------------------------------------------ 1414 1415 #Method sk_sp<SkColorSpace> refColorSpace() const 1416 #In Property 1417 #Line # returns Color_Space ## 1418 #Populate 1419 1420 #Example 1421 SkImageInfo info1 = SkImageInfo::MakeN32(16, 32, kPremul_SkAlphaType, 1422 SkColorSpace::MakeSRGBLinear()); 1423 SkImageInfo info2 = SkImageInfo::MakeN32(16, 32, kPremul_SkAlphaType, 1424 info1.refColorSpace()); 1425 SkColorSpace* colorSpace = info2.colorSpace(); 1426 SkDebugf("gammaCloseToSRGB: %s gammaIsLinear: %s isSRGB: %s\n", 1427 colorSpace->gammaCloseToSRGB() ? "true" : "false", 1428 colorSpace->gammaIsLinear() ? "true" : "false", 1429 colorSpace->isSRGB() ? "true" : "false"); 1430 ## 1431 1432 #SeeAlso Color_Space SkBitmap::refColorSpace 1433 1434 #Method ## 1435 1436 # ------------------------------------------------------------------------------ 1437 1438 #Method bool isEmpty() const 1439 #In Property 1440 #Line # returns if dimensions contain pixels ## 1441 #Populate 1442 1443 #Example 1444 for (int width : { 0, 2 } ) { 1445 for (int height : { 0, 2 } ) { 1446 SkImageInfo imageInfo= SkImageInfo::MakeA8(width, height); 1447 SkDebugf("width: %d height: %d empty: %s\n", width, height, 1448 imageInfo.isEmpty() ? "true" : "false"); 1449 } 1450 } 1451 #StdOut 1452 width: 0 height: 0 empty: true 1453 width: 0 height: 2 empty: true 1454 width: 2 height: 0 empty: true 1455 width: 2 height: 2 empty: false 1456 ## 1457 ## 1458 1459 #SeeAlso dimensions bounds SkBitmap::empty SkPixmap::bounds 1460 1461 #Method ## 1462 1463 # ------------------------------------------------------------------------------ 1464 1465 #Method bool isOpaque() const 1466 #In Property 1467 #Line # returns if Alpha_Type is kOpaque_SkAlphaType ## 1468 #Populate 1469 1470 #Example 1471 const int height = 2; 1472 const int width = 2; 1473 SkBitmap bitmap; 1474 SkImageInfo imageInfo = SkImageInfo::Make(width, height, kN32_SkColorType, kPremul_SkAlphaType); 1475 bitmap.setInfo(imageInfo); 1476 for (int index = 0; index < 2; ++index) { 1477 bitmap.allocPixels(); 1478 bitmap.eraseColor(0x00000000); 1479 SkDebugf("isOpaque: %s\n", imageInfo.isOpaque() ? "true" : "false"); 1480 bitmap.eraseColor(0xFFFFFFFF); 1481 SkDebugf("isOpaque: %s\n", imageInfo.isOpaque() ? "true" : "false"); 1482 imageInfo = imageInfo.makeAlphaType(kOpaque_SkAlphaType); 1483 bitmap.setInfo(imageInfo); 1484 } 1485 #StdOut 1486 isOpaque: false 1487 isOpaque: false 1488 isOpaque: true 1489 isOpaque: true 1490 ## 1491 ## 1492 1493 #SeeAlso Color_Alpha SkColorTypeValidateAlphaType SkBitmap::isOpaque SkImage::isOpaque SkPixmap::isOpaque 1494 1495 #Method ## 1496 1497 # ------------------------------------------------------------------------------ 1498 1499 #Method SkISize dimensions() const 1500 #In Property 1501 #Line # returns width() and height() ## 1502 #Populate 1503 1504 #Example 1505 const int height = 2; 1506 const int width = 2; 1507 SkImageInfo imageInfo = SkImageInfo::Make(width, height, kN32_SkColorType, kPremul_SkAlphaType); 1508 SkISize dimensions = imageInfo.dimensions(); 1509 SkIRect bounds = imageInfo.bounds(); 1510 SkIRect dimensionsAsBounds = SkIRect::MakeSize(dimensions); 1511 SkDebugf("dimensionsAsBounds %c= bounds\n", dimensionsAsBounds == bounds ? '=' : '!'); 1512 #StdOut 1513 dimensionsAsBounds == bounds 1514 ## 1515 ## 1516 1517 #SeeAlso width height bounds SkBitmap::dimensions 1518 1519 #Method ## 1520 1521 # ------------------------------------------------------------------------------ 1522 1523 #Method SkIRect bounds() const 1524 #In Property 1525 #Line # returns width() and height() as Rectangle ## 1526 #Populate 1527 1528 #Example 1529 #Height 64 1530 #Image 4 1531 canvas->scale(.5f, .5f); 1532 SkImageInfo imageInfo = source.info(); 1533 SkIRect bounds = imageInfo.bounds(); 1534 for (int x : { 0, bounds.width() } ) { 1535 for (int y : { 0, bounds.height() } ) { 1536 canvas->drawBitmap(source, x, y); 1537 } 1538 } 1539 ## 1540 1541 #SeeAlso width height dimensions 1542 1543 #Method ## 1544 1545 # ------------------------------------------------------------------------------ 1546 1547 #Method bool gammaCloseToSRGB() const 1548 #In Property 1549 #Line # returns if Color_Space gamma is approximately the same as sRGB ## 1550 1551 Returns true if associated Color_Space is not nullptr, and Color_Space gamma 1552 is approximately the same as sRGB. 1553 This includes the 1554 ###$ 1555 $A sRGB transfer function $ https://en.wikipedia.org/wiki/SRGB#The_sRGB_transfer_function_(%22gamma%22) $$ 1556 $$$# 1557 as well as a gamma curve described by a 2.2 exponent. 1558 1559 #Return true if Color_Space gamma is approximately the same as sRGB ## 1560 1561 #Example 1562 #Height 144 1563 const int width = 256; 1564 const int height = 64; 1565 auto drawLabel = [=](const char* what, bool closeToSRGB) -> void { 1566 SkString string; 1567 string.printf("%s gamma is %s" "close to sRGB", what, closeToSRGB ? "" : "not "); 1568 SkPaint paint; 1569 paint.setAntiAlias(true); 1570 canvas->drawString(string, 20, 56, paint); 1571 }; 1572 SkColor gradColors[] = { 0xFFFF7F00, 0xFF00FF7F, 0xFF0000FF, 0xFF7F7FFF }; 1573 SkPoint gradPoints[] = { { 0, 0 }, { width, 0 }, { width * 2, 0 }, { width * 3, 0 } }; 1574 SkPaint gradPaint; 1575 gradPaint.setShader(SkGradientShader::MakeLinear(gradPoints, gradColors, nullptr, 1576 SK_ARRAY_COUNT(gradColors), SkShader::kClamp_TileMode)); 1577 canvas->drawRect(SkRect::MakeWH(width, height), gradPaint); 1578 drawLabel("canvas", canvas->imageInfo().gammaCloseToSRGB()); 1579 SkBitmap bitmap; 1580 SkImageInfo offscreenInfo = SkImageInfo::MakeS32(width, height, kPremul_SkAlphaType); 1581 bitmap.allocPixels(offscreenInfo); 1582 SkCanvas sRGBOffscreen(bitmap); 1583 sRGBOffscreen.drawRect(SkRect::MakeWH(width, height), gradPaint); 1584 canvas->translate(0, 80); 1585 canvas->drawBitmap(bitmap, 0, 0); 1586 drawLabel("offscreen", offscreenInfo.gammaCloseToSRGB()); 1587 ## 1588 1589 #SeeAlso SkColorSpace::gammaCloseToSRGB 1590 1591 #Method ## 1592 1593 # ------------------------------------------------------------------------------ 1594 1595 #Method SkImageInfo makeWH(int newWidth, int newHeight) const 1596 #In Constructors 1597 #Line # creates Image_Info with changed dimensions ## 1598 #Populate 1599 1600 #Example 1601 #Height 144 1602 #Image 3 1603 SkImageInfo canvasImageInfo = canvas->imageInfo(); 1604 SkRect canvasBounds = SkRect::Make(canvasImageInfo.bounds()); 1605 canvas->drawBitmapRect(source, source.bounds(), canvasBounds, nullptr); 1606 SkImageInfo insetImageInfo = 1607 canvasImageInfo.makeWH(canvasBounds.width() / 2, canvasBounds.height() / 2); 1608 SkBitmap inset; 1609 inset.allocPixels(insetImageInfo); 1610 SkCanvas offscreen(inset); 1611 offscreen.drawBitmapRect(source, source.bounds(), SkRect::Make(inset.bounds()), nullptr); 1612 canvas->drawBitmap(inset, canvasBounds.width() / 4, canvasBounds.height() / 4); 1613 ## 1614 1615 #SeeAlso Make makeAlphaType makeColorSpace makeColorType 1616 1617 #Method ## 1618 1619 # ------------------------------------------------------------------------------ 1620 1621 #Method SkImageInfo makeAlphaType(SkAlphaType newAlphaType) const 1622 #In Constructors 1623 #Line # creates Image_Info with changed Alpha_Type ## 1624 #Populate 1625 1626 #Example 1627 #Image 3 1628 const int width = 256; 1629 const int height = 128; 1630 SkColor pixels[height][width]; 1631 for (int y = 0; y < height; ++y) { 1632 for (int x = 0; x < width; ++x) { 1633 int red = SkScalarRoundToInt(255 * SkScalarAbs(SkScalarSin((x * 4 + y) * 0.03f))); 1634 int blue = SkScalarRoundToInt(255 * SkScalarAbs(SkScalarCos((x * 3 + y) * 0.04f))); 1635 int green = SkScalarRoundToInt(255 * SkScalarAbs(SkScalarSin((x * 2 + y) * 0.05f))); 1636 int alpha = SkScalarRoundToInt(255 * SkScalarAbs(SkScalarCos((x * 1 + y) * 0.006f))); 1637 pixels[y][x] = 1638 SkColorSetARGB(alpha, red * alpha / 255, green * alpha / 255, blue * alpha / 255); 1639 } 1640 } 1641 SkBitmap bitmap; 1642 SkImageInfo info = SkImageInfo::Make(width, height, kBGRA_8888_SkColorType, kPremul_SkAlphaType); 1643 bitmap.installPixels(info, (void*) pixels, sizeof(SkColor) * width); 1644 canvas->drawBitmap(source, 0, 0); 1645 canvas->drawBitmap(bitmap, 0, 0); 1646 SkImageInfo unpremulInfo = info.makeAlphaType(kUnpremul_SkAlphaType); 1647 bitmap.installPixels(unpremulInfo, (void*) pixels, sizeof(SkColor) * width); 1648 canvas->drawBitmap(bitmap, 0, 128); 1649 ## 1650 1651 #SeeAlso Make MakeA8 makeColorType makeColorSpace 1652 1653 #Method ## 1654 1655 # ------------------------------------------------------------------------------ 1656 1657 #Method SkImageInfo makeColorType(SkColorType newColorType) const 1658 #In Constructors 1659 #Line # creates Image_Info with changed Color_Type ## 1660 #Populate 1661 1662 #Example 1663 const int width = 256; 1664 const int height = 128; 1665 SkColor pixels[height][width]; 1666 for (int y = 0; y < height; ++y) { 1667 for (int x = 0; x < width; ++x) { 1668 int red = SkScalarRoundToInt(255 * SkScalarAbs(SkScalarSin((x * 4 + y) * 0.03f))); 1669 int blue = SkScalarRoundToInt(255 * SkScalarAbs(SkScalarCos((x * 3 + y) * 0.04f))); 1670 int green = SkScalarRoundToInt(255 * SkScalarAbs(SkScalarSin((x * 2 + y) * 0.05f))); 1671 int alpha = SkScalarRoundToInt(255 * SkScalarAbs(SkScalarCos((x * 1 + y) * 0.006f))); 1672 pixels[y][x] = 1673 SkColorSetARGB(alpha, red * alpha / 255, green * alpha / 255, blue * alpha / 255); 1674 } 1675 } 1676 SkBitmap bitmap; 1677 SkImageInfo info = SkImageInfo::Make(width, height, kBGRA_8888_SkColorType, kPremul_SkAlphaType); 1678 bitmap.installPixels(info, (void*) pixels, sizeof(SkColor) * width); 1679 canvas->drawBitmap(source, 0, 0); 1680 canvas->drawBitmap(bitmap, 0, 0); 1681 SkImageInfo rgbaInfo = info.makeColorType(kRGBA_8888_SkColorType); 1682 bitmap.installPixels(rgbaInfo, (void*) pixels, sizeof(SkColor) * width); 1683 canvas->drawBitmap(bitmap, 0, 128); 1684 ## 1685 1686 #SeeAlso Make makeAlphaType makeColorSpace 1687 1688 #Method ## 1689 1690 # ------------------------------------------------------------------------------ 1691 1692 #Method SkImageInfo makeColorSpace(sk_sp<SkColorSpace> cs) const 1693 #In Constructors 1694 #Line # creates Image_Info with changed Color_Space ## 1695 #Populate 1696 1697 #Example 1698 #Height 224 1699 const int width = 256; 1700 const int height = 64; 1701 auto drawLabel = [=](const char* what, bool closeToSRGB) -> void { 1702 SkString string; 1703 string.printf("%s gamma is %s" "close to sRGB", what, closeToSRGB ? "" : "not "); 1704 SkPaint paint; 1705 paint.setAntiAlias(true); 1706 canvas->drawString(string, 20, 56, paint); 1707 }; 1708 SkColor gradColors[] = { 0xFFFF7F00, 0xFF00FF7F, 0xFF0000FF, 0xFF7F7FFF }; 1709 SkPoint gradPoints[] = { { 0, 0 }, { width, 0 }, { width * 2, 0 }, { width * 3, 0 } }; 1710 SkPaint gradPaint; 1711 gradPaint.setShader(SkGradientShader::MakeLinear(gradPoints, gradColors, nullptr, 1712 SK_ARRAY_COUNT(gradColors), SkShader::kClamp_TileMode)); 1713 canvas->drawRect(SkRect::MakeWH(width, height), gradPaint); 1714 drawLabel("canvas", canvas->imageInfo().gammaCloseToSRGB()); 1715 SkBitmap bitmap; 1716 SkImageInfo offscreenInfo = SkImageInfo::MakeS32(width, height, kPremul_SkAlphaType); 1717 bitmap.allocPixels(offscreenInfo); 1718 SkCanvas sRGBOffscreen(bitmap); 1719 sRGBOffscreen.drawRect(SkRect::MakeWH(width, height), gradPaint); 1720 canvas->translate(0, 80); 1721 canvas->drawBitmap(bitmap, 0, 0); 1722 drawLabel("offscreen", offscreenInfo.gammaCloseToSRGB()); 1723 SkImageInfo linearGamma = 1724 offscreenInfo.makeColorSpace(offscreenInfo.colorSpace()->makeLinearGamma()); 1725 bitmap.allocPixels(linearGamma); 1726 SkCanvas lgOffscreen(bitmap); 1727 lgOffscreen.drawRect(SkRect::MakeWH(width, height), gradPaint); 1728 canvas->translate(0, 80); 1729 canvas->drawBitmap(bitmap, 0, 0); 1730 drawLabel("linear", linearGamma.gammaCloseToSRGB()); 1731 ## 1732 1733 #SeeAlso Make MakeS32 makeAlphaType makeColorType 1734 1735 #Method ## 1736 1737 # ------------------------------------------------------------------------------ 1738 1739 #Method int bytesPerPixel() const 1740 #In Property 1741 #Line # returns number of bytes in pixel based on Color_Type ## 1742 #Populate 1743 1744 #Example 1745 const char* colors[] = {"Unknown", "Alpha_8", "RGB_565", "ARGB_4444", "RGBA_8888", "RGB_888x", 1746 "BGRA_8888", "RGBA_1010102", "RGB_101010x", "Gray_8", "RGBA_F16"}; 1747 for (SkColorType colorType : { #list_of_color_types# 1748 } ) { 1749 SkImageInfo info = SkImageInfo::Make(1, 1, colorType, kOpaque_SkAlphaType); 1750 SkDebugf("color: k" "%s" "_SkColorType" "%*s" "bytesPerPixel: %d\n", 1751 colors[colorType], 13 - strlen(colors[colorType]), " ", 1752 info.bytesPerPixel()); 1753 } 1754 #StdOut 1755 color: kUnknown_SkColorType bytesPerPixel: 0 1756 color: kAlpha_8_SkColorType bytesPerPixel: 1 1757 color: kRGB_565_SkColorType bytesPerPixel: 2 1758 color: kARGB_4444_SkColorType bytesPerPixel: 2 1759 color: kRGBA_8888_SkColorType bytesPerPixel: 4 1760 color: kRGB_888x_SkColorType bytesPerPixel: 4 1761 color: kBGRA_8888_SkColorType bytesPerPixel: 4 1762 color: kRGBA_1010102_SkColorType bytesPerPixel: 4 1763 color: kRGB_101010x_SkColorType bytesPerPixel: 4 1764 color: kGray_8_SkColorType bytesPerPixel: 1 1765 color: kRGBA_F16_SkColorType bytesPerPixel: 8 1766 ## 1767 ## 1768 1769 #SeeAlso width shiftPerPixel SkBitmap::bytesPerPixel 1770 1771 #Method ## 1772 1773 # ------------------------------------------------------------------------------ 1774 1775 #Method int shiftPerPixel() const 1776 #In Property 1777 #Line # returns bit shift from pixels to bytes ## 1778 #Populate 1779 1780 #Example 1781 const char* colors[] = {"Unknown", "Alpha_8", "RGB_565", "ARGB_4444", "RGBA_8888", "RGB_888x", 1782 "BGRA_8888", "RGBA_1010102", "RGB_101010x", "Gray_8", "RGBA_F16"}; 1783 for (SkColorType colorType : { #list_of_color_types# 1784 } ) { 1785 SkImageInfo info = SkImageInfo::Make(1, 1, colorType, kOpaque_SkAlphaType); 1786 SkDebugf("color: k" "%s" "_SkColorType" "%*s" "shiftPerPixel: %d\n", 1787 colors[colorType], 14 - strlen(colors[colorType]), " ", 1788 info.shiftPerPixel()); 1789 } 1790 #StdOut 1791 color: kUnknown_SkColorType shiftPerPixel: 0 1792 color: kAlpha_8_SkColorType shiftPerPixel: 0 1793 color: kRGB_565_SkColorType shiftPerPixel: 1 1794 color: kARGB_4444_SkColorType shiftPerPixel: 1 1795 color: kRGBA_8888_SkColorType shiftPerPixel: 2 1796 color: kRGB_888x_SkColorType shiftPerPixel: 2 1797 color: kBGRA_8888_SkColorType shiftPerPixel: 2 1798 color: kRGBA_1010102_SkColorType shiftPerPixel: 2 1799 color: kRGB_101010x_SkColorType shiftPerPixel: 2 1800 color: kGray_8_SkColorType shiftPerPixel: 0 1801 color: kRGBA_F16_SkColorType shiftPerPixel: 3 1802 ## 1803 ## 1804 1805 #SeeAlso bytesPerPixel minRowBytes SkBitmap::shiftPerPixel SkPixmap::shiftPerPixel 1806 1807 #Method ## 1808 1809 # ------------------------------------------------------------------------------ 1810 1811 #Method uint64_t minRowBytes64() const 1812 #In Property 1813 #Line # returns width() times bytesPerPixel in 64 bits ## 1814 #Populate 1815 1816 #Example 1817 for (int shift = 24; shift < 32; ++shift) { 1818 int width = 1 << shift; 1819 SkImageInfo imageInfo = 1820 SkImageInfo::Make(width, 1, kRGBA_F16_SkColorType, kPremul_SkAlphaType); 1821 uint64_t minRowBytes = imageInfo.minRowBytes64(); 1822 bool widthTooLarge = (uint64_t) (int32_t) minRowBytes != minRowBytes; 1823 SkDebugf("RGBA_F16 width %d (0x%08x) %s\n", 1824 width, width, widthTooLarge ? "too large" : "OK"); 1825 } 1826 #StdOut 1827 RGBA_F16 width 16777216 (0x01000000) OK 1828 RGBA_F16 width 33554432 (0x02000000) OK 1829 RGBA_F16 width 67108864 (0x04000000) OK 1830 RGBA_F16 width 134217728 (0x08000000) OK 1831 RGBA_F16 width 268435456 (0x10000000) too large 1832 RGBA_F16 width 536870912 (0x20000000) too large 1833 RGBA_F16 width 1073741824 (0x40000000) too large 1834 RGBA_F16 width -2147483648 (0x80000000) too large 1835 ## 1836 ## 1837 1838 #SeeAlso minRowBytes computeByteSize computeMinByteSize validRowBytes 1839 1840 #Method ## 1841 1842 # ------------------------------------------------------------------------------ 1843 1844 #Method size_t minRowBytes() const 1845 #In Property 1846 #Line # returns width() times bytesPerPixel in 32 bits ## 1847 #Populate 1848 1849 #Example 1850 for (int shift = 24; shift < 32; ++shift) { 1851 int width = 1 << shift; 1852 SkImageInfo imageInfo = 1853 SkImageInfo::Make(width, 1, kRGBA_F16_SkColorType, kPremul_SkAlphaType); 1854 size_t minRowBytes = imageInfo.minRowBytes(); 1855 bool widthTooLarge = !minRowBytes; 1856 SkDebugf("RGBA_F16 width %d (0x%08x) %s\n", 1857 width, width, widthTooLarge ? "too large" : "OK"); 1858 } 1859 #StdOut 1860 RGBA_F16 width 16777216 (0x01000000) OK 1861 RGBA_F16 width 33554432 (0x02000000) OK 1862 RGBA_F16 width 67108864 (0x04000000) OK 1863 RGBA_F16 width 134217728 (0x08000000) OK 1864 RGBA_F16 width 268435456 (0x10000000) too large 1865 RGBA_F16 width 536870912 (0x20000000) too large 1866 RGBA_F16 width 1073741824 (0x40000000) too large 1867 RGBA_F16 width -2147483648 (0x80000000) too large 1868 ## 1869 ## 1870 1871 #SeeAlso minRowBytes64 computeByteSize computeMinByteSize validRowBytes 1872 1873 #Method ## 1874 1875 # ------------------------------------------------------------------------------ 1876 1877 #Method size_t computeOffset(int x, int y, size_t rowBytes) const 1878 #In Utility 1879 #Line # returns byte offset within pixel array ## 1880 #Populate 1881 1882 #Example 1883 #Height 128 1884 uint8_t pixels[][12] = { { 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00}, 1885 { 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00}, 1886 { 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00}, 1887 { 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0xFF}, 1888 { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, 1889 { 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00}, 1890 { 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00}, 1891 { 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00} }; 1892 SkImageInfo imageInfo = SkImageInfo::MakeA8(8, 8); 1893 SkBitmap bitmap; 1894 bitmap.installPixels(imageInfo, (void*) pixels, sizeof(pixels[0])); 1895 SkPaint paint; 1896 paint.setColor(SK_ColorRED); 1897 canvas->drawBitmapRect(bitmap, SkRect::MakeWH(8, 8), SkRect::MakeWH(32, 32), &paint); 1898 size_t offset = imageInfo.computeOffset(2, 3, sizeof(pixels[0])); 1899 pixels[0][offset] = 0x7F; 1900 offset = imageInfo.computeOffset(5, 3, sizeof(pixels[0])); 1901 pixels[0][offset] = 0x7F; 1902 bitmap.installPixels(imageInfo, (void*) pixels, sizeof(pixels[0])); 1903 canvas->drawBitmapRect(bitmap, SkRect::MakeWH(8, 8), SkRect::MakeWH(128, 128), &paint); 1904 ## 1905 1906 #SeeAlso height width minRowBytes computeByteSize 1907 1908 #Method ## 1909 1910 # ------------------------------------------------------------------------------ 1911 1912 #Method bool operator==(const SkImageInfo& other) const 1913 #Line # compares Image_Info for equality ## 1914 #Populate 1915 1916 #Example 1917 SkImageInfo info1 = SkImageInfo::Make(10, 20, kGray_8_SkColorType, kPremul_SkAlphaType); 1918 SkImageInfo info2 = SkImageInfo::Make(20, 10, kAlpha_8_SkColorType, kUnpremul_SkAlphaType); 1919 SkDebugf("info1 %c= info2\n", info1 == info2 ? '=' : '!'); 1920 info2 = info2.makeWH(10, 20); 1921 SkDebugf("info1 %c= info2\n", info1 == info2 ? '=' : '!'); 1922 info2 = info2.makeColorType(kGray_8_SkColorType); 1923 SkDebugf("info1 %c= info2\n", info1 == info2 ? '=' : '!'); 1924 info2 = info2.makeAlphaType(kPremul_SkAlphaType); 1925 SkDebugf("info1 %c= info2\n", info1 == info2 ? '=' : '!'); 1926 #StdOut 1927 info1 != info2 1928 info1 != info2 1929 info1 != info2 1930 info1 == info2 1931 ## 1932 ## 1933 1934 #SeeAlso operator!=(const SkImageInfo& other) const SkColorSpace::Equals 1935 1936 #Method ## 1937 1938 # ------------------------------------------------------------------------------ 1939 1940 #Method bool operator!=(const SkImageInfo& other) const 1941 #Line # compares Image_Info for inequality ## 1942 #Populate 1943 1944 #Example 1945 SkImageInfo info1 = SkImageInfo::Make(10, 20, kGray_8_SkColorType, kPremul_SkAlphaType); 1946 SkImageInfo info2 = SkImageInfo::Make(20, 10, kAlpha_8_SkColorType, kUnpremul_SkAlphaType); 1947 SkDebugf("info1 %c= info2\n", info1 != info2 ? '!' : '='); 1948 info2 = info2.makeWH(10, 20); 1949 SkDebugf("info1 %c= info2\n", info1 != info2 ? '!' : '='); 1950 info2 = info2.makeColorType(kGray_8_SkColorType); 1951 SkDebugf("info1 %c= info2\n", info1 != info2 ? '!' : '='); 1952 info2 = info2.makeAlphaType(kPremul_SkAlphaType); 1953 SkDebugf("info1 %c= info2\n", info1 != info2 ? '!' : '='); 1954 #StdOut 1955 info1 != info2 1956 info1 != info2 1957 info1 != info2 1958 info1 == info2 1959 ## 1960 ## 1961 1962 #SeeAlso operator==(const SkImageInfo& other) const SkColorSpace::Equals 1963 1964 #Method ## 1965 1966 # ------------------------------------------------------------------------------ 1967 1968 #Method size_t computeByteSize(size_t rowBytes) const 1969 #In Utility 1970 #Line # returns memory required by pixel buffer with given row bytes ## 1971 #Populate 1972 1973 #Example 1974 #Height 130 1975 SkImageInfo info = SkImageInfo::MakeN32Premul(2, 2); 1976 const size_t size = info.computeByteSize(100000); 1977 SkAutoTMalloc<SkPMColor> storage(size); 1978 SkPMColor* pixels = storage.get(); 1979 SkBitmap bitmap; 1980 bitmap.setInfo(info); 1981 bitmap.setPixels(pixels); 1982 bitmap.eraseColor(SK_ColorRED); 1983 canvas->scale(50, 50); 1984 canvas->rotate(8); 1985 canvas->drawBitmap(bitmap, 2, 0); 1986 ## 1987 1988 #SeeAlso computeMinByteSize validRowBytes 1989 1990 #Method ## 1991 1992 # ------------------------------------------------------------------------------ 1993 1994 #Method size_t computeMinByteSize() const 1995 #In Utility 1996 #Line # returns least memory required by pixel buffer ## 1997 #Populate 1998 1999 #Example 2000 #Height 130 2001 SkImageInfo info = SkImageInfo::MakeN32Premul(2, 2); 2002 const size_t size = info.computeMinByteSize(); 2003 SkAutoTMalloc<SkPMColor> storage(size); 2004 SkPMColor* pixels = storage.get(); 2005 SkBitmap bitmap; 2006 bitmap.setInfo(info); 2007 bitmap.setPixels(pixels); 2008 bitmap.eraseColor(SK_ColorRED); 2009 canvas->scale(50, 50); 2010 canvas->rotate(8); 2011 canvas->drawBitmap(bitmap, 2, 0); 2012 ## 2013 2014 #SeeAlso computeByteSize validRowBytes 2015 2016 #Method ## 2017 2018 # ------------------------------------------------------------------------------ 2019 2020 #Method static bool ByteSizeOverflowed(size_t byteSize) 2021 #In Utility 2022 #Line # checks result of computeByteSize and computeMinByteSize ## 2023 #Populate 2024 2025 #Example 2026 SkImageInfo info = SkImageInfo::MakeN32Premul(2, 1000000000); 2027 for (size_t rowBytes = 100000000; rowBytes < 10000000000000LL; rowBytes *= 10) { 2028 const size_t size = info.computeByteSize(rowBytes); 2029 SkDebugf("rowBytes:%llu size:%llu overflowed:%s\n", rowBytes, size, 2030 SkImageInfo::ByteSizeOverflowed(size) ? "true" : "false"); 2031 } 2032 #StdOut 2033 rowBytes:100000000 size:99999999900000008 overflowed:false 2034 rowBytes:1000000000 size:999999999000000008 overflowed:false 2035 rowBytes:10000000000 size:9999999990000000008 overflowed:false 2036 rowBytes:100000000000 size:18446744073709551615 overflowed:true 2037 rowBytes:1000000000000 size:18446744073709551615 overflowed:true 2038 ## 2039 ## 2040 2041 #SeeAlso computeByteSize computeMinByteSize validRowBytes 2042 2043 #Method ## 2044 2045 # ------------------------------------------------------------------------------ 2046 2047 #Method bool validRowBytes(size_t rowBytes) const 2048 #In Utility 2049 #Line # checks if row bytes is large enough to contain pixel row ## 2050 #Populate 2051 2052 #Example 2053 SkImageInfo info = SkImageInfo::MakeN32Premul(16, 8); 2054 for (size_t rowBytes = 60; rowBytes < 72; rowBytes += sizeof(SkPMColor)) { 2055 SkDebugf("validRowBytes(%llu): %s\n", rowBytes, info.validRowBytes(rowBytes) ? 2056 "true" : "false"); 2057 } 2058 #StdOut 2059 validRowBytes(60): false 2060 validRowBytes(64): true 2061 validRowBytes(68): true 2062 ## 2063 ## 2064 2065 #SeeAlso ByteSizeOverflowed computeByteSize computeMinByteSize 2066 2067 #Method ## 2068 2069 # ------------------------------------------------------------------------------ 2070 2071 #Method void reset() 2072 #In Constructors 2073 #Line # sets zero dimensions, kUnknown_SkColorType, kUnknown_SkAlphaType ## 2074 #Populate 2075 2076 #Example 2077 SkImageInfo info = SkImageInfo::MakeN32Premul(16, 8); 2078 SkImageInfo copy = info; 2079 SkDebugf("info %c= copy\n", info == copy ? '=' : '!'); 2080 copy.reset(); 2081 SkDebugf("info %c= reset copy\n", info == copy ? '=' : '!'); 2082 SkDebugf("SkImageInfo() %c= reset copy\n", SkImageInfo() == copy ? '=' : '!'); 2083 #StdOut 2084 info == copy 2085 info != reset copy 2086 SkImageInfo() == reset copy 2087 ## 2088 ## 2089 2090 #SeeAlso SkImageInfo() 2091 2092 #Method ## 2093 2094 # ------------------------------------------------------------------------------ 2095 #Subtopic Utility 2096 #Line # rarely called management functions ## 2097 ## 2098 2099 #Method void validate() const 2100 #In Utility 2101 #Line # asserts if Image_Info is invalid (debug only) ## 2102 #Populate 2103 2104 #NoExample 2105 ## 2106 2107 #SeeAlso validRowBytes SkBitmap::validate 2108 2109 #Method ## 2110 2111 #Struct SkImageInfo ## 2112 2113 #Topic Image_Info ## 2114
