*/
void flush();
+ /**
+ * These flags can be used with the read/write pixels functions below.
+ */
+ enum PixelOpsFlags {
+ /** The GrContext will not be flushed before the surface read or write. This means that
+ the read or write may occur before previous draws have executed. */
+ kDontFlush_PixelOpsFlag = 0x1,
+ /** Any surface writes should be flushed to the backend 3D API after the surface operation
+ is complete */
+ kFlushWrites_PixelOp = 0x2,
+ /** The src for write or dst read is unpremultiplied. This is only respected if both the
+ config src and dst configs are an RGBA/BGRA 8888 format. */
+ kUnpremul_PixelOpsFlag = 0x4,
+ };
+
+ /**
+ * Reads a rectangle of pixels from a surface.
+ * @param surface the surface to read from.
+ * @param srcColorSpace color space of the surface
+ * @param left left edge of the rectangle to read (inclusive)
+ * @param top top edge of the rectangle to read (inclusive)
+ * @param width width of rectangle to read in pixels.
+ * @param height height of rectangle to read in pixels.
+ * @param config the pixel config of the destination buffer
+ * @param dstColorSpace color space of the destination buffer
+ * @param buffer memory to read the rectangle into.
+ * @param rowBytes number of bytes bewtween consecutive rows. Zero means rows are tightly
+ * packed.
+ * @param pixelOpsFlags see PixelOpsFlags enum above.
+ *
+ * @return true if the read succeeded, false if not. The read can fail because of an unsupported
+ * pixel configs
+ */
+ bool readSurfacePixels(GrSurface* surface, SkColorSpace* srcColorSpace,
+ int left, int top, int width, int height,
+ GrPixelConfig config, SkColorSpace* dstColorSpace, void* buffer,
+ size_t rowBytes = 0,
+ uint32_t pixelOpsFlags = 0);
+
+ /**
+ * Writes a rectangle of pixels to a surface.
+ * @param surface the surface to write to.
+ * @param dstColorSpace color space of the surface
+ * @param left left edge of the rectangle to write (inclusive)
+ * @param top top edge of the rectangle to write (inclusive)
+ * @param width width of rectangle to write in pixels.
+ * @param height height of rectangle to write in pixels.
+ * @param config the pixel config of the source buffer
+ * @param srcColorSpace color space of the source buffer
+ * @param buffer memory to read pixels from
+ * @param rowBytes number of bytes between consecutive rows. Zero
+ * means rows are tightly packed.
+ * @param pixelOpsFlags see PixelOpsFlags enum above.
+ * @return true if the write succeeded, false if not. The write can fail because of an
+ * unsupported combination of surface and src configs.
+ */
+ bool writeSurfacePixels(GrSurface* surface, SkColorSpace* dstColorSpace,
+ int left, int top, int width, int height,
+ GrPixelConfig config, SkColorSpace* srcColorSpace, const void* buffer,
+ size_t rowBytes,
+ uint32_t pixelOpsFlags = 0);
+
/**
* An ID associated with this context, guaranteed to be unique.
*/
GrProcessorTestData(SkRandom* random,
GrContext* context,
const GrRenderTargetContext* renderTargetContext,
- sk_sp<GrTextureProxy> proxies[2])
+ GrTexture* const textures[2])
: fRandom(random)
, fRenderTargetContext(renderTargetContext)
, fContext(context) {
- fProxies[0] = proxies[0];
- fProxies[1] = proxies[1];
+ fProxies[0] = GrSurfaceProxy::MakeWrapped(sk_ref_sp(textures[0]));
+ fProxies[1] = GrSurfaceProxy::MakeWrapped(sk_ref_sp(textures[1]));
}
SkRandom* fRandom;
const GrRenderTargetContext* fRenderTargetContext;
virtual GrRenderTarget* asRenderTarget() { return NULL; }
virtual const GrRenderTarget* asRenderTarget() const { return NULL; }
+ /**
+ * Reads a rectangle of pixels from the surface, possibly performing color space conversion.
+ * @param srcColorSpace color space of the source data (this surface)
+ * @param left left edge of the rectangle to read (inclusive)
+ * @param top top edge of the rectangle to read (inclusive)
+ * @param width width of rectangle to read in pixels.
+ * @param height height of rectangle to read in pixels.
+ * @param config the pixel config of the destination buffer
+ * @param dstColorSpace color space of the destination buffer
+ * @param buffer memory to read the rectangle into.
+ * @param rowBytes number of bytes between consecutive rows. Zero means rows are tightly
+ * packed.
+ * @param pixelOpsFlags See the GrContext::PixelOpsFlags enum.
+ *
+ * @return true if the read succeeded, false if not. The read can fail because of an unsupported
+ * pixel config.
+ */
+ bool readPixels(SkColorSpace* srcColorSpace,
+ int left, int top, int width, int height,
+ GrPixelConfig config,
+ SkColorSpace* dstColorSpace,
+ void* buffer,
+ size_t rowBytes = 0,
+ uint32_t pixelOpsFlags = 0);
+
+ /**
+ * Reads a rectangle of pixels from the surface. Does not perform any color space conversion.
+ * @param left left edge of the rectangle to read (inclusive)
+ * @param top top edge of the rectangle to read (inclusive)
+ * @param width width of rectangle to read in pixels.
+ * @param height height of rectangle to read in pixels.
+ * @param config the pixel config of the destination buffer
+ * @param buffer memory to read the rectangle into.
+ * @param rowBytes number of bytes between consecutive rows. Zero means rows are tightly
+ * packed.
+ * @param pixelOpsFlags See the GrContext::PixelOpsFlags enum.
+ *
+ * @return true if the read succeeded, false if not. The read can fail because of an unsupported
+ * pixel config.
+ */
+ bool readPixels(int left, int top, int width, int height,
+ GrPixelConfig config,
+ void* buffer,
+ size_t rowBytes = 0,
+ uint32_t pixelOpsFlags = 0) {
+ return this->readPixels(nullptr, left, top, width, height, config, nullptr, buffer,
+ rowBytes, pixelOpsFlags);
+ }
+
+ /**
+ * Copy the src pixels [buffer, rowbytes, pixelconfig] into the surface at the specified
+ * rectangle, possibly performing color space conversion.
+ * @param dstColorSpace color space of the destination (this surface)
+ * @param left left edge of the rectangle to write (inclusive)
+ * @param top top edge of the rectangle to write (inclusive)
+ * @param width width of rectangle to write in pixels.
+ * @param height height of rectangle to write in pixels.
+ * @param config the pixel config of the source buffer
+ * @param srcColorSpace color space of the source buffer
+ * @param buffer memory to read the rectangle from.
+ * @param rowBytes number of bytes between consecutive rows. Zero means rows are tightly
+ * packed.
+ * @param pixelOpsFlags See the GrContext::PixelOpsFlags enum.
+ *
+ * @return true if the write succeeded, false if not. The write can fail because of an
+ * unsupported pixel config.
+ */
+ bool writePixels(SkColorSpace* dstColorSpace,
+ int left, int top, int width, int height,
+ GrPixelConfig config,
+ SkColorSpace* srcColorSpace,
+ const void* buffer,
+ size_t rowBytes = 0,
+ uint32_t pixelOpsFlags = 0);
+
+ /**
+ * Copy the src pixels [buffer, rowbytes, pixelconfig] into the surface at the specified
+ * rectangle. Does not perform any color space conversion.
+ * @param left left edge of the rectangle to write (inclusive)
+ * @param top top edge of the rectangle to write (inclusive)
+ * @param width width of rectangle to write in pixels.
+ * @param height height of rectangle to write in pixels.
+ * @param config the pixel config of the source buffer
+ * @param buffer memory to read the rectangle from.
+ * @param rowBytes number of bytes between consecutive rows. Zero means rows are tightly
+ * packed.
+ * @param pixelOpsFlags See the GrContext::PixelOpsFlags enum.
+ *
+ * @return true if the write succeeded, false if not. The write can fail because of an
+ * unsupported pixel config.
+ */
+ bool writePixels(int left, int top, int width, int height,
+ GrPixelConfig config,
+ const void* buffer,
+ size_t rowBytes = 0,
+ uint32_t pixelOpsFlags = 0) {
+ return this->writePixels(nullptr, left, top, width, height, config, nullptr, buffer,
+ rowBytes, pixelOpsFlags);
+ }
+
/** Access methods that are only to be used within Skia code. */
inline GrSurfacePriv surfacePriv();
inline const GrSurfacePriv surfacePriv() const;
#include "effects/GrConfigConversionEffect.h"
#include "text/GrTextBlobCache.h"
-#define ASSERT_OWNED_PROXY(P) \
-SkASSERT(!(P) || !((P)->priv().peekTexture()) || (P)->priv().peekTexture()->getContext() == this)
#define ASSERT_OWNED_PROXY_PRIV(P) \
SkASSERT(!(P) || !((P)->priv().peekTexture()) || (P)->priv().peekTexture()->getContext() == fContext)
#define RETURN_IF_ABANDONED if (fDrawingManager->wasAbandoned()) { return; }
#define RETURN_IF_ABANDONED_PRIV if (fContext->fDrawingManager->wasAbandoned()) { return; }
#define RETURN_FALSE_IF_ABANDONED if (fDrawingManager->wasAbandoned()) { return false; }
-#define RETURN_FALSE_IF_ABANDONED_PRIV if (fContext->fDrawingManager->wasAbandoned()) { return false; }
#define RETURN_NULL_IF_ABANDONED if (fDrawingManager->wasAbandoned()) { return nullptr; }
////////////////////////////////////////////////////////////////////////////////
return GrPixelConfigIs8888Unorm(config) || kRGBA_half_GrPixelConfig == config;
}
-bool GrContextPriv::writeSurfacePixels(GrSurfaceProxy* srcProxy, SkColorSpace* dstColorSpace,
- int left, int top, int width, int height,
- GrPixelConfig srcConfig, SkColorSpace* srcColorSpace,
- const void* buffer, size_t rowBytes,
- uint32_t pixelOpsFlags) {
+bool GrContext::writeSurfacePixels(GrSurface* surface, SkColorSpace* dstColorSpace,
+ int left, int top, int width, int height,
+ GrPixelConfig srcConfig, SkColorSpace* srcColorSpace,
+ const void* buffer, size_t rowBytes, uint32_t pixelOpsFlags) {
// TODO: Color space conversion
- ASSERT_SINGLE_OWNER_PRIV
- RETURN_FALSE_IF_ABANDONED_PRIV
- ASSERT_OWNED_PROXY_PRIV(srcProxy);
- SkASSERT(srcProxy);
- GR_AUDIT_TRAIL_AUTO_FRAME(&fContext->fAuditTrail, "GrContextPriv::writeSurfacePixels");
-
- GrSurface* surface = srcProxy->instantiate(fContext->resourceProvider());
- if (!surface) {
- return false;
- }
+ ASSERT_SINGLE_OWNER
+ RETURN_FALSE_IF_ABANDONED
+ ASSERT_OWNED_RESOURCE(surface);
+ SkASSERT(surface);
+ GR_AUDIT_TRAIL_AUTO_FRAME(&fAuditTrail, "GrContext::writeSurfacePixels");
- fContext->testPMConversionsIfNecessary(pixelOpsFlags);
+ this->testPMConversionsIfNecessary(pixelOpsFlags);
// Trim the params here so that if we wind up making a temporary surface it can be as small as
// necessary and because GrGpu::getWritePixelsInfo requires it.
GrGpu::DrawPreference drawPreference = GrGpu::kNoDraw_DrawPreference;
// Don't prefer to draw for the conversion (and thereby access a texture from the cache) when
// we've already determined that there isn't a roundtrip preserving conversion processor pair.
- if (applyPremulToSrc && fContext->validPMUPMConversionExists(srcConfig)) {
+ if (applyPremulToSrc && this->validPMUPMConversionExists(srcConfig)) {
drawPreference = GrGpu::kCallerPrefersDraw_DrawPreference;
}
GrGpu::WritePixelTempDrawInfo tempDrawInfo;
- if (!fContext->fGpu->getWritePixelsInfo(surface, width, height, srcConfig,
- &drawPreference, &tempDrawInfo)) {
+ if (!fGpu->getWritePixelsInfo(surface, width, height, srcConfig, &drawPreference,
+ &tempDrawInfo)) {
return false;
}
if (!(kDontFlush_PixelOpsFlag & pixelOpsFlags) && surface->surfacePriv().hasPendingIO()) {
- this->flush(nullptr); // MDB TODO: tighten this
+ this->contextPriv().flush(nullptr); // MDB TODO: tighten this
}
sk_sp<GrTextureProxy> tempProxy;
if (GrGpu::kNoDraw_DrawPreference != drawPreference) {
- tempProxy = GrSurfaceProxy::MakeDeferred(fContext->resourceProvider(),
+ tempProxy = GrSurfaceProxy::MakeDeferred(this->resourceProvider(),
tempDrawInfo.fTempSurfaceDesc,
SkBackingFit::kApprox,
SkBudgeted::kYes);
if (tempProxy) {
sk_sp<GrFragmentProcessor> fp;
if (applyPremulToSrc) {
- fp = fContext->createUPMToPMEffect(tempProxy, SkMatrix::I());
+ fp = this->createUPMToPMEffect(tempProxy, SkMatrix::I());
fp = GrFragmentProcessor::SwizzleOutput(std::move(fp), tempDrawInfo.fSwizzle);
// If premultiplying was the only reason for the draw, fall back to a straight write.
if (!fp) {
}
if (tempProxy) {
if (!fp) {
- fp = GrSimpleTextureEffect::Make(fContext->resourceProvider(), tempProxy, nullptr,
+ fp = GrSimpleTextureEffect::Make(this->resourceProvider(), tempProxy, nullptr,
SkMatrix::I());
fp = GrFragmentProcessor::SwizzleOutput(std::move(fp), tempDrawInfo.fSwizzle);
}
}
if (tempProxy->priv().hasPendingIO()) {
- this->flush(tempProxy.get());
+ this->contextPriv().flush(tempProxy.get());
}
- GrTexture* texture = tempProxy->instantiate(fContext->resourceProvider());
+ GrTexture* texture = tempProxy->instantiate(this->resourceProvider());
if (!texture) {
return false;
}
buffer = tmpPixels.get();
applyPremulToSrc = false;
}
- if (!fContext->fGpu->writePixels(texture, 0, 0, width, height,
- tempDrawInfo.fWriteConfig, buffer,
- rowBytes)) {
+ if (!fGpu->writePixels(texture, 0, 0, width, height,
+ tempDrawInfo.fWriteConfig, buffer,
+ rowBytes)) {
return false;
}
SkMatrix matrix;
GrRenderTarget* renderTarget = surface->asRenderTarget();
SkASSERT(renderTarget);
sk_sp<GrRenderTargetContext> renderTargetContext(
- this->makeWrappedRenderTargetContext(sk_ref_sp(renderTarget), nullptr));
+ this->contextPriv().makeWrappedRenderTargetContext(sk_ref_sp(renderTarget),
+ nullptr));
if (!renderTargetContext) {
return false;
}
nullptr);
if (kFlushWrites_PixelOp & pixelOpsFlags) {
- this->flushSurfaceWrites(renderTargetContext->asRenderTargetProxy());
+ this->contextPriv().flushSurfaceWrites(renderTargetContext->asRenderTargetProxy());
}
}
}
buffer = tmpPixels.get();
applyPremulToSrc = false;
}
- return fContext->fGpu->writePixels(surface, left, top, width, height, srcConfig,
- buffer, rowBytes);
+ return fGpu->writePixels(surface, left, top, width, height, srcConfig, buffer, rowBytes);
}
return true;
}
-bool GrContextPriv::readSurfacePixels(GrSurfaceProxy* srcProxy, SkColorSpace* srcColorSpace,
- int left, int top, int width, int height,
- GrPixelConfig dstConfig, SkColorSpace* dstColorSpace,
- void* buffer, size_t rowBytes, uint32_t flags) {
+bool GrContext::readSurfacePixels(GrSurface* src, SkColorSpace* srcColorSpace,
+ int left, int top, int width, int height,
+ GrPixelConfig dstConfig, SkColorSpace* dstColorSpace,
+ void* buffer, size_t rowBytes, uint32_t flags) {
// TODO: Color space conversion
- ASSERT_SINGLE_OWNER_PRIV
- RETURN_FALSE_IF_ABANDONED_PRIV
- ASSERT_OWNED_PROXY_PRIV(srcProxy);
- SkASSERT(srcProxy);
- GR_AUDIT_TRAIL_AUTO_FRAME(&fContext->fAuditTrail, "GrContextPriv::readSurfacePixels");
-
- // MDB TODO: delay this instantiation until later in the method
- GrSurface* src = srcProxy->instantiate(fContext->resourceProvider());
- if (!src) {
- return false;
- }
+ ASSERT_SINGLE_OWNER
+ RETURN_FALSE_IF_ABANDONED
+ ASSERT_OWNED_RESOURCE(src);
+ SkASSERT(src);
+ GR_AUDIT_TRAIL_AUTO_FRAME(&fAuditTrail, "GrContext::readSurfacePixels");
- fContext->testPMConversionsIfNecessary(flags);
+ this->testPMConversionsIfNecessary(flags);
// Adjust the params so that if we wind up using an intermediate surface we've already done
// all the trimming and the temporary can be the min size required.
}
if (!(kDontFlush_PixelOpsFlag & flags) && src->surfacePriv().hasPendingWrite()) {
- this->flush(nullptr); // MDB TODO: tighten this
+ this->contextPriv().flush(nullptr); // MDB TODO: tighten this
}
bool unpremul = SkToBool(kUnpremul_PixelOpsFlag & flags);
GrGpu::DrawPreference drawPreference = GrGpu::kNoDraw_DrawPreference;
// Don't prefer to draw for the conversion (and thereby access a texture from the cache) when
// we've already determined that there isn't a roundtrip preserving conversion processor pair.
- if (unpremul && fContext->validPMUPMConversionExists(src->config())) {
+ if (unpremul && this->validPMUPMConversionExists(src->config())) {
drawPreference = GrGpu::kCallerPrefersDraw_DrawPreference;
}
GrGpu::ReadPixelTempDrawInfo tempDrawInfo;
- if (!fContext->fGpu->getReadPixelsInfo(src, width, height, rowBytes, dstConfig,
- &drawPreference, &tempDrawInfo)) {
+ if (!fGpu->getReadPixelsInfo(src, width, height, rowBytes, dstConfig, &drawPreference,
+ &tempDrawInfo)) {
return false;
}
- sk_sp<GrSurfaceProxy> proxyToRead = sk_ref_sp(srcProxy);
+ sk_sp<GrSurface> surfaceToRead(SkRef(src));
+ sk_sp<GrTextureProxy> drawnProxy;
bool didTempDraw = false;
if (GrGpu::kNoDraw_DrawPreference != drawPreference) {
if (SkBackingFit::kExact == tempDrawInfo.fTempSurfaceFit) {
// TODO: Need to decide the semantics of this function for color spaces. Do we support
// conversion to a passed-in color space? For now, specifying nullptr means that this
// path will do no conversion, so it will match the behavior of the non-draw path.
- sk_sp<GrRenderTargetContext> tempRTC = fContext->makeRenderTargetContext(
+ sk_sp<GrRenderTargetContext> tempRTC = this->makeRenderTargetContext(
tempDrawInfo.fTempSurfaceFit,
tempDrawInfo.fTempSurfaceDesc.fWidth,
tempDrawInfo.fTempSurfaceDesc.fHeight,
tempDrawInfo.fTempSurfaceDesc.fOrigin);
if (tempRTC) {
SkMatrix textureMatrix = SkMatrix::MakeTrans(SkIntToScalar(left), SkIntToScalar(top));
- sk_sp<GrTextureProxy> proxy = sk_ref_sp(srcProxy->asTextureProxy());
+ sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeWrapped(sk_ref_sp(src->asTexture()));
sk_sp<GrFragmentProcessor> fp;
if (unpremul) {
- fp = fContext->createPMToUPMEffect(proxy, textureMatrix);
+ fp = this->createPMToUPMEffect(proxy, textureMatrix);
fp = GrFragmentProcessor::SwizzleOutput(std::move(fp), tempDrawInfo.fSwizzle);
if (fp) {
unpremul = false; // we no longer need to do this on CPU after the read back.
}
}
if (!fp && tempRTC) {
- fp = GrSimpleTextureEffect::Make(fContext->resourceProvider(), std::move(proxy),
+ fp = GrSimpleTextureEffect::Make(this->resourceProvider(), std::move(proxy),
nullptr, textureMatrix);
fp = GrFragmentProcessor::SwizzleOutput(std::move(fp), tempDrawInfo.fSwizzle);
}
SkRect rect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
tempRTC->drawRect(GrNoClip(), std::move(paint), GrAA::kNo, SkMatrix::I(), rect,
nullptr);
- proxyToRead = tempRTC->asTextureProxyRef();
+ drawnProxy = tempRTC->asTextureProxyRef();
+ surfaceToRead = sk_ref_sp(drawnProxy->instantiate(this->resourceProvider()));
left = 0;
top = 0;
didTempDraw = true;
}
}
- if (!proxyToRead) {
- return false;
- }
-
- GrSurface* surfaceToRead = proxyToRead->instantiate(fContext->resourceProvider());
if (!surfaceToRead) {
return false;
}
}
GrPixelConfig configToRead = dstConfig;
if (didTempDraw) {
- this->flushSurfaceWrites(proxyToRead.get());
+ this->contextPriv().flushSurfaceWrites(drawnProxy.get());
configToRead = tempDrawInfo.fReadConfig;
}
- if (!fContext->fGpu->readPixels(surfaceToRead, left, top, width, height, configToRead,
- buffer, rowBytes)) {
+ if (!fGpu->readPixels(surfaceToRead.get(), left, top, width, height, configToRead, buffer,
+ rowBytes)) {
return false;
}
sk_sp<GrTexture> tex;
if (SkBackingFit::kExact == fit) {
- tex = this->resourceProvider()->createTexture(desc, budgeted);
+ tex.reset(this->resourceProvider()->createTexture(desc, budgeted));
} else {
tex.reset(this->resourceProvider()->createApproxTexture(desc, 0));
}
void GrContext::testPMConversionsIfNecessary(uint32_t flags) {
ASSERT_SINGLE_OWNER
- if (SkToBool(GrContextPriv::kUnpremul_PixelOpsFlag & flags)) {
+ if (SkToBool(kUnpremul_PixelOpsFlag & flags)) {
if (!fDidTestPMConversions) {
test_pm_conversions(this, &fPMToUPMConversion, &fUPMToPMConversion);
fDidTestPMConversions = true;
*/
void prepareSurfaceForExternalIO(GrSurfaceProxy*);
- /**
- * These flags can be used with the read/write pixels functions below.
- */
- enum PixelOpsFlags {
- /** The GrContext will not be flushed before the surface read or write. This means that
- the read or write may occur before previous draws have executed. */
- kDontFlush_PixelOpsFlag = 0x1,
- /** Any surface writes should be flushed to the backend 3D API after the surface operation
- is complete */
- kFlushWrites_PixelOp = 0x2,
- /** The src for write or dst read is unpremultiplied. This is only respected if both the
- config src and dst configs are an RGBA/BGRA 8888 format. */
- kUnpremul_PixelOpsFlag = 0x4,
- };
-
- /**
- * Reads a rectangle of pixels from a surface.
- * @param surface the surface to read from.
- * @param srcColorSpace color space of the surface
- * @param left left edge of the rectangle to read (inclusive)
- * @param top top edge of the rectangle to read (inclusive)
- * @param width width of rectangle to read in pixels.
- * @param height height of rectangle to read in pixels.
- * @param config the pixel config of the destination buffer
- * @param dstColorSpace color space of the destination buffer
- * @param buffer memory to read the rectangle into.
- * @param rowBytes number of bytes bewtween consecutive rows. Zero means rows are tightly
- * packed.
- * @param pixelOpsFlags see PixelOpsFlags enum above.
- *
- * @return true if the read succeeded, false if not. The read can fail because of an unsupported
- * pixel configs
- */
- bool readSurfacePixels(GrSurfaceProxy* src, SkColorSpace* srcColorSpace,
- int left, int top, int width, int height,
- GrPixelConfig config, SkColorSpace* dstColorSpace, void* buffer,
- size_t rowBytes = 0,
- uint32_t pixelOpsFlags = 0);
-
- /**
- * Writes a rectangle of pixels to a surface.
- * @param surface the surface to write to.
- * @param dstColorSpace color space of the surface
- * @param left left edge of the rectangle to write (inclusive)
- * @param top top edge of the rectangle to write (inclusive)
- * @param width width of rectangle to write in pixels.
- * @param height height of rectangle to write in pixels.
- * @param config the pixel config of the source buffer
- * @param srcColorSpace color space of the source buffer
- * @param buffer memory to read pixels from
- * @param rowBytes number of bytes between consecutive rows. Zero
- * means rows are tightly packed.
- * @param pixelOpsFlags see PixelOpsFlags enum above.
- * @return true if the write succeeded, false if not. The write can fail because of an
- * unsupported combination of surface and src configs.
- */
- bool writeSurfacePixels(GrSurfaceProxy* src, SkColorSpace* dstColorSpace,
- int left, int top, int width, int height,
- GrPixelConfig config, SkColorSpace* srcColorSpace, const void* buffer,
- size_t rowBytes,
- uint32_t pixelOpsFlags = 0);
-
private:
explicit GrContextPriv(GrContext* context) : fContext(context) {}
GrContextPriv(const GrContextPriv&); // unimpl
#include "GrRenderTargetContext.h"
#include "GrAppliedClip.h"
#include "GrColor.h"
-#include "GrContextPriv.h"
#include "GrDrawingManager.h"
#include "GrFixedClip.h"
#include "GrGpuResourcePriv.h"
// TODO: this seems to duplicate code in SkImage_Gpu::onReadPixels
if (kUnpremul_SkAlphaType == dstInfo.alphaType()) {
- flags |= GrContextPriv::kUnpremul_PixelOpsFlag;
+ flags |= GrContext::kUnpremul_PixelOpsFlag;
}
- return fContext->contextPriv().readSurfacePixels(fRenderTargetProxy.get(),
- this->getColorSpace(), x, y,
- dstInfo.width(), dstInfo.height(), config,
- dstInfo.colorSpace(),
- dstBuffer, dstRowBytes, flags);
+ // Deferral of the VRAM resources must end in this instance anyway
+ sk_sp<GrRenderTarget> rt(
+ sk_ref_sp(fRenderTargetProxy->instantiate(fContext->resourceProvider())));
+ if (!rt) {
+ return false;
+ }
+
+ return rt->readPixels(this->getColorSpace(), x, y, dstInfo.width(), dstInfo.height(),
+ config, dstInfo.colorSpace(), dstBuffer, dstRowBytes, flags);
}
// TODO: move this (and GrTextureContext::onReadPixels) to GrSurfaceContext?
return false;
}
if (kUnpremul_SkAlphaType == srcInfo.alphaType()) {
- flags |= GrContextPriv::kUnpremul_PixelOpsFlag;
+ flags |= GrContext::kUnpremul_PixelOpsFlag;
+ }
+
+ // Deferral of the VRAM resources must end in this instance anyway
+ sk_sp<GrRenderTarget> rt(
+ sk_ref_sp(fRenderTargetProxy->instantiate(fContext->resourceProvider())));
+ if (!rt) {
+ return false;
}
- return fContext->contextPriv().writeSurfacePixels(fRenderTargetProxy.get(),
- this->getColorSpace(), x, y,
- srcInfo.width(), srcInfo.height(),
- config, srcInfo.colorSpace(),
- srcBuffer, srcRowBytes, flags);
+ return rt->writePixels(this->getColorSpace(), x, y, srcInfo.width(), srcInfo.height(),
+ config, srcInfo.colorSpace(), srcBuffer, srcRowBytes, flags);
}
desc.fHeight = rt->height();
dstPoint = {copyRect.fLeft, copyRect.fTop};
dstOffset = {0, 0};
- copy = fContext->resourceProvider()->createTexture(desc, SkBudgeted::kYes, kFlags);
+ copy.reset(fContext->resourceProvider()->createTexture(desc, SkBudgeted::kYes, kFlags));
} else {
desc.fWidth = copyRect.width();
desc.fHeight = copyRect.height();
#include "GrBuffer.h"
#include "GrCaps.h"
#include "GrContext.h"
-#include "GrContextPriv.h"
#include "GrGpu.h"
#include "GrPathRendering.h"
#include "GrRenderTarget.h"
return proxy->priv().isExact() || (SkIsPow2(proxy->width()) && SkIsPow2(proxy->height()));
}
-// MDB TODO: this should probably be a factory on GrSurfaceProxy
-sk_sp<GrTextureProxy> GrResourceProvider::createMipMappedTexture(
- const GrSurfaceDesc& desc,
- SkBudgeted budgeted,
- const GrMipLevel* texels,
- int mipLevelCount,
- uint32_t flags,
+GrTexture* GrResourceProvider::createMipMappedTexture(const GrSurfaceDesc& desc,
+ SkBudgeted budgeted, const GrMipLevel* texels,
+ int mipLevelCount, uint32_t flags,
SkDestinationSurfaceColorMode mipColorMode) {
ASSERT_SINGLE_OWNER
if (!GrPixelConfigIsCompressed(desc.fConfig)) {
if (mipLevelCount < 2) {
flags |= kExact_Flag | kNoCreate_Flag;
- sk_sp<GrTexture> tex(this->refScratchTexture(desc, flags));
- if (tex) {
- sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeWrapped(tex);
+ if (GrTexture* texture = this->refScratchTexture(desc, flags)) {
if (!mipLevelCount ||
- fGpu->getContext()->contextPriv().writeSurfacePixels(
- proxy.get(), nullptr, 0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
- nullptr, texels[0].fPixels, texels[0].fRowBytes)) {
+ texture->writePixels(0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
+ texels[0].fPixels, texels[0].fRowBytes)) {
if (SkBudgeted::kNo == budgeted) {
- tex->resourcePriv().makeUnbudgeted();
+ texture->resourcePriv().makeUnbudgeted();
}
- tex->texturePriv().setMipColorMode(mipColorMode);
- return proxy;
+ texture->texturePriv().setMipColorMode(mipColorMode);
+ return texture;
}
+ texture->unref();
}
}
}
for (int i = 0; i < mipLevelCount; ++i) {
texelsShallowCopy.push_back(texels[i]);
}
- sk_sp<GrTexture> tex(fGpu->createTexture(desc, budgeted, texelsShallowCopy));
- if (tex) {
- tex->texturePriv().setMipColorMode(mipColorMode);
+ GrTexture* texture = fGpu->createTexture(desc, budgeted, texelsShallowCopy);
+ if (texture) {
+ texture->texturePriv().setMipColorMode(mipColorMode);
}
-
- return GrSurfaceProxy::MakeWrapped(std::move(tex));
+ return texture;
}
-sk_sp<GrTexture> GrResourceProvider::createTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted,
- uint32_t flags) {
- if ((desc.fFlags & kRenderTarget_GrSurfaceFlag) &&
- !fGpu->caps()->isConfigRenderable(desc.fConfig, desc.fSampleCnt > 0)) {
- return nullptr;
- }
-
- if (!GrPixelConfigIsCompressed(desc.fConfig)) {
- flags |= kExact_Flag | kNoCreate_Flag;
- sk_sp<GrTexture> tex(this->refScratchTexture(desc, flags));
- if (tex) {
- if (SkBudgeted::kNo == budgeted) {
- tex->resourcePriv().makeUnbudgeted();
- }
- return tex;
- }
- }
-
- sk_sp<GrTexture> tex(fGpu->createTexture(desc, budgeted));
- return tex;
+GrTexture* GrResourceProvider::createTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted,
+ const void* srcData, size_t rowBytes, uint32_t flags) {
+ GrMipLevel tempTexels;
+ GrMipLevel* texels = nullptr;
+ int levelCount = 0;
+ if (srcData) {
+ tempTexels.fPixels = srcData;
+ tempTexels.fRowBytes = rowBytes;
+ texels = &tempTexels;
+ levelCount = 1;
+ }
+ return this->createMipMappedTexture(desc, budgeted, texels, levelCount, flags);
}
GrTexture* GrResourceProvider::createApproxTexture(const GrSurfaceDesc& desc, uint32_t flags) {
* @param texels A contiguous array of mipmap levels
* @param mipLevelCount The amount of elements in the texels array
*/
- sk_sp<GrTextureProxy> createMipMappedTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted,
- const GrMipLevel* texels, int mipLevelCount,
- uint32_t flags = 0,
- SkDestinationSurfaceColorMode mipColorMode =
+ GrTexture* createMipMappedTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted,
+ const GrMipLevel* texels, int mipLevelCount,
+ uint32_t flags = 0,
+ SkDestinationSurfaceColorMode mipColorMode =
SkDestinationSurfaceColorMode::kLegacy);
+ /**
+ * This function is a shim which creates a SkTArray<GrMipLevel> of size 1.
+ * It then calls createTexture with that SkTArray.
+ *
+ * @param srcData Pointer to the pixel values (optional).
+ * @param rowBytes The number of bytes between rows of the texture. Zero
+ * implies tightly packed rows. For compressed pixel configs, this
+ * field is ignored.
+ */
+ GrTexture* createTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted, const void* srcData,
+ size_t rowBytes, uint32_t flags = 0);
+
+ /** Shortcut for creating a texture with no initial data to upload. */
+ GrTexture* createTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted, uint32_t flags = 0) {
+ return this->createTexture(desc, budgeted, nullptr, 0, flags);
+ }
+
/** Assigns a unique key to the texture. The texture will be findable via this key using
findTextureByUniqueKey(). If an existing texture has this key, it's key will be removed. */
void assignUniqueKeyToProxy(const GrUniqueKey& key, GrTextureProxy*);
*/
GrTexture* createApproxTexture(const GrSurfaceDesc&, uint32_t flags);
- /** Create an exact fit texture with no initial data to upload.
- */
- sk_sp<GrTexture> createTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted,
- uint32_t flags = 0);
-
///////////////////////////////////////////////////////////////////////////
// Wrapped Backend Surfaces
//////////////////////////////////////////////////////////////////////////////
+bool GrSurface::writePixels(SkColorSpace* dstColorSpace, int left, int top, int width, int height,
+ GrPixelConfig config, SkColorSpace* srcColorSpace, const void* buffer,
+ size_t rowBytes, uint32_t pixelOpsFlags) {
+ // go through context so that all necessary flushing occurs
+ GrContext* context = this->getContext();
+ if (nullptr == context) {
+ return false;
+ }
+ return context->writeSurfacePixels(this, dstColorSpace, left, top, width, height, config,
+ srcColorSpace, buffer, rowBytes, pixelOpsFlags);
+}
+
+bool GrSurface::readPixels(SkColorSpace* srcColorSpace, int left, int top, int width, int height,
+ GrPixelConfig config, SkColorSpace* dstColorSpace, void* buffer,
+ size_t rowBytes, uint32_t pixelOpsFlags) {
+ // go through context so that all necessary flushing occurs
+ GrContext* context = this->getContext();
+ if (nullptr == context) {
+ return false;
+ }
+ return context->readSurfacePixels(this, srcColorSpace, left, top, width, height, config,
+ dstColorSpace, buffer, rowBytes, pixelOpsFlags);
+}
+
bool GrSurface::hasPendingRead() const {
const GrTexture* thisTex = this->asTexture();
if (thisTex && thisTex->internalHasPendingRead()) {
if (SkBackingFit::kApprox == fFit) {
fTarget = resourceProvider->createApproxTexture(fDesc, fFlags);
} else {
- fTarget = resourceProvider->createTexture(fDesc, fBudgeted, fFlags).release();
+ fTarget = resourceProvider->createTexture(fDesc, fBudgeted, fFlags);
}
if (!fTarget) {
return nullptr;
const void* srcData,
size_t rowBytes) {
if (srcData) {
- GrMipLevel tempTexels;
- GrMipLevel* texels = nullptr;
- int levelCount = 0;
- if (srcData) {
- tempTexels.fPixels = srcData;
- tempTexels.fRowBytes = rowBytes;
- texels = &tempTexels;
- levelCount = 1;
- }
- return resourceProvider->createMipMappedTexture(desc, budgeted, texels, levelCount);
+ // If we have srcData, for now, we create a wrapped GrTextureProxy
+ sk_sp<GrTexture> tex(resourceProvider->createTexture(desc, budgeted, srcData, rowBytes));
+ return GrSurfaceProxy::MakeWrapped(std::move(tex));
}
return GrSurfaceProxy::MakeDeferred(resourceProvider, desc, SkBackingFit::kExact, budgeted);
// TODO: this seems to duplicate code in SkImage_Gpu::onReadPixels
if (kUnpremul_SkAlphaType == dstInfo.alphaType()) {
- flags |= GrContextPriv::kUnpremul_PixelOpsFlag;
+ flags |= GrContext::kUnpremul_PixelOpsFlag;
}
- return fContext->contextPriv().readSurfacePixels(fTextureProxy.get(), this->getColorSpace(),
- x, y, dstInfo.width(), dstInfo.height(),
- config,
- dstInfo.colorSpace(), dstBuffer, dstRowBytes,
- flags);
+ // Deferral of the VRAM resources must end in this instance anyway
+ sk_sp<GrTexture> tex(sk_ref_sp(fTextureProxy->instantiate(fContext->resourceProvider())));
+ if (!tex) {
+ return false;
+ }
+
+ return tex->readPixels(this->getColorSpace(), x, y, dstInfo.width(), dstInfo.height(),
+ config, dstInfo.colorSpace(), dstBuffer, dstRowBytes, flags);
}
// TODO: move this (and GrRenderTargetContext::onReadPixels) to GrSurfaceContext?
return false;
}
if (kUnpremul_SkAlphaType == srcInfo.alphaType()) {
- flags |= GrContextPriv::kUnpremul_PixelOpsFlag;
+ flags |= GrContext::kUnpremul_PixelOpsFlag;
+ }
+
+ // Deferral of the VRAM resources must end in this instance anyway
+ sk_sp<GrTexture> tex(sk_ref_sp(fTextureProxy->instantiate(fContext->resourceProvider())));
+ if (!tex) {
+ return false;
}
- return fContext->contextPriv().writeSurfacePixels(fTextureProxy.get(), this->getColorSpace(),
- x, y, srcInfo.width(), srcInfo.height(),
- config,
- srcInfo.colorSpace(), srcBuffer, srcRowBytes,
- flags);
+ return tex->writePixels(this->getColorSpace(), x, y, srcInfo.width(), srcInfo.height(),
+ config, srcInfo.colorSpace(), srcBuffer, srcRowBytes, flags);
}
texels[i].fRowBytes = generatedMipLevel.fPixmap.rowBytes();
}
- return ctx->resourceProvider()->createMipMappedTexture(desc,
- SkBudgeted::kYes,
- texels.get(),
- mipLevelCount,
- 0, colorMode);
+ sk_sp<GrTexture> tex(ctx->resourceProvider()->createMipMappedTexture(desc,
+ SkBudgeted::kYes,
+ texels.get(),
+ mipLevelCount,
+ 0, colorMode));
+
+ return GrSurfaceProxy::MakeWrapped(std::move(tex));
}
sk_sp<GrTextureProxy> GrUploadMipMapToTextureProxy(GrContext* ctx, const SkImageInfo& info,
}
const GrCaps* caps = ctx->caps();
- return ctx->resourceProvider()->createMipMappedTexture(GrImageInfoToSurfaceDesc(info, *caps),
+ sk_sp<GrTexture> tex(ctx->resourceProvider()->createMipMappedTexture(
+ GrImageInfoToSurfaceDesc(info, *caps),
SkBudgeted::kYes, texels,
- mipLevelCount, 0, colorMode);
+ mipLevelCount, 0, colorMode));
+ return GrSurfaceProxy::MakeWrapped(std::move(tex));
}
sk_sp<GrTextureProxy> GrRefCachedBitmapTextureProxy(GrContext* ctx,
// that is not currently in use
fTexContext->writePixels(bitmap.info(), bitmap.getPixels(), bitmap.rowBytes(),
0, rowNumber * fDesc.fRowHeight,
- GrContextPriv::kDontFlush_PixelOpsFlag);
+ GrContext::kDontFlush_PixelOpsFlag);
}
SkASSERT(rowNumber >= 0);
uint32_t flags = 0;
if (kUnpremul_SkAlphaType == rec.fInfo.alphaType() && kPremul_SkAlphaType == fAlphaType) {
// let the GPU perform this transformation for us
- flags = GrContextPriv::kUnpremul_PixelOpsFlag;
+ flags = GrContext::kUnpremul_PixelOpsFlag;
}
sk_sp<GrSurfaceContext> sContext = fContext->contextPriv().makeWrappedSurfaceContext(
backingDesc.fOrigin = kDefault_GrSurfaceOrigin;
backingDesc.fFlags = kRenderTarget_GrSurfaceFlag;
- *backingSurface = context->resourceProvider()->createTexture(backingDesc, SkBudgeted::kNo);
+ (*backingSurface)
+ .reset(context->resourceProvider()->createTexture(backingDesc, SkBudgeted::kNo));
GrBackendTextureDesc desc;
desc.fConfig = config;
#if SK_SUPPORT_GPU
#include "GrContext.h"
-#include "GrContextPriv.h"
#include "GrResourceProvider.h"
#include "GrTexture.h"
#include "SkHalf.h"
desc.fHeight = DEV_H;
desc.fConfig = config;
desc.fOrigin = 0 == origin ? kTopLeft_GrSurfaceOrigin : kBottomLeft_GrSurfaceOrigin;
- sk_sp<GrTextureProxy> fpProxy = GrSurfaceProxy::MakeDeferred(context->resourceProvider(),
- desc, SkBudgeted::kNo,
- controlPixelData.begin(), 0);
+ sk_sp<GrTexture> fpTexture(context->resourceProvider()->createTexture(
+ desc, SkBudgeted::kNo, controlPixelData.begin(), 0));
// Floating point textures are NOT supported everywhere
- if (!fpProxy) {
+ if (nullptr == fpTexture) {
continue;
}
- bool result = context->contextPriv().readSurfacePixels(fpProxy.get(), nullptr,
- 0, 0, DEV_W, DEV_H,
- desc.fConfig, nullptr,
- readBuffer.begin(), 0);
- REPORTER_ASSERT(reporter, result);
+ REPORTER_ASSERT(reporter,
+ fpTexture->readPixels(0, 0, DEV_W, DEV_H, desc.fConfig, readBuffer.begin(), 0));
REPORTER_ASSERT(reporter,
0 == memcmp(readBuffer.begin(), controlPixelData.begin(), readBuffer.bytes()));
}
bool GrDrawingManager::ProgramUnitTest(GrContext* context, int maxStages) {
GrDrawingManager* drawingManager = context->contextPriv().drawingManager();
- sk_sp<GrTextureProxy> proxies[2];
-
// setup dummy textures
GrSurfaceDesc dummyDesc;
dummyDesc.fFlags = kRenderTarget_GrSurfaceFlag;
- dummyDesc.fOrigin = kBottomLeft_GrSurfaceOrigin;
dummyDesc.fConfig = kRGBA_8888_GrPixelConfig;
dummyDesc.fWidth = 34;
dummyDesc.fHeight = 18;
- proxies[0] = GrSurfaceProxy::MakeDeferred(context->resourceProvider(),
- dummyDesc, SkBudgeted::kNo, nullptr, 0);
+ sk_sp<GrTexture> dummyTexture1(
+ context->resourceProvider()->createTexture(dummyDesc, SkBudgeted::kNo, nullptr, 0));
dummyDesc.fFlags = kNone_GrSurfaceFlags;
- dummyDesc.fOrigin = kTopLeft_GrSurfaceOrigin;
dummyDesc.fConfig = kAlpha_8_GrPixelConfig;
dummyDesc.fWidth = 16;
dummyDesc.fHeight = 22;
- proxies[1] = GrSurfaceProxy::MakeDeferred(context->resourceProvider(),
- dummyDesc, SkBudgeted::kNo, nullptr, 0);
+ sk_sp<GrTexture> dummyTexture2(
+ context->resourceProvider()->createTexture(dummyDesc, SkBudgeted::kNo, nullptr, 0));
- if (!proxies[0] || !proxies[1]) {
+ if (!dummyTexture1 || ! dummyTexture2) {
SkDebugf("Could not allocate dummy textures");
return false;
}
+ GrTexture* dummyTextures[] = {dummyTexture1.get(), dummyTexture2.get()};
+
// dummy scissor state
GrScissorState scissor;
std::unique_ptr<GrLegacyMeshDrawOp> op(GrRandomDrawOp(&random, context));
SkASSERT(op);
- GrProcessorTestData ptd(&random, context, renderTargetContext.get(), proxies);
+ GrProcessorTestData ptd(&random, context, renderTargetContext.get(), dummyTextures);
set_random_color_coverage_stages(&grPaint, &ptd, maxStages);
set_random_xpf(&grPaint, &ptd);
bool snapToCenters = set_random_state(&grPaint, &random);
for (int j = 0; j < 10; ++j) {
std::unique_ptr<GrLegacyMeshDrawOp> op(GrRandomDrawOp(&random, context));
SkASSERT(op);
- GrProcessorTestData ptd(&random, context, renderTargetContext.get(), proxies);
+ GrProcessorTestData ptd(&random, context, renderTargetContext.get(), dummyTextures);
GrPaint grPaint;
grPaint.setXPFactory(GrPorterDuffXPFactory::Get(SkBlendMode::kSrc));
desc.fWidth = 256;
desc.fHeight = 256;
desc.fSampleCnt = 0;
- sk_sp<GrSurface> texRT1 = context->resourceProvider()->createTexture(desc, SkBudgeted::kNo);
+ GrSurface* texRT1 = context->resourceProvider()->createTexture(
+ desc, SkBudgeted::kNo, nullptr, 0);
- REPORTER_ASSERT(reporter, texRT1.get() == texRT1->asRenderTarget());
- REPORTER_ASSERT(reporter, texRT1.get() == texRT1->asTexture());
+ REPORTER_ASSERT(reporter, texRT1 == texRT1->asRenderTarget());
+ REPORTER_ASSERT(reporter, texRT1 == texRT1->asTexture());
REPORTER_ASSERT(reporter, static_cast<GrSurface*>(texRT1->asRenderTarget()) ==
texRT1->asTexture());
REPORTER_ASSERT(reporter, texRT1->asRenderTarget() ==
static_cast<GrSurface*>(texRT1->asTexture()));
desc.fFlags = kNone_GrSurfaceFlags;
- sk_sp<GrTexture> tex1 = context->resourceProvider()->createTexture(desc, SkBudgeted::kNo);
+ GrSurface* tex1 = context->resourceProvider()->createTexture(desc, SkBudgeted::kNo, nullptr, 0);
REPORTER_ASSERT(reporter, nullptr == tex1->asRenderTarget());
- REPORTER_ASSERT(reporter, tex1.get() == tex1->asTexture());
- REPORTER_ASSERT(reporter, static_cast<GrSurface*>(tex1.get()) == tex1->asTexture());
+ REPORTER_ASSERT(reporter, tex1 == tex1->asTexture());
+ REPORTER_ASSERT(reporter, static_cast<GrSurface*>(tex1) == tex1->asTexture());
GrBackendObject backendTex = context->getGpu()->createTestingOnlyBackendTexture(
nullptr, 256, 256, kRGBA_8888_GrPixelConfig);
REPORTER_ASSERT(reporter, static_cast<GrSurface*>(texRT2->asRenderTarget()) ==
static_cast<GrSurface*>(texRT2->asTexture()));
+ texRT1->unref();
+ tex1->unref();
context->getGpu()->deleteTestingOnlyBackendTexture(backendTex);
}
#include "GrContext.h"
#include "GrResourceProvider.h"
+static GrTexture* create_texture(GrContext* context) {
+ SkBitmap srcBM = create_bm();
+
+ GrSurfaceDesc desc;
+ desc.fConfig = kRGBA_8888_GrPixelConfig;
+ desc.fFlags = kNone_GrSurfaceFlags;
+ desc.fWidth = kFullSize;
+ desc.fHeight = kFullSize;
+
+ return context->resourceProvider()->createTexture(desc, SkBudgeted::kNo, srcBM.getPixels(), 0);
+}
+
static sk_sp<GrTextureProxy> create_proxy(GrResourceProvider* resourceProvider) {
SkBitmap srcBM = create_bm();
srcBM.rowBytes());
}
-DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageFilterCache_ImageBackedGPU, reporter, ctxInfo) {
- GrContext* context = ctxInfo.grContext();
- sk_sp<GrTextureProxy> srcProxy(create_proxy(context->resourceProvider()));
- if (!srcProxy) {
- return;
- }
-
- GrTexture* tex = srcProxy->instantiate(context->resourceProvider());
- if (!tex) {
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageFilterCache_ImageBackedGPU, reporter, ctxInfo) {
+ sk_sp<GrTexture> srcTexture(create_texture(ctxInfo.grContext()));
+ if (!srcTexture) {
return;
}
backendDesc.fWidth = kFullSize;
backendDesc.fHeight = kFullSize;
backendDesc.fSampleCnt = 0;
- backendDesc.fTextureHandle = tex->getTextureHandle();
- sk_sp<SkImage> srcImage(SkImage::MakeFromTexture(context,
+ backendDesc.fTextureHandle = srcTexture->getTextureHandle();
+ sk_sp<SkImage> srcImage(SkImage::MakeFromTexture(ctxInfo.grContext(),
backendDesc,
kPremul_SkAlphaType));
if (!srcImage) {
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageStorageLoad, reporter, ctxInfo) {
class TestFP : public GrFragmentProcessor {
public:
- static sk_sp<GrFragmentProcessor> Make(GrResourceProvider* resourceProvider,
- sk_sp<GrTextureProxy> proxy,
- GrSLMemoryModel mm,
+ static sk_sp<GrFragmentProcessor> Make(sk_sp<GrTexture> texture, GrSLMemoryModel mm,
GrSLRestrict restrict) {
- // MDB TODO: remove this once ImageStorageAccess is converted to GrTextureProxy
- sk_sp<GrTexture> tex(sk_ref_sp(proxy->instantiate(resourceProvider)));
- if (!tex) {
- return nullptr;
- }
-
- return sk_sp<GrFragmentProcessor>(new TestFP(std::move(tex), mm, restrict));
+ return sk_sp<GrFragmentProcessor>(new TestFP(std::move(texture), mm, restrict));
}
const char* name() const override { return "Image Load Test FP"; }
continue;
}
desc.fConfig = test.fConfig;
- sk_sp<GrTextureProxy> imageStorageTexture =
- GrSurfaceProxy::MakeDeferred(context->resourceProvider(), desc,
- SkBudgeted::kYes, test.fData.get(), 0);
+ sk_sp<GrTexture> imageStorageTexture(context->resourceProvider()->createTexture(
+ desc, SkBudgeted::kYes, test.fData.get(), 0));
sk_sp<GrRenderTargetContext> rtContext =
context->makeRenderTargetContext(SkBackingFit::kExact, kS, kS,
kRGBA_8888_GrPixelConfig, nullptr);
GrPaint paint;
paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
- paint.addColorFragmentProcessor(TestFP::Make(context->resourceProvider(),
- imageStorageTexture, mm, restrict));
+ paint.addColorFragmentProcessor(TestFP::Make(imageStorageTexture, mm, restrict));
rtContext->drawPaint(GrNoClip(), std::move(paint), SkMatrix::I());
std::unique_ptr<uint32_t[]> readData(new uint32_t[kS * kS]);
SkImageInfo info = SkImageInfo::Make(kS, kS, kRGBA_8888_SkColorType,
#if SK_SUPPORT_GPU
#include "GrClip.h"
#include "GrContext.h"
-#include "GrContextPriv.h"
#include "GrRenderTargetContext.h"
#include "GrResourceProvider.h"
#include "GrTexture.h"
levels[1].fPixels = testData.get();
levels[1].fRowBytes = (kS / 2) * sizeof(int32_t);
- sk_sp<GrTextureProxy> temp(context->resourceProvider()->createMipMappedTexture(
- desc,
+ sk_sp<GrTexture> temp(context->resourceProvider()->createMipMappedTexture(desc,
SkBudgeted::kYes,
levels, 2));
REPORTER_ASSERT(reporter, !temp);
return;
}
+ GrTexture* texture = proxy->instantiate(context->resourceProvider());
+ REPORTER_ASSERT(reporter, texture);
+ if (!texture) {
+ return;
+ }
+
std::unique_ptr<int32_t[]> readData(new int32_t[kS * kS]);
// Test that reading to a non-integer config fails.
{
- bool success = context->contextPriv().readSurfacePixels(proxy.get(), nullptr,
- 0, 0, kS, kS,
- kRGBA_8888_GrPixelConfig,
- nullptr, readData.get());
+ bool success = texture->readPixels(0, 0, kS, kS, kRGBA_8888_GrPixelConfig, readData.get());
REPORTER_ASSERT(reporter, !success);
}
{
std::unique_ptr<uint16_t[]> halfData(new uint16_t[4 * kS * kS]);
- bool success = context->contextPriv().readSurfacePixels(proxy.get(), nullptr,
- 0, 0, kS, kS,
- kRGBA_half_GrPixelConfig,
- nullptr, halfData.get());
+ bool success = texture->readPixels(0, 0, kS, kS, kRGBA_half_GrPixelConfig, halfData.get());
REPORTER_ASSERT(reporter, !success);
}
{
// we don't support. Right now this test is counting on GR_RGBA_INTEGER/GL_BYTE being the
// implementation-dependent second format).
sk_bzero(readData.get(), sizeof(int32_t) * kS * kS);
- bool success = context->contextPriv().readSurfacePixels(proxy.get(), nullptr,
- 0, 0, kS, kS,
- kRGBA_8888_sint_GrPixelConfig,
- nullptr, readData.get());
+ bool success = texture->readPixels(0, 0, kS, kS, kRGBA_8888_sint_GrPixelConfig,
+ readData.get());
REPORTER_ASSERT(reporter, success);
if (success) {
check_pixels(reporter, kS, kS, testData.get(), readData.get(), "readPixels");
}
{
// readPixels should fail if we attempt to use the unpremul flag with an integer texture.
- bool success = context->contextPriv().readSurfacePixels(
- proxy.get(), nullptr,
- 0, 0, kS, kS,
- kRGBA_8888_sint_GrPixelConfig,
- nullptr, readData.get(), 0,
- GrContextPriv::kUnpremul_PixelOpsFlag);
+ bool success = texture->readPixels(0, 0, kS, kS, kRGBA_8888_sint_GrPixelConfig,
+ readData.get(), 0, GrContext::kUnpremul_PixelOpsFlag);
REPORTER_ASSERT(reporter, !success);
}
return;
}
+ GrSurface* copySurface = dstContext->asTextureProxy()->instantiate(
+ context->resourceProvider());
+ REPORTER_ASSERT(reporter, copySurface);
+ if (!copySurface) {
+ return;
+ }
+
sk_bzero(readData.get(), sizeof(int32_t) * kS * kS);
- bool success = context->contextPriv().readSurfacePixels(dstContext->asSurfaceProxy(),
- nullptr, 0, 0, kS, kS,
- kRGBA_8888_sint_GrPixelConfig,
- nullptr, readData.get());
+ bool success = copySurface->readPixels(0, 0, kS, kS,
+ kRGBA_8888_sint_GrPixelConfig, readData.get());
REPORTER_ASSERT(reporter, success);
if (success) {
check_pixels(reporter, kS, kS, testData.get(), readData.get(), "copyIntegerToInteger");
{
// Can't write pixels from a non-int config.
- bool success = context->contextPriv().writeSurfacePixels(proxy.get(), nullptr,
- 0, 0, kS/2, kS/2,
- kRGBA_8888_GrPixelConfig, nullptr,
- bottomRightQuarter, kRowBytes);
+ bool success = texture->writePixels(0, 0, kS/2, kS/2, kRGBA_8888_GrPixelConfig,
+ bottomRightQuarter, kRowBytes);
REPORTER_ASSERT(reporter, !success);
}
{
// Can't use unpremul flag.
- bool success = context->contextPriv().writeSurfacePixels(
- proxy.get(), nullptr,
- 0, 0, kS/2, kS/2,
- kRGBA_8888_sint_GrPixelConfig,
- nullptr,
+ bool success = texture->writePixels(0, 0, kS/2, kS/2, kRGBA_8888_sint_GrPixelConfig,
bottomRightQuarter, kRowBytes,
- GrContextPriv::kUnpremul_PixelOpsFlag);
+ GrContext::kUnpremul_PixelOpsFlag);
REPORTER_ASSERT(reporter, !success);
}
{
- bool success = context->contextPriv().writeSurfacePixels(proxy.get(), nullptr,
- 0, 0, kS/2, kS/2,
- kRGBA_8888_sint_GrPixelConfig,
- nullptr,
- bottomRightQuarter, kRowBytes);
+ bool success = texture->writePixels(0, 0, kS/2, kS/2, kRGBA_8888_sint_GrPixelConfig,
+ bottomRightQuarter, kRowBytes);
REPORTER_ASSERT(reporter, success);
if (!success) {
return;
}
sk_bzero(readData.get(), sizeof(int32_t) * kS * kS);
- success = context->contextPriv().readSurfacePixels(proxy.get(), nullptr,
- 0, 0, kS, kS,
- kRGBA_8888_sint_GrPixelConfig,
- nullptr, readData.get(), 0);
+ success = texture->readPixels(0, 0, kS, kS, kRGBA_8888_sint_GrPixelConfig, readData.get());
REPORTER_ASSERT(reporter, success);
if (!success) {
return;
expectedData.get()[i] = ((0xFF * a) << 24) | ((0xFF * b) << 16) |
((0xFF * g) << 8) | (0xFF * r);
}
- context->contextPriv().writeSurfacePixels(proxy.get(), nullptr,
- 0, 0, kS, kS,
- kRGBA_8888_sint_GrPixelConfig, nullptr,
- testData.get(), 0);
+ texture->writePixels(0, 0, kS, kS, kRGBA_8888_sint_GrPixelConfig, testData.get());
+
+ sk_sp<GrTextureProxy> intTextureProxy = GrSurfaceProxy::MakeWrapped(sk_ref_sp(texture));
+ texture = nullptr; // unused from here on out
sk_sp<GrRenderTargetContext> rtContext = context->makeRenderTargetContext(
SkBackingFit::kExact, kS, kS, kRGBA_8888_GrPixelConfig, nullptr);
for (auto filter : kNamedFilters) {
sk_sp<GrFragmentProcessor> fp(GrSimpleTextureEffect::Make(context->resourceProvider(),
- proxy, nullptr,
+ intTextureProxy, nullptr,
SkMatrix::I(),
filter.fMode));
REPORTER_ASSERT(reporter, fp);
#if SK_SUPPORT_GPU
#include "GrContext.h"
-#include "GrContextPriv.h"
#include "GrResourceProvider.h"
#include "GrTexture.h"
desc.fHeight = DEV_H;
desc.fConfig = config;
desc.fOrigin = 0 == origin ? kTopLeft_GrSurfaceOrigin : kBottomLeft_GrSurfaceOrigin;
- sk_sp<GrTextureProxy> fpProxy = GrSurfaceProxy::MakeDeferred(context->resourceProvider(),
- desc, SkBudgeted::kNo,
- controlPixelData.begin(), 0);
- SkASSERT(fpProxy);
- context->contextPriv().readSurfacePixels(fpProxy.get(), nullptr, 0, 0, DEV_W, DEV_H,
- kRGBA_8888_GrPixelConfig, nullptr,
- readBuffer.begin(), 0);
+ sk_sp<GrTexture> fpTexture(context->resourceProvider()->createTexture(
+ desc, SkBudgeted::kNo, controlPixelData.begin(), 0));
+ SkASSERT(fpTexture);
+ fpTexture->readPixels(0, 0, DEV_W, DEV_H, kRGBA_8888_GrPixelConfig, readBuffer.begin(), 0);
if (kRGBA_4444_GrPixelConfig == config) {
check_4444(reporter, controlPixelData, readBuffer);
} else {
desc,
SkBackingFit::kExact,
SkBudgeted::kYes));
- sk_sp<GrTexture> texture2 =
- context->resourceProvider()->createTexture(desc, SkBudgeted::kYes);
- sk_sp<GrTexture> texture3 =
- context->resourceProvider()->createTexture(desc, SkBudgeted::kYes);
- sk_sp<GrTexture> texture4 =
- context->resourceProvider()->createTexture(desc, SkBudgeted::kYes);
+ sk_sp<GrTexture> texture2(
+ context->resourceProvider()->createTexture(desc, SkBudgeted::kYes));
+ sk_sp<GrTexture> texture3(
+ context->resourceProvider()->createTexture(desc, SkBudgeted::kYes));
+ sk_sp<GrTexture> texture4(
+ context->resourceProvider()->createTexture(desc, SkBudgeted::kYes));
sk_sp<GrBuffer> buffer(texelBufferSupport
? context->resourceProvider()->createBuffer(
1024, GrBufferType::kTexel_GrBufferType,
desc.fFlags = kRenderTarget_GrSurfaceFlag;
desc.fConfig = kRGBA_8888_GrPixelConfig;
- sk_sp<GrTextureProxy> proxies[2];
-
// Put premul data into the RGBA texture that the test FPs can optionally use.
std::unique_ptr<GrColor[]> rgbaData(new GrColor[256 * 256]);
for (int y = 0; y < 256; ++y) {
texel_color(random.nextULessThan(256), random.nextULessThan(256));
}
}
- proxies[0] = GrSurfaceProxy::MakeDeferred(context->resourceProvider(), desc, SkBudgeted::kYes,
- rgbaData.get(), 256 * sizeof(GrColor));
+ sk_sp<GrTexture> tex0(context->resourceProvider()->createTexture(
+ desc, SkBudgeted::kYes, rgbaData.get(), 256 * sizeof(GrColor)));
// Put random values into the alpha texture that the test FPs can optionally use.
desc.fConfig = kAlpha_8_GrPixelConfig;
alphaData.get()[256 * y + x] = random.nextULessThan(256);
}
}
- proxies[1] = GrSurfaceProxy::MakeDeferred(context->resourceProvider(), desc, SkBudgeted::kYes,
- alphaData.get(), 256);
- GrProcessorTestData testData(&random, context, rtc.get(), proxies);
+ sk_sp<GrTexture> tex1(context->resourceProvider()->createTexture(desc, SkBudgeted::kYes,
+ alphaData.get(), 256));
+ GrTexture* textures[] = {tex0.get(), tex1.get()};
+ GrProcessorTestData testData(&random, context, rtc.get(), textures);
// Use a different array of premul colors for the output of the fragment processor that preceeds
// the fragment processor under test.
if (SkBackingFit::kApprox == fit) {
tex.reset(provider->createApproxTexture(desc, 0));
} else {
- tex = provider->createTexture(desc, budgeted);
+ tex.reset(provider->createTexture(desc, budgeted));
}
sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(
if (SkBackingFit::kApprox == fit) {
tex.reset(provider->createApproxTexture(desc, 0));
} else {
- tex = provider->createTexture(desc, budgeted);
+ tex.reset(provider->createTexture(desc, budgeted));
}
sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(provider,
// Internal offscreen render target.
if (renderable) {
desc.fFlags = kRenderTarget_GrSurfaceFlag;
- tex = provider->createTexture(desc, budgeted);
+ tex.reset(provider->createTexture(desc, budgeted));
sk_sp<GrRenderTarget> rt(sk_ref_sp(tex->asRenderTarget()));
sk_sp<GrSurfaceProxy> sProxy(GrSurfaceProxy::MakeWrapped(rt));
if (!tex) {
SkASSERT(kNone_GrSurfaceFlags == desc.fFlags );
desc.fSampleCnt = 0;
- tex = provider->createTexture(desc, budgeted);
+ tex.reset(provider->createTexture(desc, budgeted));
}
sk_sp<GrSurfaceProxy> sProxy(GrSurfaceProxy::MakeWrapped(tex));
#if SK_SUPPORT_GPU
#include "GrContext.h"
-#include "GrContextPriv.h"
#include "GrResourceProvider.h"
#include "SkGr.h"
#endif
}
#if SK_SUPPORT_GPU
-static void fill_src_texture(GrContext* context, GrTextureProxy* proxy) {
+static void fill_src_texture(GrTexture* texture) {
SkBitmap bmp = make_src_bitmap();
bmp.lockPixels();
-
- SkDEBUGCODE(bool result =) context->contextPriv().writeSurfacePixels(
- proxy, nullptr,
- 0, 0, DEV_W, DEV_H,
- kSkia8888_GrPixelConfig, nullptr,
- bmp.getPixels(), bmp.rowBytes());
- SkASSERT(result);
+ texture->writePixels(0, 0, DEV_W, DEV_H, kSkia8888_GrPixelConfig, bmp.getPixels(),
+ bmp.rowBytes());
bmp.unlockPixels();
}
#endif
#endif
#if SK_SUPPORT_GPU
-static void test_readpixels_texture(skiatest::Reporter* reporter,
- GrContext* context, sk_sp<GrTextureProxy> proxy) {
- fill_src_texture(context, proxy.get());
+static void test_readpixels_texture(skiatest::Reporter* reporter, GrTexture* texture) {
+ fill_src_texture(texture);
for (size_t rect = 0; rect < SK_ARRAY_COUNT(gReadPixelsTestRects); ++rect) {
const SkIRect& srcRect = gReadPixelsTestRects[rect];
for (BitmapInit bmi = kFirstBitmapInit; bmi <= kLast_BitmapInit; bmi = nextBMI(bmi)) {
// Try doing the read directly from a non-renderable texture
if (startsWithPixels) {
fill_dst_bmp_with_init_data(&bmp);
- GrPixelConfig dstConfig = SkImageInfo2GrPixelConfig(bmp.info(),
- *context->caps());
+ GrPixelConfig dstConfig =
+ SkImageInfo2GrPixelConfig(bmp.info(), *texture->getContext()->caps());
uint32_t flags = 0;
if (gReadPixelsConfigs[c].fAlphaType == kUnpremul_SkAlphaType) {
- flags = GrContextPriv::kUnpremul_PixelOpsFlag;
+ flags = GrContext::kUnpremul_PixelOpsFlag;
}
bmp.lockPixels();
- bool success = context->contextPriv().readSurfacePixels(
- proxy.get(), nullptr,
- srcRect.fLeft, srcRect.fTop, bmp.width(),
- bmp.height(), dstConfig, nullptr,
- bmp.getPixels(), bmp.rowBytes(), flags);
+ bool success = texture->readPixels(srcRect.fLeft, srcRect.fTop, bmp.width(),
+ bmp.height(), dstConfig, bmp.getPixels(),
+ bmp.rowBytes(), flags);
bmp.unlockPixels();
check_read(reporter, bmp, srcRect.fLeft, srcRect.fTop,
success, true,
desc.fHeight = DEV_H;
desc.fConfig = kSkia8888_GrPixelConfig;
desc.fOrigin = origin;
- sk_sp<GrTexture> texture =
- ctxInfo.grContext()->resourceProvider()->createTexture(desc, SkBudgeted::kNo);
- test_readpixels_texture(reporter, ctxInfo.grContext(),
- GrSurfaceProxy::MakeWrapped(std::move(texture)));
+ sk_sp<GrTexture> texture(ctxInfo.grContext()->resourceProvider()->createTexture(desc,
+ SkBudgeted::kNo));
+ test_readpixels_texture(reporter, texture.get());
}
}
}
rgbaData[y * X_SIZE + x] = GrColorPackRGBA(6, 7, 8, alphaData[y * X_SIZE + x]);
}
}
- sk_sp<GrTextureProxy> proxy =
- GrSurfaceProxy::MakeDeferred(context->resourceProvider(), desc, SkBudgeted::kNo,
- rgbaData, 0);
- if (!proxy) {
+ sk_sp<GrTexture> texture(
+ context->resourceProvider()->createTexture(desc, SkBudgeted::kNo, rgbaData, 0));
+ if (!texture) {
// We always expect to be able to create a RGBA texture
if (!rt && kRGBA_8888_GrPixelConfig == desc.fConfig) {
ERRORF(reporter, "Failed to create RGBA texture.");
memset(readback.get(), kClearValue, nonZeroRowBytes * Y_SIZE);
// read the texture back
- bool result = context->contextPriv().readSurfacePixels(
- proxy.get(), nullptr,
- 0, 0, desc.fWidth, desc.fHeight,
- kAlpha_8_GrPixelConfig, nullptr,
+ bool result = texture->readPixels(0, 0, desc.fWidth, desc.fHeight,
+ kAlpha_8_GrPixelConfig,
readback.get(), rowBytes);
REPORTER_ASSERT_MESSAGE(reporter, result, "8888 readPixels failed");
smallMSAART0 && smallMSAART0->asRenderTarget() &&
smallMSAART0->asRenderTarget()->numColorSamples() < 8) {
smallMSAADesc.fSampleCnt = 8;
- smallMSAART1 = resourceProvider->createTexture(smallMSAADesc, SkBudgeted::kNo);
+ smallMSAART1.reset(resourceProvider->createTexture(smallMSAADesc, SkBudgeted::kNo));
sk_sp<GrTexture> smallMSAART1(
resourceProvider->createTexture(smallMSAADesc, SkBudgeted::kNo));
if (smallMSAART1 && smallMSAART1->asRenderTarget()) {
desc.fConfig = kRGBA_8888_GrPixelConfig;
desc.fSampleCnt = sampleCnt;
- return provider->createTexture(desc, SkBudgeted::kYes);
+ return sk_sp<GrTexture>(provider->createTexture(desc, SkBudgeted::kYes));
}
-static sk_sp<GrTextureProxy> make_mipmap_proxy(GrResourceProvider* provider,
- GrSurfaceFlags flags,
- int width, int height,
- int sampleCnt) {
+static sk_sp<GrTexture> make_mipmap_texture(GrResourceProvider* provider,
+ GrSurfaceFlags flags,
+ int width, int height,
+ int sampleCnt) {
SkBitmap bm;
bm.allocN32Pixels(width, height, true);
desc.fSampleCnt = sampleCnt;
desc.fIsMipMapped = true;
- return provider->createMipMappedTexture(desc, SkBudgeted::kYes, texels.get(), mipLevelCount);
+ return sk_sp<GrTexture>(provider->createMipMappedTexture(desc, SkBudgeted::kYes,
+ texels.get(), mipLevelCount));
}
// Exercise GrSurface::gpuMemorySize for different combos of MSAA, RT-only,
static const int kSize = 64;
+ sk_sp<GrTexture> tex;
+
// Normal versions
- {
- sk_sp<GrTexture> tex;
-
- tex = make_normal_texture(provider, kRenderTarget_GrSurfaceFlag, kSize, kSize, 0);
- size_t size = tex->gpuMemorySize();
- REPORTER_ASSERT(reporter, kSize*kSize*4 == size);
-
- if (context->caps()->maxSampleCount() >= 4) {
- tex = make_normal_texture(provider, kRenderTarget_GrSurfaceFlag, kSize, kSize, 4);
- size = tex->gpuMemorySize();
- REPORTER_ASSERT(reporter, kSize*kSize*4 == size || // msaa4 failed
- kSize*kSize*4*4 == size || // auto-resolving
- kSize*kSize*4*5 == size); // explicit resolve buffer
- }
+ tex = make_normal_texture(provider, kRenderTarget_GrSurfaceFlag, kSize, kSize, 0);
+ size_t size = tex->gpuMemorySize();
+ REPORTER_ASSERT(reporter, kSize*kSize*4 == size);
- tex = make_normal_texture(provider, kNone_GrSurfaceFlags, kSize, kSize, 0);
+ if (context->caps()->maxSampleCount() >= 4) {
+ tex = make_normal_texture(provider, kRenderTarget_GrSurfaceFlag, kSize, kSize, 4);
size = tex->gpuMemorySize();
- REPORTER_ASSERT(reporter, kSize*kSize*4 == size);
+ REPORTER_ASSERT(reporter, kSize*kSize*4 == size || // msaa4 failed
+ kSize*kSize*4*4 == size || // auto-resolving
+ kSize*kSize*4*5 == size); // explicit resolve buffer
}
+ tex = make_normal_texture(provider, kNone_GrSurfaceFlags, kSize, kSize, 0);
+ size = tex->gpuMemorySize();
+ REPORTER_ASSERT(reporter, kSize*kSize*4 == size);
// Mipmapped versions
- {
- sk_sp<GrTextureProxy> proxy;
+ tex = make_mipmap_texture(provider, kRenderTarget_GrSurfaceFlag, kSize, kSize, 0);
+ size = tex->gpuMemorySize();
+ REPORTER_ASSERT(reporter, kSize*kSize*4+(kSize*kSize*4)/3 == size);
- proxy = make_mipmap_proxy(provider, kRenderTarget_GrSurfaceFlag, kSize, kSize, 0);
- size_t size = proxy->gpuMemorySize();
- REPORTER_ASSERT(reporter, kSize*kSize*4+(kSize*kSize*4)/3 == size);
-
- if (context->caps()->maxSampleCount() >= 4) {
- proxy = make_mipmap_proxy(provider, kRenderTarget_GrSurfaceFlag, kSize, kSize, 4);
- size = proxy->gpuMemorySize();
- REPORTER_ASSERT(reporter,
+ if (context->caps()->maxSampleCount() >= 4) {
+ tex = make_mipmap_texture(provider, kRenderTarget_GrSurfaceFlag, kSize, kSize, 4);
+ size = tex->gpuMemorySize();
+ REPORTER_ASSERT(reporter,
kSize*kSize*4+(kSize*kSize*4)/3 == size || // msaa4 failed
kSize*kSize*4*4+(kSize*kSize*4)/3 == size || // auto-resolving
kSize*kSize*4*5+(kSize*kSize*4)/3 == size); // explicit resolve buffer
- }
-
- proxy = make_mipmap_proxy(provider, kNone_GrSurfaceFlags, kSize, kSize, 0);
- size = proxy->gpuMemorySize();
- REPORTER_ASSERT(reporter, kSize*kSize*4+(kSize*kSize*4)/3 == size);
}
+
+ tex = make_mipmap_texture(provider, kNone_GrSurfaceFlags, kSize, kSize, 0);
+ size = tex->gpuMemorySize();
+ REPORTER_ASSERT(reporter, kSize*kSize*4+(kSize*kSize*4)/3 == size);
}
#endif
kPremul_SkAlphaType);
GrSurfaceDesc desc;
desc.fFlags = kRenderTarget_GrSurfaceFlag;
- desc.fOrigin = kBottomLeft_GrSurfaceOrigin;
desc.fWidth = kW;
desc.fHeight = kH;
desc.fConfig = kSRGBA_8888_GrPixelConfig;
}
copyDstDesc.fFlags = flags;
- copyDstDesc.fOrigin = (kNone_GrSurfaceFlags == flags) ? kTopLeft_GrSurfaceOrigin
- : kBottomLeft_GrSurfaceOrigin;
sk_sp<GrSurfaceContext> dstContext(GrSurfaceProxy::TestCopy(context, copyDstDesc, proxy));
for (auto flags : { kNone_GrSurfaceFlags, kRenderTarget_GrSurfaceFlag }) {
copySrcDesc.fFlags = flags;
- copySrcDesc.fOrigin = (kNone_GrSurfaceFlags == flags) ? kTopLeft_GrSurfaceOrigin
- : kBottomLeft_GrSurfaceOrigin;
sk_sp<GrTextureProxy> src(GrSurfaceProxy::MakeDeferred(resourceProvider,
copySrcDesc,
#if SK_SUPPORT_GPU && SK_ALLOW_STATIC_GLOBAL_INITIALIZERS && defined(SK_VULKAN)
#include "GrContextFactory.h"
-#include "GrContextPriv.h"
#include "GrTest.h"
#include "Test.h"
#include "vk/GrVkGpu.h"
surfDesc.fHeight = kHeight;
surfDesc.fConfig = config;
surfDesc.fSampleCnt = 0;
- sk_sp<GrTexture> tex0(gpu->createTexture(surfDesc, SkBudgeted::kNo, srcBuffer, 0));
+ GrTexture* tex0 = gpu->createTexture(surfDesc, SkBudgeted::kNo, srcBuffer, 0);
if (tex0) {
REPORTER_ASSERT(reporter, canCreate);
- gpu->readPixels(tex0.get(), 0, 0, kWidth, kHeight, config, dstBuffer, 0);
+ gpu->readPixels(tex0, 0, 0, kWidth, kHeight, config, dstBuffer, 0);
REPORTER_ASSERT(reporter, does_full_buffer_contain_correct_color(srcBuffer,
dstBuffer,
config,
kWidth,
kHeight));
- sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeWrapped(tex0);
-
- bool success = context->contextPriv().writeSurfacePixels(proxy.get(), nullptr,
- 2, 10, 10, 2,
- config, nullptr, srcBuffer, 0);
- REPORTER_ASSERT(reporter, success);
-
+ tex0->writePixels(2, 10, 10, 2, config, srcBuffer);
memset(dstBuffer, 0, kWidth*kHeight*sizeof(GrColor));
- gpu->readPixels(tex0.get(), 2, 10, 10, 2, config, dstBuffer, 0);
+ gpu->readPixels(tex0, 2, 10, 10, 2, config, dstBuffer, 0);
REPORTER_ASSERT(reporter, does_full_buffer_contain_correct_color(srcBuffer,
dstBuffer,
config,
10,
2));
+
+ tex0->unref();
} else {
REPORTER_ASSERT(reporter, !canCreate);
}
surfDesc.fOrigin = kBottomLeft_GrSurfaceOrigin;
- sk_sp<GrTexture> tex1(gpu->createTexture(surfDesc, SkBudgeted::kNo, srcBuffer, 0));
+ GrTexture* tex1 = gpu->createTexture(surfDesc, SkBudgeted::kNo, srcBuffer, 0);
if (tex1) {
REPORTER_ASSERT(reporter, canCreate);
- gpu->readPixels(tex1.get(), 0, 0, kWidth, kHeight, config, dstBuffer, 0);
+ gpu->readPixels(tex1, 0, 0, kWidth, kHeight, config, dstBuffer, 0);
REPORTER_ASSERT(reporter, does_full_buffer_contain_correct_color(srcBuffer,
dstBuffer,
config,
kWidth,
kHeight));
- sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeWrapped(tex1);
-
- bool success = context->contextPriv().writeSurfacePixels(proxy.get(), nullptr,
- 5, 4, 4, 5, config, nullptr,
- srcBuffer, 0);
- REPORTER_ASSERT(reporter, success);
-
+ tex1->writePixels(5, 4, 4, 5, config, srcBuffer);
memset(dstBuffer, 0, kWidth*kHeight*sizeof(GrColor));
- gpu->readPixels(tex1.get(), 5, 4, 4, 5, config, dstBuffer, 0);
+ gpu->readPixels(tex1, 5, 4, 4, 5, config, dstBuffer, 0);
REPORTER_ASSERT(reporter, does_full_buffer_contain_correct_color(srcBuffer,
dstBuffer,
config,
4,
5));
+ tex1->unref();
} else {
REPORTER_ASSERT(reporter, !canCreate);
}
projects / platform / upstream / libSkiaSharp.git / commitdiff