SkCodecPriv.h revision cf3f2347c8933596aeba873d4ece597a9339392f
1/* 2 * Copyright 2015 The Android Open Source Project 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 SkCodecPriv_DEFINED 9#define SkCodecPriv_DEFINED 10 11#include "SkColorPriv.h" 12#include "SkColorSpaceXform.h" 13#include "SkColorSpaceXformPriv.h" 14#include "SkColorTable.h" 15#include "SkEncodedInfo.h" 16#include "SkImageInfo.h" 17#include "SkTypes.h" 18 19#ifdef SK_PRINT_CODEC_MESSAGES 20 #define SkCodecPrintf SkDebugf 21#else 22 #define SkCodecPrintf(...) 23#endif 24 25// FIXME: Consider sharing with dm, nanbench, and tools. 26static inline float get_scale_from_sample_size(int sampleSize) { 27 return 1.0f / ((float) sampleSize); 28} 29 30static inline bool is_valid_subset(const SkIRect& subset, const SkISize& imageDims) { 31 return SkIRect::MakeSize(imageDims).contains(subset); 32} 33 34/* 35 * returns a scaled dimension based on the original dimension and the sampleSize 36 * NOTE: we round down here for scaled dimension to match the behavior of SkImageDecoder 37 * FIXME: I think we should call this get_sampled_dimension(). 38 */ 39static inline int get_scaled_dimension(int srcDimension, int sampleSize) { 40 if (sampleSize > srcDimension) { 41 return 1; 42 } 43 return srcDimension / sampleSize; 44} 45 46/* 47 * Returns the first coordinate that we will keep during a scaled decode. 48 * The output can be interpreted as an x-coordinate or a y-coordinate. 49 * 50 * This does not need to be called and is not called when sampleFactor == 1. 51 */ 52static inline int get_start_coord(int sampleFactor) { return sampleFactor / 2; }; 53 54/* 55 * Given a coordinate in the original image, this returns the corresponding 56 * coordinate in the scaled image. This function is meaningless if 57 * IsCoordNecessary returns false. 58 * The output can be interpreted as an x-coordinate or a y-coordinate. 59 * 60 * This does not need to be called and is not called when sampleFactor == 1. 61 */ 62static inline int get_dst_coord(int srcCoord, int sampleFactor) { return srcCoord / sampleFactor; }; 63 64/* 65 * When scaling, we will discard certain y-coordinates (rows) and 66 * x-coordinates (columns). This function returns true if we should keep the 67 * coordinate and false otherwise. 68 * The inputs may be x-coordinates or y-coordinates. 69 * 70 * This does not need to be called and is not called when sampleFactor == 1. 71 */ 72static inline bool is_coord_necessary(int srcCoord, int sampleFactor, int scaledDim) { 73 // Get the first coordinate that we want to keep 74 int startCoord = get_start_coord(sampleFactor); 75 76 // Return false on edge cases 77 if (srcCoord < startCoord || get_dst_coord(srcCoord, sampleFactor) >= scaledDim) { 78 return false; 79 } 80 81 // Every sampleFactor rows are necessary 82 return ((srcCoord - startCoord) % sampleFactor) == 0; 83} 84 85static inline bool valid_alpha(SkAlphaType dstAlpha, SkAlphaType srcAlpha) { 86 if (kUnknown_SkAlphaType == dstAlpha) { 87 return false; 88 } 89 90 if (srcAlpha != dstAlpha) { 91 if (kOpaque_SkAlphaType == srcAlpha) { 92 // If the source is opaque, we can support any. 93 SkCodecPrintf("Warning: an opaque image should be decoded as opaque " 94 "- it is being decoded as non-opaque, which will draw slower\n"); 95 return true; 96 } 97 98 // The source is not opaque 99 switch (dstAlpha) { 100 case kPremul_SkAlphaType: 101 case kUnpremul_SkAlphaType: 102 // The source is not opaque, so either of these is okay 103 break; 104 default: 105 // We cannot decode a non-opaque image to opaque (or unknown) 106 return false; 107 } 108 } 109 return true; 110} 111 112/* 113 * If there is a color table, get a pointer to the colors, otherwise return nullptr 114 */ 115static inline const SkPMColor* get_color_ptr(SkColorTable* colorTable) { 116 return nullptr != colorTable ? colorTable->readColors() : nullptr; 117} 118 119/* 120 * Given that the encoded image uses a color table, return the fill value 121 */ 122static inline uint64_t get_color_table_fill_value(SkColorType dstColorType, SkAlphaType alphaType, 123 const SkPMColor* colorPtr, uint8_t fillIndex, SkColorSpaceXform* colorXform) { 124 SkASSERT(nullptr != colorPtr); 125 switch (dstColorType) { 126 case kRGBA_8888_SkColorType: 127 case kBGRA_8888_SkColorType: 128 return colorPtr[fillIndex]; 129 case kRGB_565_SkColorType: 130 return SkPixel32ToPixel16(colorPtr[fillIndex]); 131 case kIndex_8_SkColorType: 132 return fillIndex; 133 case kRGBA_F16_SkColorType: { 134 SkASSERT(colorXform); 135 uint64_t dstColor; 136 uint32_t srcColor = colorPtr[fillIndex]; 137 SkAssertResult(colorXform->apply(select_xform_format(dstColorType), &dstColor, 138 SkColorSpaceXform::kRGBA_8888_ColorFormat, &srcColor, 1, alphaType)); 139 return dstColor; 140 } 141 default: 142 SkASSERT(false); 143 return 0; 144 } 145} 146 147/* 148 * 149 * Copy the codec color table back to the client when kIndex8 color type is requested 150 */ 151static inline void copy_color_table(const SkImageInfo& dstInfo, SkColorTable* colorTable, 152 SkPMColor* inputColorPtr, int* inputColorCount) { 153 if (kIndex_8_SkColorType == dstInfo.colorType()) { 154 SkASSERT(nullptr != inputColorPtr); 155 SkASSERT(nullptr != inputColorCount); 156 SkASSERT(nullptr != colorTable); 157 memcpy(inputColorPtr, colorTable->readColors(), *inputColorCount * sizeof(SkPMColor)); 158 } 159} 160 161/* 162 * Compute row bytes for an image using pixels per byte 163 */ 164static inline size_t compute_row_bytes_ppb(int width, uint32_t pixelsPerByte) { 165 return (width + pixelsPerByte - 1) / pixelsPerByte; 166} 167 168/* 169 * Compute row bytes for an image using bytes per pixel 170 */ 171static inline size_t compute_row_bytes_bpp(int width, uint32_t bytesPerPixel) { 172 return width * bytesPerPixel; 173} 174 175/* 176 * Compute row bytes for an image 177 */ 178static inline size_t compute_row_bytes(int width, uint32_t bitsPerPixel) { 179 if (bitsPerPixel < 16) { 180 SkASSERT(0 == 8 % bitsPerPixel); 181 const uint32_t pixelsPerByte = 8 / bitsPerPixel; 182 return compute_row_bytes_ppb(width, pixelsPerByte); 183 } else { 184 SkASSERT(0 == bitsPerPixel % 8); 185 const uint32_t bytesPerPixel = bitsPerPixel / 8; 186 return compute_row_bytes_bpp(width, bytesPerPixel); 187 } 188} 189 190/* 191 * Get a byte from a buffer 192 * This method is unsafe, the caller is responsible for performing a check 193 */ 194static inline uint8_t get_byte(uint8_t* buffer, uint32_t i) { 195 return buffer[i]; 196} 197 198/* 199 * Get a short from a buffer 200 * This method is unsafe, the caller is responsible for performing a check 201 */ 202static inline uint16_t get_short(uint8_t* buffer, uint32_t i) { 203 uint16_t result; 204 memcpy(&result, &(buffer[i]), 2); 205#ifdef SK_CPU_BENDIAN 206 return SkEndianSwap16(result); 207#else 208 return result; 209#endif 210} 211 212/* 213 * Get an int from a buffer 214 * This method is unsafe, the caller is responsible for performing a check 215 */ 216static inline uint32_t get_int(uint8_t* buffer, uint32_t i) { 217 uint32_t result; 218 memcpy(&result, &(buffer[i]), 4); 219#ifdef SK_CPU_BENDIAN 220 return SkEndianSwap32(result); 221#else 222 return result; 223#endif 224} 225 226/* 227 * @param data Buffer to read bytes from 228 * @param isLittleEndian Output parameter 229 * Indicates if the data is little endian 230 * Is unaffected on false returns 231 */ 232static inline bool is_valid_endian_marker(const uint8_t* data, bool* isLittleEndian) { 233 // II indicates Intel (little endian) and MM indicates motorola (big endian). 234 if (('I' != data[0] || 'I' != data[1]) && ('M' != data[0] || 'M' != data[1])) { 235 return false; 236 } 237 238 *isLittleEndian = ('I' == data[0]); 239 return true; 240} 241 242static inline uint16_t get_endian_short(const uint8_t* data, bool littleEndian) { 243 if (littleEndian) { 244 return (data[1] << 8) | (data[0]); 245 } 246 247 return (data[0] << 8) | (data[1]); 248} 249 250static inline SkPMColor premultiply_argb_as_rgba(U8CPU a, U8CPU r, U8CPU g, U8CPU b) { 251 if (a != 255) { 252 r = SkMulDiv255Round(r, a); 253 g = SkMulDiv255Round(g, a); 254 b = SkMulDiv255Round(b, a); 255 } 256 257 return SkPackARGB_as_RGBA(a, r, g, b); 258} 259 260static inline SkPMColor premultiply_argb_as_bgra(U8CPU a, U8CPU r, U8CPU g, U8CPU b) { 261 if (a != 255) { 262 r = SkMulDiv255Round(r, a); 263 g = SkMulDiv255Round(g, a); 264 b = SkMulDiv255Round(b, a); 265 } 266 267 return SkPackARGB_as_BGRA(a, r, g, b); 268} 269 270static inline bool is_rgba(SkColorType colorType) { 271#ifdef SK_PMCOLOR_IS_RGBA 272 return (kBGRA_8888_SkColorType != colorType); 273#else 274 return (kRGBA_8888_SkColorType == colorType); 275#endif 276} 277 278// Method for coverting to a 32 bit pixel. 279typedef uint32_t (*PackColorProc)(U8CPU a, U8CPU r, U8CPU g, U8CPU b); 280 281static inline PackColorProc choose_pack_color_proc(bool isPremul, SkColorType colorType) { 282 bool isRGBA = is_rgba(colorType); 283 if (isPremul) { 284 if (isRGBA) { 285 return &premultiply_argb_as_rgba; 286 } else { 287 return &premultiply_argb_as_bgra; 288 } 289 } else { 290 if (isRGBA) { 291 return &SkPackARGB_as_RGBA; 292 } else { 293 return &SkPackARGB_as_BGRA; 294 } 295 } 296} 297 298static inline bool needs_premul(const SkImageInfo& dstInfo, const SkEncodedInfo& encodedInfo) { 299 return kPremul_SkAlphaType == dstInfo.alphaType() && 300 SkEncodedInfo::kUnpremul_Alpha == encodedInfo.alpha(); 301} 302 303static inline bool needs_color_xform(const SkImageInfo& dstInfo, const SkImageInfo& srcInfo, 304 bool needsColorCorrectPremul) { 305 // We never perform a color xform in legacy mode. 306 if (!dstInfo.colorSpace()) { 307 return false; 308 } 309 310 // F16 is by definition a linear space, so we always must perform a color xform. 311 bool isF16 = kRGBA_F16_SkColorType == dstInfo.colorType(); 312 313 // Need a color xform when dst space does not match the src. 314 bool srcDstNotEqual = 315 !SkColorSpace_Base::EqualsIgnoreFlags(srcInfo.colorSpace(), dstInfo.colorSpace()); 316 317 return needsColorCorrectPremul || isF16 || srcDstNotEqual; 318} 319 320static inline SkAlphaType select_xform_alpha(SkAlphaType dstAlphaType, SkAlphaType srcAlphaType) { 321 return (kOpaque_SkAlphaType == srcAlphaType) ? kOpaque_SkAlphaType : dstAlphaType; 322} 323 324static inline bool apply_xform_on_decode(SkColorType dstColorType, SkEncodedInfo::Color srcColor) { 325 // We will apply the color xform when reading the color table, unless F16 is requested. 326 return SkEncodedInfo::kPalette_Color != srcColor || kRGBA_F16_SkColorType == dstColorType; 327} 328 329/* 330 * Alpha Type Conversions 331 * - kOpaque to kOpaque, kUnpremul, kPremul is valid 332 * - kUnpremul to kUnpremul, kPremul is valid 333 * 334 * Color Type Conversions 335 * - Always support kRGBA_8888, kBGRA_8888 336 * - Support kRGBA_F16 when there is a linear dst color space 337 * - Support kIndex8 if it matches the src 338 * - Support k565 if kOpaque and color correction is not required 339 * - Support k565 if it matches the src, kOpaque, and color correction is not required 340 */ 341static inline bool conversion_possible(const SkImageInfo& dst, const SkImageInfo& src) { 342 // Ensure the alpha type is valid. 343 if (!valid_alpha(dst.alphaType(), src.alphaType())) { 344 return false; 345 } 346 347 // Check for supported color types. 348 switch (dst.colorType()) { 349 case kRGBA_8888_SkColorType: 350 case kBGRA_8888_SkColorType: 351 return true; 352 case kRGBA_F16_SkColorType: 353 return dst.colorSpace() && dst.colorSpace()->gammaIsLinear(); 354 case kIndex_8_SkColorType: 355 return kIndex_8_SkColorType == src.colorType(); 356 case kRGB_565_SkColorType: 357 return kOpaque_SkAlphaType == src.alphaType() && !needs_color_xform(dst, src, false); 358 case kGray_8_SkColorType: 359 return kGray_8_SkColorType == src.colorType() && 360 kOpaque_SkAlphaType == src.alphaType() && !needs_color_xform(dst, src, false); 361 default: 362 return false; 363 } 364} 365 366#endif // SkCodecPriv_DEFINED 367