1 /*
2 * Copyright 2017 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 SkImageInfoPriv_DEFINED
9 #define SkImageInfoPriv_DEFINED
10
11 #include "include/core/SkColor.h"
12 #include "include/core/SkColorType.h"
13 #include "include/core/SkImageInfo.h"
14
SkColorTypeChannelFlags(SkColorType ct)15 static inline uint32_t SkColorTypeChannelFlags(SkColorType ct) {
16 switch (ct) {
17 case kUnknown_SkColorType: return 0;
18 case kAlpha_8_SkColorType: return kAlpha_SkColorChannelFlag;
19 case kRGB_565_SkColorType: return kRGB_SkColorChannelFlags;
20 case kARGB_4444_SkColorType: return kRGBA_SkColorChannelFlags;
21 case kRGBA_8888_SkColorType: return kRGBA_SkColorChannelFlags;
22 case kRGB_888x_SkColorType: return kRGB_SkColorChannelFlags;
23 case kBGRA_8888_SkColorType: return kRGBA_SkColorChannelFlags;
24 case kRGBA_1010102_SkColorType: return kRGBA_SkColorChannelFlags;
25 case kRGB_101010x_SkColorType: return kRGB_SkColorChannelFlags;
26 case kBGRA_1010102_SkColorType: return kRGBA_SkColorChannelFlags;
27 case kBGR_101010x_SkColorType: return kRGB_SkColorChannelFlags;
28 case kBGR_101010x_XR_SkColorType: return kRGB_SkColorChannelFlags;
29 case kBGRA_10101010_XR_SkColorType: return kRGBA_SkColorChannelFlags;
30 case kRGBA_10x6_SkColorType: return kRGBA_SkColorChannelFlags;
31 case kGray_8_SkColorType: return kGray_SkColorChannelFlag;
32 case kRGBA_F16Norm_SkColorType: return kRGBA_SkColorChannelFlags;
33 case kRGBA_F16_SkColorType: return kRGBA_SkColorChannelFlags;
34 case kRGB_F16F16F16x_SkColorType: return kRGB_SkColorChannelFlags;
35 case kRGBA_F32_SkColorType: return kRGBA_SkColorChannelFlags;
36 case kR8G8_unorm_SkColorType: return kRG_SkColorChannelFlags;
37 case kA16_unorm_SkColorType: return kAlpha_SkColorChannelFlag;
38 case kR16G16_unorm_SkColorType: return kRG_SkColorChannelFlags;
39 case kA16_float_SkColorType: return kAlpha_SkColorChannelFlag;
40 case kR16G16_float_SkColorType: return kRG_SkColorChannelFlags;
41 case kR16G16B16A16_unorm_SkColorType: return kRGBA_SkColorChannelFlags;
42 case kSRGBA_8888_SkColorType: return kRGBA_SkColorChannelFlags;
43 case kR8_unorm_SkColorType: return kRed_SkColorChannelFlag;
44 }
45 SkUNREACHABLE;
46 }
47
SkColorTypeNumChannels(SkColorType ct)48 static inline int SkColorTypeNumChannels(SkColorType ct) {
49 switch (SkColorTypeChannelFlags(ct)) {
50 case kRed_SkColorChannelFlag : return 1;
51 case kAlpha_SkColorChannelFlag : return 1;
52 case kGray_SkColorChannelFlag : return 1;
53 case kGrayAlpha_SkColorChannelFlags : return 2;
54 case kRG_SkColorChannelFlags : return 2;
55 case kRGB_SkColorChannelFlags : return 3;
56 case kRGBA_SkColorChannelFlags : return 4;
57 case 0 : return 0;
58 default:
59 SkDEBUGFAIL("unexpected color channel flags");
60 return 0;
61 }
62 SkUNREACHABLE;
63 }
64
SkColorTypeIsAlphaOnly(SkColorType ct)65 static inline bool SkColorTypeIsAlphaOnly(SkColorType ct) {
66 return SkColorTypeChannelFlags(ct) == kAlpha_SkColorChannelFlag;
67 }
68
SkAlphaTypeIsValid(unsigned value)69 static inline bool SkAlphaTypeIsValid(unsigned value) {
70 return value <= kLastEnum_SkAlphaType;
71 }
72
SkColorTypeShiftPerPixel(SkColorType ct)73 static int SkColorTypeShiftPerPixel(SkColorType ct) {
74 switch (ct) {
75 case kUnknown_SkColorType: return 0;
76 case kAlpha_8_SkColorType: return 0;
77 case kRGB_565_SkColorType: return 1;
78 case kARGB_4444_SkColorType: return 1;
79 case kRGBA_8888_SkColorType: return 2;
80 case kRGB_888x_SkColorType: return 2;
81 case kBGRA_8888_SkColorType: return 2;
82 case kRGBA_1010102_SkColorType: return 2;
83 case kRGB_101010x_SkColorType: return 2;
84 case kBGRA_1010102_SkColorType: return 2;
85 case kBGR_101010x_SkColorType: return 2;
86 case kBGR_101010x_XR_SkColorType: return 2;
87 case kBGRA_10101010_XR_SkColorType: return 3;
88 case kRGBA_10x6_SkColorType: return 3;
89 case kGray_8_SkColorType: return 0;
90 case kRGBA_F16Norm_SkColorType: return 3;
91 case kRGBA_F16_SkColorType: return 3;
92 case kRGB_F16F16F16x_SkColorType: return 3;
93 case kRGBA_F32_SkColorType: return 4;
94 case kR8G8_unorm_SkColorType: return 1;
95 case kA16_unorm_SkColorType: return 1;
96 case kR16G16_unorm_SkColorType: return 2;
97 case kA16_float_SkColorType: return 1;
98 case kR16G16_float_SkColorType: return 2;
99 case kR16G16B16A16_unorm_SkColorType: return 3;
100 case kSRGBA_8888_SkColorType: return 2;
101 case kR8_unorm_SkColorType: return 0;
102 }
103 SkUNREACHABLE;
104 }
105
SkColorTypeMinRowBytes(SkColorType ct,int width)106 static inline size_t SkColorTypeMinRowBytes(SkColorType ct, int width) {
107 return (size_t)(width * SkColorTypeBytesPerPixel(ct));
108 }
109
SkColorTypeIsValid(unsigned value)110 static inline bool SkColorTypeIsValid(unsigned value) {
111 return value <= kLastEnum_SkColorType;
112 }
113
SkColorTypeComputeOffset(SkColorType ct,int x,int y,size_t rowBytes)114 static inline size_t SkColorTypeComputeOffset(SkColorType ct, int x, int y, size_t rowBytes) {
115 if (kUnknown_SkColorType == ct) {
116 return 0;
117 }
118 return (size_t)y * rowBytes + ((size_t)x << SkColorTypeShiftPerPixel(ct));
119 }
120
SkColorTypeIsNormalized(SkColorType ct)121 static inline bool SkColorTypeIsNormalized(SkColorType ct) {
122 switch (ct) {
123 case kUnknown_SkColorType:
124 case kAlpha_8_SkColorType:
125 case kRGB_565_SkColorType:
126 case kARGB_4444_SkColorType:
127 case kRGBA_8888_SkColorType:
128 case kRGB_888x_SkColorType:
129 case kBGRA_8888_SkColorType:
130 case kRGBA_1010102_SkColorType:
131 case kRGB_101010x_SkColorType:
132 case kBGRA_1010102_SkColorType:
133 case kBGR_101010x_SkColorType:
134 case kRGBA_10x6_SkColorType:
135 case kGray_8_SkColorType:
136 case kRGBA_F16Norm_SkColorType:
137 case kR8G8_unorm_SkColorType:
138 case kA16_unorm_SkColorType:
139 case kA16_float_SkColorType: /*subtle... alpha is always [0,1]*/
140 case kR16G16_unorm_SkColorType:
141 case kR16G16B16A16_unorm_SkColorType:
142 case kSRGBA_8888_SkColorType:
143 case kR8_unorm_SkColorType:
144 return true;
145
146 case kBGRA_10101010_XR_SkColorType:
147 case kBGR_101010x_XR_SkColorType:
148 case kRGB_F16F16F16x_SkColorType:
149 case kRGBA_F16_SkColorType:
150 case kRGBA_F32_SkColorType:
151 case kR16G16_float_SkColorType:
152 return false;
153 }
154 SkUNREACHABLE;
155 }
156
SkColorTypeMaxBitsPerChannel(SkColorType ct)157 static inline int SkColorTypeMaxBitsPerChannel(SkColorType ct) {
158 switch (ct) {
159 case kUnknown_SkColorType:
160 return 0;
161
162 case kARGB_4444_SkColorType:
163 return 4;
164
165 case kRGB_565_SkColorType:
166 return 6;
167
168 case kAlpha_8_SkColorType:
169 case kRGBA_8888_SkColorType:
170 case kRGB_888x_SkColorType:
171 case kBGRA_8888_SkColorType:
172 case kGray_8_SkColorType:
173 case kR8G8_unorm_SkColorType:
174 case kSRGBA_8888_SkColorType:
175 case kR8_unorm_SkColorType:
176 return 8;
177
178 case kRGBA_1010102_SkColorType:
179 case kRGB_101010x_SkColorType:
180 case kBGRA_1010102_SkColorType:
181 case kBGR_101010x_SkColorType:
182 case kBGR_101010x_XR_SkColorType:
183 case kBGRA_10101010_XR_SkColorType:
184 case kRGBA_10x6_SkColorType:
185 return 10;
186
187 case kRGBA_F16Norm_SkColorType:
188 case kA16_unorm_SkColorType:
189 case kA16_float_SkColorType:
190 case kR16G16_unorm_SkColorType:
191 case kR16G16B16A16_unorm_SkColorType:
192 case kRGBA_F16_SkColorType:
193 case kRGB_F16F16F16x_SkColorType:
194 case kR16G16_float_SkColorType:
195 return 16;
196
197 case kRGBA_F32_SkColorType:
198 return 32;
199 }
200 SkUNREACHABLE;
201 }
202
203 /**
204 * Returns true if |info| contains a valid colorType and alphaType.
205 */
SkColorInfoIsValid(const SkColorInfo & info)206 static inline bool SkColorInfoIsValid(const SkColorInfo& info) {
207 return info.colorType() != kUnknown_SkColorType && info.alphaType() != kUnknown_SkAlphaType;
208 }
209
210 /**
211 * Returns true if |info| contains a valid combination of width, height and colorInfo.
212 */
SkImageInfoIsValid(const SkImageInfo & info)213 static inline bool SkImageInfoIsValid(const SkImageInfo& info) {
214 if (info.width() <= 0 || info.height() <= 0) {
215 return false;
216 }
217
218 const int kMaxDimension = SK_MaxS32 >> 2;
219 if (info.width() > kMaxDimension || info.height() > kMaxDimension) {
220 return false;
221 }
222
223 return SkColorInfoIsValid(info.colorInfo());
224 }
225
226 /**
227 * Returns true if Skia has defined a pixel conversion from the |src| to the |dst|.
228 * Returns false otherwise.
229 */
SkImageInfoValidConversion(const SkImageInfo & dst,const SkImageInfo & src)230 static inline bool SkImageInfoValidConversion(const SkImageInfo& dst, const SkImageInfo& src) {
231 return SkImageInfoIsValid(dst) && SkImageInfoIsValid(src);
232 }
233 #endif // SkImageInfoPriv_DEFINED
234