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

Revert of Revert[2] of add ImageShader, sharing code with its Bitmap cousin (patchset #11 id:200001 of https://codereview.chromium.org/1352293002/ )

Browse Source 
Reason for revert:
guess: Need to handle NPOT support in shader case

Original issue's description:
> Revert[2] of add ImageShader, sharing code with its Bitmap cousin
>
> Adjustment from previous land : runtime check for npot-support when texture is requested for tiling.
>
> (patchset #10 id:180001 of https://codereview.chromium.org/1342113002/ )
>
> This reverts commit f260851362.
>
> BUG=skia:4365
>
> Committed: https://skia.googlesource.com/skia/+/fe05707c356d2a8c2c69222591d4cafbd456b4e5

TBR=fmalita@chromium.org,robertphillips@google.com,bsalomon@google.com,reed@chromium.org
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=skia:4365

Review URL: https://codereview.chromium.org/1375673002
This commit is contained in:
reed 2015-09-28 10:26:51 -07:00 committed by Commit bot
parent c9e190ddac
commit 476506d070
9 changed files with 40 additions and 207 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
gyp/core.gypi
View File

@ -254,8 +254,6 @@
'<(skia_src_path)/image/SkImage_Generator.cpp',
# '<(skia_src_path)/image/SkImage_Gpu.cpp',
'<(skia_src_path)/image/SkImage_Raster.cpp',
'<(skia_src_path)/image/SkImageShader.cpp',
'<(skia_src_path)/image/SkImageShader.h',
'<(skia_src_path)/image/SkSurface.cpp',
'<(skia_src_path)/image/SkSurface_Base.h',
# '<(skia_src_path)/image/SkSurface_Gpu.cpp',

3
src/image/SkImage.cpp
View File

@ -11,7 +11,6 @@
#include "SkData.h"
#include "SkImageGenerator.h"
#include "SkImagePriv.h"
#include "SkImageShader.h"
#include "SkImage_Base.h"
#include "SkNextID.h"
#include "SkPixelRef.h"
@ -70,7 +69,7 @@ void SkImage::preroll(GrContext* ctx) const {
SkShader* SkImage::newShader(SkShader::TileMode tileX,
SkShader::TileMode tileY,
const SkMatrix* localMatrix) const {
return SkImageShader::Create(this, tileX, tileY, localMatrix);
return as_IB(this)->onNewShader(tileX, tileY, localMatrix);
}
SkData* SkImage::encode(SkImageEncoder::Type type, int quality) const {

144
src/image/SkImageShader.cpp
View File

@ -1,144 +0,0 @@
/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkBitmapProcShader.h"
#include "SkBitmapProvider.h"
#include "SkImage_Base.h"
#include "SkImageShader.h"
#include "SkReadBuffer.h"
#include "SkWriteBuffer.h"
SkImageShader::SkImageShader(const SkImage* img, TileMode tmx, TileMode tmy, const SkMatrix* matrix)
: INHERITED(matrix)
, fImage(SkRef(img))
, fTileModeX(tmx)
, fTileModeY(tmy)
{}
SkFlattenable* SkImageShader::CreateProc(SkReadBuffer& buffer) {
const TileMode tx = (TileMode)buffer.readUInt();
const TileMode ty = (TileMode)buffer.readUInt();
SkMatrix matrix;
buffer.readMatrix(&matrix);
SkAutoTUnref<SkImage> img(buffer.readImage());
if (!img) {
return nullptr;
}
return new SkImageShader(img, tx, ty, &matrix);
}
void SkImageShader::flatten(SkWriteBuffer& buffer) const {
buffer.writeUInt(fTileModeX);
buffer.writeUInt(fTileModeY);
buffer.writeMatrix(this->getLocalMatrix());
buffer.writeImage(fImage);
}
bool SkImageShader::isOpaque() const {
return fImage->isOpaque();
}
size_t SkImageShader::contextSize() const {
return SkBitmapProcShader::ContextSize();
}
SkShader::Context* SkImageShader::onCreateContext(const ContextRec& rec, void* storage) const {
return SkBitmapProcShader::MakeContext(*this, fTileModeX, fTileModeY,
SkBitmapProvider(fImage), rec, storage);
}
SkShader* SkImageShader::Create(const SkImage* image, TileMode tx, TileMode ty,
const SkMatrix* localMatrix) {
if (!image) {
return nullptr;
}
return new SkImageShader(image, tx, ty, localMatrix);
}
#ifndef SK_IGNORE_TO_STRING
void SkImageShader::toString(SkString* str) const {
const char* gTileModeName[SkShader::kTileModeCount] = {
"clamp", "repeat", "mirror"
};
str->appendf("ImageShader: ((%s %s) ", gTileModeName[fTileModeX], gTileModeName[fTileModeY]);
fImage->toString(str);
this->INHERITED::toString(str);
str->append(")");
}
#endif
///////////////////////////////////////////////////////////////////////////////////////////////////
#if SK_SUPPORT_GPU
#include "GrTextureAccess.h"
#include "SkGr.h"
#include "effects/GrSimpleTextureEffect.h"
#include "effects/GrBicubicEffect.h"
#include "effects/GrSimpleTextureEffect.h"
const GrFragmentProcessor* SkImageShader::asFragmentProcessor(GrContext* context,
const SkMatrix& viewM,
const SkMatrix* localMatrix,
SkFilterQuality filterQuality,
GrProcessorDataManager* mgr) const {
SkMatrix matrix;
matrix.setIDiv(fImage->width(), fImage->height());
SkMatrix lmInverse;
if (!this->getLocalMatrix().invert(&lmInverse)) {
return nullptr;
}
if (localMatrix) {
SkMatrix inv;
if (!localMatrix->invert(&inv)) {
return nullptr;
}
lmInverse.postConcat(inv);
}
matrix.preConcat(lmInverse);
SkShader::TileMode tm[] = { fTileModeX, fTileModeY };
// Must set wrap and filter on the sampler before requesting a texture. In two places below
// we check the matrix scale factors to determine how to interpret the filter quality setting.
// This completely ignores the complexity of the drawVertices case where explicit local coords
// are provided by the caller.
bool doBicubic;
GrTextureParams::FilterMode textureFilterMode =
GrSkFilterQualityToGrFilterMode(filterQuality, viewM, this->getLocalMatrix(), &doBicubic);
GrTextureParams params(tm, textureFilterMode);
SkImageUsageType usageType;
if (kClamp_TileMode == fTileModeX && kClamp_TileMode == fTileModeY) {
usageType = kUntiled_SkImageUsageType;
} else if (GrTextureParams::kNone_FilterMode == textureFilterMode) {
usageType = kTiled_Unfiltered_SkImageUsageType;
} else {
usageType = kTiled_Filtered_SkImageUsageType;
}
SkAutoTUnref<GrTexture> texture(as_IB(fImage)->asTextureRef(context, usageType));
if (!texture) {
return nullptr;
}
SkAutoTUnref<GrFragmentProcessor> inner;
if (doBicubic) {
inner.reset(GrBicubicEffect::Create(mgr, texture, matrix, tm));
} else {
inner.reset(GrSimpleTextureEffect::Create(mgr, texture, matrix, params));
}
if (GrPixelConfigIsAlphaOnly(texture->config())) {
return SkRef(inner.get());
}
return GrFragmentProcessor::MulOutputByInputAlpha(inner);
}
#endif

44
src/image/SkImageShader.h
View File

@ -1,44 +0,0 @@
/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkImageShader_DEFINED
#define SkImageShader_DEFINED
#include "SkImage.h"
#include "SkShader.h"
class SkImageShader : public SkShader {
public:
static SkShader* Create(const SkImage*, TileMode tx, TileMode ty, const SkMatrix* localMatrix);
bool isOpaque() const override;
size_t contextSize() const override;
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkImageShader)
#if SK_SUPPORT_GPU
const GrFragmentProcessor* asFragmentProcessor(GrContext*, const SkMatrix& viewM,
const SkMatrix*, SkFilterQuality,
GrProcessorDataManager*) const override;
#endif
protected:
void flatten(SkWriteBuffer&) const override;
Context* onCreateContext(const ContextRec&, void* storage) const override;
SkAutoTUnref<const SkImage> fImage;
const TileMode fTileModeX;
const TileMode fTileModeY;
private:
SkImageShader(const SkImage*, TileMode tx, TileMode ty, const SkMatrix* localMatrix);
typedef SkShader INHERITED;
};
#endif

5
src/image/SkImage_Base.h
View File

@ -54,8 +54,11 @@ public:
// Caller must call unref when they are done.
virtual GrTexture* asTextureRef(GrContext*, SkImageUsageType) const = 0;
virtual SkImage* onNewSubset(const SkIRect&) const = 0;
virtual SkShader* onNewShader(SkShader::TileMode,
SkShader::TileMode,
const SkMatrix* localMatrix) const { return nullptr; }
virtual SkImage* onNewSubset(const SkIRect&) const = 0;
virtual SkData* onRefEncoded() const { return nullptr; }
virtual bool onAsLegacyBitmap(SkBitmap*, LegacyBitmapMode) const;

16
src/image/SkImage_Generator.cpp
View File

@ -28,6 +28,11 @@ public:
SkImage* onNewSubset(const SkIRect&) const override;
bool getROPixels(SkBitmap*) const override;
GrTexture* asTextureRef(GrContext*, SkImageUsageType) const override;
SkShader* onNewShader(SkShader::TileMode,
SkShader::TileMode,
const SkMatrix* localMatrix) const override;
bool onIsLazyGenerated() const override { return true; }
private:
@ -38,6 +43,17 @@ private:
///////////////////////////////////////////////////////////////////////////////
SkShader* SkImage_Generator::onNewShader(SkShader::TileMode tileX, SkShader::TileMode tileY,
const SkMatrix* localMatrix) const {
// TODO: need a native Shader that takes Cacherator (or this image) so we can natively return
// textures as output from the shader.
SkBitmap bm;
if (this->getROPixels(&bm)) {
return SkShader::CreateBitmapShader(bm, tileX, tileY, localMatrix);
}
return nullptr;
}
bool SkImage_Generator::onReadPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRB,
int srcX, int srcY) const {
SkBitmap bm;

21
src/image/SkImage_Gpu.cpp
View File

@ -7,7 +7,6 @@
#include "SkBitmapCache.h"
#include "SkImage_Gpu.h"
#include "GrCaps.h"
#include "GrContext.h"
#include "GrDrawContext.h"
#include "effects/GrYUVtoRGBEffect.h"
@ -36,6 +35,13 @@ extern void SkTextureImageApplyBudgetedDecision(SkImage* image) {
}
}
SkShader* SkImage_Gpu::onNewShader(SkShader::TileMode tileX, SkShader::TileMode tileY,
const SkMatrix* localMatrix) const {
SkBitmap bm;
GrWrapTextureInBitmap(fTexture, this->width(), this->height(), this->isOpaque(), &bm);
return SkShader::CreateBitmapShader(bm, tileX, tileY, localMatrix);
}
bool SkImage_Gpu::getROPixels(SkBitmap* dst) const {
if (SkBitmapCache::Find(this->uniqueID(), dst)) {
SkASSERT(dst->getGenerationID() == this->uniqueID());
@ -60,19 +66,6 @@ bool SkImage_Gpu::getROPixels(SkBitmap* dst) const {
}
GrTexture* SkImage_Gpu::asTextureRef(GrContext* ctx, SkImageUsageType usage) const {
const bool is_pow2 = SkIsPow2(this->width()) && SkIsPow2(this->height());
const bool npot_tex_supported = ctx->caps()->npotTextureTileSupport();
if (!is_pow2 && kUntiled_SkImageUsageType != usage && !npot_tex_supported) {
// load as bitmap, since the GPU can support tiling a non-pow2 texture
// related to skbug.com/4365
SkBitmap bitmap;
if (this->getROPixels(&bitmap)) {
return GrRefCachedBitmapTexture(ctx, bitmap, usage);
} else {
return nullptr;
}
}
fTexture->ref();
return fTexture;
}

3
src/image/SkImage_Gpu.h
View File

@ -40,6 +40,9 @@ public:
SkImage* onNewSubset(const SkIRect&) const override;
GrTexture* peekTexture() const override { return fTexture; }
SkShader* onNewShader(SkShader::TileMode,
SkShader::TileMode,
const SkMatrix* localMatrix) const override;
bool isOpaque() const override;
bool onReadPixels(const SkImageInfo&, void* dstPixels, size_t dstRowBytes,
int srcX, int srcY) const override;

9
src/image/SkImage_Raster.cpp
View File

@ -80,6 +80,10 @@ public:
SkPixelRef* getPixelRef() const { return fBitmap.pixelRef(); }
SkShader* onNewShader(SkShader::TileMode,
SkShader::TileMode,
const SkMatrix* localMatrix) const override;
bool isOpaque() const override;
bool onAsLegacyBitmap(SkBitmap*, LegacyBitmapMode) const override;
@ -140,6 +144,11 @@ SkImage_Raster::SkImage_Raster(const Info& info, SkPixelRef* pr, const SkIPoint&
SkImage_Raster::~SkImage_Raster() {}
SkShader* SkImage_Raster::onNewShader(SkShader::TileMode tileX, SkShader::TileMode tileY,
const SkMatrix* localMatrix) const {
return SkShader::CreateBitmapShader(fBitmap, tileX, tileY, localMatrix);
}
bool SkImage_Raster::onReadPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes,
int srcX, int srcY) const {
SkBitmap shallowCopy(fBitmap);