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