Fix invalid storage recovery on FL 9_3.

src/libANGLE/renderer/d3d/TextureD3D.cpp

@@ -642,9 +642,9 @@ TextureD3D_2D::TextureD3D_2D(const gl::TextureState &state, RendererD3D *rendere
     : TextureD3D(state, renderer)
 {
     mEGLImageTarget = false;
-    for (int i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++i)
+    for (auto &image : mImageArray)
     {
-        mImageArray[i] = renderer->createImage();
+        image.reset(renderer->createImage());
     }
 }
 
@@ -853,22 +853,27 @@ bool TextureD3D_2DMultisample::isImageComplete(const gl::ImageIndex &index) cons
     return false;
 }
 
-TextureD3D_2D::~TextureD3D_2D()
+gl::Error TextureD3D_2D::onDestroy(const gl::Context *context)
 {
-    // Delete the Images before the TextureStorage.
-    // Images might be relying on the TextureStorage for some of their data.
-    // If TextureStorage is deleted before the Images, then their data will be wastefully copied back from the GPU before we delete the Images.
-    for (int i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++i)
+    // Delete the Images before the TextureStorage. Images might be relying on the TextureStorage
+    // for some of their data. If TextureStorage is deleted before the Images, then their data will
+    // be wastefully copied back from the GPU before we delete the Images.
+    for (auto &image : mImageArray)
     {
-        SafeDelete(mImageArray[i]);
+        image.reset();
     }
+    return TextureD3D::onDestroy(context);
+}
+
+TextureD3D_2D::~TextureD3D_2D()
+{
 }
 
 ImageD3D *TextureD3D_2D::getImage(int level, int layer) const
 {
     ASSERT(level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS);
     ASSERT(layer == 0);
-    return mImageArray[level];
+    return mImageArray[level].get();
 }
 
 ImageD3D *TextureD3D_2D::getImage(const gl::ImageIndex &index) const
@@ -876,7 +881,7 @@ ImageD3D *TextureD3D_2D::getImage(const gl::ImageIndex &index) const
     ASSERT(index.mipIndex < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS);
     ASSERT(!index.hasLayer());
     ASSERT(index.type == GL_TEXTURE_2D);
-    return mImageArray[index.mipIndex];
+    return mImageArray[index.mipIndex].get();
 }
 
 GLsizei TextureD3D_2D::getLayerCount(int level) const
@@ -1310,7 +1315,7 @@ gl::Error TextureD3D_2D::setEGLImageTarget(const gl::Context *context,
     ANGLE_TRY(redefineImage(context, 0, format.info->sizedInternalFormat, size, true));
 
     // Clear all other images.
-    for (size_t level = 1; level < ArraySize(mImageArray); level++)
+    for (size_t level = 1; level < mImageArray.size(); level++)
     {
         ANGLE_TRY(redefineImage(context, level, GL_NONE, gl::Extents(0, 0, 1), true));
     }
@@ -1383,8 +1388,9 @@ bool TextureD3D_2D::isLevelComplete(int level) const
         return true;
     }
 
