static void src_1(SkBlendMode, uint64_t dst[], const SkPM4f* src, int count, const SkAlpha aa[]) {
const Sk4f s4 = Sk4f::Load(src->fVec);
if (aa) {
for (int i = 0; i < count; ++i) {
const Sk4f d4 = SkHalfToFloat_finite_ftz(dst[i]);
SkFloatToHalf_finite_ftz(lerp_by_coverage(s4, d4, aa[i])).store(&dst[i]);
}
} else {
uint64_t s4h;
SkFloatToHalf_finite_ftz(s4).store(&s4h);
sk_memset64(dst, s4h, count);
}
}
static void srcover_1(const SkXfermode*, uint64_t dst[], const SkPM4f* src, int count,
const SkAlpha aa[]) {
const Sk4f s4 = Sk4f::Load(src->fVec);
const Sk4f dst_scale = Sk4f(1 - get_alpha(s4));
for (int i = 0; i < count; ++i) {
const Sk4f d4 = SkHalfToFloat_finite_ftz(dst[i]);
const Sk4f r4 = s4 + d4 * dst_scale;
if (aa) {
SkFloatToHalf_finite_ftz(lerp_by_coverage(r4, d4, aa[i])).store(&dst[i]);
} else {
SkFloatToHalf_finite_ftz(r4).store(&dst[i]);
}
}
}
static void src_n(SkBlendMode, uint64_t dst[], const SkPM4f src[], int count, const SkAlpha aa[]) {
if (aa) {
for (int i = 0; i < count; ++i) {
const Sk4f s4 = Sk4f::Load(src[i].fVec);
const Sk4f d4 = SkHalfToFloat_finite_ftz(dst[i]);
SkFloatToHalf_finite_ftz(lerp_by_coverage(s4, d4, aa[i])).store(&dst[i]);
}
} else {
for (int i = 0; i < count; ++i) {
const Sk4f s4 = Sk4f::Load(src[i].fVec);
SkFloatToHalf_finite_ftz(s4).store(&dst[i]);
}
}
}
DEF_TEST(SkFloatToHalf_finite_ftz, r) {
#if 0
for (uint64_t bits = 0; bits <= 0xffffffff; bits++) {
#else
SkRandom rand;
for (int i = 0; i < 1000000; i++) {
uint32_t bits = rand.nextU();
#endif
float f;
memcpy(&f, &bits, 4);
uint16_t expected = SkFloatToHalf(f);
if (!is_finite(expected)) {
// _finite_ftz() only works for values that can be represented as a finite half float.
continue;
}
uint16_t alternate = expected;
if (is_denorm(expected)) {
// _finite_ftz() may flush denorms to zero, and happens to keep the sign bit.
alternate = signbit(f) ? 0x8000 : 0x0000;
}
uint16_t actual = SkFloatToHalf_finite_ftz(Sk4f{f})[0];
// _finite_ftz() may truncate instead of rounding, so it may be one too small.
REPORTER_ASSERT(r, actual == expected || actual == expected - 1 ||
actual == alternate || actual == alternate - 1);
}
}
GrProcessorSet::Analysis GrFillRRectOp::finalize(const GrCaps& caps, const GrAppliedClip* clip,
GrFSAAType fsaaType, GrClampType clampType) {
SkASSERT(1 == fInstanceCount);
SkPMColor4f overrideColor;
const GrProcessorSet::Analysis& analysis = fProcessors.finalize(
fOriginalColor, GrProcessorAnalysisCoverage::kSingleChannel, clip,
&GrUserStencilSettings::kUnused, fsaaType, caps, clampType, &overrideColor);
// Finish writing the instance attribs.
SkPMColor4f finalColor = analysis.inputColorIsOverridden() ? overrideColor : fOriginalColor;
if (!SkPMColor4fFitsInBytes(finalColor)) {
fFlags |= Flags::kWideColor;
uint32_t halfColor[2];
SkFloatToHalf_finite_ftz(Sk4f::Load(finalColor.vec())).store(&halfColor);
this->writeInstanceData(halfColor[0], halfColor[1]);
} else {
this->writeInstanceData(finalColor.toBytes_RGBA());
}
if (analysis.usesLocalCoords()) {
this->writeInstanceData(fLocalRect);
fFlags |= Flags::kHasLocalCoords;
}
fInstanceStride = fInstanceData.count();
return analysis;
}
static void xfer_n(const SkXfermode* xfer, uint64_t dst[], const SkPM4f src[], int count,
const SkAlpha aa[]) {
SkXfermodeProc4f proc = xfer->getProc4f();
SkPM4f d;
if (aa) {
for (int i = 0; i < count; ++i) {
Sk4f d4 = SkHalfToFloat_finite_ftz(dst[i]);
d4.store(d.fVec);
Sk4f r4 = Sk4f::Load(proc(src[i], d).fVec);
SkFloatToHalf_finite_ftz(lerp_by_coverage(r4, d4, aa[i])).store(&dst[i]);
}
} else {
for (int i = 0; i < count; ++i) {
SkHalfToFloat_finite_ftz(dst[i]).store(d.fVec);
Sk4f r4 = Sk4f::Load(proc(src[i], d).fVec);
SkFloatToHalf_finite_ftz(r4).store(&dst[i]);
}
}
}
static void xfer_1(SkBlendMode mode, uint64_t dst[], const SkPM4f* src, int count,
const SkAlpha aa[]) {
SkXfermodeProc4f proc = SkXfermode::GetProc4f(mode);
SkPM4f d;
if (aa) {
for (int i = 0; i < count; ++i) {
Sk4f d4 = SkHalfToFloat_finite_ftz(dst[i]);
d4.store(d.fVec);
Sk4f r4 = Sk4f::Load(proc(*src, d).fVec);
SkFloatToHalf_finite_ftz(lerp_by_coverage(r4, d4, aa[i])).store(&dst[i]);
}
} else {
for (int i = 0; i < count; ++i) {
SkHalfToFloat_finite_ftz(dst[i]).store(d.fVec);
Sk4f r4 = Sk4f::Load(proc(*src, d).fVec);
SkFloatToHalf_finite_ftz(r4).store(&dst[i]);
}
}
}
static void clear(const SkXfermode*, uint64_t dst[], const SkPM4f*, int count, const SkAlpha aa[]) {
if (aa) {
for (int i = 0; i < count; ++i) {
if (aa[i]) {
const Sk4f d4 = SkHalfToFloat_finite_ftz(dst[i]);
SkFloatToHalf_finite_ftz(d4 * Sk4f((255 - aa[i]) * 1.0f/255)).store(&dst[i]);
}
}
} else {
sk_memset64(dst, 0, count);
}
}
static void srcover_n(const SkXfermode*, uint64_t dst[], const SkPM4f src[], int count,
const SkAlpha aa[]) {
for (int i = 0; i < count; ++i) {
Sk4f s = Sk4f::Load(src+i),
d = SkHalfToFloat_finite_ftz(dst[i]),
r = s + d*(1.0f - SkNx_shuffle<3,3,3,3>(s));
if (aa) {
r = lerp_by_coverage(r, d, aa[i]);
}
SkFloatToHalf_finite_ftz(r).store(&dst[i]);
}
}
static void clamp_if_necessary(const SkImageInfo& info, void* pixels) {
if (kRGBA_F16_SkColorType != info.colorType()) {
return;
}
for (int y = 0; y < info.height(); y++) {
for (int x = 0; x < info.width(); x++) {
uint64_t pixel = ((uint64_t*) pixels)[y * info.width() + x];
Sk4f rgba = SkHalfToFloat_finite_ftz(pixel);
if (kUnpremul_SkAlphaType == info.alphaType()) {
rgba = Sk4f::Max(0.0f, Sk4f::Min(rgba, 1.0f));
} else {
SkASSERT(kPremul_SkAlphaType == info.alphaType());
rgba = Sk4f::Max(0.0f, Sk4f::Min(rgba, rgba[3]));
}
SkFloatToHalf_finite_ftz(rgba).store(&pixel);
((uint64_t*) pixels)[y * info.width() + x] = pixel;
}
}
}
static uint64_t Compact(const Sk4f& x) {
uint64_t r;
SkFloatToHalf_finite_ftz(x).store(&r);
return r;
}
