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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
|
/*
* Copyright 2011 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkFloatBits.h"
#include "SkMathPriv.h"
/******************************************************************************
SkFloatBits_toInt[Floor, Round, Ceil] are identical except for what they
do right before they return ... >> exp;
Floor - adds nothing
Round - adds 1 << (exp - 1)
Ceil - adds (1 << exp) - 1
Floor and Cast are very similar, but Cast applies its sign after all other
computations on value. Also, Cast does not need to check for negative zero,
as that value (0x80000000) "does the right thing" for Ceil. Note that it
doesn't for Floor/Round/Ceil, hence the explicit check.
******************************************************************************/
#define EXP_BIAS (127+23)
#define MATISSA_MAGIC_BIG (1 << 23)
static inline int unpack_exp(uint32_t packed) {
return (packed << 1 >> 24);
}
#if 0
// the ARM compiler generates an extra BIC, so I use the dirty version instead
static inline int unpack_matissa(uint32_t packed) {
// we could mask with 0x7FFFFF, but that is harder for ARM to encode
return (packed & ~0xFF000000) | MATISSA_MAGIC_BIG;
}
#endif
// returns the low 24-bits, so we need to OR in the magic_bit afterwards
static inline int unpack_matissa_dirty(uint32_t packed) {
return packed & ~0xFF000000;
}
// same as (int)float
int32_t SkFloatBits_toIntCast(int32_t packed) {
int exp = unpack_exp(packed) - EXP_BIAS;
int value = unpack_matissa_dirty(packed) | MATISSA_MAGIC_BIG;
if (exp >= 0) {
if (exp > 7) { // overflow
value = SK_MaxS32;
} else {
value <<= exp;
}
} else {
exp = -exp;
if (exp > 25) { // underflow
exp = 25;
}
value >>= exp;
}
return SkApplySign(value, SkExtractSign(packed));
}
// same as (int)floor(float)
int32_t SkFloatBits_toIntFloor(int32_t packed) {
// curse you negative 0
if (SkLeftShift(packed, 1) == 0) {
return 0;
}
int exp = unpack_exp(packed) - EXP_BIAS;
int value = unpack_matissa_dirty(packed) | MATISSA_MAGIC_BIG;
if (exp >= 0) {
if (exp > 7) { // overflow
value = SK_MaxS32;
} else {
value <<= exp;
}
// apply the sign after we check for overflow
return SkApplySign(value, SkExtractSign(packed));
} else {
// apply the sign before we right-shift
value = SkApplySign(value, SkExtractSign(packed));
exp = -exp;
if (exp > 25) { // underflow
#ifdef SK_CPU_FLUSH_TO_ZERO
// The iOS ARM processor discards small denormalized numbers to go faster.
// The comparision below empirically causes the result to agree with the
// tests in MathTest test_float_floor
if (exp > 149) {
return 0;
}
#else
exp = 25;
#endif
}
// int add = 0;
return value >> exp;
}
}
// same as (int)floor(float + 0.5)
int32_t SkFloatBits_toIntRound(int32_t packed) {
// curse you negative 0
if (SkLeftShift(packed, 1) == 0) {
return 0;
}
int exp = unpack_exp(packed) - EXP_BIAS;
int value = unpack_matissa_dirty(packed) | MATISSA_MAGIC_BIG;
if (exp >= 0) {
if (exp > 7) { // overflow
value = SK_MaxS32;
} else {
value <<= exp;
}
// apply the sign after we check for overflow
return SkApplySign(value, SkExtractSign(packed));
} else {
// apply the sign before we right-shift
value = SkApplySign(value, SkExtractSign(packed));
exp = -exp;
if (exp > 25) { // underflow
exp = 25;
}
int add = 1 << (exp - 1);
return (value + add) >> exp;
}
}
// same as (int)ceil(float)
int32_t SkFloatBits_toIntCeil(int32_t packed) {
// curse you negative 0
if (SkLeftShift(packed, 1) == 0) {
return 0;
}
int exp = unpack_exp(packed) - EXP_BIAS;
int value = unpack_matissa_dirty(packed) | MATISSA_MAGIC_BIG;
if (exp >= 0) {
if (exp > 7) { // overflow
value = SK_MaxS32;
} else {
value <<= exp;
}
// apply the sign after we check for overflow
return SkApplySign(value, SkExtractSign(packed));
} else {
// apply the sign before we right-shift
value = SkApplySign(value, SkExtractSign(packed));
exp = -exp;
if (exp > 25) { // underflow
#ifdef SK_CPU_FLUSH_TO_ZERO
// The iOS ARM processor discards small denormalized numbers to go faster.
// The comparision below empirically causes the result to agree with the
// tests in MathTest test_float_ceil
if (exp > 149) {
return 0;
}
return 0 < value;
#else
exp = 25;
#endif
}
int add = (1 << exp) - 1;
return (value + add) >> exp;
}
}
float SkIntToFloatCast(int32_t value) {
if (0 == value) {
return 0;
}
int shift = EXP_BIAS;
// record the sign and make value positive
int sign = SkExtractSign(value);
value = SkApplySign(value, sign);
if (value >> 24) { // value is too big (has more than 24 bits set)
int bias = 8 - SkCLZ(value);
SkDebugf("value = %d, bias = %d\n", value, bias);
SkASSERT(bias > 0 && bias < 8);
value >>= bias; // need to round?
shift += bias;
} else {
int zeros = SkCLZ(value << 8);
SkASSERT(zeros >= 0 && zeros <= 23);
value <<= zeros;
shift -= zeros;
}
// now value is left-aligned to 24 bits
SkASSERT((value >> 23) == 1);
SkASSERT(shift >= 0 && shift <= 255);
SkFloatIntUnion data;
data.fSignBitInt = SkLeftShift(sign, 31) | SkLeftShift(shift, 23) | (value & ~MATISSA_MAGIC_BIG);
return data.fFloat;
}
|