-    ASSERT(level >= 0 && level <= (int)ArraySize(mImageArray) && mImageArray[level] != nullptr);
-    ImageD3D *image = mImageArray[level];
+    ASSERT(level >= 0 && level <= static_cast<int>(mImageArray.size()) &&
+           mImageArray[level] != nullptr);
+    ImageD3D *image = mImageArray[level].get();
 
     if (image->getInternalFormat() != getBaseLevelInternalFormat())
     {
@@ -1508,7 +1514,7 @@ gl::Error TextureD3D_2D::updateStorage(const gl::Context *context)
 
 gl::Error TextureD3D_2D::updateStorageLevel(const gl::Context *context, int level)
 {
-    ASSERT(level <= (int)ArraySize(mImageArray) && mImageArray[level] != nullptr);
+    ASSERT(level <= static_cast<int>(mImageArray.size()) && mImageArray[level] != nullptr);
     ASSERT(isLevelComplete(level));
 
     if (mImageArray[level]->isDirty())
@@ -1604,41 +1610,46 @@ gl::Error TextureD3D_2D::setStorageMultisample(const gl::Context *context,
 TextureD3D_Cube::TextureD3D_Cube(const gl::TextureState &state, RendererD3D *renderer)
     : TextureD3D(state, renderer)
 {
-    for (int i = 0; i < 6; i++)
+    for (auto &face : mImageArray)
     {
-        for (int j = 0; j < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++j)
+        for (auto &image : face)
         {
-            mImageArray[i][j] = renderer->createImage();
+            image.reset(renderer->createImage());
         }
     }
 }
 
-TextureD3D_Cube::~TextureD3D_Cube()
+gl::Error TextureD3D_Cube::onDestroy(const gl::Context *context)
 {
-    // Delete the Images before the TextureStorage.
-    // Images might be relying on the TextureStorage for some of their data.
-    // If TextureStorage is deleted before the Images, then their data will be wastefully copied back from the GPU before we delete the Images.
-    for (int i = 0; i < 6; i++)
+    // Delete the Images before the TextureStorage. Images might be relying on the TextureStorage
+    // for some of their data. If TextureStorage is deleted before the Images, then their data will
+    // be wastefully copied back from the GPU before we delete the Images.
+    for (auto &face : mImageArray)
     {
-        for (int j = 0; j < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++j)
+        for (auto &image : face)
         {
-            SafeDelete(mImageArray[i][j]);
+            image.reset();
         }
     }
+    return TextureD3D::onDestroy(context);
+}
+
+TextureD3D_Cube::~TextureD3D_Cube()
+{
 }
 
 ImageD3D *TextureD3D_Cube::getImage(int level, int layer) const
 {
     ASSERT(level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS);
     ASSERT(layer >= 0 && layer < 6);
-    return mImageArray[layer][level];
+    return mImageArray[layer][level].get();
 }
 
 ImageD3D *TextureD3D_Cube::getImage(const gl::ImageIndex &index) const
 {
     ASSERT(index.mipIndex < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS);
     ASSERT(index.layerIndex >= 0 && index.layerIndex < 6);
-    return mImageArray[index.layerIndex][index.mipIndex];
+    return mImageArray[index.layerIndex][index.mipIndex].get();
 }
 
 GLsizei TextureD3D_Cube::getLayerCount(int level) const
@@ -2160,7 +2171,7 @@ bool TextureD3D_Cube::isFaceLevelComplete(int faceIndex, int level) const
     {
         return false;
     }
-    ASSERT(level >= 0 && faceIndex < 6 && level < (int)ArraySize(mImageArray[faceIndex]) &&
+    ASSERT(level >= 0 && faceIndex < 6 && level < static_cast<int>(mImageArray[faceIndex].size()) &&
            mImageArray[faceIndex][level] != nullptr);
 
     if (isImmutable())
@@ -2184,7 +2195,7 @@ bool TextureD3D_Cube::isFaceLevelComplete(int faceIndex, int level) const
     }
 
     // Check that non-zero levels are consistent with the base level.
-    const ImageD3D *faceLevelImage = mImageArray[faceIndex][level];
+    const ImageD3D *faceLevelImage = mImageArray[faceIndex][level].get();
 
     if (faceLevelImage->getInternalFormat() != getBaseLevelInternalFormat())
     {
@@ -2208,9 +2219,9 @@ gl::Error TextureD3D_Cube::updateStorageFaceLevel(const gl::Context *context,
                                                   int faceIndex,
                                                   int level)
 {
-    ASSERT(level >= 0 && faceIndex < 6 && level < (int)ArraySize(mImageArray[faceIndex]) &&
+    ASSERT(level >= 0 && faceIndex < 6 && level < static_cast<int>(mImageArray[faceIndex].size()) &&
            mImageArray[faceIndex][level] != nullptr);
-    ImageD3D *image = mImageArray[faceIndex][level];
+    ImageD3D *image = mImageArray[faceIndex][level].get();
 
     if (image->isDirty())
     {
@@ -2289,26 +2300,31 @@ TextureD3D_3D::TextureD3D_3D(const gl::TextureState &state, RendererD3D *rendere
 {
     for (int i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++i)
     {
-        mImageArray[i] = renderer->createImage();
+        mImageArray[i].reset(renderer->createImage());
     }
 }
 
-TextureD3D_3D::~TextureD3D_3D()
+gl::Error TextureD3D_3D::onDestroy(const gl::Context *context)
 {
-    // Delete the Images before the TextureStorage.
-    // Images might be relying on the TextureStorage for some of their data.
-    // If TextureStorage is deleted before the Images, then their data will be wastefully copied back from the GPU before we delete the Images.
-    for (int i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++i)
+    // Delete the Images before the TextureStorage. Images might be relying on the TextureStorage
+    // for some of their data. If TextureStorage is deleted before the Images, then their data will
+    // be wastefully copied back from the GPU before we delete the Images.
+    for (auto &image : mImageArray)
     {
-        delete mImageArray[i];
+        image.reset();
     }
+    return TextureD3D::onDestroy(context);
+}
+
+TextureD3D_3D::~TextureD3D_3D()
+{
 }
 
 ImageD3D *TextureD3D_3D::getImage(int level, int layer) const
 {
     ASSERT(level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS);
     ASSERT(layer == 0);
-    return mImageArray[level];
+    return mImageArray[level].get();
 }
 
 ImageD3D *TextureD3D_3D::getImage(const gl::ImageIndex &index) const
@@ -2316,7 +2332,7 @@ ImageD3D *TextureD3D_3D::getImage(const gl::ImageIndex &index) const
     ASSERT(index.mipIndex < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS);
     ASSERT(!index.hasLayer());
     ASSERT(index.type == GL_TEXTURE_3D);
-    return mImageArray[index.mipIndex];
+    return mImageArray[index.mipIndex].get();
 }
 
 GLsizei TextureD3D_3D::getLayerCount(int level) const
@@ -2703,7 +2719,8 @@ bool TextureD3D_3D::isValidLevel(int level) const
 
 bool TextureD3D_3D::isLevelComplete(int level) const
 {
-    ASSERT(level >= 0 && level < (int)ArraySize(mImageArray) && mImageArray[level] != nullptr);
+    ASSERT(level >= 0 && level < static_cast<int>(mImageArray.size()) &&
+           mImageArray[level] != nullptr);
 
     if (isImmutable())
     {
@@ -2724,7 +2741,7 @@ bool TextureD3D_3D::isLevelComplete(int level) const
         return true;
     }
 
-    ImageD3D *levelImage = mImageArray[level];
+    ImageD3D *levelImage = mImageArray[level].get();
 
     if (levelImage->getInternalFormat() != getBaseLevelInternalFormat())
     {
@@ -2756,7 +2773,8 @@ bool TextureD3D_3D::isImageComplete(const gl::ImageIndex &index) const
 
 gl::Error TextureD3D_3D::updateStorageLevel(const gl::Context *context, int level)
 {
-    ASSERT(level >= 0 && level < (int)ArraySize(mImageArray) && mImageArray[level] != nullptr);
+    ASSERT(level >= 0 && level < static_cast<int>(mImageArray.size()) &&
+           mImageArray[level] != nullptr);
     ASSERT(isLevelComplete(level));
 
     if (mImageArray[level]->isDirty())
@@ -2843,12 +2861,17 @@ TextureD3D_2DArray::TextureD3D_2DArray(const gl::TextureState &state, RendererD3
     }
 }
 
-TextureD3D_2DArray::~TextureD3D_2DArray()
+gl::Error TextureD3D_2DArray::onDestroy(const gl::Context *context)
 {
-    // Delete the Images before the TextureStorage.
-    // Images might be relying on the TextureStorage for some of their data.
-    // If TextureStorage is deleted before the Images, then their data will be wastefully copied back from the GPU before we delete the Images.
+    // Delete the Images before the TextureStorage. Images might be relying on the TextureStorage
+    // for some of their data. If TextureStorage is deleted before the Images, then their data will
+    // be wastefully copied back from the GPU before we delete the Images.
     deleteImages();
+    return TextureD3D::onDestroy(context);
+}
+
+TextureD3D_2DArray::~TextureD3D_2DArray()
+{
 }
 
 ImageD3D *TextureD3D_2DArray::getImage(int level, int layer) const

src/libANGLE/renderer/d3d/TextureD3D.h

@@ -28,6 +28,9 @@ class RendererD3D;
 class RenderTargetD3D;
 class TextureStorage;
 
+template <typename T>
+using TexLevelsArray = std::array<T, gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS>;
+
 class TextureD3D : public TextureImpl
 {
   public:
@@ -181,6 +184,8 @@ class TextureD3D_2D : public TextureD3D
     TextureD3D_2D(const gl::TextureState &data, RendererD3D *renderer);
     virtual ~TextureD3D_2D();
 
+    gl::Error onDestroy(const gl::Context *context) override;
+
     ImageD3D *getImage(int level, int layer) const;
     ImageD3D *getImage(const gl::ImageIndex &index) const override;
     GLsizei getLayerCount(int level) const override;
@@ -314,7 +319,7 @@ class TextureD3D_2D : public TextureD3D
                             bool forceRelease);
 
     bool mEGLImageTarget;
-    ImageD3D *mImageArray[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
+    TexLevelsArray<std::unique_ptr<ImageD3D>> mImageArray;
 };
 
 class TextureD3D_Cube : public TextureD3D
@@ -323,6 +328,8 @@ class TextureD3D_Cube : public TextureD3D
     TextureD3D_Cube(const gl::TextureState &data, RendererD3D *renderer);
     virtual ~TextureD3D_Cube();
 
+    gl::Error onDestroy(const gl::Context *context) override;
+
     ImageD3D *getImage(int level, int layer) const;
     ImageD3D *getImage(const gl::ImageIndex &index) const override;
     GLsizei getLayerCount(int level) const override;
@@ -446,7 +453,7 @@ class TextureD3D_Cube : public TextureD3D
                             const gl::Extents &size,
                             bool forceRelease);
 
-    ImageD3D *mImageArray[6][gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
+    std::array<TexLevelsArray<std::unique_ptr<ImageD3D>>, 6> mImageArray;
 };
 
 class TextureD3D_3D : public TextureD3D
@@ -455,6 +462,8 @@ class TextureD3D_3D : public TextureD3D
     TextureD3D_3D(const gl::TextureState &data, RendererD3D *renderer);
     virtual ~TextureD3D_3D();
 
+    gl::Error onDestroy(const gl::Context *context) override;
+
     ImageD3D *getImage(int level, int layer) const;
     ImageD3D *getImage(const gl::ImageIndex &index) const override;
     GLsizei getLayerCount(int level) const override;
@@ -559,7 +568,7 @@ class TextureD3D_3D : public TextureD3D
                             const gl::Extents &size,
                             bool forceRelease);
 
-    ImageD3D *mImageArray[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
+    TexLevelsArray<std::unique_ptr<ImageD3D>> mImageArray;
 };
 
 class TextureD3D_2DArray : public TextureD3D
@@ -568,6 +577,8 @@ class TextureD3D_2DArray : public TextureD3D
     TextureD3D_2DArray(const gl::TextureState &data, RendererD3D *renderer);
     virtual ~TextureD3D_2DArray();
 
+    gl::Error onDestroy(const gl::Context *context) override;
+
     virtual ImageD3D *getImage(int level, int layer) const;
     virtual ImageD3D *getImage(const gl::ImageIndex &index) const;
     virtual GLsizei getLayerCount(int level) const;

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

@@ -488,17 +488,25 @@ gl::Error TextureStorage11::copySubresourceLevel(const gl::Context *context,
     D3D11_BOX *pSrcBox = nullptr;
     if (mRenderer->getRenderer11DeviceCaps().featureLevel <= D3D_FEATURE_LEVEL_9_3)
     {
-        // However, D3D10Level9 doesn't always perform CopySubresourceRegion correctly unless the
-        // source box is specified. This is okay, since we don't perform CopySubresourceRegion on
-        // depth/stencil textures on 9_3.
-        ASSERT(mFormatInfo.dsvFormat == DXGI_FORMAT_UNKNOWN);
-        srcBox.left   = region.x;
-        srcBox.right  = region.x + region.width;
-        srcBox.top    = region.y;
-        srcBox.bottom = region.y + region.height;
-        srcBox.front  = region.z;
-        srcBox.back   = region.z + region.depth;
-        pSrcBox       = &srcBox;
+        GLsizei width  = region.width;
+        GLsizei height = region.height;
+        d3d11::MakeValidSize(false, mFormatInfo.texFormat, &width, &height, nullptr);
+
+        // Keep srcbox as nullptr if we're dealing with tiny mips of compressed textures.
+        if (width == region.width && height == region.height)
+        {
+            // However, D3D10Level9 doesn't always perform CopySubresourceRegion correctly unless
+            // the source box is specified. This is okay, since we don't perform
+            // CopySubresourceRegion on depth/stencil textures on 9_3.
+            ASSERT(mFormatInfo.dsvFormat == DXGI_FORMAT_UNKNOWN);
+            srcBox.left   = region.x;
+            srcBox.right  = region.x + region.width;
+            srcBox.top    = region.y;
+            srcBox.bottom = region.y + region.height;
+            srcBox.front  = region.z;
+            srcBox.back   = region.z + region.depth;
+            pSrcBox       = &srcBox;
+        }
     }
 
     deviceContext->CopySubresourceRegion(dstTexture.get(), dstSubresource, region.x, region.y,

src/libANGLE/renderer/d3d/d3d11/renderer11_utils.cpp

@@ -1793,7 +1793,10 @@ void MakeValidSize(bool isImage, DXGI_FORMAT format, GLsizei *requestWidth, GLsi
             upsampleCount++;
         }
     }
-    *levelOffset = upsampleCount;
+    if (levelOffset)
+    {
+        *levelOffset = upsampleCount;
+    }
 }
 
 void GenerateInitialTextureData(GLint internalFormat,