From dbe9f094ee730847763b8f3b7d055be965146ad3 Mon Sep 17 00:00:00 2001 From: Rowan Decker Date: Thu, 29 Aug 2024 02:29:11 -0700 Subject: [PATCH] Add a few RGB-aware set & blend methods to the blitters (#1680) * BlitBuffer: Added a fill_rect variant that takes an RGB32 color as input * BlitBuffer: Added a couple of blend OVER & blend MUL methods to handle color highlights * BlitBuffer: Added a color_blit_from variant that takes an RGB32 color as input * C BlitBuffer: Fix a few minor compiler warnings * BlitBuffer: Rename the awfully named dimRect & lightenRect methods to lightenRect & darkenRect, respectively. Because they did the opposite of what it said on the tin. Added more comments explaining the results to avoid further confusion. * BlitBuffer: Defined a set of highlight colors as `BB.HIGHLIGHT_COLORS` (user patchable), most of them having a more pastel variant because those look slightly less terrible on Kaleido panels. * BlitBuffer: Added a few miscellaneous methods to ease working with this in front. * Kobo MTK: Increased the alignment constraint, because the HL color popup was getting cut off. * MuPDF: Support color annotations in `addMarkupAnnotation` Many thanks to @smasher816 for the initial implementation ;). --- blitbuffer.c | 518 ++++++++++++++++++++++++++++++++++++-- blitbuffer.h | 12 +- ffi/blitbuffer.lua | 352 +++++++++++++++++++++++++- ffi/framebuffer_mxcfb.lua | 6 +- ffi/mupdf.lua | 41 ++- 5 files changed, 880 insertions(+), 49 deletions(-) diff --git a/blitbuffer.c b/blitbuffer.c index f59ed2063..85dec512f 100644 --- a/blitbuffer.c +++ b/blitbuffer.c @@ -72,6 +72,7 @@ static const char* 39185*ColorRGB16_GetG(v) + \ 15220*ColorRGB16_GetB(v)) >> 14U) #define RGB_To_RGB16(r, g, b) (((r & 0xF8) << 8U) + ((g & 0xFC) << 3U) + (b >> 3U)) +// NOTE: `A` was a *terrible* variable name to settle on. It's actually luminance, e.g., grayscale, a.k.a., Y8. #define RGB_To_A(r, g, b) ((4898U*r + 9618U*g + 1869U*b) >> 14U) // Helpers to pack pixels manually, without going through the Color structs. @@ -92,6 +93,9 @@ static const char* (((_v >> 8U) + _v) >> 8U); \ }) +#define ColorRGB32_To_PMUL(color) \ + (ColorRGB32){DIV_255(color->r * color->alpha), DIV_255(color->g * color->alpha), DIV_255(color->b * color->alpha), color->alpha} + // MIN/MAX with no side-effects, // c.f., https://gcc.gnu.org/onlinedocs/cpp/Duplication-of-Side-Effects.html#Duplication-of-Side-Effects // & https://dustri.org/b/min-and-max-macro-considered-harmful.html @@ -182,7 +186,7 @@ static const char* }) static inline void BB8_SET_PIXEL_CLAMPED(BlitBuffer * restrict bb, int rotation, unsigned int x, unsigned int y, unsigned int width, unsigned int height, const Color8 * restrict color) { - if (likely(x >= 0U && x < width && y >= 0U && y < height)) { + if (likely(x < width && y < height)) { Color8 * restrict pixel; BB_GET_PIXEL(bb, rotation, Color8, x, y, &pixel); *pixel = *color; @@ -190,7 +194,7 @@ static inline void BB8_SET_PIXEL_CLAMPED(BlitBuffer * restrict bb, int rotation, } static inline void BB8A_SET_PIXEL_CLAMPED(BlitBuffer * restrict bb, int rotation, unsigned int x, unsigned int y, unsigned int width, unsigned int height, const Color8A * restrict color) { - if (likely(x >= 0U && x < width && y >= 0U && y < height)) { + if (likely(x < width && y < height)) { Color8A * restrict pixel; BB_GET_PIXEL(bb, rotation, Color8A, x, y, &pixel); *pixel = *color; @@ -198,7 +202,7 @@ static inline void BB8A_SET_PIXEL_CLAMPED(BlitBuffer * restrict bb, int rotation } static inline void BBRGB16_SET_PIXEL_CLAMPED(BlitBuffer * restrict bb, int rotation, unsigned int x, unsigned int y, unsigned int width, unsigned int height, const ColorRGB16 * restrict color) { - if (likely(x >= 0U && x < width && y >= 0U && y < height)) { + if (likely(x < width && y < height)) { ColorRGB16 * restrict pixel; BB_GET_PIXEL(bb, rotation, ColorRGB16, x, y, &pixel); *pixel = *color; @@ -206,7 +210,7 @@ static inline void BBRGB16_SET_PIXEL_CLAMPED(BlitBuffer * restrict bb, int rotat } static inline void BBRGB24_SET_PIXEL_CLAMPED(BlitBuffer * restrict bb, int rotation, unsigned int x, unsigned int y, unsigned int width, unsigned int height, const ColorRGB24 * restrict color) { - if (likely(x >= 0U && x < width && y >= 0U && y < height)) { + if (likely(x < width && y < height)) { ColorRGB24 * restrict pixel; BB_GET_PIXEL(bb, rotation, ColorRGB24, x, y, &pixel); *pixel = *color; @@ -214,7 +218,7 @@ static inline void BBRGB24_SET_PIXEL_CLAMPED(BlitBuffer * restrict bb, int rotat } static inline void BBRGB32_SET_PIXEL_CLAMPED(BlitBuffer * restrict bb, int rotation, unsigned int x, unsigned int y, unsigned int width, unsigned int height, const ColorRGB32 * restrict color) { - if (likely(x >= 0U && x < width && y >= 0U && y < height)) { + if (likely(x < width && y < height)) { ColorRGB32 * restrict pixel; BB_GET_PIXEL(bb, rotation, ColorRGB32, x, y, &pixel); *pixel = *color; @@ -222,7 +226,7 @@ static inline void BBRGB32_SET_PIXEL_CLAMPED(BlitBuffer * restrict bb, int rotat } static inline void BB8_BLEND_PIXEL_CLAMPED(BlitBuffer * restrict bb, int rotation, unsigned int x, unsigned int y, unsigned int width, unsigned int height, const Color8A * restrict color) { - if (likely(x >= 0U && x < width && y >= 0U && y < height)) { + if (likely(x < width && y < height)) { Color8 * restrict pixel; BB_GET_PIXEL(bb, rotation, Color8, x, y, &pixel); @@ -233,7 +237,7 @@ static inline void BB8_BLEND_PIXEL_CLAMPED(BlitBuffer * restrict bb, int rotatio } } static inline void BB8A_BLEND_PIXEL_CLAMPED(BlitBuffer * restrict bb, int rotation, unsigned int x, unsigned int y, unsigned int width, unsigned int height, const Color8A * restrict color) { - if (likely(x >= 0U && x < width && y >= 0U && y < height)) { + if (likely(x < width && y < height)) { Color8A * restrict pixel; BB_GET_PIXEL(bb, rotation, Color8A, x, y, &pixel); @@ -245,7 +249,7 @@ static inline void BB8A_BLEND_PIXEL_CLAMPED(BlitBuffer * restrict bb, int rotati } } static inline void BBRGB16_BLEND_PIXEL_CLAMPED(BlitBuffer * restrict bb, int rotation, unsigned int x, unsigned int y, unsigned int width, unsigned int height, const Color8A * restrict color) { - if (likely(x >= 0U && x < width && y >= 0U && y < height)) { + if (likely(x < width && y < height)) { ColorRGB16 * restrict pixel; BB_GET_PIXEL(bb, rotation, ColorRGB16, x, y, &pixel); @@ -260,7 +264,7 @@ static inline void BBRGB16_BLEND_PIXEL_CLAMPED(BlitBuffer * restrict bb, int rot } static inline void BBRGB24_BLEND_PIXEL_CLAMPED(BlitBuffer * restrict bb, int rotation, unsigned int x, unsigned int y, unsigned int width, unsigned int height, const ColorRGB32 * restrict color) { - if (likely(x >= 0U && x < width && y >= 0U && y < height)) { + if (likely(x < width && y < height)) { ColorRGB24 * restrict pixel; BB_GET_PIXEL(bb, rotation, ColorRGB24, x, y, &pixel); @@ -274,7 +278,7 @@ static inline void BBRGB24_BLEND_PIXEL_CLAMPED(BlitBuffer * restrict bb, int rot } static inline void BBRGB32_BLEND_PIXEL_CLAMPED(BlitBuffer * restrict bb, int rotation, unsigned int x, unsigned int y, unsigned int width, unsigned int height, const ColorRGB32 * restrict color) { - if (likely(x >= 0U && x < width && y >= 0U && y < height)) { + if (likely(x < width && y < height)) { ColorRGB32 * restrict pixel; BB_GET_PIXEL(bb, rotation, ColorRGB32, x, y, &pixel); @@ -484,7 +488,143 @@ void BB_fill_rect(BlitBuffer * restrict bb, unsigned int x, unsigned int y, unsi } } -void BB_blend_rect(BlitBuffer * restrict bb, unsigned int x, unsigned int y, unsigned int w, unsigned int h, Color8A * restrict color) { +void BB_fill_rect_RGB32(BlitBuffer * restrict bb, unsigned int x, unsigned int y, unsigned int w, unsigned int h, const ColorRGB32 * restrict color) { + const int rotation = GET_BB_ROTATION(bb); + unsigned int rx, ry, rw, rh; + // Compute rotated rectangle coordinates & size + switch (rotation) { + case 0: + rx = x; + ry = y; + rw = w; + rh = h; + break; + case 1: + rx = bb->w - (y + h); + ry = x; + rw = h; + rh = w; + break; + case 2: + rx = bb->w - (x + w); + ry = bb->h - (y + h); + rw = w; + rh = h; + break; + case 3: + rx = y; + ry = bb->h - (x + w); + rw = h; + rh = w; + break; + } + + // Handle any target pitch properly + const int bb_type = GET_BB_TYPE(bb); + switch (bb_type) { + case TYPE_BB8: + if (rx == 0 && rw == bb->w) { + // Single step for contiguous scanlines (e.g., BB_fill()) + //fprintf(stdout, "%s: Full BB8 paintRect\n", __FUNCTION__); + uint8_t * restrict p = bb->data + bb->stride*ry; + memset(p, RGB_To_A(color->r, color->g, color->b), bb->stride*rh); + } else { + // Scanline per scanline + //fprintf(stdout, "%s: Scanline BB8 paintRect\n", __FUNCTION__); + const uint8_t source_y8 = RGB_To_A(color->r, color->g, color->b); + for (unsigned int j = ry; j < ry+rh; j++) { + uint8_t * restrict p = bb->data + bb->stride*j + rx; + memset(p, source_y8, rw); + } + } + break; + case TYPE_BB8A: + // We do NOT want to stomp on the alpha byte here... + if (rx == 0 && rw == bb->w) { + // Single step for contiguous scanlines + const uint16_t src = (uint16_t) Y8_To_Y8A(RGB_To_A(color->r, color->g, color->b)); + //fprintf(stdout, "%s: Full BB8A paintRect\n", __FUNCTION__); + uint16_t * restrict p = (uint16_t *) (bb->data + bb->stride*ry); + size_t px_count = bb->pixel_stride*rh; + while (px_count--) { + *p++ = src; + } + } else { + // Scanline per scanline + const uint16_t src = (uint16_t) Y8_To_Y8A(RGB_To_A(color->r, color->g, color->b)); + //fprintf(stdout, "%s: Scanline BB8A paintRect\n", __FUNCTION__); + for (unsigned int j = ry; j < ry+rh; j++) { + uint16_t * restrict p = (uint16_t *) (bb->data + bb->stride*j) + rx; + size_t px_count = rw; + while (px_count--) { + *p++ = src; + } + } + } + break; + case TYPE_BBRGB16: + // Again, RGB565 means we can't use a straight memset + if (rx == 0 && rw == bb->w) { + // Single step for contiguous scanlines + const ColorRGB16 src = ColorRGB32_To_Color16(color); + //fprintf(stdout, "%s: Full BBRGB16 paintRect\n", __FUNCTION__); + ColorRGB16 * restrict p = (ColorRGB16 *) (bb->data + bb->stride*ry); + size_t px_count = bb->pixel_stride*rh; + while (px_count--) { + *p++ = src; + } + } else { + // Scanline per scanline + const ColorRGB16 src = ColorRGB32_To_Color16(color); + //fprintf(stdout, "%s: Sanline BBRGB16 paintRect\n", __FUNCTION__); + for (unsigned int j = ry; j < ry+rh; j++) { + ColorRGB16 * restrict p = (ColorRGB16 *) (bb->data + bb->stride*j) + rx; + size_t px_count = rw; + while (px_count--) { + *p++ = src; + } + } + } + break; + case TYPE_BBRGB24: + { + // Pixel per pixel + const ColorRGB24 src = ColorRGB32_To_Color24(color); + //fprintf(stdout, "%s: Pixel BBRGB24 paintRect\n", __FUNCTION__); + for (unsigned int j = ry; j < ry+rh; j++) { + for (unsigned int k = rx; k < rx+rw; k++) { + uint8_t * restrict p = bb->data + bb->stride*j + (k * 3U); + memcpy(p, &src, 3); + } + } + } + break; + case TYPE_BBRGB32: + // And here either, as we want to preserve the alpha byte + if (rx == 0 && rw == bb->w) { + // Single step for contiguous scanlines + //fprintf(stdout, "%s: Full BBRGB32 paintRect\n", __FUNCTION__); + ColorRGB32 * restrict p = (ColorRGB32 *) (bb->data + bb->stride*ry); + size_t px_count = bb->pixel_stride*rh; + while (px_count--) { + *p++ = *color; + } + } else { + // Scanline per scanline + //fprintf(stdout, "%s: Pixel BBRGB32 paintRect\n", __FUNCTION__); + for (unsigned int j = ry; j < ry+rh; j++) { + ColorRGB32 * restrict p = (ColorRGB32 *) (bb->data + bb->stride*j) + rx; + size_t px_count = rw; + while (px_count--) { + *p++ = *color; + } + } + } + break; + } +} + +void BB_blend_rect(BlitBuffer * restrict bb, unsigned int x, unsigned int y, unsigned int w, unsigned int h, const Color8A * restrict color) { const int bb_type = GET_BB_TYPE(bb); const int bb_rotation = GET_BB_ROTATION(bb); const uint8_t alpha = color->alpha; @@ -545,6 +685,211 @@ void BB_blend_rect(BlitBuffer * restrict bb, unsigned int x, unsigned int y, uns } } +void BB_blend_RGB32_over_rect(BlitBuffer * restrict bb, unsigned int x, unsigned int y, unsigned int w, unsigned int h, const ColorRGB32 * restrict color) { + const int bb_type = GET_BB_TYPE(bb); + const int bb_rotation = GET_BB_ROTATION(bb); + const uint8_t alpha = color->alpha; + const uint8_t ainv = alpha ^ 0xFF; + switch (bb_type) { + case TYPE_BB8: + { + const uint8_t source_y8 = RGB_To_A(color->r, color->g, color->b); + for (unsigned int j = y; j < y + h; j++) { + for (unsigned int i = x; i < x + w; i++) { + Color8 * restrict dstptr; + BB_GET_PIXEL(bb, bb_rotation, Color8, i, j, &dstptr); + dstptr->a = (uint8_t) DIV_255(dstptr->a * ainv + source_y8 * alpha); + } + } + } + break; + case TYPE_BB8A: + { + const uint8_t source_y8 = RGB_To_A(color->r, color->g, color->b); + for (unsigned int j = y; j < y + h; j++) { + for (unsigned int i = x; i < x + w; i++) { + Color8A * restrict dstptr; + BB_GET_PIXEL(bb, bb_rotation, Color8A, i, j, &dstptr); + dstptr->a = (uint8_t) DIV_255(dstptr->a * ainv + source_y8 * alpha); + } + } + } + break; + case TYPE_BBRGB16: + for (unsigned int j = y; j < y + h; j++) { + for (unsigned int i = x; i < x + w; i++) { + ColorRGB16 * restrict dstptr; + BB_GET_PIXEL(bb, bb_rotation, ColorRGB16, i, j, &dstptr); + const uint8_t r = (uint8_t) DIV_255(ColorRGB16_GetR(dstptr->v) * ainv + color->r * alpha); + const uint8_t g = (uint8_t) DIV_255(ColorRGB16_GetG(dstptr->v) * ainv + color->g * alpha); + const uint8_t b = (uint8_t) DIV_255(ColorRGB16_GetB(dstptr->v) * ainv + color->b * alpha); + dstptr->v = (uint16_t) RGB_To_RGB16(r, g, b); + } + } + break; + case TYPE_BBRGB24: + for (unsigned int j = y; j < y + h; j++) { + for (unsigned int i = x; i < x + w; i++) { + ColorRGB24 * restrict dstptr; + BB_GET_PIXEL(bb, bb_rotation, ColorRGB24, i, j, &dstptr); + dstptr->r = (uint8_t) DIV_255(dstptr->r * ainv + color->r * alpha); + dstptr->g = (uint8_t) DIV_255(dstptr->g * ainv + color->g * alpha); + dstptr->b = (uint8_t) DIV_255(dstptr->b * ainv + color->b * alpha); + } + } + break; + case TYPE_BBRGB32: + for (unsigned int j = y; j < y + h; j++) { + for (unsigned int i = x; i < x + w; i++) { + ColorRGB32 * restrict dstptr; + BB_GET_PIXEL(bb, bb_rotation, ColorRGB32, i, j, &dstptr); + dstptr->r = (uint8_t) DIV_255(dstptr->r * ainv + color->r * alpha); + dstptr->g = (uint8_t) DIV_255(dstptr->g * ainv + color->g * alpha); + dstptr->b = (uint8_t) DIV_255(dstptr->b * ainv + color->b * alpha); + } + } + break; + } +} + +// Dumb multiply blending mode (used for painting book highlights) +void BB_blend_RGB_multiply_rect(BlitBuffer * restrict bb, unsigned int x, unsigned int y, unsigned int w, unsigned int h, const ColorRGB24 * restrict color) { + const int bb_type = GET_BB_TYPE(bb); + const int bb_rotation = GET_BB_ROTATION(bb); + switch (bb_type) { + case TYPE_BB8: + { + const uint8_t source_y8 = RGB_To_A(color->r, color->g, color->b); + for (unsigned int j = y; j < y + h; j++) { + for (unsigned int i = x; i < x + w; i++) { + Color8 * restrict dstptr; + BB_GET_PIXEL(bb, bb_rotation, Color8, i, j, &dstptr); + dstptr->a = (uint8_t) DIV_255(dstptr->a * source_y8); + } + } + } + break; + case TYPE_BB8A: + { + const uint8_t source_y8 = RGB_To_A(color->r, color->g, color->b); + for (unsigned int j = y; j < y + h; j++) { + for (unsigned int i = x; i < x + w; i++) { + Color8A * restrict dstptr; + BB_GET_PIXEL(bb, bb_rotation, Color8A, i, j, &dstptr); + dstptr->a = (uint8_t) DIV_255(dstptr->a * source_y8); + } + } + } + break; + case TYPE_BBRGB16: + for (unsigned int j = y; j < y + h; j++) { + for (unsigned int i = x; i < x + w; i++) { + ColorRGB16 * restrict dstptr; + BB_GET_PIXEL(bb, bb_rotation, ColorRGB16, i, j, &dstptr); + const uint8_t r = (uint8_t) DIV_255(ColorRGB16_GetR(dstptr->v) * color->r); + const uint8_t g = (uint8_t) DIV_255(ColorRGB16_GetG(dstptr->v) * color->g); + const uint8_t b = (uint8_t) DIV_255(ColorRGB16_GetB(dstptr->v) * color->b); + dstptr->v = (uint16_t) RGB_To_RGB16(r, g, b); + } + } + break; + case TYPE_BBRGB24: + for (unsigned int j = y; j < y + h; j++) { + for (unsigned int i = x; i < x + w; i++) { + ColorRGB24 * restrict dstptr; + BB_GET_PIXEL(bb, bb_rotation, ColorRGB24, i, j, &dstptr); + dstptr->r = (uint8_t) DIV_255(dstptr->r * color->r); + dstptr->g = (uint8_t) DIV_255(dstptr->g * color->g); + dstptr->b = (uint8_t) DIV_255(dstptr->b * color->b); + } + } + break; + case TYPE_BBRGB32: + for (unsigned int j = y; j < y + h; j++) { + for (unsigned int i = x; i < x + w; i++) { + ColorRGB32 * restrict dstptr; + BB_GET_PIXEL(bb, bb_rotation, ColorRGB32, i, j, &dstptr); + dstptr->r = (uint8_t) DIV_255(dstptr->r * color->r); + dstptr->g = (uint8_t) DIV_255(dstptr->g * color->g); + dstptr->b = (uint8_t) DIV_255(dstptr->b * color->b); + } + } + break; + } +} + +// Fancier variant if we ever want to honor color's alpha... +// Function name is a slight misnommer, as we're essentially doing (color MUL rect) OVER rect +void BB_blend_RGB32_multiply_rect(BlitBuffer * restrict bb, unsigned int x, unsigned int y, unsigned int w, unsigned int h, const ColorRGB32 * restrict color) { + const int bb_type = GET_BB_TYPE(bb); + const int bb_rotation = GET_BB_ROTATION(bb); + const uint8_t alpha = color->alpha; + const uint8_t ainv = alpha ^ 0xFF; + switch (bb_type) { + case TYPE_BB8: + { + const uint8_t source_y8 = RGB_To_A(color->r, color->g, color->b); + for (unsigned int j = y; j < y + h; j++) { + for (unsigned int i = x; i < x + w; i++) { + Color8 * restrict dstptr; + BB_GET_PIXEL(bb, bb_rotation, Color8, i, j, &dstptr); + dstptr->a = (uint8_t) DIV_255(dstptr->a * ainv + DIV_255(dstptr->a * source_y8) * alpha); + } + } + } + break; + case TYPE_BB8A: + { + const uint8_t source_y8 = RGB_To_A(color->r, color->g, color->b); + for (unsigned int j = y; j < y + h; j++) { + for (unsigned int i = x; i < x + w; i++) { + Color8A * restrict dstptr; + BB_GET_PIXEL(bb, bb_rotation, Color8A, i, j, &dstptr); + dstptr->a = (uint8_t) DIV_255(dstptr->a * ainv + DIV_255(dstptr->a * source_y8) * alpha); + } + } + } + break; + case TYPE_BBRGB16: + for (unsigned int j = y; j < y + h; j++) { + for (unsigned int i = x; i < x + w; i++) { + ColorRGB16 * restrict dstptr; + BB_GET_PIXEL(bb, bb_rotation, ColorRGB16, i, j, &dstptr); + const uint8_t dr = ColorRGB16_GetR(dstptr->v); + const uint8_t dg = ColorRGB16_GetR(dstptr->v); + const uint8_t db = ColorRGB16_GetR(dstptr->v); + const uint8_t r = (uint8_t) DIV_255(dr * ainv + DIV_255(dr * color->r) * alpha); + const uint8_t g = (uint8_t) DIV_255(dg * ainv + DIV_255(dg * color->g) * alpha); + const uint8_t b = (uint8_t) DIV_255(db * ainv + DIV_255(db * color->b) * alpha); + dstptr->v = (uint16_t) RGB_To_RGB16(r, g, b); + } + } + break; + case TYPE_BBRGB24: + for (unsigned int j = y; j < y + h; j++) { + for (unsigned int i = x; i < x + w; i++) { + ColorRGB24 * restrict dstptr; + BB_GET_PIXEL(bb, bb_rotation, ColorRGB24, i, j, &dstptr); + dstptr->r = (uint8_t) DIV_255(dstptr->r * ainv + DIV_255(dstptr->r * color->r) * alpha); + dstptr->g = (uint8_t) DIV_255(dstptr->g * ainv + DIV_255(dstptr->g * color->g) * alpha); + dstptr->b = (uint8_t) DIV_255(dstptr->b * ainv + DIV_255(dstptr->b * color->b) * alpha); + } + } + break; + case TYPE_BBRGB32: + for (unsigned int j = y; j < y + h; j++) { + for (unsigned int i = x; i < x + w; i++) { + ColorRGB32 * restrict dstptr; + BB_GET_PIXEL(bb, bb_rotation, ColorRGB32, i, j, &dstptr); + dstptr->r = (uint8_t) DIV_255(dstptr->r * ainv + DIV_255(dstptr->r * color->r) * alpha); + dstptr->g = (uint8_t) DIV_255(dstptr->g * ainv + DIV_255(dstptr->g * color->g) * alpha); + dstptr->b = (uint8_t) DIV_255(dstptr->b * ainv + DIV_255(dstptr->b * color->b) * alpha); + } + } + break; + } +} + void BB_invert_rect(BlitBuffer * restrict bb, unsigned int x, unsigned int y, unsigned int w, unsigned int h) { const int rotation = GET_BB_ROTATION(bb); unsigned int rx, ry, rw, rh; @@ -691,7 +1036,7 @@ void BB_invert_rect(BlitBuffer * restrict bb, unsigned int x, unsigned int y, un } } -void BB_hatch_rect(BlitBuffer * restrict bb, unsigned int x, unsigned int y, unsigned int w, unsigned int h, unsigned int stripe_width, Color8 * restrict color, uint8_t alpha) { +void BB_hatch_rect(BlitBuffer * restrict bb, unsigned int x, unsigned int y, unsigned int w, unsigned int h, unsigned int stripe_width, const Color8 * restrict color, uint8_t alpha) { if (alpha == 0) { // NOP return; } @@ -2412,7 +2757,7 @@ void BB_invert_blit_from(BlitBuffer * restrict dst, const BlitBuffer * restrict } void BB_color_blit_from(BlitBuffer * restrict dst, const BlitBuffer * restrict src, - unsigned int dest_x, unsigned int dest_y, unsigned int offs_x, unsigned int offs_y, unsigned int w, unsigned int h, Color8A * restrict color) { + unsigned int dest_x, unsigned int dest_y, unsigned int offs_x, unsigned int offs_y, unsigned int w, unsigned int h, const Color8A * restrict color) { const int dbb_type = GET_BB_TYPE(dst); const int sbb_type = GET_BB_TYPE(src); const int sbb_rotation = GET_BB_ROTATION(src); @@ -2535,10 +2880,140 @@ void BB_color_blit_from(BlitBuffer * restrict dst, const BlitBuffer * restrict s } } +void BB_color_blit_from_RGB32(BlitBuffer * restrict dst, const BlitBuffer * restrict src, + unsigned int dest_x, unsigned int dest_y, unsigned int offs_x, unsigned int offs_y, unsigned int w, unsigned int h, const ColorRGB32 * restrict color) { + const int dbb_type = GET_BB_TYPE(dst); + const int sbb_type = GET_BB_TYPE(src); + const int sbb_rotation = GET_BB_ROTATION(src); + const int dbb_rotation = GET_BB_ROTATION(dst); + switch (dbb_type) { + case TYPE_BB8: + { + const uint8_t source_y8 = RGB_To_A(color->r, color->g, color->b); + for (unsigned int d_y = dest_y, o_y = offs_y; d_y < dest_y + h; d_y++, o_y++) { + for (unsigned int d_x = dest_x, o_x = offs_x; d_x < dest_x + w; d_x++, o_x++) { + uint8_t alpha; + SET_ALPHA_FROM_A(src, sbb_type, sbb_rotation, o_x, o_y, &alpha); + if (alpha == 0) { + // NOP + } else if (alpha == 0xFF) { + Color8 * restrict dstptr; + BB_GET_PIXEL(dst, dbb_rotation, Color8, d_x, d_y, &dstptr); + dstptr->a = source_y8; + } else { + const uint8_t ainv = alpha ^ 0xFF; + Color8 * restrict dstptr; + BB_GET_PIXEL(dst, dbb_rotation, Color8, d_x, d_y, &dstptr); + dstptr->a = (uint8_t) DIV_255(dstptr->a * ainv + source_y8 * alpha); + } + } + } + } + break; + case TYPE_BB8A: + { + const uint8_t source_y8 = RGB_To_A(color->r, color->g, color->b); + for (unsigned int d_y = dest_y, o_y = offs_y; d_y < dest_y + h; d_y++, o_y++) { + for (unsigned int d_x = dest_x, o_x = offs_x; d_x < dest_x + w; d_x++, o_x++) { + uint8_t alpha; + SET_ALPHA_FROM_A(src, sbb_type, sbb_rotation, o_x, o_y, &alpha); + if (alpha == 0) { + // NOP + } else if (alpha == 0xFF) { + Color8A * restrict dstptr; + BB_GET_PIXEL(dst, dbb_rotation, Color8A, d_x, d_y, &dstptr); + dstptr->a = source_y8; + } else { + const uint8_t ainv = alpha ^ 0xFF; + Color8A * restrict dstptr; + BB_GET_PIXEL(dst, dbb_rotation, Color8A, d_x, d_y, &dstptr); + dstptr->a = (uint8_t) DIV_255(dstptr->a * ainv + source_y8 * alpha); + } + } + } + } + break; + case TYPE_BBRGB16: + for (unsigned int d_y = dest_y, o_y = offs_y; d_y < dest_y + h; d_y++, o_y++) { + for (unsigned int d_x = dest_x, o_x = offs_x; d_x < dest_x + w; d_x++, o_x++) { + uint8_t alpha; + SET_ALPHA_FROM_A(src, sbb_type, sbb_rotation, o_x, o_y, &alpha); + if (alpha == 0) { + // NOP + } else if (alpha == 0xFF) { + ColorRGB16 * restrict dstptr; + BB_GET_PIXEL(dst, dbb_rotation, ColorRGB16, d_x, d_y, &dstptr); + dstptr->v = (uint16_t) RGB_To_RGB16(color->r, color->g, color->b); + } else { + const uint8_t ainv = alpha ^ 0xFF; + ColorRGB16 * restrict dstptr; + BB_GET_PIXEL(dst, dbb_rotation, ColorRGB16, d_x, d_y, &dstptr); + const uint8_t r = (uint8_t) DIV_255(ColorRGB16_GetR(dstptr->v) * ainv + color->r * alpha); + const uint8_t g = (uint8_t) DIV_255(ColorRGB16_GetG(dstptr->v) * ainv + color->g * alpha); + const uint8_t b = (uint8_t) DIV_255(ColorRGB16_GetB(dstptr->v) * ainv + color->b * alpha); + dstptr->v = (uint16_t) RGB_To_RGB16(r, g, b); + } + } + } + break; + case TYPE_BBRGB24: + for (unsigned int d_y = dest_y, o_y = offs_y; d_y < dest_y + h; d_y++, o_y++) { + for (unsigned int d_x = dest_x, o_x = offs_x; d_x < dest_x + w; d_x++, o_x++) { + uint8_t alpha; + SET_ALPHA_FROM_A(src, sbb_type, sbb_rotation, o_x, o_y, &alpha); + if (alpha == 0) { + // NOP + } else if (alpha == 0xFF) { + ColorRGB24 * restrict dstptr; + BB_GET_PIXEL(dst, dbb_rotation, ColorRGB24, d_x, d_y, &dstptr); + dstptr->r = color->r; + dstptr->g = color->g; + dstptr->b = color->b; + } else { + const uint8_t ainv = alpha ^ 0xFF; + ColorRGB24 * restrict dstptr; + BB_GET_PIXEL(dst, dbb_rotation, ColorRGB24, d_x, d_y, &dstptr); + dstptr->r = (uint8_t) DIV_255(dstptr->r * ainv + color->r * alpha); + dstptr->g = (uint8_t) DIV_255(dstptr->g * ainv + color->g * alpha); + dstptr->b = (uint8_t) DIV_255(dstptr->b * ainv + color->b * alpha); + } + } + } + break; + case TYPE_BBRGB32: + for (unsigned int d_y = dest_y, o_y = offs_y; d_y < dest_y + h; d_y++, o_y++) { + for (unsigned int d_x = dest_x, o_x = offs_x; d_x < dest_x + w; d_x++, o_x++) { + // NOTE: GCC *may* throw a -Wmaybe-uninitialized about alpha here, + // because of the lack of default case in the SET_ALPHA_FROM_A switch. + // Not a cause for alarm here :). + uint8_t alpha; + SET_ALPHA_FROM_A(src, sbb_type, sbb_rotation, o_x, o_y, &alpha); + if (alpha == 0) { + // NOP + } else if (alpha == 0xFF) { + ColorRGB32 * restrict dstptr; + BB_GET_PIXEL(dst, dbb_rotation, ColorRGB32, d_x, d_y, &dstptr); + dstptr->r = color->r; + dstptr->g = color->g; + dstptr->b = color->b; + } else { + const uint8_t ainv = alpha ^ 0xFF; + ColorRGB32 * restrict dstptr; + BB_GET_PIXEL(dst, dbb_rotation, ColorRGB32, d_x, d_y, &dstptr); + dstptr->r = (uint8_t) DIV_255(dstptr->r * ainv + color->r * alpha); + dstptr->g = (uint8_t) DIV_255(dstptr->g * ainv + color->g * alpha); + dstptr->b = (uint8_t) DIV_255(dstptr->b * ainv + color->b * alpha); + } + } + } + break; + } +} + // Information about those three algorithms can be found on http://members.chello.at/~easyfilter/ (Zingl Alois) void BB_paint_rounded_corner_noAA(BlitBuffer * restrict bb, unsigned int off_x, unsigned int off_y, unsigned int w, unsigned int h, int bw, int r, uint8_t c); void BB_paint_rounded_corner_AA(BlitBuffer * restrict bb, unsigned int off_x, unsigned int off_y, unsigned int w, unsigned int h, int bw, int r, uint8_t c); -void BB_paint_rounded_corner_AA_1px(BlitBuffer * restrict bb, unsigned int off_x, unsigned int off_y, unsigned int w, unsigned int h, int bw, int r, uint8_t c); +void BB_paint_rounded_corner_AA_1px(BlitBuffer * restrict bb, unsigned int off_x, unsigned int off_y, unsigned int w, unsigned int h, int r, uint8_t c); void BB_paint_rounded_corner(BlitBuffer * restrict bb, unsigned int off_x, unsigned int off_y, unsigned int w, unsigned int h, unsigned int bw, unsigned int r, uint8_t c, int anti_aliasing) { /* @@ -2553,13 +3028,14 @@ void BB_paint_rounded_corner(BlitBuffer * restrict bb, unsigned int off_x, unsig bw = r; } - if (!anti_aliasing) + if (!anti_aliasing) { BB_paint_rounded_corner_noAA(bb, off_x, off_y, w, h, bw, r, c); - else { - if (bw == 1) - BB_paint_rounded_corner_AA_1px(bb, off_x, off_y, w, h, 1, r, c); - else + } else { + if (bw == 1) { + BB_paint_rounded_corner_AA_1px(bb, off_x, off_y, w, h, r, c); + } else { BB_paint_rounded_corner_AA(bb, off_x, off_y, w, h, bw, r, c); + } } } @@ -2615,7 +3091,7 @@ void BB_paint_rounded_corner_noAA(BlitBuffer * restrict bb, unsigned int off_x, } // Fill between inner and outer circle. - for (unsigned int tmp_y = y; tmp_y > y2; tmp_y--) { + for (int tmp_y = y; tmp_y > y2; tmp_y--) { if (bb_type == TYPE_BB8) { const Color8 color = { .a = c }; @@ -2727,7 +3203,7 @@ void BB_paint_rounded_corner_noAA(BlitBuffer * restrict bb, unsigned int off_x, setPixelAA_BBRGB32(off_x+r+x0, off_y+h-r-1+y0); \ setPixelAA_BBRGB32(off_x+w-r-1+x1,off_y+h-r-1+y0); -void BB_paint_rounded_corner_AA_1px(BlitBuffer * restrict bb, unsigned int off_x, unsigned int off_y, unsigned int w, unsigned int h, int bw, int r, uint8_t c) { // draw a black anti-aliased circle with thickness 1 +void BB_paint_rounded_corner_AA_1px(BlitBuffer * restrict bb, unsigned int off_x, unsigned int off_y, unsigned int w, unsigned int h, int r, uint8_t c) { // draw a black anti-aliased circle with thickness 1 const int bb_type = GET_BB_TYPE(bb); const int bb_rotation = GET_BB_ROTATION(bb); const unsigned int bb_width = BB_GET_WIDTH(bb); diff --git a/blitbuffer.h b/blitbuffer.h index 3c6f148a7..ce115f7ad 100644 --- a/blitbuffer.h +++ b/blitbuffer.h @@ -132,9 +132,13 @@ typedef struct BlitBufferRGB32 { DLL_PUBLIC void BB_fill(BlitBuffer * restrict bb, uint8_t v); DLL_PUBLIC void BB_fill_rect(BlitBuffer * restrict bb, unsigned int x, unsigned int y, unsigned int w, unsigned int h, uint8_t v); -DLL_PUBLIC void BB_blend_rect(BlitBuffer * restrict bb, unsigned int x, unsigned int y, unsigned int w, unsigned int h, Color8A * restrict color); +DLL_PUBLIC void BB_fill_rect_RGB32(BlitBuffer * restrict bb, unsigned int x, unsigned int y, unsigned int w, unsigned int h, const ColorRGB32 * restrict color); +DLL_PUBLIC void BB_blend_rect(BlitBuffer * restrict bb, unsigned int x, unsigned int y, unsigned int w, unsigned int h, const Color8A * restrict color); +DLL_PUBLIC void BB_blend_RGB32_over_rect(BlitBuffer * restrict bb, unsigned int x, unsigned int y, unsigned int w, unsigned int h, const ColorRGB32 * restrict color); +DLL_PUBLIC void BB_blend_RGB_multiply_rect(BlitBuffer * restrict bb, unsigned int x, unsigned int y, unsigned int w, unsigned int h, const ColorRGB24 * restrict color); +DLL_PUBLIC void BB_blend_RGB32_multiply_rect(BlitBuffer * restrict bb, unsigned int x, unsigned int y, unsigned int w, unsigned int h, const ColorRGB32 * restrict color); DLL_PUBLIC void BB_invert_rect(BlitBuffer * restrict bb, unsigned int x, unsigned int y, unsigned int w, unsigned int h); -DLL_PUBLIC void BB_hatch_rect(BlitBuffer * restrict bb, unsigned int x, unsigned int y, unsigned int w, unsigned int h, unsigned int stripe_width, Color8 * restrict color, uint8_t alpha); +DLL_PUBLIC void BB_hatch_rect(BlitBuffer * restrict bb, unsigned int x, unsigned int y, unsigned int w, unsigned int h, unsigned int stripe_width, const Color8 * restrict color, uint8_t alpha); DLL_PUBLIC void BB_blit_to_BB8(const BlitBuffer * restrict src, BlitBuffer * restrict dst, unsigned int dest_x, unsigned int dest_y, unsigned int offs_x, unsigned int offs_y, unsigned int w, unsigned int h); DLL_PUBLIC void BB_dither_blit_to_BB8(const BlitBuffer * restrict src, BlitBuffer * restrict dst, @@ -164,7 +168,9 @@ DLL_PUBLIC void BB_dither_pmulalpha_blit_from(BlitBuffer * restrict dest, const DLL_PUBLIC void BB_invert_blit_from(BlitBuffer * restrict dest, const BlitBuffer * restrict source, unsigned int dest_x, unsigned int dest_y, unsigned int offs_x, unsigned int offs_y, unsigned int w, unsigned int h); DLL_PUBLIC void BB_color_blit_from(BlitBuffer * restrict dest, const BlitBuffer * restrict source, unsigned int dest_x, unsigned int dest_y, - unsigned int offs_x, unsigned int offs_y, unsigned int w, unsigned int h, Color8A * restrict color); + unsigned int offs_x, unsigned int offs_y, unsigned int w, unsigned int h, const Color8A * restrict color); +DLL_PUBLIC void BB_color_blit_from_RGB32(BlitBuffer * restrict dest, const BlitBuffer * restrict source, unsigned int dest_x, unsigned int dest_y, + unsigned int offs_x, unsigned int offs_y, unsigned int w, unsigned int h, const ColorRGB32 * restrict color); DLL_PUBLIC void BB_paint_rounded_corner(BlitBuffer * restrict bb, unsigned int off_x, unsigned int off_y, unsigned int w, unsigned int h, unsigned int bw, unsigned int r, uint8_t c, int anti_aliasing); #endif diff --git a/ffi/blitbuffer.lua b/ffi/blitbuffer.lua index a67af380a..d6c38ebbe 100644 --- a/ffi/blitbuffer.lua +++ b/ffi/blitbuffer.lua @@ -119,9 +119,13 @@ typedef struct BlitBufferRGB32 { void BB_fill(BlitBuffer * restrict bb, uint8_t v); void BB_fill_rect(BlitBuffer * restrict bb, unsigned int x, unsigned int y, unsigned int w, unsigned int h, uint8_t v); -void BB_blend_rect(BlitBuffer * restrict bb, unsigned int x, unsigned int y, unsigned int w, unsigned int h, Color8A * restrict color); +void BB_fill_rect_RGB32(BlitBuffer * restrict bb, unsigned int x, unsigned int y, unsigned int w, unsigned int h, const ColorRGB32 * restrict color); +void BB_blend_rect(BlitBuffer * restrict bb, unsigned int x, unsigned int y, unsigned int w, unsigned int h, const Color8A * restrict color); +void BB_blend_RGB32_over_rect(BlitBuffer * restrict bb, unsigned int x, unsigned int y, unsigned int w, unsigned int h, const ColorRGB32 * restrict color); +void BB_blend_RGB_multiply_rect(BlitBuffer * restrict bb, unsigned int x, unsigned int y, unsigned int w, unsigned int h, const ColorRGB24 * restrict color); +void BB_blend_RGB32_multiply_rect(BlitBuffer * restrict bb, unsigned int x, unsigned int y, unsigned int w, unsigned int h, const ColorRGB32 * restrict color); void BB_invert_rect(BlitBuffer * restrict bb, unsigned int x, unsigned int y, unsigned int w, unsigned int h); -void BB_hatch_rect(BlitBuffer * restrict bb, unsigned int x, unsigned int y, unsigned int w, unsigned int h, unsigned int stripe_width, Color8 * restrict color, uint8_t alpha); +void BB_hatch_rect(BlitBuffer * restrict bb, unsigned int x, unsigned int y, unsigned int w, unsigned int h, unsigned int stripe_width, const Color8 * restrict color, uint8_t alpha); void BB_blit_to(const BlitBuffer * restrict source, BlitBuffer * restrict dest, unsigned int dest_x, unsigned int dest_y, unsigned int offs_x, unsigned int offs_y, unsigned int w, unsigned int h); void BB_dither_blit_to(const BlitBuffer * restrict source, BlitBuffer * restrict dest, unsigned int dest_x, unsigned int dest_y, @@ -139,7 +143,9 @@ void BB_dither_pmulalpha_blit_from(BlitBuffer * restrict dest, const BlitBuffer void BB_invert_blit_from(BlitBuffer * restrict dest, const BlitBuffer * restrict source, unsigned int dest_x, unsigned int dest_y, unsigned int offs_x, unsigned int offs_y, unsigned int w, unsigned int h); void BB_color_blit_from(BlitBuffer * restrict dest, const BlitBuffer * restrict source, unsigned int dest_x, unsigned int dest_y, - unsigned int offs_x, unsigned int offs_y, unsigned int w, unsigned int h, Color8A * restrict color); + unsigned int offs_x, unsigned int offs_y, unsigned int w, unsigned int h, const Color8A * restrict color); +void BB_color_blit_from_RGB32(BlitBuffer * restrict dest, const BlitBuffer * restrict source, unsigned int dest_x, unsigned int dest_y, + unsigned int offs_x, unsigned int offs_y, unsigned int w, unsigned int h, const ColorRGB32 * restrict color); void BB_paint_rounded_corner(BlitBuffer * restrict bb, unsigned int off_x, unsigned int off_y, unsigned int w, unsigned int h, unsigned int bw, unsigned int r, uint8_t c, int anti_alias); ]] @@ -365,6 +371,36 @@ function Color8_mt.__index:ditherpmulblend(x, y, color) value = dither_o8x8(x, y, value) self:set(Color8(value)) end +-- Dumb multiply blending with an RGB24 color (will be grayscaled when targeting grayscale BBs) +function Color4L_mt.__index:mul(color) + local value = div255(self:getColor8() * color:getColor8()) + self:set(Color4L(value)) +end +function Color4U_mt.__index:mul(color) +local value = div255(self:getColor8() * color:getColor8()) + self:set(Color4U(value)) +end +function Color8_mt.__index:mul(color) + local value = div255(self.a * color:getColor8()) + self:set(Color8(value)) +end +function Color8A_mt.__index:mul(color) + local value = div255(self.a * color:getColor8()) + self:set(Color8A(value, self:getAlpha())) +end +function ColorRGB16_mt.__index:mul(color) + local r = div255(self:getR() * color:getR()) + local g = div255(self:getG() * color:getG()) + local b = div255(self:getB() * color:getB()) + self:set(ColorRGB24(r, g, b)) +end +ColorRGB24_mt.__index.mul = ColorRGB16_mt.__index.mul +function ColorRGB32_mt.__index:mul(color) + local r = div255(self:getR() * color:getR()) + local g = div255(self:getG() * color:getG()) + local b = div255(self:getB() * color:getB()) + self:set(ColorRGB32(r, g, b, self:getAlpha())) +end -- color conversions: -- NOTE: These *always* return a new Color? object, even when no conversion is needed. @@ -506,7 +542,7 @@ end function ColorRGB24_mt.__index:getColorRGB32() return ColorRGB32(self.r, self.g, self.b, 0xFF) end function ColorRGB32_mt.__index:getColorRGB32() return ColorRGB32(self.r, self.g, self.b, self.alpha) end --- RGB getters (special case for 4bpp mode) +-- RGB getters (with the necessary trickery for non-RGB color types) function Color4L_mt.__index:getR() return self:getColor8().a end Color4L_mt.__index.getG = Color4L_mt.__index.getR Color4L_mt.__index.getB = Color4L_mt.__index.getR @@ -846,6 +882,14 @@ function BBRGB16_mt.__index:setPixelAdd(x, y, color, alpha) end BBRGB24_mt.__index.setPixelAdd = BBRGB16_mt.__index.setPixelAdd BBRGB32_mt.__index.setPixelAdd = BBRGB16_mt.__index.setPixelAdd +-- Multiply +function BB_mt.__index:setPixelMultiply(x, y, color) + -- this method uses an RGB24 color value + local px, py = self:getPhysicalCoordinates(x, y) + local c = color:getColorRGB24() + if self:getInverse() == 1 then c = c:invert() end + self:getPixelP(px, py)[0]:mul(c) +end -- Straight alpha blending function BB_mt.__index:setPixelBlend(x, y, color) -- fast path: @@ -960,6 +1004,41 @@ function BB_mt.__index:setPixelColorize(x, y, mask, color) self:getPixelP(px, py)[0]:blend(color, alpha) end end +-- Colorize in an RGB32 color (NOTE: colorblitFrom has already handled inversion for us) +function BB_mt.__index:setPixelColorizeRGB32(x, y, mask, color) + -- use 8bit grayscale pixel value as alpha for blitting + local alpha = mask:getColor8().a + -- fast path: + if alpha == 0 then + return + end + local px, py = self:getPhysicalCoordinates(x, y) + -- Grayscale the input color + local c = color:getColor8() + if alpha == 0xFF then + self:getPixelP(px, py)[0]:set(c) + else + -- NOTE: We're using an alpha mask, not color's actual alpha value, which we don't want to mess with, + -- as that's a pointer to our set_param... + -- Avoids screwing with alpha when blitting to 8A or RGB32 bbs (c.f., #3949). + self:getPixelP(px, py)[0]:blend(c, alpha) + end +end +function BBRGB16_mt.__index:setPixelColorizeRGB32(x, y, mask, color) + local alpha = mask:getColor8().a + if alpha == 0 then + return + end + local px, py = self:getPhysicalCoordinates(x, y) + -- We keep the input ColorRGB32 color as-is + if alpha == 0xFF then + self:getPixelP(px, py)[0]:set(color) + else + self:getPixelP(px, py)[0]:blend(color, alpha) + end +end +BBRGB24_mt.__index.setPixelColorizeRGB32 = BBRGB16_mt.__index.setPixelColorizeRGB32 +BBRGB32_mt.__index.setPixelColorizeRGB32 = BBRGB16_mt.__index.setPixelColorizeRGB32 -- Invert function BB_mt.__index:setPixelInverted(x, y, color) self:setPixel(x, y, color:invert()) @@ -1339,6 +1418,23 @@ function BB_mt.__index:colorblitFrom(source, dest_x, dest_y, offs_x, offs_y, wid end end +function BB_mt.__index:colorblitFromRGB32(source, dest_x, dest_y, offs_x, offs_y, width, height, color) + -- Enforce type coercion for safety (plus, we might need a copy for inversion anyway) + local c = color:getColorRGB32() + if self:canUseCbbTogether(source) then + width, height = width or source:getWidth(), height or source:getHeight() + width, dest_x, offs_x = BB.checkBounds(width, dest_x or 0, offs_x or 0, self:getWidth(), source:getWidth()) + height, dest_y, offs_y = BB.checkBounds(height, dest_y or 0, offs_y or 0, self:getHeight(), source:getHeight()) + if width <= 0 or height <= 0 then return end + cblitbuffer.BB_color_blit_from_RGB32(ffi.cast(P_BlitBuffer, self), + ffi.cast(P_BlitBuffer_ROData, source), + dest_x, dest_y, offs_x, offs_y, width, height, c) + else + if self:getInverse() == 1 then c = c:invert() end + self:blitFrom(source, dest_x, dest_y, offs_x, offs_y, width, height, self.setPixelColorizeRGB32, c) + end +end + -- scale method does not modify the original blitbuffer, instead, it allocates -- and returns a new scaled blitbuffer. function BB_mt.__index:scale(new_width, new_height) @@ -1404,7 +1500,7 @@ PAINTING --]] --[[ -fill the whole blitbuffer with a given (grayscale) color value +fill the whole blitbuffer with a given (grayscale) value --]] function BB_mt.__index:fill(value) if self:canUseCbb() then @@ -1691,6 +1787,121 @@ function BB4_mt.__index:paintRect(x, y, w, h, value, setter) end end +--[[ +paintRect variant that takes a ColorRGB32 instead of a luminance value +--]] +function BB_mt.__index:paintRectRGB32(x, y, w, h, color, setter) + setter = setter or self.setPixel + x, y, w, h = self:getBoundedRect(x, y, w, h) + if w <= 0 or h <= 0 then return end + -- Type coercion for safety + local c = color and color:getColorRGB32() or ColorRGB32(0x80, 0x80, 0x80, 0xFF) + if self:canUseCbb() and setter == self.setPixel then + cblitbuffer.BB_fill_rect_RGB32(ffi.cast(P_BlitBuffer, self), + x, y, w, h, c) + else + -- We can only do fast filling when there's no complex processing involved (i.e., simple setPixel only) + local bbtype = self:getType() + if setter == self.setPixel and bbtype ~= TYPE_BBRGB24 then + -- Handle rotation... + x, y, w, h = self:getPhysicalRect(x, y, w, h) + + if self:getInverse() == 1 then c = c:invert() end + + -- We check against the BB's unrotated coordinates (i.e., self.w and not self:getWidth()), + -- as our memory region has a fixed layout, too! + if x == 0 and w == self.w then + -- Single step for contiguous scanlines + --print("Single fill paintRect") + if bbtype == TYPE_BBRGB32 then + local src = c + local p = ffi.cast(P_ColorRGB32, ffi.cast(uint8pt, self.data) + self.stride*y) + for i = 1, self.pixel_stride*h do + p[0] = src + p = p+1 + end + elseif bbtype == TYPE_BBRGB16 then + local src = c:getColorRGB16() + local p = ffi.cast(P_ColorRGB16, ffi.cast(uint8pt, self.data) + self.stride*y) + for i = 1, self.pixel_stride*h do + p[0] = src + p = p+1 + end + elseif bbtype == TYPE_BB8A then + local src = c:getColor8A() + local p = ffi.cast(P_Color8A, ffi.cast(uint8pt, self.data) + self.stride*y) + for i = 1, self.pixel_stride*h do + p[0] = src + p = p+1 + end + else + -- BB8, where we can just use ffi.fill + local p = ffi.cast(uint8pt, self.data) + self.stride*y + ffi.fill(p, self.stride*h, c:getColor8().a) + end + else + -- Scanline per scanline fill + --print("Scanline fill paintRect") + if bbtype == TYPE_BBRGB32 then + local src = c + for j = y, y+h-1 do + local p = ffi.cast(P_ColorRGB32, ffi.cast(uint8pt, self.data) + self.stride*j) + x + for i = 0, w-1 do + p[0] = src + p = p+1 + end + end + elseif bbtype == TYPE_BBRGB16 then + local src = c:getColorRGB16() + for j = y, y+h-1 do + local p = ffi.cast(P_ColorRGB16, ffi.cast(uint8pt, self.data) + self.stride*j) + x + for i = 0, w-1 do + p[0] = src + p = p+1 + end + end + elseif bbtype == TYPE_BB8A then + local src = c:getColor8A() + for j = y, y+h-1 do + local p = ffi.cast(P_Color8A, ffi.cast(uint8pt, self.data) + self.stride*j) + x + for i = 0, w-1 do + p[0] = src + p = p+1 + end + end + else + -- BB8 + for j = y, y+h-1 do + local p = ffi.cast(uint8pt, self.data) + self.stride*j + x + ffi.fill(p, w, c:getColor8().a) + end + end + end + else + --print("Old-style paintRect pixel loop") + for tmp_y = y, y+h-1 do + for tmp_x = x, x+w-1 do + setter(self, tmp_x, tmp_y, color) + end + end + end + end +end + +-- BB4 version, identical if not for the lack of fast filling, because nibbles aren't addressable... +-- Also, no cbb branch, as cbb doesn't handle 4bpp targets at all. +function BB4_mt.__index:paintRectRGB32(x, y, w, h, color, setter) + setter = setter or self.setPixel + color = color and color:getColor8() or Color8(0x80) + x, y, w, h = self:getBoundedRect(x, y, w, h) + if w <= 0 or h <= 0 then return end + for tmp_y = y, y+h-1 do + for tmp_x = x, x+w-1 do + setter(self, tmp_x, tmp_y, color) + end + end +end + --[[ paint a circle onto this buffer @@ -1977,15 +2188,17 @@ function BB_mt.__index:progressBar(x, y, w, h, load_m_w, load_m_h, load_percent, end --[[ -dim color values in rectangular area +Ligthen color values in a rectangular area +(i.e., blend pure white at the requested opacity OVER rect). +NOTE: Used to be called dimRect because it effectively makes black text dimmer. @param x X coordinate @param y Y coordinate @param w width @param h height -@param by dim by this factor (default: 0.5) +@param by lighten by this factor (default: 0.5) --]] -function BB_mt.__index:dimRect(x, y, w, h, by) +function BB_mt.__index:lightenRect(x, y, w, h, by) local color = Color8A(0xFF, 0xFF*(by or 0.5)) if self:canUseCbb() then x, y, w, h = self:getBoundedRect(x, y, w, h) @@ -1998,15 +2211,16 @@ function BB_mt.__index:dimRect(x, y, w, h, by) end --[[ -lighten color values in rectangular area +Darken color values in a rectangular area +(i.e., blend pure black at the requested opacity OVER rect). @param x X coordinate @param y Y coordinate @param w width @param h height -@param by lighten by this factor (default: 0.5) +@param by darken by this factor (default: 0.5) --]] -function BB_mt.__index:lightenRect(x, y, w, h, by) +function BB_mt.__index:darkenRect(x, y, w, h, by) local color = Color8A(0, 0xFF*(by or 0.5)) if self:canUseCbb() then x, y, w, h = self:getBoundedRect(x, y, w, h) @@ -2018,6 +2232,53 @@ function BB_mt.__index:lightenRect(x, y, w, h, by) end end +--[[ +Multiply color values in a rectangular area by a given source color. +(i.e., blend color MUL rect). +Mainly used to emulate a highlighter pen over a text buffer. + +@param x X coordinate +@param y Y coordinate +@param w width +@param h height +@param color source color (alpha is ignored) +--]] +function BB_mt.__index:multiplyRectRGB(x, y, w, h, color) + -- Type coercion for safety + local c = color and color:getColorRGB24() or ColorRGB24(0x80, 0x80, 0x80) + if self:canUseCbb() then + x, y, w, h = self:getBoundedRect(x, y, w, h) + if w <= 0 or h <= 0 then return end + cblitbuffer.BB_blend_RGB_multiply_rect(ffi.cast(P_BlitBuffer, self), + x, y, w, h, c) + else + self:paintRect(x, y, w, h, c, self.setPixelMultiply) + end +end + +--[[ +Blend color values in a rectangular area +(i.e., blend color OVER rect). + +@param x X coordinate +@param y Y coordinate +@param w width +@param h height +@param color source color +--]] +function BB_mt.__index:blendRectRGB32(x, y, w, h, color) + -- Type coercion for safety + local c = color and color:getColorRGB32() or ColorRGB32(0x80, 0x80, 0x80, 0xFF) + if self:canUseCbb() then + x, y, w, h = self:getBoundedRect(x, y, w, h) + if w <= 0 or h <= 0 then return end + cblitbuffer.BB_blend_RGB32_over_rect(ffi.cast(P_BlitBuffer, self), + x, y, w, h, c) + else + self:paintRect(x, y, w, h, c, self.setPixelBlend) + end +end + --[[ make a full copy of the current buffer, with its own memory --]] @@ -2161,11 +2422,11 @@ local Jpeg -- lazy load ffi/jpeg function BB_mt.__index:getBufferData() local w, h = self:getWidth(), self:getHeight() local bbdump, source_ptr, stride - if self:getType() == BB.TYPE_BBRGB24 then + if self:getType() == TYPE_BBRGB24 then source_ptr = ffi.cast(uint8pt, self.data) stride = self.stride else - bbdump = BB.new(w, h, BB.TYPE_BBRGB24, nil) + bbdump = BB.new(w, h, TYPE_BBRGB24, nil) bbdump:blitFrom(self) source_ptr = ffi.cast(uint8pt, bbdump.data) stride = bbdump.stride @@ -2297,6 +2558,71 @@ function BB.gray(level) return Color8(bxor(floor(0xFF * level), 0xFF)) end +--[[ +return a Color value resembling a given hex string (nil on failure) +--]] +function BB.colorFromString(value) + value = value:gsub('#','') + -- #rrggbbaa + if(#value == 8) then + return ColorRGB32( + tonumber(value:sub(1, 2), 16), + tonumber(value:sub(3, 4), 16), + tonumber(value:sub(5, 6), 16), + tonumber(value:sub(7, 8), 16) + ) + -- #rrggbb + elseif(#value == 6) then + return ColorRGB32( + tonumber(value:sub(1, 2), 16), + tonumber(value:sub(3, 4), 16), + tonumber(value:sub(5, 6), 16), + 0xFF + ) + -- #vv + elseif(#value == 2) then + return ColorRGB32( + tonumber(value:sub(1, 2), 16), + tonumber(value:sub(1, 2), 16), + tonumber(value:sub(1, 2), 16), + 0xFF + ) + else + return nil + end +end + +-- Common color names used for highlights +BB.HIGHLIGHT_COLORS = { + ["red"] = "#FF3300", + ["orange"] = "#FF8800", + ["yellow"] = "#FFFF33", + ["green"] = "#00AA66", + ["olive"] = "#88FF77", + ["cyan"] = "#00FFEE", + ["blue"] = "#0066FF", + ["purple"] = "#EE00FF", +} +--[[ +return a Color value given a common color name (nil for unknown colors) +--]] +function BB.colorFromName(name) + local color_hash = BB.HIGHLIGHT_COLORS[name:lower()] + if not color_hash then return nil end + return BB.colorFromString(color_hash) +end + +--[[ +Test whether a Color is a Luminance-only type. + +Technically that would mean anything <= Color8A, +but, in practice, since we only care about the constants defined below, +we only check against Color8. +--]] +function BB.isColor8(color) + return ffi.istype(Color8, color) +end + -- the full eInk palette: BB.COLOR_WHITE = Color8(0xFF) BB.COLOR_GRAY_E = Color8(0xEE) diff --git a/ffi/framebuffer_mxcfb.lua b/ffi/framebuffer_mxcfb.lua index 347ffa1bc..fa9ed96e9 100644 --- a/ffi/framebuffer_mxcfb.lua +++ b/ffi/framebuffer_mxcfb.lua @@ -40,6 +40,7 @@ local framebuffer = { refresh_pixel_size = 1, -- Used to enforce an alignment constraint on devices with quirky drivers alignment_constraint = nil, + dither_alignment_constraint = 8, -- We recycle ffi cdata marker_data = nil, @@ -279,7 +280,7 @@ local function mxc_update(fb, ioc_cmd, ioc_data, is_flashing, waveform_mode, x, -- (Sidebar: this is probably a kernel issue, the EPDC driver is responsible for the alignment fixup, -- c.f., epdc_process_update @ drivers/video/fbdev/mxc/mxc_epdc_v2_fb.c on a Kobo Mk. 7 kernel...). -- And regardless of alignment constraints, make sure the rectangle is strictly bounded inside the screen. - x, y, w, h = bb:getBoundedRect(x, y, w, h, dither and 8 or fb.alignment_constraint) + x, y, w, h = bb:getBoundedRect(x, y, w, h, dither and fb.dither_alignment_constraint or fb.alignment_constraint) -- The ioctl operates in the native rotation, so, make sure we rotate the rectangle as needed x, y, w, h = bb:getPhysicalRect(x, y, w, h) @@ -1014,7 +1015,8 @@ function framebuffer:init() -- so partial refreshes at exact coordinates will sometimes be cut-off one pixel short... -- That can obviously lead to leftover stale content visible on screen, -- so, just enforce larger refresh regions on our side... - self.alignment_constraint = 8 + self.alignment_constraint = 16 + self.dither_alignment_constraint = 16 self.waveform_a2 = C.HWTCON_WAVEFORM_MODE_A2 self.waveform_fast = C.HWTCON_WAVEFORM_MODE_DU diff --git a/ffi/mupdf.lua b/ffi/mupdf.lua index 887fe7ab6..f7a5059d6 100644 --- a/ffi/mupdf.lua +++ b/ffi/mupdf.lua @@ -676,23 +676,44 @@ end mupdf.STRIKE_HEIGHT = 0.375 mupdf.UNDERLINE_HEIGHT = 0 mupdf.LINE_THICKNESS = 0.05 +mupdf.HIGHLIGHT_COLOR = {1.0, 1.0, 0.0} +mupdf.UNDERLINE_COLOR = {0.0, 0.0, 1.0} +mupdf.STRIKE_OUT_COLOR = {1.0, 0.0, 0.0} -function page_mt.__index:addMarkupAnnotation(points, n, type) +function page_mt.__index:addMarkupAnnotation(points, n, type, bb_color) local color = ffi.new("float[3]") local alpha = 1.0 if type == M.PDF_ANNOT_HIGHLIGHT then - color[0] = 1.0 - color[1] = 1.0 - color[2] = 0.0 + if bb_color then + color[0] = bb_color.r / 255 + color[1] = bb_color.g / 255 + color[2] = bb_color.b / 255 + else + color[0] = mupdf.HIGHLIGHT_COLOR[1] + color[1] = mupdf.HIGHLIGHT_COLOR[2] + color[2] = mupdf.HIGHLIGHT_COLOR[3] + end alpha = 0.5 elseif type == M.PDF_ANNOT_UNDERLINE then - color[0] = 0.0 - color[1] = 0.0 - color[2] = 1.0 + if bb_color then + color[0] = bb_color.r / 255 + color[1] = bb_color.g / 255 + color[2] = bb_color.b / 255 + else + color[0] = mupdf.UNDERLINE_COLOR[1] + color[1] = mupdf.UNDERLINE_COLOR[2] + color[2] = mupdf.UNDERLINE_COLOR[3] + end elseif type == M.PDF_ANNOT_STRIKE_OUT then - color[0] = 1.0 - color[1] = 0.0 - color[2] = 0.0 + if bb_color then + color[0] = bb_color.r / 255 + color[1] = bb_color.g / 255 + color[2] = bb_color.b / 255 + else + color[0] = mupdf.STRIKE_OUT_COLOR[1] + color[1] = mupdf.STRIKE_OUT_COLOR[2] + color[2] = mupdf.STRIKE_OUT_COLOR[3] + end else return end