Updated the swizzle generation functions to use Error objects.

src/libGLESv2/Context.cpp

@@ -1390,7 +1390,7 @@ void Context::applyShaders(ProgramBinary *programBinary, bool transformFeedbackA
     programBinary->applyUniforms();
 }
 
-void Context::generateSwizzles(ProgramBinary *programBinary, SamplerType type)
+Error Context::generateSwizzles(ProgramBinary *programBinary, SamplerType type)
 {
     size_t samplerRange = programBinary->getUsedSamplerRange(type);
 
@@ -1403,16 +1403,33 @@ void Context::generateSwizzles(ProgramBinary *programBinary, SamplerType type)
             Texture* texture = getSamplerTexture(textureUnit, textureType);
             if (texture->getSamplerState().swizzleRequired())
             {
-                mRenderer->generateSwizzle(texture);
+                Error error = mRenderer->generateSwizzle(texture);
+                if (error.isError())
+                {
+                    return error;
+                }
             }
         }
     }
+
+    return Error(GL_NO_ERROR);
 }
 
-void Context::generateSwizzles(ProgramBinary *programBinary)
+Error Context::generateSwizzles(ProgramBinary *programBinary)
 {
-    generateSwizzles(programBinary, SAMPLER_VERTEX);
-    generateSwizzles(programBinary, SAMPLER_PIXEL);
+    Error error = generateSwizzles(programBinary, SAMPLER_VERTEX);
+    if (error.isError())
+    {
+        return error;
+    }
+
+    error = generateSwizzles(programBinary, SAMPLER_PIXEL);
+    if (error.isError())
+    {
+        return error;
+    }
+
+    return Error(GL_NO_ERROR);
 }
 
 // For each Direct3D sampler of either the pixel or vertex stage,
