bool FlingState::evaluateMatrix(SkMatrix* matrix) {
if (!fActive) {
return false;
}
const float t = getseconds() - fTime0;
const float MIN_SPEED = 2;
const float K0 = 5.0;
const float K1 = 0.02;
const float speed = fSpeed0 * (sk_float_exp(- K0 * t) - K1);
if (speed <= MIN_SPEED) {
fActive = false;
return false;
}
float dist = (fSpeed0 - speed) / K0;
// printf("---- time %g speed %g dist %g\n", t, speed, dist);
float tx = fDirection.fX * dist;
float ty = fDirection.fY * dist;
if (DISCRETIZE_TRANSLATE_TO_AVOID_FLICKER) {
tx = sk_float_round2int(tx);
ty = sk_float_round2int(ty);
}
matrix->setTranslate(tx, ty);
// printf("---- evaluate (%g %g)\n", tx, ty);
return true;
}
void SkTouchGesture::touchMoved(void* owner, float x, float y) {
// SkDebugf("--- %d touchMoved %p %g %g\n", fTouches.count(), owner, x, y);
if (kEmpty_State == fState) {
return;
}
int index = this->findRec(owner);
if (index < 0) {
// not found, so I guess we should add it...
SkDebugf("---- add missing begin\n");
this->appendNewRec(owner, x, y);
index = fTouches.count() - 1;
}
Rec& rec = fTouches[index];
// not sure how valuable this is
if (fTouches.count() == 2) {
if (close_enough_for_jitter(rec.fLastX, rec.fLastY, x, y)) {
// SkDebugf("--- drop touchMove, withing jitter tolerance %g %g\n", rec.fLastX - x, rec.fLastY - y);
return;
}
}
rec.fPrevX = rec.fLastX; rec.fLastX = x;
rec.fPrevY = rec.fLastY; rec.fLastY = y;
rec.fPrevT = rec.fLastT; rec.fLastT = SkTime::GetMSecs();
switch (fTouches.count()) {
case 1: {
float dx = rec.fLastX - rec.fStartX;
float dy = rec.fLastY - rec.fStartY;
dx = (float)sk_float_round2int(dx);
dy = (float)sk_float_round2int(dy);
fLocalM.setTranslate(dx, dy);
} break;
case 2: {
SkASSERT(kZoom_State == fState);
const Rec& rec0 = fTouches[0];
const Rec& rec1 = fTouches[1];
float scale = this->computePinch(rec0, rec1);
scale = this->limitTotalZoom(scale);
fLocalM.setTranslate(-center(rec0.fStartX, rec1.fStartX),
-center(rec0.fStartY, rec1.fStartY));
fLocalM.postScale(scale, scale);
fLocalM.postTranslate(center(rec0.fLastX, rec1.fLastX),
center(rec0.fLastY, rec1.fLastY));
} break;
default:
break;
}
}
void SkTMaskGamma_build_correcting_lut(uint8_t table[256], U8CPU srcI, SkScalar contrast,
const SkColorSpaceLuminance& srcConvert, SkScalar srcGamma,
const SkColorSpaceLuminance& dstConvert, SkScalar dstGamma) {
const float src = (float)srcI / 255.0f;
const float linSrc = srcConvert.toLuma(srcGamma, src);
//Guess at the dst. The perceptual inverse provides smaller visual
//discontinuities when slight changes to desaturated colors cause a channel
//to map to a different correcting lut with neighboring srcI.
//See https://code.google.com/p/chromium/issues/detail?id=141425#c59 .
const float dst = 1.0f - src;
const float linDst = dstConvert.toLuma(dstGamma, dst);
//Contrast value tapers off to 0 as the src luminance becomes white
const float adjustedContrast = SkScalarToFloat(contrast) * linDst;
//Remove discontinuity and instability when src is close to dst.
//The value 1/256 is arbitrary and appears to contain the instability.
if (fabs(src - dst) < (1.0f / 256.0f)) {
float ii = 0.0f;
for (int i = 0; i < 256; ++i, ii += 1.0f) {
float rawSrca = ii / 255.0f;
float srca = apply_contrast(rawSrca, adjustedContrast);
table[i] = SkToU8(sk_float_round2int(255.0f * srca));
}
} else {
// Avoid slow int to float conversion.
float ii = 0.0f;
for (int i = 0; i < 256; ++i, ii += 1.0f) {
// 'rawSrca += 1.0f / 255.0f' and even
// 'rawSrca = i * (1.0f / 255.0f)' can add up to more than 1.0f.
// When this happens the table[255] == 0x0 instead of 0xff.
// See http://code.google.com/p/chromium/issues/detail?id=146466
float rawSrca = ii / 255.0f;
float srca = apply_contrast(rawSrca, adjustedContrast);
SkASSERT(srca <= 1.0f);
float dsta = 1.0f - srca;
//Calculate the output we want.
float linOut = (linSrc * srca + dsta * linDst);
SkASSERT(linOut <= 1.0f);
float out = dstConvert.fromLuma(dstGamma, linOut);
//Undo what the blit blend will do.
float result = (out - dst) / (src - dst);
SkASSERT(sk_float_round2int(255.0f * result) <= 255);
table[i] = SkToU8(sk_float_round2int(255.0f * result));
}
}
}
void SkTableMaskFilter::MakeGammaTable(uint8_t table[256], SkScalar gamma) {
const float dx = 1 / 255.0f;
const float g = SkScalarToFloat(gamma);
float x = 0;
for (int i = 0; i < 256; i++) {
// float ee = powf(x, g) * 255;
table[i] = SkPin32(sk_float_round2int(powf(x, g) * 255), 0, 255);
x += dx;
}
}
static inline bool is_int(float x) {
return x == (float) sk_float_round2int(x);
}
DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(SRGBMipMaps, reporter, ctxInfo) {
GrContext* context = ctxInfo.grContext();
if (!context->caps()->srgbSupport()) {
return;
}
const int rtS = 16;
const int texS = rtS * 2;
// Fill texture with a dither of black and 60% sRGB (~ 32.5% linear) gray. Although there is
// only one likely failure mode (doing a direct downsample of the sRGB values), this pattern
// maximizes the minimum error across all three conceivable failure modes:
// 1) Likely incorrect:
// (A + B) / 2
// 2) No input decode, decode output:
// linear_to_srgb((A + B) / 2)
// 3) Decode input, no output encode:
// (srgb_to_linear(A) + srgb_to_linear(B)) / 2
const U8CPU srgb60 = sk_float_round2int(0.6f * 255.0f);
static const SkPMColor colors[2] = {
SkPackARGB32(0xFF, srgb60, srgb60, srgb60),
SkPackARGB32(0xFF, 0x00, 0x00, 0x00)
};
uint32_t texData[texS * texS];
for (int y = 0; y < texS; ++y) {
for (int x = 0; x < texS; ++x) {
texData[y * texS + x] = colors[(x + y) % 2];
}
}
// We can be pretty generous with the error detection, thanks to the choice of input.
// The closest likely failure mode is off by > 0.1, so anything that encodes within
// 10/255 of optimal is more than good enough for this test.
const U8CPU expectedSRGB = sk_float_round2int(
linear_to_srgb(srgb_to_linear(srgb60 / 255.0f) / 2.0f) * 255.0f);
const U8CPU expectedLinear = srgb60 / 2;
const U8CPU error = 10;
// Create our test texture
GrSurfaceDesc desc;
desc.fFlags = kNone_GrSurfaceFlags;
desc.fConfig = kSRGBA_8888_GrPixelConfig;
desc.fWidth = texS;
desc.fHeight = texS;
GrTextureProvider* texProvider = context->textureProvider();
SkAutoTUnref<GrTexture> texture(texProvider->createTexture(desc, SkBudgeted::kNo, texData, 0));
// Create two render target contexts (L32 and S32)
sk_sp<SkColorSpace> srgbColorSpace = SkColorSpace::MakeNamed(SkColorSpace::kSRGB_Named);
sk_sp<GrRenderTargetContext> l32RenderTargetContext = context->makeRenderTargetContext(
SkBackingFit::kExact, rtS, rtS, kRGBA_8888_GrPixelConfig, nullptr);
sk_sp<GrRenderTargetContext> s32RenderTargetContext = context->makeRenderTargetContext(
SkBackingFit::kExact, rtS, rtS, kSRGBA_8888_GrPixelConfig, std::move(srgbColorSpace));
SkRect rect = SkRect::MakeWH(SkIntToScalar(rtS), SkIntToScalar(rtS));
GrNoClip noClip;
GrPaint paint;
paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
GrTextureParams mipMapParams(SkShader::kRepeat_TileMode, GrTextureParams::kMipMap_FilterMode);
paint.addColorTextureProcessor(texture, nullptr, SkMatrix::MakeScale(0.5f), mipMapParams);
// 1) Draw texture to S32 surface (should generate/use sRGB mips)
paint.setGammaCorrect(true);
s32RenderTargetContext->drawRect(noClip, paint, SkMatrix::I(), rect);
read_and_check_pixels(reporter, s32RenderTargetContext->asTexture().get(), expectedSRGB, error,
"first render of sRGB");
// 2) Draw texture to L32 surface (should generate/use linear mips)
paint.setGammaCorrect(false);
l32RenderTargetContext->drawRect(noClip, paint, SkMatrix::I(), rect);
read_and_check_pixels(reporter, l32RenderTargetContext->asTexture().get(), expectedLinear,
error, "re-render as linear");
// 3) Go back to sRGB
paint.setGammaCorrect(true);
s32RenderTargetContext->drawRect(noClip, paint, SkMatrix::I(), rect);
read_and_check_pixels(reporter, s32RenderTargetContext->asTexture().get(), expectedSRGB, error,
"re-render as sRGB");
}
