1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
/*
* Copyright 2013 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkImageInfo_DEFINED
#define SkImageInfo_DEFINED
#include "SkTypes.h"
/**
* Describes how to interpret the alpha compoent of a pixel.
*/
enum SkAlphaType {
/**
* All pixels should be treated as opaque, regardless of the value stored
* in their alpha field. Used for legacy images that wrote 0 or garbarge
* in their alpha field, but intended the RGB to be treated as opaque.
*/
kIgnore_SkAlphaType,
/**
* All pixels are stored as opaque. This differs slightly from kIgnore in
* that kOpaque has correct "opaque" values stored in the pixels, while
* kIgnore may not, but in both cases the caller should treat the pixels
* as opaque.
*/
kOpaque_SkAlphaType,
/**
* All pixels have their alpha premultiplied in their color components.
* This is the natural format for the rendering target pixels.
*/
kPremul_SkAlphaType,
/**
* All pixels have their color components stored without any regard to the
* alpha. e.g. this is the default configuration for PNG images.
*
* This alpha-type is ONLY supported for input images. Rendering cannot
* generate this on output.
*/
kUnpremul_SkAlphaType,
kLastEnum_SkAlphaType = kUnpremul_SkAlphaType
};
static inline bool SkAlphaTypeIsOpaque(SkAlphaType at) {
SK_COMPILE_ASSERT(kIgnore_SkAlphaType < kOpaque_SkAlphaType, bad_alphatype_order);
SK_COMPILE_ASSERT(kPremul_SkAlphaType > kOpaque_SkAlphaType, bad_alphatype_order);
SK_COMPILE_ASSERT(kUnpremul_SkAlphaType > kOpaque_SkAlphaType, bad_alphatype_order);
return (unsigned)at <= kOpaque_SkAlphaType;
}
///////////////////////////////////////////////////////////////////////////////
/**
* Describes how to interpret the components of a pixel.
*/
enum SkColorType {
kAlpha_8_SkColorType,
kRGB_565_SkColorType,
kRGBA_8888_SkColorType,
kBGRA_8888_SkColorType,
kIndex8_SkColorType,
kLastEnum_SkColorType = kIndex8_SkColorType,
#if SK_PMCOLOR_BYTE_ORDER(B,G,R,A)
kPMColor_SkColorType = kBGRA_8888_SkColorType
#elif SK_PMCOLOR_BYTE_ORDER(R,G,B,A)
kPMColor_SkColorType = kRGBA_8888_SkColorType
#else
#error "SK_*32_SHFIT values must correspond to BGRA or RGBA byte order"
#endif
};
static int SkColorTypeBytesPerPixel(SkColorType ct) {
static const uint8_t gSize[] = {
1, // Alpha_8
2, // RGB_565
4, // RGBA_8888
4, // BGRA_8888
1, // kIndex_8
};
SK_COMPILE_ASSERT(SK_ARRAY_COUNT(gSize) == (size_t)(kLastEnum_SkColorType + 1),
size_mismatch_with_SkColorType_enum);
SkASSERT((size_t)ct < SK_ARRAY_COUNT(gSize));
return gSize[ct];
}
///////////////////////////////////////////////////////////////////////////////
/**
* Describe an image's dimensions and pixel type.
*/
struct SkImageInfo {
int fWidth;
int fHeight;
SkColorType fColorType;
SkAlphaType fAlphaType;
bool isOpaque() const {
return SkAlphaTypeIsOpaque(fAlphaType);
}
int bytesPerPixel() const {
return SkColorTypeBytesPerPixel(fColorType);
}
bool operator==(const SkImageInfo& other) const {
return 0 == memcmp(this, &other, sizeof(other));
}
bool operator!=(const SkImageInfo& other) const {
return 0 != memcmp(this, &other, sizeof(other));
}
};
#endif
|
