From: Pierre Ossman Date: Thu, 25 Sep 2014 07:58:55 +0000 (+0200) Subject: Add pixel conversion correctness test X-Git-Tag: v1.3.90~26^2~1 X-Git-Url: https://source.dussan.org/?a=commitdiff_plain;h=41deb88359d96b782f8da7126c8060bd285686e6;p=tigervnc.git Add pixel conversion correctness test --- diff --git a/common/rfb/PixelFormat.h b/common/rfb/PixelFormat.h index 8dfa5f1a..8d67f8a1 100644 --- a/common/rfb/PixelFormat.h +++ b/common/rfb/PixelFormat.h @@ -141,6 +141,12 @@ namespace rfb { class Init; friend class Init; static Init _init; + + /* Only for testing this class */ + friend void makePixel(const rfb::PixelFormat &, rdr::U8 *); + friend bool verifyPixel(const rfb::PixelFormat &, + const rfb::PixelFormat &, + const rdr::U8 *); }; } diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index cce2f1ec..afab3e26 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -4,3 +4,6 @@ add_library(test_util STATIC util.cxx) add_executable(convperf convperf.cxx) target_link_libraries(convperf test_util rfb) + +add_executable(conv conv.cxx) +target_link_libraries(conv rfb) diff --git a/tests/conv.cxx b/tests/conv.cxx new file mode 100644 index 00000000..22c86c4e --- /dev/null +++ b/tests/conv.cxx @@ -0,0 +1,323 @@ +/* Copyright 2013-2014 Pierre Ossman for Cendio AB + * + * This is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + * USA. + */ + +#include +#include +#include + +#include + +static const rdr::U8 pixelRed = 0xf1; +static const rdr::U8 pixelGreen = 0xc3; +static const rdr::U8 pixelBlue = 0x97; + +typedef bool (*testfn) (const rfb::PixelFormat&, const rfb::PixelFormat&); + +struct TestEntry { + const char *label; + testfn fn; +}; + +#define min(a,b) (((a) < (b)) ? (a) : (b)) + +namespace rfb { + +void makePixel(const rfb::PixelFormat &pf, + rdr::U8 *buffer) +{ + rfb::Pixel p; + + p = 0; + p |= (pixelRed >> (8 - pf.redBits)) << pf.redShift; + p |= (pixelGreen >> (8 - pf.greenBits)) << pf.greenShift; + p |= (pixelBlue >> (8 - pf.blueBits)) << pf.blueShift; + + // FIXME: Should we reimplement this as well? + pf.bufferFromPixel(buffer, p); +} + +bool verifyPixel(const rfb::PixelFormat &dstpf, + const rfb::PixelFormat &srcpf, + const rdr::U8 *buffer) +{ + rfb::Pixel p; + int r, g, b; + int re, ge, be; + + // FIXME: Should we reimplement this as well? + p = dstpf.pixelFromBuffer(buffer); + + r = (p >> dstpf.redShift) & dstpf.redMax; + g = (p >> dstpf.greenShift) & dstpf.greenMax; + b = (p >> dstpf.blueShift) & dstpf.blueMax; + + r <<= 8 - dstpf.redBits; + g <<= 8 - dstpf.greenBits; + b <<= 8 - dstpf.blueBits; + + // The allowed error depends on: + // + // a) The number of bits the format can hold + // b) The number of bits the source format could hold + + re = (1 << (8 - min(dstpf.redBits, srcpf.redBits))) - 1; + ge = (1 << (8 - min(dstpf.greenBits, srcpf.greenBits))) - 1; + be = (1 << (8 - min(dstpf.blueBits, srcpf.blueBits))) - 1; + + if (abs(r - pixelRed) > re) + return false; + if (abs(g - pixelGreen) > ge) + return false; + if (abs(b - pixelBlue) > be) + return false; + + return true; +} + +} + +using rfb::makePixel; +using rfb::verifyPixel; + +static bool testPixel(const rfb::PixelFormat &dstpf, + const rfb::PixelFormat &srcpf) +{ + rfb::Pixel p; + rdr::U8 buffer[4]; + + makePixel(srcpf, buffer); + + p = srcpf.pixelFromBuffer(buffer); + p = dstpf.pixelFromPixel(srcpf, p); + memset(buffer, 0, sizeof(buffer)); + dstpf.bufferFromPixel(buffer, p); + + if (!verifyPixel(dstpf, srcpf, buffer)) + return false; + + return true; +} + +static bool testBuffer(const rfb::PixelFormat &dstpf, + const rfb::PixelFormat &srcpf) +{ + int i, unaligned; + rdr::U8 bufIn[1024 + 1], bufOut[1024 + 1]; + + // Once aligned, and once unaligned + for (unaligned = 0;unaligned < 2;unaligned++) { + for (i = 0;i < 1024/4;i++) + makePixel(srcpf, bufIn + unaligned + i*srcpf.bpp/8); + + memset(bufOut, 0, sizeof(bufOut)); + dstpf.bufferFromBuffer(bufOut + unaligned, srcpf, + bufIn + unaligned, 1024/4); + + for (i = 0;i < 1024/4;i++) { + if (!verifyPixel(dstpf, srcpf, bufOut + unaligned + i*dstpf.bpp/8)) + return false; + } + + memset(bufOut, 0, sizeof(bufOut)); + dstpf.bufferFromBuffer(bufOut + unaligned, srcpf, bufIn + unaligned, + 1024/4/10, 10, 1024/4/10, 1024/4/10); + + for (i = 0;i < 1024/4/10*10;i++) { + if (!verifyPixel(dstpf, srcpf, bufOut + unaligned + i*dstpf.bpp/8)) + return false; + } + } + + return true; +} + +static bool testRGB(const rfb::PixelFormat &dstpf, + const rfb::PixelFormat &srcpf) +{ + int i, unaligned; + rdr::U8 bufIn[1024 + 1], bufRGB[1024 + 1], bufOut[1024 + 1]; + + // Once aligned, and once unaligned + for (unaligned = 0;unaligned < 2;unaligned++) { + for (i = 0;i < 1024/4;i++) + makePixel(srcpf, bufIn + unaligned + i*srcpf.bpp/8); + + memset(bufRGB, 0, sizeof(bufRGB)); + srcpf.rgbFromBuffer(bufRGB + unaligned, bufIn + unaligned, 1024/4); + + memset(bufOut, 0, sizeof(bufOut)); + dstpf.bufferFromRGB(bufOut + unaligned, bufRGB + unaligned, 1024/4); + + for (i = 0;i < 1024/4;i++) { + if (!verifyPixel(dstpf, srcpf, bufOut + unaligned + i*dstpf.bpp/8)) + return false; + } + + memset(bufRGB, 0, sizeof(bufRGB)); + srcpf.rgbFromBuffer(bufRGB + unaligned, bufIn + unaligned, + 1024/4/10, 1024/4/10, 10); + + memset(bufOut, 0, sizeof(bufOut)); + dstpf.bufferFromRGB(bufOut + unaligned, bufRGB + unaligned, + 1024/4/10, 1024/4/10, 10); + + for (i = 0;i < 1024/4/10*10;i++) { + if (!verifyPixel(dstpf, srcpf, bufOut + unaligned + i*dstpf.bpp/8)) + return false; + } + } + + return true; +} + +static bool testPixelRGB(const rfb::PixelFormat &dstpf, + const rfb::PixelFormat &srcpf) +{ + rfb::Pixel p; + rdr::U16 r16, g16, b16; + rdr::U8 r8, g8, b8; + rdr::U8 buffer[4]; + + makePixel(srcpf, buffer); + + p = srcpf.pixelFromBuffer(buffer); + srcpf.rgbFromPixel(p, &r16, &g16, &b16); + p = dstpf.pixelFromRGB(r16, g16, b16); + memset(buffer, 0, sizeof(buffer)); + dstpf.bufferFromPixel(buffer, p); + + if (!verifyPixel(dstpf, srcpf, buffer)) + return false; + + makePixel(srcpf, buffer); + + p = srcpf.pixelFromBuffer(buffer); + srcpf.rgbFromPixel(p, &r8, &g8, &b8); + p = dstpf.pixelFromRGB(r8, g8, b8); + memset(buffer, 0, sizeof(buffer)); + dstpf.bufferFromPixel(buffer, p); + + if (!verifyPixel(dstpf, srcpf, buffer)) + return false; + + return true; +} + +struct TestEntry tests[] = { + {"Pixel from pixel", testPixel}, + {"Buffer from buffer", testBuffer}, + {"Buffer to/from RGB", testRGB}, + {"Pixel to/from RGB", testPixelRGB}, +}; + +static void doTests(const rfb::PixelFormat &dstpf, + const rfb::PixelFormat &srcpf) +{ + int i; + char dstb[256], srcb[256]; + + dstpf.print(dstb, sizeof(dstb)); + srcpf.print(srcb, sizeof(srcb)); + + printf("\n"); + printf("%s to %s\n", srcb, dstb); + printf("\n"); + + for (i = 0;i < sizeof(tests)/sizeof(tests[0]);i++) { + printf(" %s: ", tests[i].label); + fflush(stdout); + if (tests[i].fn(dstpf, srcpf)) + printf("OK"); + else + printf("FAILED"); + printf("\n"); + } +} + +int main(int argc, char **argv) +{ + rfb::PixelFormat dstpf, srcpf; + + printf("Pixel Conversion Correctness Test\n"); + + /* rgb888 targets */ + + dstpf.parse("rgb888"); + + srcpf.parse("rgb888"); + doTests(dstpf, srcpf); + + srcpf.parse("bgr888"); + doTests(dstpf, srcpf); + + srcpf.parse("rgb565"); + doTests(dstpf, srcpf); + + srcpf.parse("rgb232"); + doTests(dstpf, srcpf); + + /* rgb565 targets */ + + dstpf.parse("rgb565"); + + srcpf.parse("rgb888"); + doTests(dstpf, srcpf); + + srcpf.parse("bgr565"); + doTests(dstpf, srcpf); + + srcpf.parse("rgb232"); + doTests(dstpf, srcpf); + + /* rgb232 targets */ + + dstpf.parse("rgb232"); + + srcpf.parse("rgb888"); + doTests(dstpf, srcpf); + + srcpf.parse("rgb565"); + doTests(dstpf, srcpf); + + srcpf.parse("bgr232"); + doTests(dstpf, srcpf); + + /* endian conversion (both ways) */ + + dstpf = rfb::PixelFormat(32, 24, false, true, 255, 255, 255, 0, 8, 16); + srcpf = rfb::PixelFormat(32, 24, true, true, 255, 255, 255, 0, 8, 16); + + doTests(dstpf, srcpf); + + doTests(srcpf, dstpf); + + dstpf = rfb::PixelFormat(16, 16, false, true, 31, 63, 31, 0, 5, 11); + srcpf = rfb::PixelFormat(16, 16, true, true, 31, 63, 31, 0, 5, 11); + + doTests(dstpf, srcpf); + + doTests(srcpf, dstpf); + + // Pesky case that is very asymetrical + dstpf = rfb::PixelFormat(32, 24, false, true, 255, 255, 255, 0, 8, 16); + srcpf = rfb::PixelFormat(32, 24, true, true, 255, 255, 255, 0, 24, 8); + + doTests(dstpf, srcpf); + + doTests(srcpf, dstpf); +}