1
2 /*
3 * Copyright 2011 Google Inc.
4 *
5 * Use of this source code is governed by a BSD-style license that can be
6 * found in the LICENSE file.
7 */
8 #include "SkFloatBits.h"
9 #include "SkMath.h"
10
11 /******************************************************************************
12 SkFloatBits_toInt[Floor, Round, Ceil] are identical except for what they
13 do right before they return ... >> exp;
14 Floor - adds nothing
15 Round - adds 1 << (exp - 1)
16 Ceil - adds (1 << exp) - 1
17
18 Floor and Cast are very similar, but Cast applies its sign after all other
19 computations on value. Also, Cast does not need to check for negative zero,
20 as that value (0x80000000) "does the right thing" for Ceil. Note that it
21 doesn't for Floor/Round/Ceil, hence the explicit check.
22 ******************************************************************************/
23
24 #define EXP_BIAS (127+23)
25 #define MATISSA_MAGIC_BIG (1 << 23)
26
unpack_exp(uint32_t packed)27 static inline int unpack_exp(uint32_t packed) {
28 return (packed << 1 >> 24);
29 }
30
31 #if 0
32 // the ARM compiler generates an extra BIC, so I use the dirty version instead
33 static inline int unpack_matissa(uint32_t packed) {
34 // we could mask with 0x7FFFFF, but that is harder for ARM to encode
35 return (packed & ~0xFF000000) | MATISSA_MAGIC_BIG;
36 }
37 #endif
38
39 // returns the low 24-bits, so we need to OR in the magic_bit afterwards
unpack_matissa_dirty(uint32_t packed)40 static inline int unpack_matissa_dirty(uint32_t packed) {
41 return packed & ~0xFF000000;
42 }
43
44 // same as (int)float
SkFloatBits_toIntCast(int32_t packed)45 int32_t SkFloatBits_toIntCast(int32_t packed) {
46 int exp = unpack_exp(packed) - EXP_BIAS;
47 int value = unpack_matissa_dirty(packed) | MATISSA_MAGIC_BIG;
48
49 if (exp >= 0) {
50 if (exp > 7) { // overflow
51 value = SK_MaxS32;
52 } else {
53 value <<= exp;
54 }
55 } else {
56 exp = -exp;
57 if (exp > 25) { // underflow
58 exp = 25;
59 }
60 value >>= exp;
61 }
62 return SkApplySign(value, SkExtractSign(packed));
63 }
64
65 // same as (int)floor(float)
SkFloatBits_toIntFloor(int32_t packed)66 int32_t SkFloatBits_toIntFloor(int32_t packed) {
67 // curse you negative 0
68 if ((packed << 1) == 0) {
69 return 0;
70 }
71
72 int exp = unpack_exp(packed) - EXP_BIAS;
73 int value = unpack_matissa_dirty(packed) | MATISSA_MAGIC_BIG;
74
75 if (exp >= 0) {
76 if (exp > 7) { // overflow
77 value = SK_MaxS32;
78 } else {
79 value <<= exp;
80 }
81 // apply the sign after we check for overflow
82 return SkApplySign(value, SkExtractSign(packed));
83 } else {
84 // apply the sign before we right-shift
85 value = SkApplySign(value, SkExtractSign(packed));
86 exp = -exp;
87 if (exp > 25) { // underflow
88 exp = 25;
89 }
90 // int add = 0;
91 return value >> exp;
92 }
93 }
94
95 // same as (int)floor(float + 0.5)
SkFloatBits_toIntRound(int32_t packed)96 int32_t SkFloatBits_toIntRound(int32_t packed) {
97 // curse you negative 0
98 if ((packed << 1) == 0) {
99 return 0;
100 }
101
102 int exp = unpack_exp(packed) - EXP_BIAS;
103 int value = unpack_matissa_dirty(packed) | MATISSA_MAGIC_BIG;
104
105 if (exp >= 0) {
106 if (exp > 7) { // overflow
107 value = SK_MaxS32;
108 } else {
109 value <<= exp;
110 }
111 // apply the sign after we check for overflow
112 return SkApplySign(value, SkExtractSign(packed));
113 } else {
114 // apply the sign before we right-shift
115 value = SkApplySign(value, SkExtractSign(packed));
116 exp = -exp;
117 if (exp > 25) { // underflow
118 exp = 25;
119 }
120 int add = 1 << (exp - 1);
121 return (value + add) >> exp;
122 }
123 }
124
125 // same as (int)ceil(float)
SkFloatBits_toIntCeil(int32_t packed)126 int32_t SkFloatBits_toIntCeil(int32_t packed) {
127 // curse you negative 0
128 if ((packed << 1) == 0) {
129 return 0;
130 }
131
132 int exp = unpack_exp(packed) - EXP_BIAS;
133 int value = unpack_matissa_dirty(packed) | MATISSA_MAGIC_BIG;
134
135 if (exp >= 0) {
136 if (exp > 7) { // overflow
137 value = SK_MaxS32;
138 } else {
139 value <<= exp;
140 }
141 // apply the sign after we check for overflow
142 return SkApplySign(value, SkExtractSign(packed));
143 } else {
144 // apply the sign before we right-shift
145 value = SkApplySign(value, SkExtractSign(packed));
146 exp = -exp;
147 if (exp > 25) { // underflow
148 exp = 25;
149 }
150 int add = (1 << exp) - 1;
151 return (value + add) >> exp;
152 }
153 }
154
155 #ifdef SK_CAN_USE_FLOAT
156
SkIntToFloatCast(int32_t value)157 float SkIntToFloatCast(int32_t value) {
158 if (0 == value) {
159 return 0;
160 }
161
162 int shift = EXP_BIAS;
163
164 // record the sign and make value positive
165 int sign = SkExtractSign(value);
166 value = SkApplySign(value, sign);
167
168 if (value >> 24) { // value is too big (has more than 24 bits set)
169 int bias = 8 - SkCLZ(value);
170 SkDebugf("value = %d, bias = %d\n", value, bias);
171 SkASSERT(bias > 0 && bias < 8);
172 value >>= bias; // need to round?
173 shift += bias;
174 } else {
175 int zeros = SkCLZ(value << 8);
176 SkASSERT(zeros >= 0 && zeros <= 23);
177 value <<= zeros;
178 shift -= zeros;
179 }
180
181 // now value is left-aligned to 24 bits
182 SkASSERT((value >> 23) == 1);
183 SkASSERT(shift >= 0 && shift <= 255);
184
185 SkFloatIntUnion data;
186 data.fSignBitInt = (sign << 31) | (shift << 23) | (value & ~MATISSA_MAGIC_BIG);
187 return data.fFloat;
188 }
189
SkIntToFloatCast_NoOverflowCheck(int32_t value)190 float SkIntToFloatCast_NoOverflowCheck(int32_t value) {
191 if (0 == value) {
192 return 0;
193 }
194
195 int shift = EXP_BIAS;
196
197 // record the sign and make value positive
198 int sign = SkExtractSign(value);
199 value = SkApplySign(value, sign);
200
201 int zeros = SkCLZ(value << 8);
202 value <<= zeros;
203 shift -= zeros;
204
205 SkFloatIntUnion data;
206 data.fSignBitInt = (sign << 31) | (shift << 23) | (value & ~MATISSA_MAGIC_BIG);
207 return data.fFloat;
208 }
209
210 #endif
211