AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

remove dead code after HQ change

Browse Source 
BUG=skia:

Review URL: https://codereview.chromium.org/845303005
This commit is contained in:
reed 2015-01-20 08:50:37 -08:00 committed by Commit bot
parent c7bfd5b441
commit 94443b8718
6 changed files with 0 additions and 395 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

112
src/core/SkBitmapFilter.cpp
View File

@ -22,86 +22,6 @@
// the image is rotated or has some other complex transformation applied.
// Scaled images will usually be rescaled directly before rasterization.
namespace {
template <typename Color, typename ColorPacker>
void highQualityFilter(ColorPacker pack, const SkBitmapProcState& s, int x, int y, Color* SK_RESTRICT colors, int count) {
const int maxX = s.fBitmap->width();
const int maxY = s.fBitmap->height();
SkAutoTMalloc<SkScalar> xWeights(maxX);
const SkBitmapFilter* filter = s.getBitmapFilter();
while (count-- > 0) {
SkPoint srcPt;
s.fInvProc(s.fInvMatrix, x + 0.5f,
y + 0.5f, &srcPt);
srcPt.fX -= SK_ScalarHalf;
srcPt.fY -= SK_ScalarHalf;
SkScalar weight = 0;
SkScalar fr = 0, fg = 0, fb = 0, fa = 0;
int y0 = SkClampMax(SkScalarCeilToInt(srcPt.fY - filter->width()), maxY);
int y1 = SkClampMax(SkScalarFloorToInt(srcPt.fY + filter->width() + 1), maxY);
int x0 = SkClampMax(SkScalarCeilToInt(srcPt.fX - filter->width()), maxX);
int x1 = SkClampMax(SkScalarFloorToInt(srcPt.fX + filter->width()) + 1, maxX);
for (int srcX = x0; srcX < x1 ; srcX++) {
// Looking these up once instead of each loop is a ~15% speedup.
xWeights[srcX - x0] = filter->lookupScalar((srcPt.fX - srcX));
}
for (int srcY = y0; srcY < y1; srcY++) {
SkScalar yWeight = filter->lookupScalar((srcPt.fY - srcY));
for (int srcX = x0; srcX < x1 ; srcX++) {
SkScalar xWeight = xWeights[srcX - x0];
SkScalar combined_weight = SkScalarMul(xWeight, yWeight);
weight += combined_weight;
SkPMColor c = *s.fBitmap->getAddr32(srcX, srcY);
if (!c) {
continue;
}
fr += combined_weight * SkGetPackedR32(c);
fg += combined_weight * SkGetPackedG32(c);
fb += combined_weight * SkGetPackedB32(c);
fa += combined_weight * SkGetPackedA32(c);
}
}
fr = SkScalarDiv(fr, weight);
fg = SkScalarDiv(fg, weight);
fb = SkScalarDiv(fb, weight);
fa = SkScalarDiv(fa, weight);
int a = SkClampMax(SkScalarRoundToInt(fa), 255);
int r = SkClampMax(SkScalarRoundToInt(fr), a);
int g = SkClampMax(SkScalarRoundToInt(fg), a);
int b = SkClampMax(SkScalarRoundToInt(fb), a);
*colors++ = pack(a, r, g, b);
x++;
}
}
uint16_t PackTo565(int /*a*/, int r, int g, int b) {
return SkPack888ToRGB16(r, g, b);
}
} // namespace
void highQualityFilter32(const SkBitmapProcState& s, int x, int y, SkPMColor* SK_RESTRICT colors, int count) {
highQualityFilter(&SkPackARGB32, s, x, y, colors, count);
}
void highQualityFilter16(const SkBitmapProcState& s, int x, int y, uint16_t* SK_RESTRICT colors, int count) {
highQualityFilter(&PackTo565, s, x, y, colors, count);
}
SK_CONF_DECLARE(const char *, c_bitmapFilter, "bitmap.filter", "mitchell", "Which scanline bitmap filter to use [mitchell, lanczos, hamming, gaussian, triangle, box]");
SkBitmapFilter *SkBitmapFilter::Allocate() {
@ -124,35 +44,3 @@ SkBitmapFilter *SkBitmapFilter::Allocate() {
return NULL;
}
bool SkBitmapProcState::setBitmapFilterProcs() {
if (fFilterLevel != SkPaint::kHigh_FilterLevel) {
return false;
}
if (fAlphaScale != 256) {
return false;
}
// TODO: consider supporting other colortypes (e.g. 565, A8)
if (fBitmap->colorType() != kN32_SkColorType) {
return false;
}
// TODO: consider supporting repeat and mirror
if (SkShader::kClamp_TileMode != fTileModeX || SkShader::kClamp_TileMode != fTileModeY) {
return false;
}
// TODO: is this right? do we want fBitmapFilter allocated even if we can't set shader procs?
if (fInvType & (SkMatrix::kAffine_Mask | SkMatrix::kScale_Mask)) {
fBitmapFilter = SkBitmapFilter::Allocate();
}
if (fInvType & SkMatrix::kScale_Mask) {
fShaderProc32 = highQualityFilter32;
fShaderProc16 = highQualityFilter16;
return true;
} else {
return false;
}
}

175
src/core/SkBitmapProcState.cpp
View File

@ -124,160 +124,6 @@ static inline bool cache_size_okay(const SkBitmap& bm, const SkMatrix& invMat) {
< (maximumAllocation * invMat.getScaleX() * invMat.getScaleY());
}
// TODO -- we may want to pass the clip into this function so we only scale
// the portion of the image that we're going to need. This will complicate
// the interface to the cache, but might be well worth it.
bool SkBitmapProcState::possiblyScaleImage() {
SkASSERT(NULL == fBitmap);
if (fFilterLevel <= SkPaint::kLow_FilterLevel) {
return false;
}
// Check to see if the transformation matrix is simple, and if we're
// doing high quality scaling. If so, do the bitmap scale here and
// remove the (non-fractional) scaling component from the matrix.
SkScalar invScaleX = fInvMatrix.getScaleX();
SkScalar invScaleY = fInvMatrix.getScaleY();
float trueDestWidth = fOrigBitmap.width() / invScaleX;
float trueDestHeight = fOrigBitmap.height() / invScaleY;
float roundedDestWidth = SkScalarRoundToScalar(trueDestWidth);
float roundedDestHeight = SkScalarRoundToScalar(trueDestHeight);
if (SkPaint::kHigh_FilterLevel == fFilterLevel &&
fInvMatrix.getType() <= (SkMatrix::kScale_Mask | SkMatrix::kTranslate_Mask) &&
kN32_SkColorType == fOrigBitmap.colorType() &&
cache_size_okay(fOrigBitmap, fInvMatrix)) {
if (SkScalarNearlyEqual(invScaleX,1.0f) &&
SkScalarNearlyEqual(invScaleY,1.0f)) {
// short-circuit identity scaling; the output is supposed to
// be the same as the input, so we might as well go fast.
// Note(humper): We could also probably do this if the scales
// are close to -1 as well, since the flip doesn't require
// any fancy re-sampling...
// Set our filter level to low -- the only post-filtering this
// image might require is some interpolation if the translation
// is fractional.
fFilterLevel = SkPaint::kLow_FilterLevel;
return false;
}
if (!SkBitmapCache::Find(fOrigBitmap, roundedDestWidth, roundedDestHeight, &fScaledBitmap)) {
// All the criteria are met; let's make a new bitmap.
if (!SkBitmapScaler::Resize(&fScaledBitmap,
fOrigBitmap,
SkBitmapScaler::RESIZE_BEST,
roundedDestWidth,
roundedDestHeight,
SkResourceCache::GetAllocator())) {
// we failed to create fScaledBitmap, so just return and let
// the scanline proc handle it.
return false;
}
SkASSERT(fScaledBitmap.getPixels());
fScaledBitmap.setImmutable();
SkBitmapCache::Add(fOrigBitmap, roundedDestWidth, roundedDestHeight, fScaledBitmap);
}
SkASSERT(fScaledBitmap.getPixels());
fBitmap = &fScaledBitmap;
// clean up the inverse matrix by incorporating the scale we just performed.
fInvMatrix.postScale(roundedDestWidth / fOrigBitmap.width(),
roundedDestHeight / fOrigBitmap.height());
// Set our filter level to low -- the only post-filtering this
// image might require is some interpolation if the translation
// is fractional or if there's any remaining scaling to be done.
fFilterLevel = SkPaint::kLow_FilterLevel;
return true;
}
/*
* If High, then our special-case for scale-only did not take, and so we
* have to make a choice:
* 1. fall back on mipmaps + bilerp
* 2. fall back on scanline bicubic filter
* For now, we compute the "scale" value from the matrix, and have a
* threshold to decide when bicubic is better, and when mips are better.
* No doubt a fancier decision tree could be used uere.
*
* If Medium, then we just try to build a mipmap and select a level,
* setting the filter-level to kLow to signal that we just need bilerp
* to process the selected level.
*/
SkScalar scaleSqd = effective_matrix_scale_sqrd(fInvMatrix);
if (SkPaint::kHigh_FilterLevel == fFilterLevel) {
// Set the limit at 0.25 for the CTM... if the CTM is scaling smaller
// than this, then the mipmaps quality may be greater (certainly faster)
// so we only keep High quality if the scale is greater than this.
//
// Since we're dealing with the inverse, we compare against its inverse.
const SkScalar bicubicLimit = 4.0f;
const SkScalar bicubicLimitSqd = bicubicLimit * bicubicLimit;
if (scaleSqd < bicubicLimitSqd) { // use bicubic scanline
return false;
}
// else set the filter-level to Medium, since we're scaling down and
// want to reqeust mipmaps
fFilterLevel = SkPaint::kMedium_FilterLevel;
}
SkASSERT(SkPaint::kMedium_FilterLevel == fFilterLevel);
/**
* Medium quality means use a mipmap for down-scaling, and just bilper
* for upscaling. Since we're examining the inverse matrix, we look for
* a scale > 1 to indicate down scaling by the CTM.
*/
if (scaleSqd > SK_Scalar1) {
fCurrMip.reset(SkMipMapCache::FindAndRef(fOrigBitmap));
if (NULL == fCurrMip.get()) {
fCurrMip.reset(SkMipMapCache::AddAndRef(fOrigBitmap));
if (NULL == fCurrMip.get()) {
return false;
}
}
// diagnostic for a crasher...
if (NULL == fCurrMip->data()) {
sk_throw();
}
SkScalar levelScale = SkScalarInvert(SkScalarSqrt(scaleSqd));
SkMipMap::Level level;
if (fCurrMip->extractLevel(levelScale, &level)) {
SkScalar invScaleFixup = level.fScale;
fInvMatrix.postScale(invScaleFixup, invScaleFixup);
const SkImageInfo info = fOrigBitmap.info().makeWH(level.fWidth, level.fHeight);
// todo: if we could wrap the fCurrMip in a pixelref, then we could just install
// that here, and not need to explicitly track it ourselves.
fScaledBitmap.installPixels(info, level.fPixels, level.fRowBytes);
fBitmap = &fScaledBitmap;
fFilterLevel = SkPaint::kLow_FilterLevel;
return true;
} else {
// failed to extract, so release the mipmap
fCurrMip.reset(NULL);
}
}
return false;
}
/*
* Extract the "best" scale factors from a matrix.
*/
@ -439,10 +285,6 @@ bool SkBitmapProcState::lockBaseBitmap() {
return true;
}
SkBitmapProcState::~SkBitmapProcState() {
SkDELETE(fBitmapFilter);
}
static bool valid_for_drawing(const SkBitmap& bm) {
if (0 == bm.width() || 0 == bm.height()) {
return false; // nothing to draw
@ -553,23 +395,6 @@ bool SkBitmapProcState::chooseProcs(const SkMatrix& inv, const SkPaint& paint) {
trivialMatrix = (fInvMatrix.getType() & ~SkMatrix::kTranslate_Mask) == 0;
if (SkPaint::kHigh_FilterLevel == fFilterLevel) {
// If this is still set, that means we wanted HQ sampling
// but couldn't do it as a preprocess. Let's try to install
// the scanline version of the HQ sampler. If that process fails,
// downgrade to bilerp.
// NOTE: Might need to be careful here in the future when we want
// to have the platform proc have a shot at this; it's possible that
// the chooseBitmapFilterProc will fail to install a shader but a
// platform-specific one might succeed, so it might be premature here
// to fall back to bilerp. This needs thought.
if (!this->setBitmapFilterProcs()) {
fFilterLevel = SkPaint::kLow_FilterLevel;
}
}
if (SkPaint::kLow_FilterLevel == fFilterLevel) {
// Only try bilerp if the matrix is "interesting" and
// the image has a suitable size.

23
src/core/SkBitmapProcState.h
View File

@ -23,10 +23,6 @@ typedef SkFixed3232 SkFractionalInt;
class SkPaint;
struct SkBitmapProcState {
SkBitmapProcState() : fBitmapFilter(NULL) {}
~SkBitmapProcState();
typedef void (*ShaderProc32)(const SkBitmapProcState&, int x, int y,
SkPMColor[], int count);
@ -107,8 +103,6 @@ struct SkBitmapProcState {
ShaderProc32 getShaderProc32() const { return fShaderProc32; }
ShaderProc16 getShaderProc16() const { return fShaderProc16; }
SkBitmapFilter* getBitmapFilter() const { return fBitmapFilter; }
#ifdef SK_DEBUG
MatrixProc getMatrixProc() const;
#else
@ -131,7 +125,6 @@ private:
SkBitmap fScaledBitmap; // chooseProcs
SkAutoTUnref<const SkMipMap> fCurrMip;
bool fAdjustedMatrix; // set by possiblyScaleImage
void processHQRequest();
void processMediumRequest();
@ -141,20 +134,10 @@ private:
bool chooseScanlineProcs(bool trivialMatrix, bool clampClamp, const SkPaint& paint);
ShaderProc32 chooseShaderProc32();
// returns false if we did not try to scale the image. In that case, we
// will need to "lock" its pixels some other way.
bool possiblyScaleImage();
// returns false if we failed to "lock" the pixels at all. Typically this
// means we have to abort the shader.
bool lockBaseBitmap();
SkBitmapFilter* fBitmapFilter;
// If supported, sets fShaderProc32 and fShaderProc16 and returns true,
// otherwise returns false.
bool setBitmapFilterProcs();
// Return false if we failed to setup for fast translate (e.g. overflow)
bool setupForTranslate();
@ -211,10 +194,4 @@ void S32_D16_filter_DX(const SkBitmapProcState& s,
void S32_D16_filter_DXDY(const SkBitmapProcState& s,
const uint32_t* xy, int count, uint16_t* colors);
void highQualityFilter32(const SkBitmapProcState &s, int x, int y,
SkPMColor *SK_RESTRICT colors, int count);
void highQualityFilter16(const SkBitmapProcState &s, int x, int y,
uint16_t *SK_RESTRICT colors, int count);
#endif

72
src/opts/SkBitmapFilter_opts_SSE2.cpp
View File

@ -40,78 +40,6 @@ static inline void print128f(__m128 value) {
}
#endif
// because the border is handled specially, this is guaranteed to have all 16 pixels
// available to it without running off the bitmap's edge.
void highQualityFilter_SSE2(const SkBitmapProcState& s, int x, int y,
SkPMColor* SK_RESTRICT colors, int count) {
const int maxX = s.fBitmap->width();
const int maxY = s.fBitmap->height();
SkAutoTMalloc<SkScalar> xWeights(maxX);
const SkBitmapFilter* filter = s.getBitmapFilter();
while (count-- > 0) {
SkPoint srcPt;
s.fInvProc(s.fInvMatrix, x + 0.5f, y + 0.5f, &srcPt);
srcPt.fX -= SK_ScalarHalf;
srcPt.fY -= SK_ScalarHalf;
__m128 weight = _mm_setzero_ps();
__m128 accum = _mm_setzero_ps();
int y0 = SkClampMax(SkScalarCeilToInt(srcPt.fY - filter->width()), maxY);
int y1 = SkClampMax(SkScalarFloorToInt(srcPt.fY + filter->width() + 1), maxY);
int x0 = SkClampMax(SkScalarCeilToInt(srcPt.fX - filter->width()), maxX);
int x1 = SkClampMax(SkScalarFloorToInt(srcPt.fX + filter->width()) + 1, maxX);
for (int srcX = x0; srcX < x1 ; srcX++) {
// Looking these up once instead of each loop is a ~15% speedup.
xWeights[srcX - x0] = filter->lookupScalar((srcPt.fX - srcX));
}
for (int srcY = y0; srcY < y1; srcY++) {
SkScalar yWeight = filter->lookupScalar((srcPt.fY - srcY));
for (int srcX = x0; srcX < x1 ; srcX++) {
SkScalar xWeight = xWeights[srcX - x0];
SkScalar combined_weight = SkScalarMul(xWeight, yWeight);
__m128 weightVector = _mm_set1_ps(combined_weight);
weight = _mm_add_ps( weight, weightVector );
SkPMColor color = *s.fBitmap->getAddr32(srcX, srcY);
if (!color) {
continue;
}
__m128i c = _mm_cvtsi32_si128(color);
c = _mm_unpacklo_epi8(c, _mm_setzero_si128());
c = _mm_unpacklo_epi16(c, _mm_setzero_si128());
__m128 cfloat = _mm_cvtepi32_ps(c);
accum = _mm_add_ps(accum, _mm_mul_ps(cfloat, weightVector));
}
}
accum = _mm_div_ps(accum, weight);
accum = _mm_add_ps(accum, _mm_set1_ps(0.5f));
__m128i accumInt = _mm_cvttps_epi32(accum);
accumInt = _mm_packs_epi32(accumInt, _mm_setzero_si128());
accumInt = _mm_packus_epi16(accumInt, _mm_setzero_si128());
SkPMColor c = _mm_cvtsi128_si32(accumInt);
int a = SkClampMax(SkGetPackedA32(c), 255);
int r = SkClampMax(SkGetPackedR32(c), a);
int g = SkClampMax(SkGetPackedG32(c), a);
int b = SkClampMax(SkGetPackedB32(c), a);
*colors++ = SkPackARGB32(a, r, g, b);
x++;
}
}
// Convolves horizontally along a single row. The row data is given in
// |src_data| and continues for the num_values() of the filter.
void convolveHorizontally_SSE2(const unsigned char* src_data,

4
src/opts/SkBitmapFilter_opts_SSE2.h
View File

@ -11,10 +11,6 @@
#include "SkBitmapProcState.h"
#include "SkConvolver.h"
void highQualityFilter_SSE2(const SkBitmapProcState &s, int x, int y,
SkPMColor *SK_RESTRICT colors, int count);
void convolveVertically_SSE2(const SkConvolutionFilter1D::ConvolutionFixed* filter_values,
int filter_length,
unsigned char* const* source_data_rows,

9
src/opts/opts_check_x86.cpp
View File

@ -130,8 +130,6 @@ static inline bool supports_simd(int minLevel) {
////////////////////////////////////////////////////////////////////////////////
SK_CONF_DECLARE( bool, c_hqfilter_sse, "bitmap.filter.highQualitySSE", true, "Use SSE optimized version of high quality image filters");
void SkBitmapScaler::PlatformConvolutionProcs(SkConvolutionProcs* procs) {
if (supports_simd(SK_CPU_SSE_LEVEL_SSE2)) {
procs->fExtraHorizontalReads = 3;
@ -195,13 +193,6 @@ void SkBitmapProcState::platformProcs() {
} else if (fMatrixProc == ClampX_ClampY_nofilter_affine) {
fMatrixProc = ClampX_ClampY_nofilter_affine_SSE2;
}
/* Check fShaderProc32 */
if (c_hqfilter_sse) {
if (fShaderProc32 == highQualityFilter32) {
fShaderProc32 = highQualityFilter_SSE2;
}
}
}
////////////////////////////////////////////////////////////////////////////////