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 "SkColorData.h"
12 #include "SkColorSpaceXform.h"
13 #include "SkColorSpaceXformPriv.h"
14 #include "SkColorTable.h"
15 #include "SkEncodedInfo.h"
16 #include "SkEncodedOrigin.h"
17 #include "SkImageInfo.h"
18 #include "SkTypes.h"
19
20 #ifdef SK_PRINT_CODEC_MESSAGES
21 #define SkCodecPrintf SkDebugf
22 #else
23 #define SkCodecPrintf(...)
24 #endif
25
26 // FIXME: Consider sharing with dm, nanbench, and tools.
get_scale_from_sample_size(int sampleSize)27 static inline float get_scale_from_sample_size(int sampleSize) {
28 return 1.0f / ((float) sampleSize);
29 }
30
is_valid_subset(const SkIRect & subset,const SkISize & imageDims)31 static inline bool is_valid_subset(const SkIRect& subset, const SkISize& imageDims) {
32 return SkIRect::MakeSize(imageDims).contains(subset);
33 }
34
35 /*
36 * returns a scaled dimension based on the original dimension and the sampleSize
37 * NOTE: we round down here for scaled dimension to match the behavior of SkImageDecoder
38 * FIXME: I think we should call this get_sampled_dimension().
39 */
get_scaled_dimension(int srcDimension,int sampleSize)40 static inline int get_scaled_dimension(int srcDimension, int sampleSize) {
41 if (sampleSize > srcDimension) {
42 return 1;
43 }
44 return srcDimension / sampleSize;
45 }
46
47 /*
48 * Returns the first coordinate that we will keep during a scaled decode.
49 * The output can be interpreted as an x-coordinate or a y-coordinate.
50 *
51 * This does not need to be called and is not called when sampleFactor == 1.
52 */
get_start_coord(int sampleFactor)53 static inline int get_start_coord(int sampleFactor) { return sampleFactor / 2; };
54
55 /*
56 * Given a coordinate in the original image, this returns the corresponding
57 * coordinate in the scaled image. This function is meaningless if
58 * IsCoordNecessary returns false.
59 * The output can be interpreted as an x-coordinate or a y-coordinate.
60 *
61 * This does not need to be called and is not called when sampleFactor == 1.
62 */
get_dst_coord(int srcCoord,int sampleFactor)63 static inline int get_dst_coord(int srcCoord, int sampleFactor) { return srcCoord / sampleFactor; };
64
65 /*
66 * When scaling, we will discard certain y-coordinates (rows) and
67 * x-coordinates (columns). This function returns true if we should keep the
68 * coordinate and false otherwise.
69 * The inputs may be x-coordinates or y-coordinates.
70 *
71 * This does not need to be called and is not called when sampleFactor == 1.
72 */
is_coord_necessary(int srcCoord,int sampleFactor,int scaledDim)73 static inline bool is_coord_necessary(int srcCoord, int sampleFactor, int scaledDim) {
74 // Get the first coordinate that we want to keep
75 int startCoord = get_start_coord(sampleFactor);
76
77 // Return false on edge cases
78 if (srcCoord < startCoord || get_dst_coord(srcCoord, sampleFactor) >= scaledDim) {
79 return false;
80 }
81
82 // Every sampleFactor rows are necessary
83 return ((srcCoord - startCoord) % sampleFactor) == 0;
84 }
85
valid_alpha(SkAlphaType dstAlpha,bool srcIsOpaque)86 static inline bool valid_alpha(SkAlphaType dstAlpha, bool srcIsOpaque) {
87 if (kUnknown_SkAlphaType == dstAlpha) {
88 return false;
89 }
90
91 if (srcIsOpaque) {
92 if (kOpaque_SkAlphaType != dstAlpha) {
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 }
96 return true;
97 }
98
99 return dstAlpha != kOpaque_SkAlphaType;
100 }
101
102 /*
103 * If there is a color table, get a pointer to the colors, otherwise return nullptr
104 */
get_color_ptr(SkColorTable * colorTable)105 static inline const SkPMColor* get_color_ptr(SkColorTable* colorTable) {
106 return nullptr != colorTable ? colorTable->readColors() : nullptr;
107 }
108
109 /*
110 * Given that the encoded image uses a color table, return the fill value
111 */
get_color_table_fill_value(SkColorType dstColorType,SkAlphaType alphaType,const SkPMColor * colorPtr,uint8_t fillIndex,SkColorSpaceXform * colorXform,bool isRGBA)112 static inline uint64_t get_color_table_fill_value(SkColorType dstColorType, SkAlphaType alphaType,
113 const SkPMColor* colorPtr, uint8_t fillIndex, SkColorSpaceXform* colorXform, bool isRGBA) {
114 SkASSERT(nullptr != colorPtr);
115 switch (dstColorType) {
116 case kRGBA_8888_SkColorType:
117 case kBGRA_8888_SkColorType:
118 return colorPtr[fillIndex];
119 case kRGB_565_SkColorType:
120 return SkPixel32ToPixel16(colorPtr[fillIndex]);
121 case kRGBA_F16_SkColorType: {
122 SkASSERT(colorXform);
123 uint64_t dstColor;
124 uint32_t srcColor = colorPtr[fillIndex];
125 SkColorSpaceXform::ColorFormat srcFormat =
126 isRGBA ? SkColorSpaceXform::kRGBA_8888_ColorFormat
127 : SkColorSpaceXform::kBGRA_8888_ColorFormat;
128 SkAssertResult(colorXform->apply(select_xform_format(dstColorType), &dstColor,
129 srcFormat, &srcColor, 1, alphaType));
130 return dstColor;
131 }
132 default:
133 SkASSERT(false);
134 return 0;
135 }
136 }
137
138 /*
139 * Compute row bytes for an image using pixels per byte
140 */
compute_row_bytes_ppb(int width,uint32_t pixelsPerByte)141 static inline size_t compute_row_bytes_ppb(int width, uint32_t pixelsPerByte) {
142 return (width + pixelsPerByte - 1) / pixelsPerByte;
143 }
144
145 /*
146 * Compute row bytes for an image using bytes per pixel
147 */
compute_row_bytes_bpp(int width,uint32_t bytesPerPixel)148 static inline size_t compute_row_bytes_bpp(int width, uint32_t bytesPerPixel) {
149 return width * bytesPerPixel;
150 }
151
152 /*
153 * Compute row bytes for an image
154 */
compute_row_bytes(int width,uint32_t bitsPerPixel)155 static inline size_t compute_row_bytes(int width, uint32_t bitsPerPixel) {
156 if (bitsPerPixel < 16) {
157 SkASSERT(0 == 8 % bitsPerPixel);
158 const uint32_t pixelsPerByte = 8 / bitsPerPixel;
159 return compute_row_bytes_ppb(width, pixelsPerByte);
160 } else {
161 SkASSERT(0 == bitsPerPixel % 8);
162 const uint32_t bytesPerPixel = bitsPerPixel / 8;
163 return compute_row_bytes_bpp(width, bytesPerPixel);
164 }
165 }
166
167 /*
168 * Get a byte from a buffer
169 * This method is unsafe, the caller is responsible for performing a check
170 */
get_byte(uint8_t * buffer,uint32_t i)171 static inline uint8_t get_byte(uint8_t* buffer, uint32_t i) {
172 return buffer[i];
173 }
174
175 /*
176 * Get a short from a buffer
177 * This method is unsafe, the caller is responsible for performing a check
178 */
get_short(uint8_t * buffer,uint32_t i)179 static inline uint16_t get_short(uint8_t* buffer, uint32_t i) {
180 uint16_t result;
181 memcpy(&result, &(buffer[i]), 2);
182 #ifdef SK_CPU_BENDIAN
183 return SkEndianSwap16(result);
184 #else
185 return result;
186 #endif
187 }
188
189 /*
190 * Get an int from a buffer
191 * This method is unsafe, the caller is responsible for performing a check
192 */
get_int(uint8_t * buffer,uint32_t i)193 static inline uint32_t get_int(uint8_t* buffer, uint32_t i) {
194 uint32_t result;
195 memcpy(&result, &(buffer[i]), 4);
196 #ifdef SK_CPU_BENDIAN
197 return SkEndianSwap32(result);
198 #else
199 return result;
200 #endif
201 }
202
203 /*
204 * @param data Buffer to read bytes from
205 * @param isLittleEndian Output parameter
206 * Indicates if the data is little endian
207 * Is unaffected on false returns
208 */
is_valid_endian_marker(const uint8_t * data,bool * isLittleEndian)209 static inline bool is_valid_endian_marker(const uint8_t* data, bool* isLittleEndian) {
210 // II indicates Intel (little endian) and MM indicates motorola (big endian).
211 if (('I' != data[0] || 'I' != data[1]) && ('M' != data[0] || 'M' != data[1])) {
212 return false;
213 }
214
215 *isLittleEndian = ('I' == data[0]);
216 return true;
217 }
218
get_endian_short(const uint8_t * data,bool littleEndian)219 static inline uint16_t get_endian_short(const uint8_t* data, bool littleEndian) {
220 if (littleEndian) {
221 return (data[1] << 8) | (data[0]);
222 }
223
224 return (data[0] << 8) | (data[1]);
225 }
226
premultiply_argb_as_rgba(U8CPU a,U8CPU r,U8CPU g,U8CPU b)227 static inline SkPMColor premultiply_argb_as_rgba(U8CPU a, U8CPU r, U8CPU g, U8CPU b) {
228 if (a != 255) {
229 r = SkMulDiv255Round(r, a);
230 g = SkMulDiv255Round(g, a);
231 b = SkMulDiv255Round(b, a);
232 }
233
234 return SkPackARGB_as_RGBA(a, r, g, b);
235 }
236
premultiply_argb_as_bgra(U8CPU a,U8CPU r,U8CPU g,U8CPU b)237 static inline SkPMColor premultiply_argb_as_bgra(U8CPU a, U8CPU r, U8CPU g, U8CPU b) {
238 if (a != 255) {
239 r = SkMulDiv255Round(r, a);
240 g = SkMulDiv255Round(g, a);
241 b = SkMulDiv255Round(b, a);
242 }
243
244 return SkPackARGB_as_BGRA(a, r, g, b);
245 }
246
is_rgba(SkColorType colorType)247 static inline bool is_rgba(SkColorType colorType) {
248 #ifdef SK_PMCOLOR_IS_RGBA
249 return (kBGRA_8888_SkColorType != colorType);
250 #else
251 return (kRGBA_8888_SkColorType == colorType);
252 #endif
253 }
254
255 // Method for coverting to a 32 bit pixel.
256 typedef uint32_t (*PackColorProc)(U8CPU a, U8CPU r, U8CPU g, U8CPU b);
257
choose_pack_color_proc(bool isPremul,SkColorType colorType)258 static inline PackColorProc choose_pack_color_proc(bool isPremul, SkColorType colorType) {
259 bool isRGBA = is_rgba(colorType);
260 if (isPremul) {
261 if (isRGBA) {
262 return &premultiply_argb_as_rgba;
263 } else {
264 return &premultiply_argb_as_bgra;
265 }
266 } else {
267 if (isRGBA) {
268 return &SkPackARGB_as_RGBA;
269 } else {
270 return &SkPackARGB_as_BGRA;
271 }
272 }
273 }
274
needs_premul(SkAlphaType dstAT,SkEncodedInfo::Alpha encodedAlpha)275 static inline bool needs_premul(SkAlphaType dstAT, SkEncodedInfo::Alpha encodedAlpha) {
276 return kPremul_SkAlphaType == dstAT && SkEncodedInfo::kUnpremul_Alpha == encodedAlpha;
277 }
278
needs_color_xform(const SkImageInfo & dstInfo,const SkColorSpace * srcCS,bool needsColorCorrectPremul)279 static inline bool needs_color_xform(const SkImageInfo& dstInfo, const SkColorSpace* srcCS,
280 bool needsColorCorrectPremul) {
281 // We never perform a color xform in legacy mode.
282 if (!dstInfo.colorSpace()) {
283 return false;
284 }
285
286 // F16 is by definition a linear space, so we always must perform a color xform.
287 bool isF16 = kRGBA_F16_SkColorType == dstInfo.colorType();
288
289 // Need a color xform when dst space does not match the src.
290 bool srcDstNotEqual = !SkColorSpace::Equals(srcCS, dstInfo.colorSpace());
291
292 return needsColorCorrectPremul || isF16 || srcDstNotEqual;
293 }
294
select_xform_alpha(SkAlphaType dstAlphaType,SkAlphaType srcAlphaType)295 static inline SkAlphaType select_xform_alpha(SkAlphaType dstAlphaType, SkAlphaType srcAlphaType) {
296 return (kOpaque_SkAlphaType == srcAlphaType) ? kOpaque_SkAlphaType : dstAlphaType;
297 }
298
299 bool is_orientation_marker(const uint8_t* data, size_t data_length, SkEncodedOrigin* orientation);
300
301 #endif // SkCodecPriv_DEFINED
302