| /*------------------------------------------------------------------------- |
| * drawElements Quality Program Tester Core |
| * ---------------------------------------- |
| * |
| * Copyright 2014 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| *//*! |
| * \file |
| * \brief Bilinear image comparison. |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "tcuBilinearImageCompare.hpp" |
| #include "tcuTexture.hpp" |
| #include "tcuTextureUtil.hpp" |
| #include "tcuRGBA.hpp" |
| |
| namespace tcu |
| { |
| |
| namespace |
| { |
| |
| enum |
| { |
| NUM_SUBPIXEL_BITS = 8 //!< Number of subpixel bits used when doing bilinear interpolation. |
| }; |
| |
| // \note Algorithm assumes that colors are packed to 32-bit values as dictated by |
| // tcu::RGBA::*_SHIFT values. |
| |
| template <int Channel> |
| static inline uint8_t getChannel(uint32_t color) |
| { |
| return (uint8_t)((color >> (Channel * 8)) & 0xff); |
| } |
| |
| #if (DE_ENDIANNESS == DE_LITTLE_ENDIAN) |
| inline uint32_t readRGBA8Raw(const ConstPixelBufferAccess &src, uint32_t x, uint32_t y) |
| { |
| return *(const uint32_t *)((const uint8_t *)src.getDataPtr() + y * src.getRowPitch() + x * 4); |
| } |
| #else |
| inline uint32_t readRGBA8Raw(const ConstPixelBufferAccess &src, uint32_t x, uint32_t y) |
| { |
| return deReverseBytes32(*(const uint32_t *)((const uint8_t *)src.getDataPtr() + y * src.getRowPitch() + x * 4)); |
| } |
| #endif |
| |
| inline RGBA readRGBA8(const ConstPixelBufferAccess &src, uint32_t x, uint32_t y) |
| { |
| uint32_t raw = readRGBA8Raw(src, x, y); |
| uint32_t res = 0; |
| |
| res |= getChannel<0>(raw) << RGBA::RED_SHIFT; |
| res |= getChannel<1>(raw) << RGBA::GREEN_SHIFT; |
| res |= getChannel<2>(raw) << RGBA::BLUE_SHIFT; |
| res |= getChannel<3>(raw) << RGBA::ALPHA_SHIFT; |
| |
| return RGBA(res); |
| } |
| |
| inline uint8_t interpolateChannel(uint32_t fx1, uint32_t fy1, uint8_t p00, uint8_t p01, uint8_t p10, uint8_t p11) |
| { |
| const uint32_t fx0 = (1u << NUM_SUBPIXEL_BITS) - fx1; |
| const uint32_t fy0 = (1u << NUM_SUBPIXEL_BITS) - fy1; |
| const uint32_t half = 1u << (NUM_SUBPIXEL_BITS * 2 - 1); |
| const uint32_t sum = fx0 * fy0 * p00 + fx1 * fy0 * p10 + fx0 * fy1 * p01 + fx1 * fy1 * p11; |
| const uint32_t rounded = (sum + half) >> (NUM_SUBPIXEL_BITS * 2); |
| |
| DE_ASSERT(de::inRange<uint32_t>(rounded, 0, 0xff)); |
| return (uint8_t)rounded; |
| } |
| |
| RGBA bilinearSampleRGBA8(const ConstPixelBufferAccess &access, uint32_t u, uint32_t v) |
| { |
| uint32_t x0 = u >> NUM_SUBPIXEL_BITS; |
| uint32_t y0 = v >> NUM_SUBPIXEL_BITS; |
| uint32_t x1 = x0 + 1; //de::min(x0+1, (uint32_t)(access.getWidth()-1)); |
| uint32_t y1 = y0 + 1; //de::min(y0+1, (uint32_t)(access.getHeight()-1)); |
| |
| DE_ASSERT(x1 < (uint32_t)access.getWidth()); |
| DE_ASSERT(y1 < (uint32_t)access.getHeight()); |
| |
| uint32_t fx1 = u - (x0 << NUM_SUBPIXEL_BITS); |
| uint32_t fy1 = v - (y0 << NUM_SUBPIXEL_BITS); |
| |
| uint32_t p00 = readRGBA8Raw(access, x0, y0); |
| uint32_t p10 = readRGBA8Raw(access, x1, y0); |
| uint32_t p01 = readRGBA8Raw(access, x0, y1); |
| uint32_t p11 = readRGBA8Raw(access, x1, y1); |
| |
| uint32_t res = 0; |
| |
| res |= interpolateChannel(fx1, fy1, getChannel<0>(p00), getChannel<0>(p01), getChannel<0>(p10), getChannel<0>(p11)) |
| << RGBA::RED_SHIFT; |
| res |= interpolateChannel(fx1, fy1, getChannel<1>(p00), getChannel<1>(p01), getChannel<1>(p10), getChannel<1>(p11)) |
| << RGBA::GREEN_SHIFT; |
| res |= interpolateChannel(fx1, fy1, getChannel<2>(p00), getChannel<2>(p01), getChannel<2>(p10), getChannel<2>(p11)) |
| << RGBA::BLUE_SHIFT; |
| res |= interpolateChannel(fx1, fy1, getChannel<3>(p00), getChannel<3>(p01), getChannel<3>(p10), getChannel<3>(p11)) |
| << RGBA::ALPHA_SHIFT; |
| |
| return RGBA(res); |
| } |
| |
| bool comparePixelRGBA8(const ConstPixelBufferAccess &reference, const ConstPixelBufferAccess &result, |
| const RGBA threshold, int x, int y) |
| { |
| const RGBA resPix = readRGBA8(result, (uint32_t)x, (uint32_t)y); |
| |
| // Step 1: Compare result pixel to 3x3 neighborhood pixels in reference. |
| { |
| const uint32_t x0 = (uint32_t)de::max(x - 1, 0); |
| const uint32_t x1 = (uint32_t)x; |
| const uint32_t x2 = (uint32_t)de::min(x + 1, reference.getWidth() - 1); |
| const uint32_t y0 = (uint32_t)de::max(y - 1, 0); |
| const uint32_t y1 = (uint32_t)y; |
| const uint32_t y2 = (uint32_t)de::min(y + 1, reference.getHeight() - 1); |
| |
| if (compareThreshold(resPix, readRGBA8(reference, x1, y1), threshold) || |
| compareThreshold(resPix, readRGBA8(reference, x0, y1), threshold) || |
| compareThreshold(resPix, readRGBA8(reference, x2, y1), threshold) || |
| compareThreshold(resPix, readRGBA8(reference, x0, y0), threshold) || |
| compareThreshold(resPix, readRGBA8(reference, x1, y0), threshold) || |
| compareThreshold(resPix, readRGBA8(reference, x2, y0), threshold) || |
| compareThreshold(resPix, readRGBA8(reference, x0, y2), threshold) || |
| compareThreshold(resPix, readRGBA8(reference, x1, y2), threshold) || |
| compareThreshold(resPix, readRGBA8(reference, x2, y2), threshold)) |
| return true; |
| } |
| |
| // Step 2: Compare using bilinear sampling. |
| { |
| // \todo [pyry] Optimize sample positions! |
| static const uint32_t s_offsets[][2] = {{226, 186}, {335, 235}, {279, 334}, {178, 272}, {112, 202}, {306, 117}, |
| {396, 299}, {206, 382}, {146, 96}, {423, 155}, {361, 412}, {84, 339}, |
| {48, 130}, {367, 43}, {455, 367}, {105, 439}, {83, 46}, {217, 24}, |
| {461, 71}, {450, 459}, {239, 469}, {67, 267}, {459, 255}, {13, 416}, |
| {10, 192}, {141, 502}, {503, 304}, {380, 506}}; |
| |
| for (int sampleNdx = 0; sampleNdx < DE_LENGTH_OF_ARRAY(s_offsets); sampleNdx++) |
| { |
| const int u = (x << NUM_SUBPIXEL_BITS) + (int)s_offsets[sampleNdx][0] - (1 << NUM_SUBPIXEL_BITS); |
| const int v = (y << NUM_SUBPIXEL_BITS) + (int)s_offsets[sampleNdx][1] - (1 << NUM_SUBPIXEL_BITS); |
| |
| if (!de::inBounds(u, 0, (reference.getWidth() - 1) << NUM_SUBPIXEL_BITS) || |
| !de::inBounds(v, 0, (reference.getHeight() - 1) << NUM_SUBPIXEL_BITS)) |
| continue; |
| |
| if (compareThreshold(resPix, bilinearSampleRGBA8(reference, (uint32_t)u, (uint32_t)v), threshold)) |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| bool bilinearCompareRGBA8(const ConstPixelBufferAccess &reference, const ConstPixelBufferAccess &result, |
| const PixelBufferAccess &errorMask, const RGBA threshold) |
| { |
| DE_ASSERT(reference.getFormat() == TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8) && |
| result.getFormat() == TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8)); |
| |
| // Clear error mask first to green (faster this way). |
| clear(errorMask, Vec4(0.0f, 1.0f, 0.0f, 1.0f)); |
| |
| bool allOk = true; |
| |
| for (int y = 0; y < reference.getHeight(); y++) |
| { |
| for (int x = 0; x < reference.getWidth(); x++) |
| { |
| if (!comparePixelRGBA8(reference, result, threshold, x, y) && |
| !comparePixelRGBA8(result, reference, threshold, x, y)) |
| { |
| allOk = false; |
| errorMask.setPixel(Vec4(1.0f, 0.0f, 0.0f, 1.0f), x, y); |
| } |
| } |
| } |
| |
| return allOk; |
| } |
| |
| } // namespace |
| |
| bool bilinearCompare(const ConstPixelBufferAccess &reference, const ConstPixelBufferAccess &result, |
| const PixelBufferAccess &errorMask, const RGBA threshold) |
| { |
| DE_ASSERT(reference.getWidth() == result.getWidth() && reference.getHeight() == result.getHeight() && |
| reference.getDepth() == result.getDepth() && reference.getFormat() == result.getFormat()); |
| DE_ASSERT(reference.getWidth() == errorMask.getWidth() && reference.getHeight() == errorMask.getHeight() && |
| reference.getDepth() == errorMask.getDepth()); |
| |
| if (reference.getFormat() == TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8)) |
| return bilinearCompareRGBA8(reference, result, errorMask, threshold); |
| else |
| throw InternalError("Unsupported format for bilinear comparison"); |
| } |
| |
| } // namespace tcu |
