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

Revert 2717

Browse Source 
git-svn-id: http://skia.googlecode.com/svn/trunk@2718 2bbb7eff-a529-9590-31e7-b0007b416f81
This commit is contained in:
bsalomon@google.com 2011-11-18 21:07:03 +00:00
parent 5c56e3441c
commit 484be2bafd
6 changed files with 27 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
include/gpu/GrGLConfig.h
View File

@ -78,9 +78,9 @@
* The GrGLInterface field fCallback specifies the function ptr and there is an
* additional field fCallbackData of type intptr_t for client data.
*
* GR_GL_RGBA_8888_PIXEL_OPS_SLOW: Set this to 1 if it is known that performing
* glReadPixels / glTex(Sub)Image with format=GL_RGBA, type=GL_UNISIGNED_BYTE is
* significantly slower than format=GL_BGRA, type=GL_UNISIGNED_BYTE.
* GR_GL_RGBA_8888_READBACK_SLOW: Set this to 1 if it is known that performing
* glReadPixels with format=GL_RGBA, type=GL_UNISIGNED_BYTE is significantly
* slower than format=GL_BGRA, type=GL_UNISIGNED_BYTE.
*/
#if !defined(GR_GL_LOG_CALLS)
@ -115,8 +115,8 @@
#define GR_GL_PER_GL_FUNC_CALLBACK 0
#endif
#if !defined(GR_GL_RGBA_8888_PIXEL_OPS_SLOW)
#define GR_GL_RGBA_8888_PIXEL_OPS_SLOW 0
#if !defined(GR_GL_RGBA_8888_READBACK_SLOW)
#define GR_GL_RGBA_8888_READBACK_SLOW 0
#endif
#if(GR_GL_NO_CONSTANT_ATTRIBUTES) && (GR_GL_ATTRIBUTE_MATRICES)

4
include/gpu/GrGLConfig_chrome.h
View File

@ -14,8 +14,8 @@
// ANGLE creates a temp VB for vertex attributes not specified per-vertex.
#define GR_GL_NO_CONSTANT_ATTRIBUTES GR_WIN32_BUILD
// For RGBA teximage/readpixels ANGLE will sw-convert to/from BGRA.
#define GR_GL_RGBA_8888_PIXEL_OPS_SLOW GR_WIN32_BUILD
// RGBA Readbacks are a slow path in ANGLE
#define GR_GL_RGBA_8888_READBACK_SLOW GR_WIN32_BUILD
// cmd buffer allocates memory and memsets it to zero when it sees glBufferData
// with NULL.

20
src/gpu/GrContext.cpp
View File

