From a65278c7bc9c0dbca8a74db09fd0aebf1c26ef28 Mon Sep 17 00:00:00 2001 From: Bent Bisballe Nyeng Date: Sat, 29 Feb 2020 16:12:26 +0100 Subject: Read images as uint8_t instead of float. Convert Colour and all colour related operations to use uint8_t instade of float and finally optimize rendering to render lines instead of single pixels. --- plugingui/pixelbuffer.cc | 248 +++++++++++++++++++++++++++++++++++------------ 1 file changed, 184 insertions(+), 64 deletions(-) (limited to 'plugingui/pixelbuffer.cc') diff --git a/plugingui/pixelbuffer.cc b/plugingui/pixelbuffer.cc index 360ad06..1df1d5a 100644 --- a/plugingui/pixelbuffer.cc +++ b/plugingui/pixelbuffer.cc @@ -29,6 +29,7 @@ #include #include +#include namespace GUI { @@ -47,43 +48,63 @@ PixelBuffer::~PixelBuffer() void PixelBuffer::realloc(std::size_t width, std::size_t height) { free(buf); - buf = (unsigned char *)calloc(width * height, 3); + buf = (std::uint8_t *)calloc(width * height, 3); this->width = width; this->height = height; } #define PX(k) ((x + y * width) * 3 + k) -void PixelBuffer::setPixel(std::size_t x, std::size_t y, - unsigned char red, - unsigned char green, - unsigned char blue, - unsigned char alpha) +void PixelBuffer::setPixel(std::size_t x, std::size_t y, const Colour& c) { - assert(x < width); - assert(y < height); - - if(alpha == 0) + if(c.alpha() == 0) { return; } - if(alpha < 255) + if(c.alpha() < 255) { - unsigned int a = alpha; - unsigned int b = 255 - alpha; + unsigned int a = c.alpha(); + unsigned int b = 255 - a; - buf[PX(0)] = (unsigned char)(((int)red * a + (int)buf[PX(0)] * b) / 255); - buf[PX(1)] = (unsigned char)(((int)green * a + (int)buf[PX(1)] * b) / 255); - buf[PX(2)] = (unsigned char)(((int)blue * a + (int)buf[PX(2)] * b) / 255); + std::uint8_t* pixel = &buf[PX(0)]; + *pixel = (std::uint8_t)(((int)c.red() * a + (int)*pixel * b) / 255); + ++pixel; + *pixel = (std::uint8_t)(((int)c.green() * a + (int)*pixel * b) / 255); + ++pixel; + *pixel = (std::uint8_t)(((int)c.blue() * a + (int)*pixel * b) / 255); } else { - buf[PX(0)] = red; - buf[PX(1)] = green; - buf[PX(2)] = blue; + memcpy(&buf[PX(0)], c.data(), 3); + } +} + +void PixelBuffer::writeLine(std::size_t x, std::size_t y, + const std::uint8_t* line, std::size_t len) +{ + std::uint8_t* target = &buf[PX(0)]; + while(len) + { + if(line[3] == 0xff) + { + memcpy(target, line, 3); + } + else + { + unsigned int a = line[3]; + unsigned int b = 255 - a; + + target[0] = (std::uint8_t)(((int)line[0] * a + (int)target[0] * b) / 255); + target[1] = (std::uint8_t)(((int)line[1] * a + (int)target[1] * b) / 255); + target[2] = (std::uint8_t)(((int)line[2] * a + (int)target[2] * b) / 255); + } + target += 3; + line += 4; + --len; } } + PixelBufferAlpha::PixelBufferAlpha(std::size_t width, std::size_t height) : managed(true) , buf(nullptr) @@ -104,30 +125,110 @@ PixelBufferAlpha::~PixelBufferAlpha() void PixelBufferAlpha::realloc(std::size_t width, std::size_t height) { free(buf); - buf = (unsigned char *)calloc(width * height, 4); + buf = (std::uint8_t *)calloc(width * height, 4); this->width = width; this->height = height; } +void PixelBufferAlpha::clear() +{ + memset(buf, 0, width * height * 4); +} + #undef PX #define PX(k) ((x + y * width) * 4 + k) -void PixelBufferAlpha::setPixel(std::size_t x, std::size_t y, - unsigned char red, - unsigned char green, - unsigned char blue, - unsigned char alpha) +//void PixelBufferAlpha::setPixel(std::size_t x, std::size_t y, +// std::uint8_t red, +// std::uint8_t green, +// std::uint8_t blue, +// std::uint8_t alpha) +//{ +// //assert(x < width); +// //assert(y < height); +// +// std::uint8_t* pixel = &buf[PX(0)]; +// *pixel = red; +// ++pixel; +// *pixel = green; +// ++pixel; +// *pixel = blue; +// ++pixel; +// *pixel = alpha; +//} + +void PixelBufferAlpha::setPixel(std::size_t x, std::size_t y, const Colour& c) { - assert(x < width); - assert(y < height); + std::uint8_t* pixel = &buf[PX(0)]; + *pixel = c.red(); + ++pixel; + *pixel = c.green(); + ++pixel; + *pixel = c.blue(); + ++pixel; + *pixel = c.alpha(); +} - buf[PX(0)] = red; - buf[PX(1)] = green; - buf[PX(2)] = blue; - buf[PX(3)] = alpha; +void PixelBufferAlpha::writeLine(std::size_t x, std::size_t y, + const std::uint8_t* line, std::size_t len) +{ + auto offset = &buf[PX(0)]; + if(x + y * width + len > width * height) + { + return; // out of bounds + } + std::memcpy(offset, line, len * 4); } +// SIMD: https://github.com/WojciechMula/toys/blob/master/blend_32bpp/blend_32bpp.c + +void PixelBufferAlpha::blendLine(std::size_t x, std::size_t y, + const std::uint8_t* line, std::size_t len) +{ + auto offset = &buf[PX(0)]; + if(x + y * width + len > width * height) + { + return; // out of bounds + } + + std::uint32_t* foreground = (std::uint32_t*)line; + std::uint32_t* background = (std::uint32_t*)offset; + for(std::size_t x = 0; x < len; ++x) + { + auto Rf = *foreground & 0xff; + auto Gf = (*foreground >> 8) & 0xff; + auto Bf = (*foreground >> 16) & 0xff; + auto Af = (*foreground >> 24) & 0xff; + + auto Rb = *background & 0xff; + auto Gb = (*background >> 8) & 0xff; + auto Bb = (*background >> 16) & 0xff; + auto Ab = (*background >> 24) & 0xff; + + auto R = (Rf * Af)/256 + Rb; + auto G = (Gf * Af)/256 + Gb; + auto B = (Bf * Af)/256 + Bb; + + if (R > 255) R = 255; + if (G > 255) G = 255; + if (B > 255) B = 255; + +// auto a = Ab / 255.0; +// auto b = Af / 255.0; +// b *= (1 - a); + +// (Af / 255.0 * (1 - Ab / 255.0)) * 255 + auto b = Ab * (255 - Af); + + *background = R | (G << 8) | (B << 16) | b << 24; + + ++foreground; + ++background; + } +} + + // http://en.wikipedia.org/wiki/Alpha_compositing -static inline void getAlpha(unsigned char _a, unsigned char _b, +static inline void getAlpha(std::uint8_t _a, std::uint8_t _b, float &a, float &b) { a = _a / 255.0; @@ -136,61 +237,80 @@ static inline void getAlpha(unsigned char _a, unsigned char _b, } void PixelBufferAlpha::addPixel(std::size_t x, std::size_t y, - unsigned char red, - unsigned char green, - unsigned char blue, - unsigned char alpha) + std::uint8_t red, + std::uint8_t green, + std::uint8_t blue, + std::uint8_t alpha) { - assert(x < width); - assert(y < height); + //assert(x < width); + //assert(y < height); if(alpha == 0) { return; } + std::uint8_t* pixel = &buf[PX(0)]; + if(alpha < 255) { float a, b; getAlpha(alpha, buf[PX(3)], a, b); - buf[PX(0)] = (unsigned char)((float)red * a + (float)buf[PX(0)] * b); - buf[PX(0)] /= (a + b); - buf[PX(1)] = (unsigned char)((float)green * a + (float)buf[PX(1)] * b); - buf[PX(1)] /= (a + b); - buf[PX(2)] = (unsigned char)((float)blue * a + (float)buf[PX(2)] * b); - buf[PX(2)] /= (a + b); - - buf[PX(3)] = (a + b) * 255; + *pixel = (std::uint8_t)((red * a + *pixel * b) / (a + b)); + ++pixel; + *pixel = (std::uint8_t)((green * a + *pixel * b) / (a + b)); + ++pixel; + *pixel = (std::uint8_t)((blue * a + *pixel * b) / (a + b)); + ++pixel; + *pixel = (a + b) * 255; } else { - buf[PX(0)] = red; - buf[PX(1)] = green; - buf[PX(2)] = blue; - buf[PX(3)] = alpha; + *pixel = red; + ++pixel; + *pixel = green; + ++pixel; + *pixel = blue; + ++pixel; + *pixel = alpha; } } void PixelBufferAlpha::addPixel(std::size_t x, std::size_t y, const Colour& c) { - addPixel(x, y, - c.red() * 255, c.green() * 255, c.blue() * 255, c.alpha() * 255); + addPixel(x, y, c.red(), c.green(), c.blue(), c.alpha()); } void PixelBufferAlpha::pixel(std::size_t x, std::size_t y, - unsigned char* red, - unsigned char* green, - unsigned char* blue, - unsigned char* alpha) const -{ - assert(x < width); - assert(y < height); - - *red = buf[PX(0)]; - *green = buf[PX(1)]; - *blue = buf[PX(2)]; - *alpha = buf[PX(3)]; + std::uint8_t* red, + std::uint8_t* green, + std::uint8_t* blue, + std::uint8_t* alpha) const +{ + //assert(x < width); + //assert(y < height); + + std::uint8_t* pixel = &buf[PX(0)]; + *red = *pixel; + ++pixel; + *green = *pixel; + ++pixel; + *blue = *pixel; + ++pixel; + *alpha = *pixel; +} + +const Colour& PixelBufferAlpha::pixel(std::size_t x, std::size_t y) const +{ + static Colour c; + c = Colour(buf[PX(0)], buf[PX(1)], buf[PX(2)], buf[PX(3)]); + return c; +} + +const std::uint8_t* PixelBufferAlpha::getLine(std::size_t x, std::size_t y) const +{ + return &buf[PX(0)]; } } // GUI:: -- cgit v1.2.3