diff options
26 files changed, 615 insertions, 149 deletions
diff --git a/include/gpu/GrTypesPriv.h b/include/gpu/GrTypesPriv.h index 9202742df9..6135c14c12 100644 --- a/include/gpu/GrTypesPriv.h +++ b/include/gpu/GrTypesPriv.h @@ -25,8 +25,9 @@ enum GrSLType { kMat33f_GrSLType, kMat44f_GrSLType, kSampler2D_GrSLType, + kSamplerExternal_GrSLType, - kLast_GrSLType = kSampler2D_GrSLType + kLast_GrSLType = kSamplerExternal_GrSLType }; static const int kGrSLTypeCount = kLast_GrSLType + 1; @@ -63,7 +64,7 @@ static const int kGrSLPrecisionCount = kLast_GrSLPrecision + 1; */ static inline int GrSLTypeVectorCount(GrSLType type) { SkASSERT(type >= 0 && type < static_cast<GrSLType>(kGrSLTypeCount)); - static const int kCounts[] = { -1, 1, 2, 3, 4, -1, -1, -1 }; + static const int kCounts[] = { -1, 1, 2, 3, 4, -1, -1, -1, -1 }; return kCounts[type]; GR_STATIC_ASSERT(0 == kVoid_GrSLType); @@ -74,6 +75,7 @@ static inline int GrSLTypeVectorCount(GrSLType type) { GR_STATIC_ASSERT(5 == kMat33f_GrSLType); GR_STATIC_ASSERT(6 == kMat44f_GrSLType); GR_STATIC_ASSERT(7 == kSampler2D_GrSLType); + GR_STATIC_ASSERT(8 == kSamplerExternal_GrSLType); GR_STATIC_ASSERT(SK_ARRAY_COUNT(kCounts) == kGrSLTypeCount); } @@ -102,7 +104,8 @@ static inline bool GrSLTypeIsFloatType(GrSLType type) { GR_STATIC_ASSERT(5 == kMat33f_GrSLType); GR_STATIC_ASSERT(6 == kMat44f_GrSLType); GR_STATIC_ASSERT(7 == kSampler2D_GrSLType); - GR_STATIC_ASSERT(8 == kGrSLTypeCount); + GR_STATIC_ASSERT(8 == kSamplerExternal_GrSLType); + GR_STATIC_ASSERT(9 == kGrSLTypeCount); } ////////////////////////////////////////////////////////////////////////////// diff --git a/include/gpu/gl/GrGLFunctions.h b/include/gpu/gl/GrGLFunctions.h index a8a721e7e6..1086186df8 100644 --- a/include/gpu/gl/GrGLFunctions.h +++ b/include/gpu/gl/GrGLFunctions.h @@ -69,6 +69,7 @@ typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLDrawArraysProc)(GrGLenum mode, GrGLin typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLDrawBufferProc)(GrGLenum mode); typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLDrawBuffersProc)(GrGLsizei n, const GrGLenum* bufs); typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLDrawElementsProc)(GrGLenum mode, GrGLsizei count, GrGLenum type, const GrGLvoid* indices); +typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLEGLImageTargetTexture2DProc)(GrGLenum target, GrGLeglImage image); typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLEnableProc)(GrGLenum cap); typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLEnableVertexAttribArrayProc)(GrGLuint index); typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLEndQueryProc)(GrGLenum target); @@ -352,8 +353,8 @@ typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLObjectLabelProc)(GrGLenum identifier, /** EGL functions */ typedef const char* (GR_GL_FUNCTION_TYPE* GrEGLQueryStringProc)(GrEGLDisplay dpy, GrEGLint name); typedef GrEGLDisplay (GR_GL_FUNCTION_TYPE* GrEGLGetCurrentDisplayProc)(); -typedef GrEGLImageKHR (GR_GL_FUNCTION_TYPE* GrEGLCreateImageProc)(GrEGLDisplay dpy, GrEGLContext ctx, GrEGLenum target, GrEGLClientBuffer buffer, const GrEGLint *attrib_list); -typedef GrEGLBoolean (GR_GL_FUNCTION_TYPE* GrEGLDestroyImageProc)(GrEGLDisplay dpy, GrEGLImageKHR image); +typedef GrEGLImage (GR_GL_FUNCTION_TYPE* GrEGLCreateImageProc)(GrEGLDisplay dpy, GrEGLContext ctx, GrEGLenum target, GrEGLClientBuffer buffer, const GrEGLint *attrib_list); +typedef GrEGLBoolean (GR_GL_FUNCTION_TYPE* GrEGLDestroyImageProc)(GrEGLDisplay dpy, GrEGLImage image); } // extern "C" #endif diff --git a/include/gpu/gl/GrGLInterface.h b/include/gpu/gl/GrGLInterface.h index ec27ace81f..31429a8ebc 100644 --- a/include/gpu/gl/GrGLInterface.h +++ b/include/gpu/gl/GrGLInterface.h @@ -498,8 +498,8 @@ public: GLPtr<GrGLObjectLabelProc> fObjectLabel; /* EGL functions */ - GLPtr<GrEGLCreateImageProc> fCreateImage; - GLPtr<GrEGLDestroyImageProc> fDestroyImage; + GLPtr<GrEGLCreateImageProc> fEGLCreateImage; + GLPtr<GrEGLDestroyImageProc> fEGLDestroyImage; } fFunctions; // Per-GL func callback diff --git a/include/gpu/gl/GrGLTypes.h b/include/gpu/gl/GrGLTypes.h index 275eba556d..248ce8886d 100644 --- a/include/gpu/gl/GrGLTypes.h +++ b/include/gpu/gl/GrGLTypes.h @@ -57,12 +57,12 @@ typedef signed long int GrGLsizeiptr; typedef signed long int GrGLintptr; typedef signed long int GrGLsizeiptr; #endif - +typedef void* GrGLeglImage; /** * EGL types. */ -typedef void* GrEGLImageKHR; +typedef void* GrEGLImage; typedef void* GrEGLDisplay; typedef void* GrEGLContext; typedef void* GrEGLClientBuffer; diff --git a/include/gpu/gl/SkGLContext.h b/include/gpu/gl/SkGLContext.h index 75cfcfee04..3420a47973 100644 --- a/include/gpu/gl/SkGLContext.h +++ b/include/gpu/gl/SkGLContext.h @@ -14,8 +14,9 @@ /** * Create an offscreen opengl context with an RGBA8 / 8bit stencil FBO. * Provides a GrGLInterface struct of function pointers for the context. + * This class is intended for Skia's testing needs and not for general + * use. */ - class SK_API SkGLContext : public SkRefCnt { public: ~SkGLContext() override; @@ -36,6 +37,16 @@ public: void makeCurrent() const; + /** Used for testing EGLImage integration. Take a GL_TEXTURE_2D and wraps it in an EGL Image */ + virtual GrEGLImage texture2DToEGLImage(GrGLuint /*texID*/) const { return 0; } + virtual void destroyEGLImage(GrEGLImage) const {} + + /** + * Used for testing EGLImage integration. Takes a EGLImage and wraps it in a + * GL_TEXTURE_EXTERNAL_OES. + */ + virtual GrGLuint eglImageToExternalTexture(GrEGLImage) const { return 0; } + /** * The only purpose of this function it to provide a means of scheduling * work on the GPU (since all of the subclasses create primary buffers for @@ -59,6 +70,12 @@ public: */ void testAbandon(); + /** + * Creates a new GL context of the same type and makes the returned context current + * (if not null). + */ + virtual SkGLContext* createNew() const { return nullptr; } + class GLFenceSync; // SkGpuFenceSync implementation that uses the OpenGL functionality. protected: diff --git a/include/gpu/gl/angle/SkANGLEGLContext.h b/include/gpu/gl/angle/SkANGLEGLContext.h index 8d5f83041a..7858fff964 100644 --- a/include/gpu/gl/angle/SkANGLEGLContext.h +++ b/include/gpu/gl/angle/SkANGLEGLContext.h @@ -27,6 +27,10 @@ public: } return ctx; } + GrEGLImage texture2DToEGLImage(GrGLuint texID) const override; + void destroyEGLImage(GrEGLImage) const override; + GrGLuint eglImageToExternalTexture(GrEGLImage) const override; + SkGLContext* createNew() const override; // The param is an EGLNativeDisplayType and the return is an EGLDispay. static void* GetD3DEGLDisplay(void* nativeDisplay, bool useGLBackend); @@ -42,6 +46,7 @@ private: void* fContext; void* fDisplay; void* fSurface; + bool fIsGLBackend; }; #endif diff --git a/src/gpu/GrResourceProvider.cpp b/src/gpu/GrResourceProvider.cpp index 31568144a2..38213e6266 100644 --- a/src/gpu/GrResourceProvider.cpp +++ b/src/gpu/GrResourceProvider.cpp @@ -202,7 +202,7 @@ GrStencilAttachment* GrResourceProvider::attachStencilAttachment(GrRenderTarget* if (rt->renderTargetPriv().attachStencilAttachment(stencil)) { if (newStencil) { // Right now we're clearing the stencil attachment here after it is - // attached to an RT for the first time. When we start matching + // attached to a RT for the first time. When we start matching // stencil buffers with smaller color targets this will no longer // be correct because it won't be guaranteed to clear the entire // sb. diff --git a/src/gpu/gl/GrGLAssembleInterface.cpp b/src/gpu/gl/GrGLAssembleInterface.cpp index e606f4a29e..dbc54adbe4 100644 --- a/src/gpu/gl/GrGLAssembleInterface.cpp +++ b/src/gpu/gl/GrGLAssembleInterface.cpp @@ -14,7 +14,7 @@ #define GET_PROC_SUFFIX(F, S) functions->f ## F = (GrGL ## F ## Proc) get(ctx, "gl" #F #S) #define GET_PROC_LOCAL(F) GrGL ## F ## Proc F = (GrGL ## F ## Proc) get(ctx, "gl" #F) -#define GET_EGL_PROC_SUFFIX(F, S) functions->f ## F = (GrEGL ## F ## Proc) get(ctx, "egl" #F #S) +#define GET_EGL_PROC_SUFFIX(F, S) functions->fEGL ## F = (GrEGL ## F ## Proc) get(ctx, "egl" #F #S) const GrGLInterface* GrGLAssembleInterface(void* ctx, GrGLGetProc get) { GET_PROC_LOCAL(GetString); diff --git a/src/gpu/gl/GrGLCaps.cpp b/src/gpu/gl/GrGLCaps.cpp index 28401fe9e6..a768b37105 100644 --- a/src/gpu/gl/GrGLCaps.cpp +++ b/src/gpu/gl/GrGLCaps.cpp @@ -46,6 +46,7 @@ GrGLCaps::GrGLCaps(const GrContextOptions& contextOptions, fUseNonVBOVertexAndIndexDynamicData = false; fIsCoreProfile = false; fBindFragDataLocationSupport = false; + fExternalTextureSupport = false; fSRGBWriteControl = false; fRGBA8888PixelsOpsAreSlow = false; fPartialFBOReadIsSlow = false; @@ -259,6 +260,16 @@ void GrGLCaps::init(const GrContextOptions& contextOptions, fBindUniformLocationSupport = false; #endif + if (ctxInfo.hasExtension("GL_OES_EGL_image_external")) { + if (ctxInfo.glslGeneration() == k110_GrGLSLGeneration) { + fExternalTextureSupport = true; + } else if (ctxInfo.hasExtension("GL_OES_EGL_image_external_essl3") || + ctxInfo.hasExtension("OES_EGL_image_external_essl3")) { + // At least one driver has been found that has this extension without the "GL_" prefix. + fExternalTextureSupport = true; + } + } + #ifdef SK_BUILD_FOR_WIN // We're assuming that on Windows Chromium we're using ANGLE. bool isANGLE = kANGLE_GrGLDriver == ctxInfo.driver() || @@ -588,13 +599,21 @@ void GrGLCaps::initGLSL(const GrGLContextInfo& ctxInfo) { glslCaps->fSecondaryOutputExtensionString = "GL_EXT_blend_func_extended"; } + if (fExternalTextureSupport) { + if (ctxInfo.glslGeneration() == k110_GrGLSLGeneration) { + glslCaps->fExternalTextureExtensionString = "GL_OES_EGL_image_external"; + } else { + glslCaps->fExternalTextureExtensionString = "GL_OES_EGL_image_external_essl3"; + } + } + // The Tegra3 compiler will sometimes never return if we have min(abs(x), 1.0), so we must do // the abs first in a separate expression. if (kTegra3_GrGLRenderer == ctxInfo.renderer()) { glslCaps->fCanUseMinAndAbsTogether = false; } - // On Intel GPU there is an issue where it reads the second arguement to atan "- %s.x" as an int + // On Intel GPU there is an issue where it reads the second argument to atan "- %s.x" as an int // thus must us -1.0 * %s.x to work correctly if (kIntel_GrGLVendor == ctxInfo.vendor()) { glslCaps->fMustForceNegatedAtanParamToFloat = true; diff --git a/src/gpu/gl/GrGLCaps.h b/src/gpu/gl/GrGLCaps.h index 5f1ca3e340..0ec6c85b47 100644 --- a/src/gpu/gl/GrGLCaps.h +++ b/src/gpu/gl/GrGLCaps.h @@ -232,6 +232,9 @@ public: bool bindUniformLocationSupport() const { return fBindUniformLocationSupport; } + /// Are textures with GL_TEXTURE_EXTERNAL_OES type supported. + bool externalTextureSupport() const { return fExternalTextureSupport; } + /** * Is there support for enabling/disabling sRGB writes for sRGB-capable color attachments? * If false this does not mean sRGB is not supported but rather that if it is supported @@ -360,6 +363,7 @@ private: bool fRGBA8888PixelsOpsAreSlow : 1; bool fPartialFBOReadIsSlow : 1; bool fBindUniformLocationSupport : 1; + bool fExternalTextureSupport : 1; struct ReadPixelsSupportedFormat { GrGLenum fFormat; diff --git a/src/gpu/gl/GrGLDefines.h b/src/gpu/gl/GrGLDefines.h index 603a319ca0..dfab5e7e13 100644 --- a/src/gpu/gl/GrGLDefines.h +++ b/src/gpu/gl/GrGLDefines.h @@ -928,8 +928,18 @@ #define GR_GL_PROGRAM_PIPELINE 0x82E4 #define GR_GL_SAMPLER 0x82E6 +/* GL_OES_EGL_image_external */ +#define GR_GL_TEXTURE_EXTERNAL 0x8D65 + /* EGL Defines */ #define GR_EGL_NO_DISPLAY ((GrEGLDisplay)0) #define GR_EGL_EXTENSIONS 0x3055 +#define GR_EGL_GL_TEXTURE_2D 0x30B1 +#define GR_EGL_GL_TEXTURE_LEVEL 0x30BC +#define GR_EGL_IMAGE_PRESERVED 0x30D2 +#define GR_EGL_FALSE 0x0 +#define GR_EGL_TRUE 0x1 +#define GR_EGL_NONE 0x3038 +#define GR_EGL_NO_IMAGE ((GrEGLImage)0) #endif diff --git a/src/gpu/gl/GrGLGpu.cpp b/src/gpu/gl/GrGLGpu.cpp index 2bd36b6404..51145c8988 100644 --- a/src/gpu/gl/GrGLGpu.cpp +++ b/src/gpu/gl/GrGLGpu.cpp @@ -233,7 +233,7 @@ GrGLGpu::GrGLGpu(GrGLContext* ctx, GrContext* context) fPathRendering.reset(new GrGLPathRendering(this)); } - this->createCopyProgram(); + this->createCopyPrograms(); } GrGLGpu::~GrGLGpu() { @@ -253,12 +253,13 @@ GrGLGpu::~GrGLGpu() { GL_CALL(DeleteFramebuffers(1, &fStencilClearFBOID)); } - if (0 != fCopyProgram.fArrayBuffer) { - GL_CALL(DeleteBuffers(1, &fCopyProgram.fArrayBuffer)); + for (size_t i = 0; i < SK_ARRAY_COUNT(fCopyPrograms); ++i) { + if (0 != fCopyPrograms[i].fProgram) { + GL_CALL(DeleteProgram(fCopyPrograms[i].fProgram)); + } } - - if (0 != fCopyProgram.fProgram) { - GL_CALL(DeleteProgram(fCopyProgram.fProgram)); + if (0 != fCopyProgramArrayBuffer) { + GL_CALL(DeleteBuffers(1, &fCopyProgramArrayBuffer)); } delete fProgramCache; @@ -271,8 +272,10 @@ void GrGLGpu::contextAbandoned() { fTempSrcFBOID = 0; fTempDstFBOID = 0; fStencilClearFBOID = 0; - fCopyProgram.fArrayBuffer = 0; - fCopyProgram.fProgram = 0; + fCopyProgramArrayBuffer = 0; + for (size_t i = 0; i < SK_ARRAY_COUNT(fCopyPrograms); ++i) { + fCopyPrograms[i].fProgram = 0; + } if (this->glCaps().shaderCaps()->pathRenderingSupport()) { this->glPathRendering()->abandonGpuResources(); } @@ -429,6 +432,9 @@ GrTexture* GrGLGpu::onWrapBackendTexture(const GrBackendTextureDesc& desc, return nullptr; } + // next line relies on GrBackendTextureDesc's flags matching GrTexture's + bool renderTarget = SkToBool(desc.fFlags & kRenderTarget_GrBackendTextureFlag); + GrGLTexture::IDDesc idDesc; GrSurfaceDesc surfDesc; @@ -439,6 +445,15 @@ GrTexture* GrGLGpu::onWrapBackendTexture(const GrBackendTextureDesc& desc, #else idDesc.fInfo = *info; #endif + if (GR_GL_TEXTURE_EXTERNAL == idDesc.fInfo.fTarget) { + if (renderTarget) { + // This combination is not supported. + return nullptr; + } + if (!this->glCaps().externalTextureSupport()) { + return nullptr; + } + } switch (ownership) { case kAdopt_GrWrapOwnership: @@ -449,13 +464,11 @@ GrTexture* GrGLGpu::onWrapBackendTexture(const GrBackendTextureDesc& desc, break; } - // next line relies on GrBackendTextureDesc's flags matching GrTexture's surfDesc.fFlags = (GrSurfaceFlags) desc.fFlags; surfDesc.fWidth = desc.fWidth; surfDesc.fHeight = desc.fHeight; surfDesc.fConfig = desc.fConfig; surfDesc.fSampleCnt = SkTMin(desc.fSampleCnt, this->caps()->maxSampleCount()); - bool renderTarget = SkToBool(desc.fFlags & kRenderTarget_GrBackendTextureFlag); // FIXME: this should be calling resolve_origin(), but Chrome code is currently // assuming the old behaviour, which is that backend textures are always // BottomLeft, even for non-RT's. Once Chrome is fixed, change this to: @@ -524,6 +537,12 @@ bool GrGLGpu::onGetWritePixelsInfo(GrSurface* dstSurface, int width, int height, // into it. We could use glDrawPixels on GLs that have it, but we don't today. if (!dstSurface->asTexture()) { ElevateDrawPreference(drawPreference, kRequireDraw_DrawPreference); + } else { + GrGLTexture* texture = static_cast<GrGLTexture*>(dstSurface->asTexture()); + if (GR_GL_TEXTURE_2D != texture->target()) { + // We don't currently support writing pixels to non-TEXTURE_2D textures. + return false; + } } if (GrPixelConfigIsSRGB(dstSurface->config()) != GrPixelConfigIsSRGB(srcConfig)) { @@ -585,6 +604,11 @@ bool GrGLGpu::onWritePixels(GrSurface* surface, return false; } + // Write pixels is only implemented for TEXTURE_2D textures + if (GR_GL_TEXTURE_2D != glTex->target()) { + return false; + } + this->setScratchTextureUnit(); GL_CALL(BindTexture(glTex->target(), glTex->textureID())); @@ -2752,11 +2776,10 @@ void GrGLGpu::setScratchTextureUnit() { fHWBoundTextureUniqueIDs[lastUnitIdx] = SK_InvalidUniqueID; } -namespace { // Determines whether glBlitFramebuffer could be used between src and dst. -inline bool can_blit_framebuffer(const GrSurface* dst, - const GrSurface* src, - const GrGLGpu* gpu) { +static inline bool can_blit_framebuffer(const GrSurface* dst, + const GrSurface* src, + const GrGLGpu* gpu) { if (gpu->glCaps().isConfigRenderable(dst->config(), dst->desc().fSampleCnt > 0) && gpu->glCaps().isConfigRenderable(src->config(), src->desc().fSampleCnt > 0) && gpu->glCaps().usesMSAARenderBuffers()) { @@ -2766,15 +2789,23 @@ inline bool can_blit_framebuffer(const GrSurface* dst, (src->desc().fSampleCnt > 0 || src->config() != dst->config())) { return false; } + const GrGLTexture* dstTex = static_cast<const GrGLTexture*>(dst->asTexture()); + if (dstTex && dstTex->target() != GR_GL_TEXTURE_2D) { + return false; + } + const GrGLTexture* srcTex = static_cast<const GrGLTexture*>(dst->asTexture()); + if (srcTex && srcTex->target() != GR_GL_TEXTURE_2D) { + return false; + } return true; } else { return false; } } -inline bool can_copy_texsubimage(const GrSurface* dst, - const GrSurface* src, - const GrGLGpu* gpu) { +static inline bool can_copy_texsubimage(const GrSurface* dst, + const GrSurface* src, + const GrGLGpu* gpu) { // Table 3.9 of the ES2 spec indicates the supported formats with CopyTexSubImage // and BGRA isn't in the spec. There doesn't appear to be any extension that adds it. Perhaps // many drivers would allow it to work, but ANGLE does not. @@ -2794,18 +2825,29 @@ inline bool can_copy_texsubimage(const GrSurface* dst, if (srcRT && srcRT->renderFBOID() != srcRT->textureFBOID()) { return false; } + + const GrGLTexture* dstTex = static_cast<const GrGLTexture*>(dst->asTexture()); + // CopyTex(Sub)Image writes to a texture and we have no way of dynamically wrapping a RT in a + // texture. + if (!dstTex) { + return false; + } + + const GrGLTexture* srcTex = static_cast<const GrGLTexture*>(src->asTexture()); + + // Check that we could wrap the source in an FBO, that the dst is TEXTURE_2D, that no mirroring + // is required. if (gpu->glCaps().isConfigRenderable(src->config(), src->desc().fSampleCnt > 0) && - dst->asTexture() && - dst->origin() == src->origin() && - !GrPixelConfigIsCompressed(src->config())) { + !GrPixelConfigIsCompressed(src->config()) && + (!srcTex || srcTex->target() == GR_GL_TEXTURE_2D) && + dstTex->target() == GR_GL_TEXTURE_2D && + dst->origin() == src->origin()) { return true; } else { return false; } } -} - // If a temporary FBO was created, its non-zero ID is returned. The viewport that the copy rect is // relative to is output. void GrGLGpu::bindSurfaceFBOForCopy(GrSurface* surface, GrGLenum fboTarget, GrGLIRect* viewport, @@ -2863,6 +2905,12 @@ bool GrGLGpu::initCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* desc) return true; } + const GrGLTexture* srcTexture = static_cast<const GrGLTexture*>(src->asTexture()); + if (srcTexture && srcTexture->target() != GR_GL_TEXTURE_2D) { + // Not supported for FBO blit or CopyTexSubImage + return false; + } + // We look for opportunities to use CopyTexSubImage, or fbo blit. If neither are // possible and we return false to fallback to creating a render target dst for render-to- // texture. This code prefers CopyTexSubImage to fbo blit and avoids triggering temporary fbo @@ -2927,92 +2975,109 @@ bool GrGLGpu::onCopySurface(GrSurface* dst, } -void GrGLGpu::createCopyProgram() { +void GrGLGpu::createCopyPrograms() { + for (size_t i = 0; i < SK_ARRAY_COUNT(fCopyPrograms); ++i) { + fCopyPrograms[i].fProgram = 0; + } const char* version = this->glCaps().glslCaps()->versionDeclString(); - - GrGLSLShaderVar aVertex("a_vertex", kVec2f_GrSLType, GrShaderVar::kAttribute_TypeModifier); - GrGLSLShaderVar uTexCoordXform("u_texCoordXform", kVec4f_GrSLType, + static const GrSLType kSamplerTypes[2] = { kSampler2D_GrSLType, kSamplerExternal_GrSLType }; + SkASSERT(2 == SK_ARRAY_COUNT(fCopyPrograms)); + int programCount = this->glCaps().externalTextureSupport() ? 2 : 1; + for (int i = 0; i < programCount; ++i) { + GrGLSLShaderVar aVertex("a_vertex", kVec2f_GrSLType, GrShaderVar::kAttribute_TypeModifier); + GrGLSLShaderVar uTexCoordXform("u_texCoordXform", kVec4f_GrSLType, + GrShaderVar::kUniform_TypeModifier); + GrGLSLShaderVar uPosXform("u_posXform", kVec4f_GrSLType, + GrShaderVar::kUniform_TypeModifier); + GrGLSLShaderVar uTexture("u_texture", kSamplerTypes[i], GrShaderVar::kUniform_TypeModifier); - GrGLSLShaderVar uPosXform("u_posXform", kVec4f_GrSLType, GrShaderVar::kUniform_TypeModifier); - GrGLSLShaderVar uTexture("u_texture", kSampler2D_GrSLType, GrShaderVar::kUniform_TypeModifier); - GrGLSLShaderVar vTexCoord("v_texCoord", kVec2f_GrSLType, GrShaderVar::kVaryingOut_TypeModifier); - GrGLSLShaderVar oFragColor("o_FragColor", kVec4f_GrSLType, GrShaderVar::kOut_TypeModifier); + GrGLSLShaderVar vTexCoord("v_texCoord", kVec2f_GrSLType, + GrShaderVar::kVaryingOut_TypeModifier); + GrGLSLShaderVar oFragColor("o_FragColor", kVec4f_GrSLType, + GrShaderVar::kOut_TypeModifier); - SkString vshaderTxt(version); - aVertex.appendDecl(this->glCaps().glslCaps(), &vshaderTxt); - vshaderTxt.append(";"); - uTexCoordXform.appendDecl(this->glCaps().glslCaps(), &vshaderTxt); - vshaderTxt.append(";"); - uPosXform.appendDecl(this->glCaps().glslCaps(), &vshaderTxt); - vshaderTxt.append(";"); - vTexCoord.appendDecl(this->glCaps().glslCaps(), &vshaderTxt); - vshaderTxt.append(";"); + SkString vshaderTxt(version); + aVertex.appendDecl(this->glCaps().glslCaps(), &vshaderTxt); + vshaderTxt.append(";"); + uTexCoordXform.appendDecl(this->glCaps().glslCaps(), &vshaderTxt); + vshaderTxt.append(";"); + uPosXform.appendDecl(this->glCaps().glslCaps(), &vshaderTxt); + vshaderTxt.append(";"); + vTexCoord.appendDecl(this->glCaps().glslCaps(), &vshaderTxt); + vshaderTxt.append(";"); - vshaderTxt.append( - "// Copy Program VS\n" - "void main() {" - " v_texCoord = a_vertex.xy * u_texCoordXform.xy + u_texCoordXform.zw;" - " gl_Position.xy = a_vertex * u_posXform.xy + u_posXform.zw;" - " gl_Position.zw = vec2(0, 1);" - "}" - ); - - SkString fshaderTxt(version); - GrGLSLAppendDefaultFloatPrecisionDeclaration(kDefault_GrSLPrecision, - *this->glCaps().glslCaps(), - &fshaderTxt); - vTexCoord.setTypeModifier(GrShaderVar::kVaryingIn_TypeModifier); - vTexCoord.appendDecl(this->glCaps().glslCaps(), &fshaderTxt); - fshaderTxt.append(";"); - uTexture.appendDecl(this->glCaps().glslCaps(), &fshaderTxt); - fshaderTxt.append(";"); - const char* fsOutName; - if (this->glCaps().glslCaps()->mustDeclareFragmentShaderOutput()) { - oFragColor.appendDecl(this->glCaps().glslCaps(), &fshaderTxt); + vshaderTxt.append( + "// Copy Program VS\n" + "void main() {" + " v_texCoord = a_vertex.xy * u_texCoordXform.xy + u_texCoordXform.zw;" + " gl_Position.xy = a_vertex * u_posXform.xy + u_posXform.zw;" + " gl_Position.zw = vec2(0, 1);" + "}" + ); + + SkString fshaderTxt(version); + if (kSamplerTypes[i] == kSamplerExternal_GrSLType) { + fshaderTxt.appendf("#extension %s : require\n", + this->glCaps().glslCaps()->externalTextureExtensionString()); + } + GrGLSLAppendDefaultFloatPrecisionDeclaration(kDefault_GrSLPrecision, + *this->glCaps().glslCaps(), + &fshaderTxt); + vTexCoord.setTypeModifier(GrShaderVar::kVaryingIn_TypeModifier); + vTexCoord.appendDecl(this->glCaps().glslCaps(), &fshaderTxt); fshaderTxt.append(";"); - fsOutName = oFragColor.c_str(); - } else { - fsOutName = "gl_FragColor"; - } - fshaderTxt.appendf( - "// Copy Program FS\n" - "void main() {" - " %s = %s(u_texture, v_texCoord);" - "}", - fsOutName, - GrGLSLTexture2DFunctionName(kVec2f_GrSLType, this->glslGeneration()) - ); + uTexture.appendDecl(this->glCaps().glslCaps(), &fshaderTxt); + fshaderTxt.append(";"); + const char* fsOutName; + if (this->glCaps().glslCaps()->mustDeclareFragmentShaderOutput()) { + oFragColor.appendDecl(this->glCaps().glslCaps(), &fshaderTxt); + fshaderTxt.append(";"); + fsOutName = oFragColor.c_str(); + } else { + fsOutName = "gl_FragColor"; + } + fshaderTxt.appendf( + "// Copy Program FS\n" + "void main() {" + " %s = %s(u_texture, v_texCoord);" + "}", + fsOutName, + GrGLSLTexture2DFunctionName(kVec2f_GrSLType, this->glslGeneration()) + ); - GL_CALL_RET(fCopyProgram.fProgram, CreateProgram()); - const char* str; - GrGLint length; + GL_CALL_RET(fCopyPrograms[i].fProgram, CreateProgram()); + const char* str; + GrGLint length; - str = vshaderTxt.c_str(); - length = SkToInt(vshaderTxt.size()); - GrGLuint vshader = GrGLCompileAndAttachShader(*fGLContext, fCopyProgram.fProgram, - GR_GL_VERTEX_SHADER, &str, &length, 1, &fStats); + str = vshaderTxt.c_str(); + length = SkToInt(vshaderTxt.size()); + GrGLuint vshader = GrGLCompileAndAttachShader(*fGLContext, fCopyPrograms[i].fProgram, + GR_GL_VERTEX_SHADER, &str, &length, 1, + &fStats); - str = fshaderTxt.c_str(); - length = SkToInt(fshaderTxt.size()); - GrGLuint fshader = GrGLCompileAndAttachShader(*fGLContext, fCopyProgram.fProgram, - GR_GL_FRAGMENT_SHADER, &str, &length, 1, &fStats); + str = fshaderTxt.c_str(); + length = SkToInt(fshaderTxt.size()); + GrGLuint fshader = GrGLCompileAndAttachShader(*fGLContext, fCopyPrograms[i].fProgram, + GR_GL_FRAGMENT_SHADER, &str, &length, 1, + &fStats); - GL_CALL(LinkProgram(fCopyProgram.fProgram)); + GL_CALL(LinkProgram(fCopyPrograms[i].fProgram)); - GL_CALL_RET(fCopyProgram.fTextureUniform, GetUniformLocation(fCopyProgram.fProgram, - "u_texture")); - GL_CALL_RET(fCopyProgram.fPosXformUniform, GetUniformLocation(fCopyProgram.fProgram, - "u_posXform")); - GL_CALL_RET(fCopyProgram.fTexCoordXformUniform, GetUniformLocation(fCopyProgram.fProgram, - "u_texCoordXform")); + GL_CALL_RET(fCopyPrograms[i].fTextureUniform, + GetUniformLocation(fCopyPrograms[i].fProgram, "u_texture")); + GL_CALL_RET(fCopyPrograms[i].fPosXformUniform, + GetUniformLocation(fCopyPrograms[i].fProgram, "u_posXform")); + GL_CALL_RET(fCopyPrograms[i].fTexCoordXformUniform, + GetUniformLocation(fCopyPrograms[i].fProgram, "u_texCoordXform")); - GL_CALL(BindAttribLocation(fCopyProgram.fProgram, 0, "a_vertex")); + GL_CALL(BindAttribLocation(fCopyPrograms[i].fProgram, 0, "a_vertex")); - GL_CALL(DeleteShader(vshader)); - GL_CALL(DeleteShader(fshader)); + GL_CALL(DeleteShader(vshader)); + GL_CALL(DeleteShader(fshader)); + } - GL_CALL(GenBuffers(1, &fCopyProgram.fArrayBuffer)); - fHWGeometryState.setVertexBufferID(this, fCopyProgram.fArrayBuffer); + GL_CALL(GenBuffers(1, &fCopyProgramArrayBuffer)); + fHWGeometryState.setVertexBufferID(this, fCopyProgramArrayBuffer); static const GrGLfloat vdata[] = { 0, 0, 0, 1, @@ -3041,14 +3106,16 @@ void GrGLGpu::copySurfaceAsDraw(GrSurface* dst, SkIRect dstRect = SkIRect::MakeXYWH(dstPoint.fX, dstPoint.fY, w, h); this->flushRenderTarget(dstRT, &dstRect); - GL_CALL(UseProgram(fCopyProgram.fProgram)); - fHWProgramID = fCopyProgram.fProgram; + int progIdx = TextureTargetToCopyProgramIdx(srcTex->target()); + + GL_CALL(UseProgram(fCopyPrograms[progIdx].fProgram)); + fHWProgramID = fCopyPrograms[progIdx].fProgram; fHWGeometryState.setVertexArrayID(this, 0); GrGLAttribArrayState* attribs = - fHWGeometryState.bindArrayAndBufferToDraw(this, fCopyProgram.fArrayBuffer); - attribs->set(this, 0, fCopyProgram.fArrayBuffer, 2, GR_GL_FLOAT, false, + fHWGeometryState.bindArrayAndBufferToDraw(this, fCopyProgramArrayBuffer); + attribs->set(this, 0, fCopyProgramArrayBuffer, 2, GR_GL_FLOAT, false, 2 * sizeof(GrGLfloat), 0); attribs->disableUnusedArrays(this, 0x1); @@ -3076,9 +3143,10 @@ void GrGLGpu::copySurfaceAsDraw(GrSurface* dst, sy1 = 1.f - sy1; } - GL_CALL(Uniform4f(fCopyProgram.fPosXformUniform, dx1 - dx0, dy1 - dy0, dx0, dy0)); - GL_CALL(Uniform4f(fCopyProgram.fTexCoordXformUniform, sx1 - sx0, sy1 - sy0, sx0, sy0)); - GL_CALL(Uniform1i(fCopyProgram.fTextureUniform, 0)); + GL_CALL(Uniform4f(fCopyPrograms[progIdx].fPosXformUniform, dx1 - dx0, dy1 - dy0, dx0, dy0)); + GL_CALL(Uniform4f(fCopyPrograms[progIdx].fTexCoordXformUniform, + sx1 - sx0, sy1 - sy0, sx0, sy0)); + GL_CALL(Uniform1i(fCopyPrograms[progIdx].fTextureUniform, 0)); GrXferProcessor::BlendInfo blendInfo; blendInfo.reset(); diff --git a/src/gpu/gl/GrGLGpu.h b/src/gpu/gl/GrGLGpu.h index c8da150a0d..637a1cf161 100644 --- a/src/gpu/gl/GrGLGpu.h +++ b/src/gpu/gl/GrGLGpu.h @@ -322,7 +322,7 @@ private: SkAutoTUnref<GrGLContext> fGLContext; - void createCopyProgram(); + void createCopyPrograms(); // GL program-related state ProgramCache* fProgramCache; @@ -497,8 +497,17 @@ private: GrGLint fTextureUniform; GrGLint fTexCoordXformUniform; GrGLint fPosXformUniform; - GrGLuint fArrayBuffer; - } fCopyProgram; + } fCopyPrograms[2]; + GrGLuint fCopyProgramArrayBuffer; + + static int TextureTargetToCopyProgramIdx(GrGLenum target) { + if (target == GR_GL_TEXTURE_2D) { + return 0; + } else { + SkASSERT(target == GR_GL_TEXTURE_EXTERNAL); + return 1; + } + } TriState fMSAAEnabled; diff --git a/src/gpu/gl/GrGLInterface.cpp b/src/gpu/gl/GrGLInterface.cpp index c6c846abf8..da3c656c18 100644 --- a/src/gpu/gl/GrGLInterface.cpp +++ b/src/gpu/gl/GrGLInterface.cpp @@ -727,8 +727,8 @@ bool GrGLInterface::validate() const { } if (fExtensions.has("EGL_KHR_image") || fExtensions.has("EGL_KHR_image_base")) { - if (nullptr == fFunctions.fCreateImage || - nullptr == fFunctions.fDestroyImage) { + if (nullptr == fFunctions.fEGLCreateImage || + nullptr == fFunctions.fEGLDestroyImage) { RETURN_FALSE_INTERFACE } } diff --git a/src/gpu/gl/GrGLProgramDataManager.cpp b/src/gpu/gl/GrGLProgramDataManager.cpp index a61e6974b6..f0aba49720 100644 --- a/src/gpu/gl/GrGLProgramDataManager.cpp +++ b/src/gpu/gl/GrGLProgramDataManager.cpp @@ -62,7 +62,7 @@ GrGLProgramDataManager::GrGLProgramDataManager(GrGLGpu* gpu, GrGLuint programID, void GrGLProgramDataManager::setSampler(UniformHandle u, int texUnit) const { const Uniform& uni = fUniforms[u.toIndex()]; - SkASSERT(uni.fType == kSampler2D_GrSLType); + SkASSERT(uni.fType == kSampler2D_GrSLType || uni.fType == kSamplerExternal_GrSLType); SkASSERT(GrGLSLShaderVar::kNonArray == uni.fArrayCount); // FIXME: We still insert a single sampler uniform for every stage. If the shader does not // reference the sampler then the compiler may have optimized it out. Uncomment this assert diff --git a/src/gpu/gl/GrGLProgramDesc.cpp b/src/gpu/gl/GrGLProgramDesc.cpp index 172aca77ab..a1646618e8 100644 --- a/src/gpu/gl/GrGLProgramDesc.cpp +++ b/src/gpu/gl/GrGLProgramDesc.cpp @@ -31,11 +31,16 @@ static bool swizzle_requires_alpha_remapping(const GrGLSLCaps& caps, GrPixelConf static uint32_t gen_texture_key(const GrProcessor& proc, const GrGLCaps& caps) { uint32_t key = 0; int numTextures = proc.numTextures(); + int shift = 0; for (int t = 0; t < numTextures; ++t) { const GrTextureAccess& access = proc.textureAccess(t); if (swizzle_requires_alpha_remapping(*caps.glslCaps(), access.getTexture()->config())) { - key |= 1 << t; + key |= 1 << shift; } + if (GR_GL_TEXTURE_EXTERNAL == static_cast<GrGLTexture*>(access.getTexture())->target()) { + key |= 2 << shift; + } + shift += 2; } return key; } @@ -48,10 +53,8 @@ static uint32_t gen_texture_key(const GrProcessor& proc, const GrGLCaps& caps) { * which must be different for every GrProcessor subclass. It can fail if an effect uses too many * textures, transforms, etc, for the space allotted in the meta-key. NOTE, both FPs and GPs share * this function because it is hairy, though FPs do not have attribs, and GPs do not have transforms - * - * TODO: A better name for this function would be "compute" instead of "get". */ -static bool get_meta_key(const GrProcessor& proc, +static bool gen_meta_key(const GrProcessor& proc, const GrGLCaps& caps, uint32_t transformKey, GrProcessorKeyBuilder* b) { @@ -75,15 +78,12 @@ static bool get_meta_key(const GrProcessor& proc, return true; } -/* - * TODO: A better name for this function would be "compute" instead of "get". - */ -static bool get_frag_proc_and_meta_keys(const GrPrimitiveProcessor& primProc, +static bool gen_frag_proc_and_meta_keys(const GrPrimitiveProcessor& primProc, const GrFragmentProcessor& fp, const GrGLCaps& caps, GrProcessorKeyBuilder* b) { for (int i = 0; i < fp.numChildProcessors(); ++i) { - if (!get_frag_proc_and_meta_keys(primProc, fp.childProcessor(i), caps, b)) { + if (!gen_frag_proc_and_meta_keys(primProc, fp.childProcessor(i), caps, b)) { return false; } } @@ -91,7 +91,7 @@ static bool get_frag_proc_and_meta_keys(const GrPrimitiveProcessor& primProc, fp.getGLSLProcessorKey(*caps.glslCaps(), b); //**** use glslCaps here? - return get_meta_key(fp, caps, primProc.getTransformKey(fp.coordTransforms(), + return gen_meta_key(fp, caps, primProc.getTransformKey(fp.coordTransforms(), fp.numTransformsExclChildren()), b); } @@ -115,14 +115,14 @@ bool GrGLProgramDescBuilder::Build(GrProgramDesc* desc, primProc.getGLSLProcessorKey(*gpu->glCaps().glslCaps(), &b); //**** use glslCaps here? - if (!get_meta_key(primProc, gpu->glCaps(), 0, &b)) { + if (!gen_meta_key(primProc, gpu->glCaps(), 0, &b)) { glDesc->key().reset(); return false; } for (int i = 0; i < pipeline.numFragmentProcessors(); ++i) { const GrFragmentProcessor& fp = pipeline.getFragmentProcessor(i); - if (!get_frag_proc_and_meta_keys(primProc, fp, gpu->glCaps(), &b)) { + if (!gen_frag_proc_and_meta_keys(primProc, fp, gpu->glCaps(), &b)) { glDesc->key().reset(); return false; } @@ -131,7 +131,7 @@ bool GrGLProgramDescBuilder::Build(GrProgramDesc* desc, const GrXferProcessor& xp = *pipeline.getXferProcessor(); xp.getGLSLProcessorKey(*gpu->glCaps().glslCaps(), &b); //**** use glslCaps here? - if (!get_meta_key(xp, gpu->glCaps(), 0, &b)) { + if (!gen_meta_key(xp, gpu->glCaps(), 0, &b)) { glDesc->key().reset(); return false; } diff --git a/src/gpu/gl/angle/GrGLCreateANGLEInterface.cpp b/src/gpu/gl/angle/GrGLCreateANGLEInterface.cpp index 834e122f57..05afb2cb1c 100644 --- a/src/gpu/gl/angle/GrGLCreateANGLEInterface.cpp +++ b/src/gpu/gl/angle/GrGLCreateANGLEInterface.cpp @@ -12,8 +12,20 @@ #include <EGL/egl.h> +namespace { +struct Libs { + void* fGLLib; + void* fEGLLib; +}; +} + static GrGLFuncPtr angle_get_gl_proc(void* ctx, const char name[]) { - GrGLFuncPtr proc = (GrGLFuncPtr) GetProcedureAddress(ctx, name); + const Libs* libs = reinterpret_cast<const Libs*>(ctx); + GrGLFuncPtr proc = (GrGLFuncPtr) GetProcedureAddress(libs->fGLLib, name); + if (proc) { + return proc; + } + proc = (GrGLFuncPtr) GetProcedureAddress(libs->fEGLLib, name); if (proc) { return proc; } @@ -21,23 +33,26 @@ static GrGLFuncPtr angle_get_gl_proc(void* ctx, const char name[]) { } const GrGLInterface* GrGLCreateANGLEInterface() { - static void* gANGLELib = nullptr; + static Libs gLibs = { nullptr, nullptr }; - if (nullptr == gANGLELib) { + if (nullptr == gLibs.fGLLib) { // We load the ANGLE library and never let it go #if defined _WIN32 - gANGLELib = DynamicLoadLibrary("libGLESv2.dll"); + gLibs.fGLLib = DynamicLoadLibrary("libGLESv2.dll"); + gLibs.fEGLLib = DynamicLoadLibrary("libEGL.dll"); #elif defined SK_BUILD_FOR_MAC - gANGLELib = DynamicLoadLibrary("libGLESv2.dylib"); + gLibs.fGLLib = DynamicLoadLibrary("libGLESv2.dylib"); + gLibs.fEGLLib = DynamicLoadLibrary("libEGL.dylib"); #else - gANGLELib = DynamicLoadLibrary("libGLESv2.so"); -#endif // defined _WIN32 + gLibs.fGLLib = DynamicLoadLibrary("libGLESv2.so"); + gLibs.fGLLib = DynamicLoadLibrary("libEGL.so"); +#endif } - if (nullptr == gANGLELib) { + if (nullptr == gLibs.fGLLib || nullptr == gLibs.fEGLLib) { // We can't setup the interface correctly w/o the so return nullptr; } - return GrGLAssembleGLESInterface(gANGLELib, angle_get_gl_proc); + return GrGLAssembleGLESInterface(&gLibs, angle_get_gl_proc); } diff --git a/src/gpu/gl/angle/SkANGLEGLContext.cpp b/src/gpu/gl/angle/SkANGLEGLContext.cpp index 64a3bdec74..54ef02d492 100644 --- a/src/gpu/gl/angle/SkANGLEGLContext.cpp +++ b/src/gpu/gl/angle/SkANGLEGLContext.cpp @@ -11,6 +11,9 @@ #include <EGL/egl.h> #include <EGL/eglext.h> +#include "gl/GrGLDefines.h" +#include "gl/GrGLUtil.h" + #define EGL_PLATFORM_ANGLE_ANGLE 0x3202 #define EGL_PLATFORM_ANGLE_TYPE_ANGLE 0x3203 #define EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE 0x3207 @@ -34,8 +37,7 @@ void* SkANGLEGLContext::GetD3DEGLDisplay(void* nativeDisplay, bool useGLBackend) EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE, EGL_NONE }; - display = eglGetPlatformDisplayEXT(EGL_PLATFORM_ANGLE_ANGLE, - nativeDisplay, attribs); + display = eglGetPlatformDisplayEXT(EGL_PLATFORM_ANGLE_ANGLE, nativeDisplay, attribs); } else { // Try for an ANGLE D3D11 context, fall back to D3D9, and finally GL. EGLint attribs[3][3] = { @@ -56,8 +58,7 @@ void* SkANGLEGLContext::GetD3DEGLDisplay(void* nativeDisplay, bool useGLBackend) } }; for (int i = 0; i < 3 && display == EGL_NO_DISPLAY; ++i) { - display = eglGetPlatformDisplayEXT(EGL_PLATFORM_ANGLE_ANGLE, - nativeDisplay, attribs[i]); + display = eglGetPlatformDisplayEXT(EGL_PLATFORM_ANGLE_ANGLE,nativeDisplay, attribs[i]); } } return display; @@ -79,6 +80,7 @@ SkANGLEGLContext::SkANGLEGLContext(bool useGLBackend) EGL_NONE }; + fIsGLBackend = useGLBackend; fDisplay = GetD3DEGLDisplay(EGL_DEFAULT_DISPLAY, useGLBackend); if (EGL_NO_DISPLAY == fDisplay) { SkDebugf("Could not create EGL display!"); @@ -129,6 +131,62 @@ SkANGLEGLContext::~SkANGLEGLContext() { this->destroyGLContext(); } +GrEGLImage SkANGLEGLContext::texture2DToEGLImage(GrGLuint texID) const { + if (!this->gl()->hasExtension("EGL_KHR_gl_texture_2D_image")) { + return GR_EGL_NO_IMAGE; + } + GrEGLImage img; + GrEGLint attribs[] = { GR_EGL_GL_TEXTURE_LEVEL, 0, + GR_EGL_IMAGE_PRESERVED, GR_EGL_TRUE, + GR_EGL_NONE }; + // 64 bit cast is to shut Visual C++ up about casting 32 bit value to a pointer. + GrEGLClientBuffer clientBuffer = reinterpret_cast<GrEGLClientBuffer>((uint64_t)texID); + GR_GL_CALL_RET(this->gl(), img, + EGLCreateImage(fDisplay, fContext, GR_EGL_GL_TEXTURE_2D, clientBuffer, + attribs)); + return img; +} + +void SkANGLEGLContext::destroyEGLImage(GrEGLImage image) const { + GR_GL_CALL(this->gl(), EGLDestroyImage(fDisplay, image)); +} + +GrGLuint SkANGLEGLContext::eglImageToExternalTexture(GrEGLImage image) const { + GrGLClearErr(this->gl()); + if (!this->gl()->hasExtension("GL_OES_EGL_image_external")) { + return 0; + } + GrGLEGLImageTargetTexture2DProc glEGLImageTargetTexture2D = + (GrGLEGLImageTargetTexture2DProc)eglGetProcAddress("glEGLImageTargetTexture2DOES"); + if (!glEGLImageTargetTexture2D) { + return 0; + } + GrGLuint texID; + GR_GL_CALL(this->gl(), GenTextures(1, &texID)); + if (!texID) { + return 0; + } + GR_GL_CALL(this->gl(), BindTexture(GR_GL_TEXTURE_EXTERNAL, texID)); + if (GR_GL_GET_ERROR(this->gl()) != GR_GL_NO_ERROR) { + GR_GL_CALL(this->gl(), DeleteTextures(1, &texID)); + return 0; + } + glEGLImageTargetTexture2D(GR_GL_TEXTURE_EXTERNAL, image); + if (GR_GL_GET_ERROR(this->gl()) != GR_GL_NO_ERROR) { + GR_GL_CALL(this->gl(), DeleteTextures(1, &texID)); + return 0; + } + return texID; +} + +SkGLContext* SkANGLEGLContext::createNew() const { + SkGLContext* ctx = SkANGLEGLContext::Create(this->gl()->fStandard, fIsGLBackend); + if (ctx) { + ctx->makeCurrent(); + } + return ctx; +} + void SkANGLEGLContext::destroyGLContext() { if (fDisplay) { eglMakeCurrent(fDisplay, 0, 0, 0); diff --git a/src/gpu/gl/builders/GrGLProgramBuilder.cpp b/src/gpu/gl/builders/GrGLProgramBuilder.cpp index 0ae4f96101..b5108a74d0 100644 --- a/src/gpu/gl/builders/GrGLProgramBuilder.cpp +++ b/src/gpu/gl/builders/GrGLProgramBuilder.cpp @@ -319,6 +319,16 @@ void GrGLProgramBuilder::verify(const GrFragmentProcessor& fp) { SkASSERT(fFS.hasReadFragmentPosition() == fp.willReadFragmentPosition()); } +static GrSLType get_sampler_type(const GrTextureAccess& access) { + GrGLTexture* glTexture = static_cast<GrGLTexture*>(access.getTexture()); + if (glTexture->target() == GR_GL_TEXTURE_EXTERNAL) { + return kSamplerExternal_GrSLType; + } else { + SkASSERT(glTexture->target() == GR_GL_TEXTURE_2D); + return kSampler2D_GrSLType; + } +} + template <class Proc> void GrGLProgramBuilder::emitSamplers(const GrProcessor& processor, GrGLSLTextureSampler::TextureSamplerArray* outSamplers, @@ -329,11 +339,19 @@ void GrGLProgramBuilder::emitSamplers(const GrProcessor& processor, SkString name; for (int t = 0; t < numTextures; ++t) { name.printf("Sampler%d", t); + GrSLType samplerType = get_sampler_type(processor.textureAccess(t)); localSamplerUniforms[t] = this->addUniform(GrGLProgramBuilder::kFragment_Visibility, - kSampler2D_GrSLType, kDefault_GrSLPrecision, + samplerType, kDefault_GrSLPrecision, name.c_str()); SkNEW_APPEND_TO_TARRAY(outSamplers, GrGLSLTextureSampler, (localSamplerUniforms[t], processor.textureAccess(t))); + if (kSamplerExternal_GrSLType == samplerType) { + const char* externalFeatureString = this->glslCaps()->externalTextureExtensionString(); + // We shouldn't ever create a GrGLTexture that requires external sampler type + SkASSERT(externalFeatureString); + fFS.addFeature(1 << GrGLSLFragmentShaderBuilder::kExternalTexture_GLSLPrivateFeature, + externalFeatureString); + } } } diff --git a/src/gpu/gl/egl/GrGLCreateNativeInterface_egl.cpp b/src/gpu/gl/egl/GrGLCreateNativeInterface_egl.cpp index 703e39d097..fef4f0276f 100644 --- a/src/gpu/gl/egl/GrGLCreateNativeInterface_egl.cpp +++ b/src/gpu/gl/egl/GrGLCreateNativeInterface_egl.cpp @@ -14,7 +14,15 @@ static GrGLFuncPtr egl_get_gl_proc(void* ctx, const char name[]) { SkASSERT(nullptr == ctx); - return eglGetProcAddress(name); + GrGLFuncPtr ptr = eglGetProcAddress(name); + if (!ptr) { + if (0 == strcmp("eglQueryString", name)) { + return (GrGLFuncPtr)eglQueryString; + } else if (0 == strcmp("eglGetCurrentDisplay", name)) { + return (GrGLFuncPtr)eglGetCurrentDisplay; + } + } + return ptr; } const GrGLInterface* GrGLCreateNativeInterface() { diff --git a/src/gpu/gl/egl/SkCreatePlatformGLContext_egl.cpp b/src/gpu/gl/egl/SkCreatePlatformGLContext_egl.cpp index d1335d355f..591cae349c 100644 --- a/src/gpu/gl/egl/SkCreatePlatformGLContext_egl.cpp +++ b/src/gpu/gl/egl/SkCreatePlatformGLContext_egl.cpp @@ -13,6 +13,9 @@ #include <EGL/egl.h> #include <EGL/eglext.h> +#include "gl/GrGLDefines.h" +#include "gl/GrGLUtil.h" + namespace { // TODO: Share this class with ANGLE if/when it gets support for EGL_KHR_fence_sync. @@ -37,6 +40,11 @@ public: EGLGLContext(GrGLStandard forcedGpuAPI); ~EGLGLContext() override; + GrEGLImage texture2DToEGLImage(GrGLuint texID) const override; + void destroyEGLImage(GrEGLImage) const override; + GrGLuint eglImageToExternalTexture(GrEGLImage) const override; + SkGLContext* createNew() const override; + private: void destroyGLContext(); @@ -200,6 +208,57 @@ void EGLGLContext::destroyGLContext() { } } +GrEGLImage EGLGLContext::texture2DToEGLImage(GrGLuint texID) const { + if (!this->gl()->hasExtension("EGL_KHR_gl_texture_2D_image")) { + return GR_EGL_NO_IMAGE; + } + GrEGLImage img; + GrEGLint attribs[] = { GR_EGL_GL_TEXTURE_LEVEL, 0, GR_EGL_NONE }; + GrEGLClientBuffer clientBuffer = reinterpret_cast<GrEGLClientBuffer>(texID); + GR_GL_CALL_RET(this->gl(), img, + EGLCreateImage(fDisplay, fContext, GR_EGL_GL_TEXTURE_2D, clientBuffer, attribs)); + return img; +} + +void EGLGLContext::destroyEGLImage(GrEGLImage image) const { + GR_GL_CALL(this->gl(), EGLDestroyImage(fDisplay, image)); +} + +GrGLuint EGLGLContext::eglImageToExternalTexture(GrEGLImage image) const { + GrGLClearErr(this->gl()); + if (!this->gl()->hasExtension("GL_OES_EGL_image_external")) { + return 0; + } + GrGLEGLImageTargetTexture2DProc glEGLImageTargetTexture2D = + (GrGLEGLImageTargetTexture2DProc) eglGetProcAddress("glEGLImageTargetTexture2DOES"); + if (!glEGLImageTargetTexture2D) { + return 0; + } + GrGLuint texID; + glGenTextures(1, &texID); + if (!texID) { + return 0; + } + glBindTexture(GR_GL_TEXTURE_EXTERNAL, texID); + if (glGetError() != GR_GL_NO_ERROR) { + glDeleteTextures(1, &texID); + return 0; + } + glEGLImageTargetTexture2D(GR_GL_TEXTURE_EXTERNAL, image); + if (glGetError() != GR_GL_NO_ERROR) { + glDeleteTextures(1, &texID); + return 0; + } + return texID; +} + +SkGLContext* EGLGLContext::createNew() const { + SkGLContext* ctx = SkCreatePlatformGLContext(this->gl()->fStandard); + if (ctx) { + ctx->makeCurrent(); + } + return ctx; +} void EGLGLContext::onPlatformMakeCurrent() const { if (!eglMakeCurrent(fDisplay, fSurface, fSurface, fContext)) { diff --git a/src/gpu/glsl/GrGLSL.h b/src/gpu/glsl/GrGLSL.h index a39f104fab..ac38522ca1 100644 --- a/src/gpu/glsl/GrGLSL.h +++ b/src/gpu/glsl/GrGLSL.h @@ -85,6 +85,8 @@ static inline const char* GrGLSLTypeString(GrSLType t) { return "mat4"; case kSampler2D_GrSLType: return "sampler2D"; + case kSamplerExternal_GrSLType: + return "samplerExternalOES"; default: SkFAIL("Unknown shader var type."); return ""; // suppress warning diff --git a/src/gpu/glsl/GrGLSLCaps.cpp b/src/gpu/glsl/GrGLSLCaps.cpp index aed98880f5..191fb567e6 100755 --- a/src/gpu/glsl/GrGLSLCaps.cpp +++ b/src/gpu/glsl/GrGLSLCaps.cpp @@ -28,6 +28,7 @@ GrGLSLCaps::GrGLSLCaps(const GrContextOptions& options) { fShaderDerivativeExtensionString = nullptr; fFragCoordConventionsExtensionString = nullptr; fSecondaryOutputExtensionString = nullptr; + fExternalTextureExtensionString = nullptr; fFBFetchColorName = nullptr; fFBFetchExtensionString = nullptr; fAdvBlendEqInteraction = kNotSupported_AdvBlendEqInteraction; diff --git a/src/gpu/glsl/GrGLSLCaps.h b/src/gpu/glsl/GrGLSLCaps.h index 68e91b6666..9924773139 100755 --- a/src/gpu/glsl/GrGLSLCaps.h +++ b/src/gpu/glsl/GrGLSLCaps.h @@ -102,6 +102,10 @@ public: return fSecondaryOutputExtensionString; } + const char* externalTextureExtensionString() const { + return fExternalTextureExtensionString; + } + bool mustSwizzleInShader() const { return fMustSwizzleInShader; } /** @@ -140,6 +144,7 @@ private: const char* fShaderDerivativeExtensionString; const char* fFragCoordConventionsExtensionString; const char* fSecondaryOutputExtensionString; + const char* fExternalTextureExtensionString; const char* fFBFetchColorName; const char* fFBFetchExtensionString; diff --git a/src/gpu/glsl/GrGLSLFragmentShaderBuilder.h b/src/gpu/glsl/GrGLSLFragmentShaderBuilder.h index 924e3110df..a55fdd2860 100644 --- a/src/gpu/glsl/GrGLSLFragmentShaderBuilder.h +++ b/src/gpu/glsl/GrGLSLFragmentShaderBuilder.h @@ -172,6 +172,7 @@ private: kFragCoordConventions_GLSLPrivateFeature = kLastGLSLFeature + 1, kBlendEquationAdvanced_GLSLPrivateFeature, kBlendFuncExtended_GLSLPrivateFeature, + kExternalTexture_GLSLPrivateFeature, kLastGLSLPrivateFeature = kBlendFuncExtended_GLSLPrivateFeature }; diff --git a/tests/EGLImageTest.cpp b/tests/EGLImageTest.cpp new file mode 100644 index 0000000000..088049ee1f --- /dev/null +++ b/tests/EGLImageTest.cpp @@ -0,0 +1,163 @@ +/* + * 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 "Test.h" +#if SK_SUPPORT_GPU +#include "GrContext.h" +#include "GrContextFactory.h" +#include "gl/GrGLGpu.h" +#include "gl/GrGLUtil.h" +#include "gl/SkGLContext.h" + +static void cleanup(SkGLContext* glctx0, GrGLuint texID0, SkGLContext* glctx1, GrContext* grctx1, + const GrGLTextureInfo* grbackendtex1, GrEGLImage image1) { + if (glctx1) { + glctx1->makeCurrent(); + if (grctx1) { + if (grbackendtex1) { + GrGLGpu* gpu1 = static_cast<GrGLGpu*>(grctx1->getGpu()); + GrBackendObject handle = reinterpret_cast<GrBackendObject>(grbackendtex1); + gpu1->deleteTestingOnlyBackendTexture(handle, false); + } + grctx1->unref(); + } + if (GR_EGL_NO_IMAGE != image1) { + glctx1->destroyEGLImage(image1); + } + glctx1->unref(); + } + + glctx0->makeCurrent(); + if (texID0) { + GR_GL_CALL(glctx0->gl(), DeleteTextures(1, &texID0)); + } +} + +DEF_GPUTEST(EGLImageTest, reporter, factory) { + for (int glCtxType = 0; glCtxType < GrContextFactory::kGLContextTypeCnt; ++glCtxType) { + GrContextFactory::GLContextType type = (GrContextFactory::GLContextType)glCtxType; + if (!GrContextFactory::IsRenderingGLContext(type)) { + continue; + } + + // Try to create a second GL context and then check if the contexts have necessary + // extensions to run this test. + + GrContext* context0 = factory->get(type); + if (!context0) { + continue; + } + SkGLContext* glCtx0 = factory->getGLContext(type); + SkGLContext* glCtx1 = glCtx0->createNew(); + if (!glCtx1) { + continue; + } + GrContext* context1 = GrContext::Create(kOpenGL_GrBackend, (GrBackendContext)glCtx1->gl()); + const GrGLTextureInfo* backendTexture1 = nullptr; + GrEGLImage image = GR_EGL_NO_IMAGE; + GrGLTextureInfo externalTexture; + externalTexture.fID = 0; + + if (!context1) { + cleanup(glCtx0, externalTexture.fID, glCtx1, context1, backendTexture1, image); + continue; + } + + SkASSERT(glCtx0); + if (!glCtx0->gl()->hasExtension("EGL_KHR_image") || + !glCtx0->gl()->hasExtension("GL_OES_EGL_image_external") || + !glCtx1->gl()->hasExtension("EGL_KHR_image") || + !glCtx1->gl()->hasExtension("EGL_KHR_gl_texture_2D_image")) { + cleanup(glCtx0, externalTexture.fID, glCtx1, context1, backendTexture1, image); + continue; + } + +///////////////////////////////// CONTEXT 1 /////////////////////////////////// + + // Use GL Context 1 to create a texture unknown to GrContext. + context1->flush(); + GrGpu* gpu1 = context1->getGpu(); + static const int kSize = 100; + backendTexture1 = reinterpret_cast<const GrGLTextureInfo*>( + gpu1->createTestingOnlyBackendTexture(nullptr, kSize, kSize, kRGBA_8888_GrPixelConfig)); + if (!backendTexture1 || !backendTexture1->fID) { + ERRORF(reporter, "Error creating texture for EGL Image"); + cleanup(glCtx0, externalTexture.fID, glCtx1, context1, backendTexture1, image); + continue; + } + if (GR_GL_TEXTURE_2D != backendTexture1->fTarget) { + ERRORF(reporter, "Expected backend texture to be 2D"); + cleanup(glCtx0, externalTexture.fID, glCtx1, context1, backendTexture1, image); + continue; + } + + // Wrap the texture in an EGLImage + image = glCtx1->texture2DToEGLImage(backendTexture1->fID); + if (GR_EGL_NO_IMAGE == image) { + ERRORF(reporter, "Error creating EGL Image from texture"); + cleanup(glCtx0, externalTexture.fID, glCtx1, context1, backendTexture1, image); + continue; + } + + // Populate the texture using GL context 1. Important to use TexSubImage as TexImage orphans + // the EGL image. Also, this must be done after creating the EGLImage as the texture + // contents may not be preserved when the image is created. + SkAutoTMalloc<uint32_t> pixels(kSize * kSize); + for (int i = 0; i < kSize*kSize; ++i) { + pixels.get()[i] = 0xDDAABBCC; + } + GR_GL_CALL(glCtx1->gl(), ActiveTexture(GR_GL_TEXTURE0)); + GR_GL_CALL(glCtx1->gl(), BindTexture(backendTexture1->fTarget, backendTexture1->fID)); + GR_GL_CALL(glCtx1->gl(), TexSubImage2D(backendTexture1->fTarget, 0, 0, 0, kSize, kSize, + GR_GL_RGBA, GR_GL_UNSIGNED_BYTE, pixels.get())); + GR_GL_CALL(glCtx1->gl(), Finish()); + // We've been making direct GL calls in GL context 1, let GrContext 1 know its internal + // state is invalid. + context1->resetContext(); + +///////////////////////////////// CONTEXT 0 /////////////////////////////////// + + // Make a new texture ID in GL Context 0 from the EGL Image + glCtx0->makeCurrent(); + externalTexture.fTarget = GR_GL_TEXTURE_EXTERNAL; + externalTexture.fID = glCtx0->eglImageToExternalTexture(image); + + // Wrap this texture ID in a GrTexture + GrBackendTextureDesc externalDesc; + externalDesc.fConfig = kRGBA_8888_GrPixelConfig; + externalDesc.fWidth = kSize; + externalDesc.fHeight = kSize; + externalDesc.fTextureHandle = reinterpret_cast<GrBackendObject>(&externalTexture); + SkAutoTUnref<GrTexture> externalTextureObj( + context0->textureProvider()->wrapBackendTexture(externalDesc)); + if (!externalTextureObj) { + ERRORF(reporter, "Error wrapping external texture in GrTexture."); + cleanup(glCtx0, externalTexture.fID, glCtx1, context1, backendTexture1, image); + continue; + } + + // Read the pixels and see if we get the values set in GL context 1 + memset(pixels.get(), 0, sizeof(uint32_t)*kSize*kSize); + bool read = externalTextureObj->readPixels(0, 0, kSize, kSize, kRGBA_8888_GrPixelConfig, + pixels.get()); + if (!read) { + ERRORF(reporter, "Error reading external texture."); + cleanup(glCtx0, externalTexture.fID, glCtx1, context1, backendTexture1, image); + continue; + } + for (int i = 0; i < kSize*kSize; ++i) { + if (pixels.get()[i] != 0xDDAABBCC) { + ERRORF(reporter, "Error, external texture pixel value %d should be 0xDDAABBCC," + " got 0x%08x.", pixels.get()[i]); + break; + } + } + cleanup(glCtx0, externalTexture.fID, glCtx1, context1, backendTexture1, image); + } +} + +#endif |