@ -1803,25 +1803,6 @@ void GrContext::internalWriteRenderTargetPixels(GrRenderTarget* target,
// TODO: when underlying api has a direct way to do this we should use it
// (e.g. glDrawPixels on desktop GL).
// If the RT is also a texture and we don't have to do PM/UPM conversion
// then take the texture path, which we expect to be at least as fast or
// faster since it doesn't use an intermediate texture as we do below.
if (NULL != target->asTexture() &&
GrPixelConfigIsUnpremultiplied(target->config()) ==
GrPixelConfigIsUnpremultiplied(config)) {
this->internalWriteTexturePixels(target->asTexture(),
left, top, width, height,
config, buffer, rowBytes, flags);
return;
}
bool swapRAndB = fGpu->preferredReadPixelsConfig(config) ==
GrPixelConfigSwapRAndB(config);
if (swapRAndB) {
config = GrPixelConfigSwapRAndB(config);
}
const GrTextureDesc desc = {
kNone_GrTextureFlags, kNone_GrAALevel, width, height, { config }
};
@ -1846,7 +1827,6 @@ void GrContext::internalWriteRenderTargetPixels(GrRenderTarget* target,
sampler.setClampNoFilter();
matrix.setIDiv(texture->width(), texture->height());
sampler.setMatrix(matrix);
sampler.setRAndBSwap(swapRAndB);
fGpu->setSamplerState(0, sampler);
GrVertexLayout layout = GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(0);

8
src/gpu/GrGpu.h
View File

@ -194,13 +194,6 @@ public:
return config;
}
/**
* Same as above but applies to writeTexturePixels
*/
virtual GrPixelConfig preferredWritePixelsConfig(GrPixelConfig config) {
return config;
}
/**
* OpenGL's readPixels returns the result bottom-to-top while the skia
* API is top-to-bottom. Thus we have to do a y-axis flip. The obvious
@ -254,7 +247,6 @@ public:
/**
* Updates the pixels in a rectangle of a texture.
*
* @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.

85
src/gpu/GrGpuGL.cpp
View File

@ -439,15 +439,7 @@ void GrGpuGL::initStencilFormats() {
}
GrPixelConfig GrGpuGL::preferredReadPixelsConfig(GrPixelConfig config) {
if (GR_GL_RGBA_8888_PIXEL_OPS_SLOW && GrPixelConfigIsRGBA8888(config)) {
return GrPixelConfigSwapRAndB(config);
} else {
return config;
}
}
GrPixelConfig GrGpuGL::preferredWritePixelsConfig(GrPixelConfig config) {
if (GR_GL_RGBA_8888_PIXEL_OPS_SLOW && GrPixelConfigIsRGBA8888(config)) {
if (GR_GL_RGBA_8888_READBACK_SLOW && GrPixelConfigIsRGBA8888(config)) {
return GrPixelConfigSwapRAndB(config);
} else {
return config;
@ -701,46 +693,21 @@ void GrGpuGL::onWriteTexturePixels(GrTexture* texture,
this->uploadTexData(desc, left, top, width, height, config, buffer, rowBytes);
}
namespace {
bool adjust_pixel_ops_params(int surfaceWidth,
int surfaceHeight,
size_t bpp,
int* left, int* top, int* width, int* height,
const void** data,
size_t* rowBytes) {
if (!*rowBytes) {
*rowBytes = *width * bpp;
}
GrIRect subRect = GrIRect::MakeXYWH(*left, *top, *width, *height);
GrIRect bounds = GrIRect::MakeWH(surfaceWidth, surfaceHeight);
if (!subRect.intersect(bounds)) {
return false;
}
*data = reinterpret_cast<const void*>(reinterpret_cast<intptr_t>(*data) +
(subRect.fTop - *top) * *rowBytes + (subRect.fLeft - *left) * bpp);
*left = subRect.fLeft;
*top = subRect.fTop;
*width = subRect.width();
*height = subRect.height();
return true;
}
}
void GrGpuGL::uploadTexData(const GrGLTexture::Desc& desc,
int left, int top, int width, int height,
GrPixelConfig dataConfig,
const void* data,
size_t rowBytes) {
size_t bpp = GrBytesPerPixel(dataConfig);
if (!adjust_pixel_ops_params(desc.fWidth, desc.fHeight, bpp, &left, &top,
&width, &height, &data, &rowBytes)) {
GrIRect bounds = GrIRect::MakeWH(desc.fWidth, desc.fHeight);
GrIRect subrect = GrIRect::MakeXYWH(left, top, width, height);
if (!bounds.contains(subrect)) {
return;
}
size_t trimRowBytes = width * bpp;
// ES2 glCompressedTexSubImage2D doesn't support any formats
// (at least without extensions)
GrAssert(desc.fInternalFormat != GR_GL_PALETTE8_RGBA8 ||
bounds == subrect);
// in case we need a temporary, trimmed copy of the src pixels
SkAutoSMalloc<128 * 128> tempStorage;
@ -753,6 +720,11 @@ void GrGpuGL::uploadTexData(const GrGLTexture::Desc& desc,
return;
}
size_t bpp = GrBytesPerPixel(dataConfig);
size_t trimRowBytes = width * bpp;
if (!rowBytes) {
rowBytes = trimRowBytes;
}
/*
* check whether to allocate a temporary buffer for flipping y or
* because our srcData has extra bytes past each row. If so, we need
@ -786,14 +758,13 @@ void GrGpuGL::uploadTexData(const GrGLTexture::Desc& desc,
}
dst += trimRowBytes;
}
// now point data to our copied version
// now point dat to our copied version
data = tempStorage.get();
}
}
GL_CALL(PixelStorei(GR_GL_UNPACK_ALIGNMENT, static_cast<GrGLint>(bpp)));
if (0 == left && 0 == top &&
desc.fWidth == width && desc.fHeight == height) {
if (bounds == subrect) {
GL_CALL(TexImage2D(GR_GL_TEXTURE_2D, 0, desc.fInternalFormat,
desc.fWidth, desc.fHeight, 0,
externalFormat, externalType, data));
@ -1349,18 +1320,9 @@ bool GrGpuGL::readPixelsWillPayForYFlip(GrRenderTarget* renderTarget,
size_t rowBytes) {
// if we have to do memcpy to handle non-trim rowBytes then we
// get the flip for free. Otherwise it costs.
if (this->glCaps().fPackRowLengthSupport) {
return true;
}
// If we have to do memcpys to handle rowBytes then y-flip is free
// Note the rowBytes might be tight to the passed in data, but if data
// gets clipped in x to the target the rowBytes will no longer be tight.
if (left >= 0 && (left + width) < renderTarget->width()) {
return 0 == rowBytes ||
GrBytesPerPixel(config) * width == rowBytes;
} else {
return false;
}
return this->glCaps().fPackRowLengthSupport ||
0 == rowBytes ||
GrBytesPerPixel(config) * width == rowBytes;
}
bool GrGpuGL::onReadPixels(GrRenderTarget* target,
@ -1376,13 +1338,6 @@ bool GrGpuGL::onReadPixels(GrRenderTarget* target,
if (!this->canBeTexture(config, &internalFormat, &format, &type)) {
return false;
}
size_t bpp = GrBytesPerPixel(config);
if (!adjust_pixel_ops_params(target->width(), target->height(), bpp,
&left, &top, &width, &height,
const_cast<const void**>(&buffer),
&rowBytes)) {
return false;
}
// resolve the render target if necessary
GrGLRenderTarget* tgt = static_cast<GrGLRenderTarget*>(target);
@ -1411,7 +1366,7 @@ bool GrGpuGL::onReadPixels(GrRenderTarget* target,
GrGLIRect readRect;
readRect.setRelativeTo(glvp, left, top, width, height);
size_t tightRowBytes = bpp * width;
size_t tightRowBytes = GrBytesPerPixel(config) * width;
if (0 == rowBytes) {
rowBytes = tightRowBytes;
}

2
src/gpu/GrGpuGL.h
View File

@ -31,8 +31,6 @@ public:
virtual GrPixelConfig preferredReadPixelsConfig(GrPixelConfig config)
SK_OVERRIDE;
virtual GrPixelConfig preferredWritePixelsConfig(GrPixelConfig config)
SK_OVERRIDE;
virtual bool readPixelsWillPayForYFlip(
GrRenderTarget* renderTarget,