Merged two internal pixel storage calculating functions into one.

I guess this might fix *some* issues.

src/Magnum/PixelStorage.h

@@ -414,25 +414,10 @@ namespace Implementation {
     }
     #endif
 
-    /* Use in compressed image upload functions */
     #ifndef MAGNUM_TARGET_GLES
-    template<class T> std::size_t occupiedCompressedImageDataSize(const T& image, std::size_t dataSize) {
-        if(!image.storage().compressedBlockSize().product() || !image.storage().compressedBlockDataSize())
-            return dataSize;
-
-        return ((Vector3i::pad(image.size(), 1) + image.storage().compressedBlockSize() - Vector3i{1})/image.storage().compressedBlockSize()).product()*image.storage().compressedBlockDataSize();
-    }
-    #else
-    template<class T> std::size_t occupiedCompressedImageDataSize(const T&, std::size_t dataSize) {
-        return dataSize;
-    }
-    #endif
-
-    #ifndef MAGNUM_TARGET_GLES
-    /* Used in image query functions */
-    template<std::size_t dimensions, class T> std::size_t compressedImageDataSizeFor(const T& image, const Math::Vector<dimensions, Int>& size, std::size_t dataSize) {
+    template<std::size_t dimensions, class T> std::pair<std::size_t, std::size_t> compressedImageDataOffsetSizeFor(const T& image, const Math::Vector<dimensions, Int>& size, std::size_t dataSize) {
         if(!image.storage().compressedBlockSize().product() || !image.storage().compressedBlockDataSize())
-            return dataSize;
+            return {0, dataSize};
 
         std::size_t offset;
         Math::Vector3<std::size_t> blockCount;
@@ -441,7 +426,22 @@ namespace Implementation {
 
         const auto realBlockCount = Math::Vector3<std::size_t>{(Vector3i::pad(size, 1) + image.storage().compressedBlockSize() - Vector3i{1})/image.storage().compressedBlockSize()};
 
-        return offset + (blockCount.product() - (blockCount.x() - realBlockCount.x()) - (blockCount.y() - realBlockCount.y())*blockCount.x())*blockDataSize;
+        return {offset, (blockCount.product() - (blockCount.x() - realBlockCount.x()) - (blockCount.y() - realBlockCount.y())*blockCount.x())*blockDataSize};
+    }
+
+    /* Used in image query functions */
+    template<std::size_t dimensions, class T> std::size_t compressedImageDataSizeFor(const T& image, const Math::Vector<dimensions, Int>& size, std::size_t dataSize) {
+        auto r = compressedImageDataOffsetSizeFor(image, size, dataSize);
+        return r.first + r.second;
+    }
+
+    /* Use in compressed image upload functions */
+    template<class T> std::size_t occupiedCompressedImageDataSize(const T& image, std::size_t dataSize) {
+        return compressedImageDataOffsetSizeFor(image, image.size(), dataSize).second;
+    }
+    #else
+    template<class T> std::size_t occupiedCompressedImageDataSize(const T&, std::size_t dataSize) {
+        return dataSize;
     }
     #endif
 

src/Magnum/Test/PixelStorageTest.cpp

@@ -50,7 +50,7 @@ struct PixelStorageTest: TestSuite::Tester {
     void dataPropertiesCompressedRowLength();
     void dataPropertiesCompressedImageHeight();
 
-    void dataSizeCompressed();
+    void dataOffsetSizeCompressed();
     #endif
 };
 
@@ -73,7 +73,7 @@ PixelStorageTest::PixelStorageTest() {
               &PixelStorageTest::dataPropertiesCompressedRowLength,
               &PixelStorageTest::dataPropertiesCompressedImageHeight,
 
-              &PixelStorageTest::dataSizeCompressed
+              &PixelStorageTest::dataOffsetSizeCompressed
               #endif
               });
 }
@@ -207,11 +207,11 @@ void PixelStorageTest::dataPropertiesCompressedImageHeight() {
         (std::tuple<std::size_t, Vector3st, std::size_t>{(2 + 2 + 9)*16, {1, 3, 3}, 16}));
 }
 
-void PixelStorageTest::dataSizeCompressed() {
-    /* Tf the storage doesn't contain any info about block sizes (the default,
+void PixelStorageTest::dataOffsetSizeCompressed() {
+    /* Tf the storage doesn't contain any info about block sizes (the default),
        using the provided value */
-    CORRADE_COMPARE(Implementation::compressedImageDataSizeFor(CompressedImage3D{},
-        Vector2i{37, 35}, 1579), 1579);
+    CORRADE_COMPARE(Implementation::compressedImageDataOffsetSizeFor(CompressedImage3D{},
+        Vector2i{37, 35}, 1579), (std::pair<std::size_t, std::size_t>{0, 1579}));
 
     /* The same parameters as in PixelStorageGLTest 3D case */
     const CompressedImage3D image{CompressedPixelStorage{}
@@ -220,8 +220,8 @@ void PixelStorageTest::dataSizeCompressed() {
         .setRowLength(8)
         .setImageHeight(8)
         .setSkip({4, 4, 4})};
-    CORRADE_COMPARE(Implementation::compressedImageDataSizeFor(image, Vector3i{4, 4, 1}, 1579),
-        16*4*4 + 16*4);
+    CORRADE_COMPARE(Implementation::compressedImageDataOffsetSizeFor(image, Vector3i{4, 4, 1}, 1579),
+        (std::pair<std::size_t, std::size_t>{16*4*4 + 16*2 + 16, 16}));
 }
 #endif