@@ -1673,7 +1690,11 @@ void Context::drawArrays(GLenum mode, GLint first, GLsizei count, GLsizei instan
     ProgramBinary *programBinary = mState.getCurrentProgramBinary();
     programBinary->updateSamplerMapping();
 
-    generateSwizzles(programBinary);
+    Error error = generateSwizzles(programBinary);
+    if (error.isError())
+    {
+        return gl::error(error.getCode());
+    }
 
     if (!mRenderer->applyPrimitiveType(mode, count))
     {
@@ -1683,7 +1704,7 @@ void Context::drawArrays(GLenum mode, GLint first, GLsizei count, GLsizei instan
     applyRenderTarget(mode, false);
     applyState(mode);
 
-    Error error = mRenderer->applyVertexBuffer(programBinary, mState.getVertexArray()->getVertexAttributes(), mState.getVertexAttribCurrentValues(), first, count, instances);
+    error = mRenderer->applyVertexBuffer(programBinary, mState.getVertexArray()->getVertexAttributes(), mState.getVertexAttribCurrentValues(), first, count, instances);
     if (error.isError())
     {
         return gl::error(error.getCode());
@@ -1720,7 +1741,11 @@ void Context::drawElements(GLenum mode, GLsizei count, GLenum type,
     ProgramBinary *programBinary = mState.getCurrentProgramBinary();
     programBinary->updateSamplerMapping();
 
-    generateSwizzles(programBinary);
+    Error error = generateSwizzles(programBinary);
+    if (error.isError())
+    {
+        return gl::error(error.getCode());
+    }
 
     if (!mRenderer->applyPrimitiveType(mode, count))
     {
@@ -1733,7 +1758,7 @@ void Context::drawElements(GLenum mode, GLsizei count, GLenum type,
     VertexArray *vao = mState.getVertexArray();
     rx::TranslatedIndexData indexInfo;
     indexInfo.indexRange = indexRange;
-    Error error = mRenderer->applyIndexBuffer(indices, vao->getElementArrayBuffer(), count, mode, type, &indexInfo);
+    error = mRenderer->applyIndexBuffer(indices, vao->getElementArrayBuffer(), count, mode, type, &indexInfo);
     if (error.isError())
     {
         return gl::error(error.getCode());

src/libGLESv2/Context.h

@@ -249,8 +249,8 @@ class Context
     void detachTransformFeedback(GLuint transformFeedback);
     void detachSampler(GLuint sampler);
 
-    void generateSwizzles(ProgramBinary *programBinary, SamplerType type);
-    void generateSwizzles(ProgramBinary *programBinary);
+    Error generateSwizzles(ProgramBinary *programBinary, SamplerType type);
+    Error generateSwizzles(ProgramBinary *programBinary);
 
     Texture *getIncompleteTexture(GLenum type);
 

src/libGLESv2/renderer/Renderer.h

@@ -109,7 +109,7 @@ class Renderer
 
     virtual SwapChain *createSwapChain(HWND window, HANDLE shareHandle, GLenum backBufferFormat, GLenum depthBufferFormat) = 0;
 
-    virtual void generateSwizzle(gl::Texture *texture) = 0;
+    virtual gl::Error generateSwizzle(gl::Texture *texture) = 0;
     virtual void setSamplerState(gl::SamplerType type, int index, const gl::SamplerState &sampler) = 0;
     virtual void setTexture(gl::SamplerType type, int index, gl::Texture *texture) = 0;
 

src/libGLESv2/renderer/d3d/d3d11/Blit11.cpp

@@ -368,8 +368,8 @@ static inline unsigned int GetSwizzleIndex(GLenum swizzle)
     return colorIndex;
 }
 
-bool Blit11::swizzleTexture(ID3D11ShaderResourceView *source, ID3D11RenderTargetView *dest, const gl::Extents &size,
-                            GLenum swizzleRed, GLenum swizzleGreen, GLenum swizzleBlue, GLenum swizzleAlpha)
+gl::Error Blit11::swizzleTexture(ID3D11ShaderResourceView *source, ID3D11RenderTargetView *dest, const gl::Extents &size,
+                                 GLenum swizzleRed, GLenum swizzleGreen, GLenum swizzleBlue, GLenum swizzleAlpha)
 {
     HRESULT result;
     ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext();
@@ -407,7 +407,7 @@ bool Blit11::swizzleTexture(ID3D11ShaderResourceView *source, ID3D11RenderTarget
     if (i == mSwizzleShaderMap.end())
     {
         UNREACHABLE();
-        return false;
+        return gl::Error(GL_INVALID_OPERATION, "Internal error, missing swizzle shader.");
     }
 
     const Shader &shader = i->second;
@@ -417,8 +417,7 @@ bool Blit11::swizzleTexture(ID3D11ShaderResourceView *source, ID3D11RenderTarget
     result = deviceContext->Map(mVertexBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
     if (FAILED(result))
     {
-        ERR("Failed to map vertex buffer for texture swizzle, HRESULT: 0x%X.", result);
-        return false;
+        return gl::Error(GL_OUT_OF_MEMORY, "Failed to map internal vertex buffer for swizzle, HRESULT: 0x%X.", result);
     }
 
     UINT stride = 0;
@@ -435,8 +434,7 @@ bool Blit11::swizzleTexture(ID3D11ShaderResourceView *source, ID3D11RenderTarget
     result = deviceContext->Map(mSwizzleCB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
     if (FAILED(result))
     {
-        ERR("Failed to map constant buffer for texture swizzle, HRESULT: 0x%X.", result);
-        return false;
+        return gl::Error(GL_OUT_OF_MEMORY, "Failed to map internal constant buffer for swizzle, HRESULT: 0x%X.", result);
     }
 
     unsigned int *swizzleIndices = reinterpret_cast<unsigned int*>(mappedResource.pData);
@@ -503,7 +501,7 @@ bool Blit11::swizzleTexture(ID3D11ShaderResourceView *source, ID3D11RenderTarget
 
     mRenderer->markAllStateDirty();
 
-    return true;
+    return gl::Error(GL_NO_ERROR);
 }
 
 bool Blit11::copyTexture(ID3D11ShaderResourceView *source, const gl::Box &sourceArea, const gl::Extents &sourceSize,

src/libGLESv2/renderer/d3d/d3d11/Blit11.h

@@ -11,6 +11,7 @@
 
 #include "common/angleutils.h"
 #include "libGLESv2/angletypes.h"
+#include "libGLESv2/Error.h"
 
 #include <map>
 
@@ -30,8 +31,8 @@ class Blit11
     explicit Blit11(Renderer11 *renderer);
     ~Blit11();
 
-    bool swizzleTexture(ID3D11ShaderResourceView *source, ID3D11RenderTargetView *dest, const gl::Extents &size,
-                        GLenum swizzleRed, GLenum swizzleGreen, GLenum swizzleBlue, GLenum swizzleAlpha);
+    gl::Error swizzleTexture(ID3D11ShaderResourceView *source, ID3D11RenderTargetView *dest, const gl::Extents &size,
+                             GLenum swizzleRed, GLenum swizzleGreen, GLenum swizzleBlue, GLenum swizzleAlpha);
 
     bool copyTexture(ID3D11ShaderResourceView *source, const gl::Box &sourceArea, const gl::Extents &sourceSize,
                      ID3D11RenderTargetView *dest, const gl::Box &destArea, const gl::Extents &destSize,

src/libGLESv2/renderer/d3d/d3d11/Renderer11.cpp

@@ -413,7 +413,7 @@ SwapChain *Renderer11::createSwapChain(HWND window, HANDLE shareHandle, GLenum b
     return new rx::SwapChain11(this, window, shareHandle, backBufferFormat, depthBufferFormat);
 }
 
-void Renderer11::generateSwizzle(gl::Texture *texture)
+gl::Error Renderer11::generateSwizzle(gl::Texture *texture)
 {
     if (texture)
     {
@@ -422,12 +422,18 @@ void Renderer11::generateSwizzle(gl::Texture *texture)
         {
             TextureStorage11 *storage11 = TextureStorage11::makeTextureStorage11(texStorage);
 
-            storage11->generateSwizzles(texture->getSamplerState().swizzleRed,
-                                        texture->getSamplerState().swizzleGreen,
-                                        texture->getSamplerState().swizzleBlue,
-                                        texture->getSamplerState().swizzleAlpha);
+            gl::Error error = storage11->generateSwizzles(texture->getSamplerState().swizzleRed,
+                                                          texture->getSamplerState().swizzleGreen,
+                                                          texture->getSamplerState().swizzleBlue,
+                                                          texture->getSamplerState().swizzleAlpha);
+            if (error.isError())
+            {
+                return error;
+            }
         }
     }
+
+    return gl::Error(GL_NO_ERROR);
 }
 
 void Renderer11::setSamplerState(gl::SamplerType type, int index, const gl::SamplerState &samplerState)

src/libGLESv2/renderer/d3d/d3d11/Renderer11.h

@@ -59,7 +59,7 @@ class Renderer11 : public Renderer
 
     virtual SwapChain *createSwapChain(HWND window, HANDLE shareHandle, GLenum backBufferFormat, GLenum depthBufferFormat);
 
-    virtual void generateSwizzle(gl::Texture *texture);
+    virtual gl::Error generateSwizzle(gl::Texture *texture);
     virtual void setSamplerState(gl::SamplerType type, int index, const gl::SamplerState &sampler);
     virtual void setTexture(gl::SamplerType type, int index, gl::Texture *texture);
 

src/libGLESv2/renderer/d3d/d3d11/TextureStorage11.cpp

@@ -240,7 +240,7 @@ ID3D11ShaderResourceView *TextureStorage11::getSRVLevel(int mipLevel)
     }
 }
 
-void TextureStorage11::generateSwizzles(GLenum swizzleRed, GLenum swizzleGreen, GLenum swizzleBlue, GLenum swizzleAlpha)
+gl::Error TextureStorage11::generateSwizzles(GLenum swizzleRed, GLenum swizzleGreen, GLenum swizzleBlue, GLenum swizzleAlpha)
 {
     SwizzleCacheValue swizzleTarget(swizzleRed, swizzleGreen, swizzleBlue, swizzleAlpha);
     for (int level = 0; level < getLevelCount(); level++)
@@ -256,16 +256,17 @@ void TextureStorage11::generateSwizzles(GLenum swizzleRed, GLenum swizzleGreen,
 
             Blit11 *blitter = mRenderer->getBlitter();
 
-            if (blitter->swizzleTexture(sourceSRV, destRTV, size, swizzleRed, swizzleGreen, swizzleBlue, swizzleAlpha))
+            gl::Error error = blitter->swizzleTexture(sourceSRV, destRTV, size, swizzleRed, swizzleGreen, swizzleBlue, swizzleAlpha);
+            if (error.isError())
             {
-                mSwizzleCache[level] = swizzleTarget;
-            }
-            else
-            {
-                ERR("Failed to swizzle texture.");
+                return error;
             }
+
+            mSwizzleCache[level] = swizzleTarget;
         }
     }
+
+    return gl::Error(GL_NO_ERROR);
 }
 
 void TextureStorage11::invalidateSwizzleCacheLevel(int mipLevel)

src/libGLESv2/renderer/d3d/d3d11/TextureStorage11.h

@@ -11,6 +11,7 @@
 #define LIBGLESV2_RENDERER_TEXTURESTORAGE11_H_
 
 #include "libGLESv2/Texture.h"
+#include "libGLESv2/Error.h"
 #include "libGLESv2/renderer/d3d/TextureStorage.h"
 
 #include <map>
@@ -52,7 +53,7 @@ class TextureStorage11 : public TextureStorage
     virtual int getLevelCount() const;
     UINT getSubresourceIndex(int mipLevel, int layerTarget) const;
 
-    void generateSwizzles(GLenum swizzleRed, GLenum swizzleGreen, GLenum swizzleBlue, GLenum swizzleAlpha);
+    gl::Error generateSwizzles(GLenum swizzleRed, GLenum swizzleGreen, GLenum swizzleBlue, GLenum swizzleAlpha);
     void invalidateSwizzleCacheLevel(int mipLevel);
     void invalidateSwizzleCache();
 

src/libGLESv2/renderer/d3d/d3d9/Renderer9.cpp

@@ -636,10 +636,11 @@ bool Renderer9::fastCopyBufferToTexture(const gl::PixelUnpackState &unpack, unsi
     return false;
 }
 
-void Renderer9::generateSwizzle(gl::Texture *texture)
+gl::Error Renderer9::generateSwizzle(gl::Texture *texture)
 {
     // Swizzled textures are not available in ES2 or D3D9
     UNREACHABLE();
+    return gl::Error(GL_INVALID_OPERATION);
 }
 
 void Renderer9::setSamplerState(gl::SamplerType type, int index, const gl::SamplerState &samplerState)

src/libGLESv2/renderer/d3d/d3d9/Renderer9.h

@@ -60,7 +60,7 @@ class Renderer9 : public Renderer
     IDirect3DPixelShader9 *createPixelShader(const DWORD *function, size_t length);
     HRESULT createVertexBuffer(UINT Length, DWORD Usage, IDirect3DVertexBuffer9 **ppVertexBuffer);
     HRESULT createIndexBuffer(UINT Length, DWORD Usage, D3DFORMAT Format, IDirect3DIndexBuffer9 **ppIndexBuffer);
-    virtual void generateSwizzle(gl::Texture *texture);
+    virtual gl::Error generateSwizzle(gl::Texture *texture);
     virtual void setSamplerState(gl::SamplerType type, int index, const gl::SamplerState &sampler);
     virtual void setTexture(gl::SamplerType type, int index, gl::Texture *texture);