1 /* 2 * Copyright 2013 Google Inc. 3 * 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 */ 7 8 #ifndef SkImageInfo_DEFINED 9 #define SkImageInfo_DEFINED 10 11 #include "SkColorSpace.h" 12 #include "SkMath.h" 13 #include "SkRect.h" 14 #include "SkSize.h" 15 16 class SkReadBuffer; 17 class SkWriteBuffer; 18 19 /** 20 * Describes how to interpret the alpha component of a pixel. 21 */ 22 enum SkAlphaType { 23 kUnknown_SkAlphaType, 24 25 /** 26 * All pixels are stored as opaque. This differs slightly from kIgnore in 27 * that kOpaque has correct "opaque" values stored in the pixels, while 28 * kIgnore may not, but in both cases the caller should treat the pixels 29 * as opaque. 30 */ 31 kOpaque_SkAlphaType, 32 33 /** 34 * All pixels have their alpha premultiplied in their color components. 35 * This is the natural format for the rendering target pixels. 36 */ 37 kPremul_SkAlphaType, 38 39 /** 40 * All pixels have their color components stored without any regard to the 41 * alpha. e.g. this is the default configuration for PNG images. 42 * 43 * This alpha-type is ONLY supported for input images. Rendering cannot 44 * generate this on output. 45 */ 46 kUnpremul_SkAlphaType, 47 48 kLastEnum_SkAlphaType = kUnpremul_SkAlphaType 49 }; 50 51 static inline bool SkAlphaTypeIsOpaque(SkAlphaType at) { 52 return kOpaque_SkAlphaType == at; 53 } 54 55 static inline bool SkAlphaTypeIsValid(unsigned value) { 56 return value <= kLastEnum_SkAlphaType; 57 } 58 59 /////////////////////////////////////////////////////////////////////////////// 60 61 /** 62 * Describes how to interpret the components of a pixel. 63 * 64 * kN32_SkColorType is an alias for whichever 32bit ARGB format is the "native" 65 * form for skia's blitters. Use this if you don't have a swizzle preference 66 * for 32bit pixels. 67 */ 68 enum SkColorType { 69 kUnknown_SkColorType, 70 kAlpha_8_SkColorType, 71 kRGB_565_SkColorType, 72 kARGB_4444_SkColorType, 73 kRGBA_8888_SkColorType, 74 kBGRA_8888_SkColorType, 75 kGray_8_SkColorType, 76 kRGBA_F16_SkColorType, 77 78 kLastEnum_SkColorType = kRGBA_F16_SkColorType, 79 80 #if SK_PMCOLOR_BYTE_ORDER(B,G,R,A) 81 kN32_SkColorType = kBGRA_8888_SkColorType, 82 #elif SK_PMCOLOR_BYTE_ORDER(R,G,B,A) 83 kN32_SkColorType = kRGBA_8888_SkColorType, 84 #else 85 #error "SK_*32_SHFIT values must correspond to BGRA or RGBA byte order" 86 #endif 87 }; 88 89 static int SkColorTypeBytesPerPixel(SkColorType ct) { 90 static const uint8_t gSize[] = { 91 0, // Unknown 92 1, // Alpha_8 93 2, // RGB_565 94 2, // ARGB_4444 95 4, // RGBA_8888 96 4, // BGRA_8888 97 1, // kGray_8 98 8, // kRGBA_F16 99 }; 100 static_assert(SK_ARRAY_COUNT(gSize) == (size_t)(kLastEnum_SkColorType + 1), 101 "size_mismatch_with_SkColorType_enum"); 102 103 SkASSERT((size_t)ct < SK_ARRAY_COUNT(gSize)); 104 return gSize[ct]; 105 } 106 107 static int SkColorTypeShiftPerPixel(SkColorType ct) { 108 static const uint8_t gShift[] = { 109 0, // Unknown 110 0, // Alpha_8 111 1, // RGB_565 112 1, // ARGB_4444 113 2, // RGBA_8888 114 2, // BGRA_8888 115 0, // kGray_8 116 3, // kRGBA_F16 117 }; 118 static_assert(SK_ARRAY_COUNT(gShift) == (size_t)(kLastEnum_SkColorType + 1), 119 "size_mismatch_with_SkColorType_enum"); 120 121 SkASSERT((size_t)ct < SK_ARRAY_COUNT(gShift)); 122 return gShift[ct]; 123 } 124 125 static inline size_t SkColorTypeMinRowBytes(SkColorType ct, int width) { 126 return width * SkColorTypeBytesPerPixel(ct); 127 } 128 129 static inline bool SkColorTypeIsValid(unsigned value) { 130 return value <= kLastEnum_SkColorType; 131 } 132 133 static inline size_t SkColorTypeComputeOffset(SkColorType ct, int x, int y, size_t rowBytes) { 134 if (kUnknown_SkColorType == ct) { 135 return 0; 136 } 137 return y * rowBytes + (x << SkColorTypeShiftPerPixel(ct)); 138 } 139 140 /////////////////////////////////////////////////////////////////////////////// 141 142 /** 143 * Return true if alphaType is supported by colorType. If there is a canonical 144 * alphaType for this colorType, return it in canonical. 145 */ 146 bool SkColorTypeValidateAlphaType(SkColorType colorType, SkAlphaType alphaType, 147 SkAlphaType* canonical = NULL); 148 149 /////////////////////////////////////////////////////////////////////////////// 150 151 /** 152 * Describes the color space a YUV pixel. 153 */ 154 enum SkYUVColorSpace { 155 /** Standard JPEG color space. */ 156 kJPEG_SkYUVColorSpace, 157 /** SDTV standard Rec. 601 color space. Uses "studio swing" [16, 235] color 158 range. See http://en.wikipedia.org/wiki/Rec._601 for details. */ 159 kRec601_SkYUVColorSpace, 160 /** HDTV standard Rec. 709 color space. Uses "studio swing" [16, 235] color 161 range. See http://en.wikipedia.org/wiki/Rec._709 for details. */ 162 kRec709_SkYUVColorSpace, 163 164 kLastEnum_SkYUVColorSpace = kRec709_SkYUVColorSpace 165 }; 166 167 /////////////////////////////////////////////////////////////////////////////// 168 169 enum class SkDestinationSurfaceColorMode { 170 kLegacy, 171 kGammaAndColorSpaceAware, 172 }; 173 174 /** 175 * Describe an image's dimensions and pixel type. 176 * Used for both src images and render-targets (surfaces). 177 */ 178 struct SK_API SkImageInfo { 179 public: 180 SkImageInfo() 181 : fColorSpace(nullptr) 182 , fWidth(0) 183 , fHeight(0) 184 , fColorType(kUnknown_SkColorType) 185 , fAlphaType(kUnknown_SkAlphaType) 186 {} 187 188 static SkImageInfo Make(int width, int height, SkColorType ct, SkAlphaType at, 189 sk_sp<SkColorSpace> cs = nullptr) { 190 return SkImageInfo(width, height, ct, at, std::move(cs)); 191 } 192 193 /** 194 * Sets colortype to the native ARGB32 type. 195 */ 196 static SkImageInfo MakeN32(int width, int height, SkAlphaType at, 197 sk_sp<SkColorSpace> cs = nullptr) { 198 return Make(width, height, kN32_SkColorType, at, cs); 199 } 200 201 /** 202 * Create an ImageInfo marked as SRGB with N32 swizzle. 203 */ 204 static SkImageInfo MakeS32(int width, int height, SkAlphaType at); 205 206 /** 207 * Sets colortype to the native ARGB32 type, and the alphatype to premul. 208 */ 209 static SkImageInfo MakeN32Premul(int width, int height, sk_sp<SkColorSpace> cs = nullptr) { 210 return Make(width, height, kN32_SkColorType, kPremul_SkAlphaType, cs); 211 } 212 213 static SkImageInfo MakeN32Premul(const SkISize& size) { 214 return MakeN32Premul(size.width(), size.height()); 215 } 216 217 static SkImageInfo MakeA8(int width, int height) { 218 return Make(width, height, kAlpha_8_SkColorType, kPremul_SkAlphaType, nullptr); 219 } 220 221 static SkImageInfo MakeUnknown(int width, int height) { 222 return Make(width, height, kUnknown_SkColorType, kUnknown_SkAlphaType, nullptr); 223 } 224 225 static SkImageInfo MakeUnknown() { 226 return MakeUnknown(0, 0); 227 } 228 229 int width() const { return fWidth; } 230 int height() const { return fHeight; } 231 SkColorType colorType() const { return fColorType; } 232 SkAlphaType alphaType() const { return fAlphaType; } 233 SkColorSpace* colorSpace() const { return fColorSpace.get(); } 234 sk_sp<SkColorSpace> refColorSpace() const { return fColorSpace; } 235 236 bool isEmpty() const { return fWidth <= 0 || fHeight <= 0; } 237 238 bool isOpaque() const { 239 return SkAlphaTypeIsOpaque(fAlphaType); 240 } 241 242 SkISize dimensions() const { return SkISize::Make(fWidth, fHeight); } 243 SkIRect bounds() const { return SkIRect::MakeWH(fWidth, fHeight); } 244 245 bool gammaCloseToSRGB() const { 246 return fColorSpace && fColorSpace->gammaCloseToSRGB(); 247 } 248 249 /** 250 * Return a new ImageInfo with the same colortype and alphatype as this info, 251 * but with the specified width and height. 252 */ 253 SkImageInfo makeWH(int newWidth, int newHeight) const { 254 return Make(newWidth, newHeight, fColorType, fAlphaType, fColorSpace); 255 } 256 257 SkImageInfo makeAlphaType(SkAlphaType newAlphaType) const { 258 return Make(fWidth, fHeight, fColorType, newAlphaType, fColorSpace); 259 } 260 261 SkImageInfo makeColorType(SkColorType newColorType) const { 262 return Make(fWidth, fHeight, newColorType, fAlphaType, fColorSpace); 263 } 264 265 SkImageInfo makeColorSpace(sk_sp<SkColorSpace> cs) const { 266 return Make(fWidth, fHeight, fColorType, fAlphaType, std::move(cs)); 267 } 268 269 int bytesPerPixel() const { return SkColorTypeBytesPerPixel(fColorType); } 270 271 int shiftPerPixel() const { return SkColorTypeShiftPerPixel(fColorType); } 272 273 uint64_t minRowBytes64() const { 274 return sk_64_mul(fWidth, this->bytesPerPixel()); 275 } 276 277 size_t minRowBytes() const { 278 uint64_t minRowBytes = this->minRowBytes64(); 279 if (!sk_64_isS32(minRowBytes)) { 280 return 0; 281 } 282 return sk_64_asS32(minRowBytes); 283 } 284 285 size_t computeOffset(int x, int y, size_t rowBytes) const { 286 SkASSERT((unsigned)x < (unsigned)fWidth); 287 SkASSERT((unsigned)y < (unsigned)fHeight); 288 return SkColorTypeComputeOffset(fColorType, x, y, rowBytes); 289 } 290 291 bool operator==(const SkImageInfo& other) const { 292 return fWidth == other.fWidth && fHeight == other.fHeight && 293 fColorType == other.fColorType && fAlphaType == other.fAlphaType && 294 SkColorSpace::Equals(fColorSpace.get(), other.fColorSpace.get()); 295 } 296 bool operator!=(const SkImageInfo& other) const { 297 return !(*this == other); 298 } 299 300 void unflatten(SkReadBuffer&); 301 void flatten(SkWriteBuffer&) const; 302 303 int64_t getSafeSize64(size_t rowBytes) const { 304 if (0 == fHeight) { 305 return 0; 306 } 307 return sk_64_mul(fHeight - 1, rowBytes) + sk_64_mul(fWidth, this->bytesPerPixel()); 308 } 309 310 size_t getSafeSize(size_t rowBytes) const { 311 int64_t size = this->getSafeSize64(rowBytes); 312 if (!sk_64_isS32(size)) { 313 return 0; 314 } 315 return sk_64_asS32(size); 316 } 317 318 bool validRowBytes(size_t rowBytes) const { 319 uint64_t rb = sk_64_mul(fWidth, this->bytesPerPixel()); 320 return rowBytes >= rb; 321 } 322 323 void reset() { 324 fColorSpace = nullptr; 325 fWidth = 0; 326 fHeight = 0; 327 fColorType = kUnknown_SkColorType; 328 fAlphaType = kUnknown_SkAlphaType; 329 } 330 331 SkDEBUGCODE(void validate() const;) 332 333 private: 334 sk_sp<SkColorSpace> fColorSpace; 335 int fWidth; 336 int fHeight; 337 SkColorType fColorType; 338 SkAlphaType fAlphaType; 339 340 SkImageInfo(int width, int height, SkColorType ct, SkAlphaType at, sk_sp<SkColorSpace> cs) 341 : fColorSpace(std::move(cs)) 342 , fWidth(width) 343 , fHeight(height) 344 , fColorType(ct) 345 , fAlphaType(at) 346 {} 347 }; 348 349 #endif 350