diff options
Diffstat (limited to 'core/fxge/dib/fx_dib_composite.cpp')
| -rw-r--r-- | core/fxge/dib/fx_dib_composite.cpp | 3904 |
1 files changed, 0 insertions, 3904 deletions
diff --git a/core/fxge/dib/fx_dib_composite.cpp b/core/fxge/dib/fx_dib_composite.cpp index fb00cb855b..86be539008 100644 --- a/core/fxge/dib/fx_dib_composite.cpp +++ b/core/fxge/dib/fx_dib_composite.cpp @@ -8,3912 +8,8 @@ #include "core/fxcodec/fx_codec.h" #include "core/fxge/cfx_gemodule.h" -#include "core/fxge/dib/dib_int.h" #include "core/fxge/ge/cfx_cliprgn.h" -namespace { - -const uint8_t color_sqrt[256] = { - 0x00, 0x03, 0x07, 0x0B, 0x0F, 0x12, 0x16, 0x19, 0x1D, 0x20, 0x23, 0x26, - 0x29, 0x2C, 0x2F, 0x32, 0x35, 0x37, 0x3A, 0x3C, 0x3F, 0x41, 0x43, 0x46, - 0x48, 0x4A, 0x4C, 0x4E, 0x50, 0x52, 0x54, 0x56, 0x57, 0x59, 0x5B, 0x5C, - 0x5E, 0x60, 0x61, 0x63, 0x64, 0x65, 0x67, 0x68, 0x69, 0x6B, 0x6C, 0x6D, - 0x6E, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, - 0x7B, 0x7C, 0x7D, 0x7E, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, - 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x91, - 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, - 0x9C, 0x9D, 0x9E, 0x9F, 0xA0, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA4, 0xA5, - 0xA6, 0xA7, 0xA7, 0xA8, 0xA9, 0xAA, 0xAA, 0xAB, 0xAC, 0xAD, 0xAD, 0xAE, - 0xAF, 0xB0, 0xB0, 0xB1, 0xB2, 0xB3, 0xB3, 0xB4, 0xB5, 0xB5, 0xB6, 0xB7, - 0xB7, 0xB8, 0xB9, 0xBA, 0xBA, 0xBB, 0xBC, 0xBC, 0xBD, 0xBE, 0xBE, 0xBF, - 0xC0, 0xC0, 0xC1, 0xC2, 0xC2, 0xC3, 0xC4, 0xC4, 0xC5, 0xC6, 0xC6, 0xC7, - 0xC7, 0xC8, 0xC9, 0xC9, 0xCA, 0xCB, 0xCB, 0xCC, 0xCC, 0xCD, 0xCE, 0xCE, - 0xCF, 0xD0, 0xD0, 0xD1, 0xD1, 0xD2, 0xD3, 0xD3, 0xD4, 0xD4, 0xD5, 0xD6, - 0xD6, 0xD7, 0xD7, 0xD8, 0xD9, 0xD9, 0xDA, 0xDA, 0xDB, 0xDC, 0xDC, 0xDD, - 0xDD, 0xDE, 0xDE, 0xDF, 0xE0, 0xE0, 0xE1, 0xE1, 0xE2, 0xE2, 0xE3, 0xE4, - 0xE4, 0xE5, 0xE5, 0xE6, 0xE6, 0xE7, 0xE7, 0xE8, 0xE9, 0xE9, 0xEA, 0xEA, - 0xEB, 0xEB, 0xEC, 0xEC, 0xED, 0xED, 0xEE, 0xEE, 0xEF, 0xF0, 0xF0, 0xF1, - 0xF1, 0xF2, 0xF2, 0xF3, 0xF3, 0xF4, 0xF4, 0xF5, 0xF5, 0xF6, 0xF6, 0xF7, - 0xF7, 0xF8, 0xF8, 0xF9, 0xF9, 0xFA, 0xFA, 0xFB, 0xFB, 0xFC, 0xFC, 0xFD, - 0xFD, 0xFE, 0xFE, 0xFF}; - -int Blend(int blend_mode, int back_color, int src_color) { - switch (blend_mode) { - case FXDIB_BLEND_NORMAL: - return src_color; - case FXDIB_BLEND_MULTIPLY: - return src_color * back_color / 255; - case FXDIB_BLEND_SCREEN: - return src_color + back_color - src_color * back_color / 255; - case FXDIB_BLEND_OVERLAY: - return Blend(FXDIB_BLEND_HARDLIGHT, src_color, back_color); - case FXDIB_BLEND_DARKEN: - return src_color < back_color ? src_color : back_color; - case FXDIB_BLEND_LIGHTEN: - return src_color > back_color ? src_color : back_color; - case FXDIB_BLEND_COLORDODGE: { - if (src_color == 255) - return src_color; - - return std::min(back_color * 255 / (255 - src_color), 255); - } - case FXDIB_BLEND_COLORBURN: { - if (src_color == 0) - return src_color; - - return 255 - std::min((255 - back_color) * 255 / src_color, 255); - } - case FXDIB_BLEND_HARDLIGHT: - if (src_color < 128) - return (src_color * back_color * 2) / 255; - - return Blend(FXDIB_BLEND_SCREEN, back_color, 2 * src_color - 255); - case FXDIB_BLEND_SOFTLIGHT: { - if (src_color < 128) { - return back_color - - (255 - 2 * src_color) * back_color * (255 - back_color) / 255 / - 255; - } - return back_color + - (2 * src_color - 255) * (color_sqrt[back_color] - back_color) / - 255; - } - case FXDIB_BLEND_DIFFERENCE: - return back_color < src_color ? src_color - back_color - : back_color - src_color; - case FXDIB_BLEND_EXCLUSION: - return back_color + src_color - 2 * back_color * src_color / 255; - } - return src_color; -} - -struct RGB { - int red; - int green; - int blue; -}; - -int Lum(RGB color) { - return (color.red * 30 + color.green * 59 + color.blue * 11) / 100; -} - -RGB ClipColor(RGB color) { - int l = Lum(color); - int n = std::min(color.red, std::min(color.green, color.blue)); - int x = std::max(color.red, std::max(color.green, color.blue)); - if (n < 0) { - color.red = l + ((color.red - l) * l / (l - n)); - color.green = l + ((color.green - l) * l / (l - n)); - color.blue = l + ((color.blue - l) * l / (l - n)); - } - if (x > 255) { - color.red = l + ((color.red - l) * (255 - l) / (x - l)); - color.green = l + ((color.green - l) * (255 - l) / (x - l)); - color.blue = l + ((color.blue - l) * (255 - l) / (x - l)); - } - return color; -} - -RGB SetLum(RGB color, int l) { - int d = l - Lum(color); - color.red += d; - color.green += d; - color.blue += d; - return ClipColor(color); -} - -int Sat(RGB color) { - return std::max(color.red, std::max(color.green, color.blue)) - - std::min(color.red, std::min(color.green, color.blue)); -} - -RGB SetSat(RGB color, int s) { - int min = std::min(color.red, std::min(color.green, color.blue)); - int max = std::max(color.red, std::max(color.green, color.blue)); - if (min == max) - return {0, 0, 0}; - - color.red = (color.red - min) * s / (max - min); - color.green = (color.green - min) * s / (max - min); - color.blue = (color.blue - min) * s / (max - min); - return color; -} - -void RGB_Blend(int blend_mode, - const uint8_t* src_scan, - const uint8_t* dest_scan, - int results[3]) { - RGB result = {0, 0, 0}; - RGB src; - src.red = src_scan[2]; - src.green = src_scan[1]; - src.blue = src_scan[0]; - RGB back; - back.red = dest_scan[2]; - back.green = dest_scan[1]; - back.blue = dest_scan[0]; - switch (blend_mode) { - case FXDIB_BLEND_HUE: - result = SetLum(SetSat(src, Sat(back)), Lum(back)); - break; - case FXDIB_BLEND_SATURATION: - result = SetLum(SetSat(back, Sat(src)), Lum(back)); - break; - case FXDIB_BLEND_COLOR: - result = SetLum(src, Lum(back)); - break; - case FXDIB_BLEND_LUMINOSITY: - result = SetLum(back, Lum(src)); - break; - } - results[0] = result.blue; - results[1] = result.green; - results[2] = result.red; -} - -int GetAlpha(uint8_t src_alpha, const uint8_t* clip_scan, int col) { - return clip_scan ? clip_scan[col] * src_alpha / 255 : src_alpha; -} - -void CompositeRow_AlphaToMask(uint8_t* dest_scan, - const uint8_t* src_scan, - int pixel_count, - const uint8_t* clip_scan, - uint8_t stride) { - src_scan += stride - 1; - for (int col = 0; col < pixel_count; ++col) { - int src_alpha = GetAlpha(*src_scan, clip_scan, col); - uint8_t back_alpha = *dest_scan; - if (!back_alpha) - *dest_scan = src_alpha; - else if (src_alpha) - *dest_scan = back_alpha + src_alpha - back_alpha * src_alpha / 255; - ++dest_scan; - src_scan += stride; - } -} - -void CompositeRow_Rgb2Mask(uint8_t* dest_scan, - const uint8_t* src_scan, - int width, - const uint8_t* clip_scan) { - if (!clip_scan) { - FXSYS_memset(dest_scan, 0xff, width); - return; - } - for (int i = 0; i < width; ++i) { - *dest_scan = FXDIB_ALPHA_UNION(*dest_scan, *clip_scan); - ++dest_scan; - ++clip_scan; - } -} - -uint8_t GetGray(void* pIccTransform, - CCodec_IccModule* pIccModule, - const uint8_t* src_scan) { - if (!pIccTransform) - return FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan); - - uint8_t gray; - pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1); - return gray; -} - -uint8_t GetGrayWithBlend(void* pIccTransform, - CCodec_IccModule* pIccModule, - const uint8_t* src_scan, - const uint8_t* dest_scan, - int blend_type) { - uint8_t gray = GetGray(pIccTransform, pIccModule, src_scan); - if (blend_type >= FXDIB_BLEND_NONSEPARABLE) - gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan; - else if (blend_type) - gray = Blend(blend_type, *dest_scan, gray); - return gray; -} - -void CompositeRow_Argb2Graya(uint8_t* dest_scan, - const uint8_t* src_scan, - int pixel_count, - int blend_type, - const uint8_t* clip_scan, - const uint8_t* src_alpha_scan, - uint8_t* dst_alpha_scan, - void* pIccTransform) { - CCodec_IccModule* pIccModule = nullptr; - if (pIccTransform) - pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule(); - uint8_t offset = src_alpha_scan ? 3 : 4; - for (int col = 0; col < pixel_count; ++col) { - const uint8_t* alpha_scan = - src_alpha_scan ? src_alpha_scan++ : &src_scan[3]; - uint8_t back_alpha = *dst_alpha_scan; - if (back_alpha == 0) { - int src_alpha = GetAlpha(*alpha_scan, clip_scan, col); - if (src_alpha) { - *dest_scan = GetGray(pIccTransform, pIccModule, src_scan); - *dst_alpha_scan = src_alpha; - } - ++dest_scan; - ++dst_alpha_scan; - src_scan += offset; - continue; - } - uint8_t src_alpha = GetAlpha(*alpha_scan, clip_scan, col); - if (src_alpha == 0) { - ++dest_scan; - ++dst_alpha_scan; - src_scan += offset; - continue; - } - *dst_alpha_scan = FXDIB_ALPHA_UNION(back_alpha, src_alpha); - int alpha_ratio = src_alpha * 255 / (*dst_alpha_scan); - uint8_t gray = GetGray(pIccTransform, pIccModule, src_scan); - // TODO(npm): Does this if really need src_alpha_scan or was that a bug? - if (blend_type && src_alpha_scan) { - if (blend_type >= FXDIB_BLEND_NONSEPARABLE) - gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan; - else - gray = Blend(blend_type, *dest_scan, gray); - } - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio); - ++dest_scan; - ++dst_alpha_scan; - src_scan += offset; - } -} - -void CompositeRow_Argb2Gray(uint8_t* dest_scan, - const uint8_t* src_scan, - int pixel_count, - int blend_type, - const uint8_t* clip_scan, - const uint8_t* src_alpha_scan, - void* pIccTransform) { - CCodec_IccModule* pIccModule = nullptr; - uint8_t gray; - if (pIccTransform) - pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule(); - - uint8_t offset = src_alpha_scan ? 3 : 4; - for (int col = 0; col < pixel_count; ++col) { - const uint8_t* alpha_scan = - src_alpha_scan ? src_alpha_scan++ : &src_scan[3]; - int src_alpha = GetAlpha(*alpha_scan, clip_scan, col); - if (src_alpha) { - gray = GetGrayWithBlend(pIccTransform, pIccModule, src_scan, dest_scan, - blend_type); - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, src_alpha); - } - ++dest_scan; - src_scan += offset; - } -} - -void CompositeRow_Rgb2Gray(uint8_t* dest_scan, - const uint8_t* src_scan, - int src_Bpp, - int pixel_count, - int blend_type, - const uint8_t* clip_scan, - void* pIccTransform) { - CCodec_IccModule* pIccModule = nullptr; - uint8_t gray; - if (pIccTransform) - pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule(); - for (int col = 0; col < pixel_count; ++col) { - gray = GetGrayWithBlend(pIccTransform, pIccModule, src_scan, dest_scan, - blend_type); - if (clip_scan && clip_scan[col] < 255) - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, clip_scan[col]); - else - *dest_scan = gray; - ++dest_scan; - src_scan += src_Bpp; - } -} - -void CompositeRow_Rgb2Graya(uint8_t* dest_scan, - const uint8_t* src_scan, - int src_Bpp, - int pixel_count, - int blend_type, - const uint8_t* clip_scan, - uint8_t* dest_alpha_scan, - void* pIccTransform) { - CCodec_IccModule* pIccModule = nullptr; - if (pIccTransform) - pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule(); - for (int col = 0; col < pixel_count; ++col) { - if (blend_type && *dest_alpha_scan == 0) { - *dest_scan = GetGray(pIccTransform, pIccModule, src_scan); - ++dest_scan; - ++dest_alpha_scan; - src_scan += src_Bpp; - continue; - } - int src_alpha = clip_scan ? clip_scan[col] : 255; - if (src_alpha == 255) { - *dest_scan = GetGrayWithBlend(pIccTransform, pIccModule, src_scan, - dest_scan, blend_type); - ++dest_scan; - *dest_alpha_scan = 255; - ++dest_alpha_scan; - src_scan += src_Bpp; - continue; - } - if (src_alpha == 0) { - ++dest_scan; - ++dest_alpha_scan; - src_scan += src_Bpp; - continue; - } - int back_alpha = *dest_alpha_scan; - uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255; - *dest_alpha_scan = dest_alpha; - ++dest_alpha_scan; - int alpha_ratio = src_alpha * 255 / dest_alpha; - uint8_t gray = GetGrayWithBlend(pIccTransform, pIccModule, src_scan, - dest_scan, blend_type); - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio); - ++dest_scan; - src_scan += src_Bpp; - } -} - -void CompositeRow_Argb2Argb(uint8_t* dest_scan, - const uint8_t* src_scan, - int pixel_count, - int blend_type, - const uint8_t* clip_scan, - uint8_t* dest_alpha_scan, - const uint8_t* src_alpha_scan) { - int blended_colors[3]; - uint8_t dest_offset = dest_alpha_scan ? 3 : 4; - uint8_t src_offset = src_alpha_scan ? 3 : 4; - bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE; - bool has_src = !!src_alpha_scan; - bool has_dest = !!dest_alpha_scan; - for (int col = 0; col < pixel_count; ++col) { - uint8_t back_alpha = has_dest ? *dest_alpha_scan : dest_scan[3]; - const uint8_t* alpha_source = has_src ? src_alpha_scan++ : &src_scan[3]; - uint8_t src_alpha = GetAlpha(*alpha_source, clip_scan, col); - if (back_alpha == 0) { - if (!has_dest && !has_src) { - if (clip_scan) { - FXARGB_SETDIB(dest_scan, (FXARGB_GETDIB(src_scan) & 0xffffff) | - (src_alpha << 24)); - } else { - FXARGB_COPY(dest_scan, src_scan); - } - } else if (has_dest) { - *dest_alpha_scan = src_alpha; - for (int i = 0; i < 3; ++i) { - *dest_scan = *src_scan++; - ++dest_scan; - } - ++dest_alpha_scan; - if (!has_src) - ++src_scan; - } else { - FXARGB_SETDIB(dest_scan, FXARGB_MAKE((src_alpha << 24), src_scan[2], - src_scan[1], *src_scan)); - } - if (!has_dest) { - dest_scan += dest_offset; - src_scan += src_offset; - } - continue; - } - if (src_alpha == 0) { - dest_scan += dest_offset; - src_scan += src_offset; - if (has_dest) - ++dest_alpha_scan; - continue; - } - uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255; - if (has_dest) { - *dest_alpha_scan = dest_alpha; - ++dest_alpha_scan; - } else { - dest_scan[3] = dest_alpha; - } - int alpha_ratio = src_alpha * 255 / dest_alpha; - if (bNonseparableBlend) - RGB_Blend(blend_type, src_scan, dest_scan, blended_colors); - for (int color = 0; color < 3; ++color) { - if (blend_type) { - int blended = bNonseparableBlend - ? blended_colors[color] - : Blend(blend_type, *dest_scan, *src_scan); - blended = FXDIB_ALPHA_MERGE(*src_scan, blended, back_alpha); - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio); - } else { - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, alpha_ratio); - } - ++dest_scan; - ++src_scan; - } - if (!has_dest) - ++dest_scan; - if (!has_src) - ++src_scan; - } -} - -void CompositeRow_Rgb2Argb_Blend_NoClip(uint8_t* dest_scan, - const uint8_t* src_scan, - int width, - int blend_type, - int src_Bpp, - uint8_t* dest_alpha_scan) { - int blended_colors[3]; - bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE; - int src_gap = src_Bpp - 3; - for (int col = 0; col < width; ++col) { - uint8_t* dest_alpha = dest_alpha_scan ? dest_alpha_scan : &dest_scan[3]; - uint8_t back_alpha = *dest_alpha; - if (back_alpha == 0) { - if (dest_alpha_scan) { - for (int i = 0; i < 3; ++i) { - *dest_scan = *src_scan++; - ++dest_scan; - } - *dest_alpha_scan = 0xff; - ++dest_alpha_scan; - } else { - if (src_Bpp == 4) { - FXARGB_SETDIB(dest_scan, 0xff000000 | FXARGB_GETDIB(src_scan)); - } else { - FXARGB_SETDIB(dest_scan, FXARGB_MAKE(0xff, src_scan[2], src_scan[1], - src_scan[0])); - } - dest_scan += 4; - } - src_scan += src_Bpp; - continue; - } - *dest_alpha = 0xff; - if (bNonseparableBlend) - RGB_Blend(blend_type, src_scan, dest_scan, blended_colors); - for (int color = 0; color < 3; ++color) { - int src_color = *src_scan; - int blended = bNonseparableBlend - ? blended_colors[color] - : Blend(blend_type, *dest_scan, src_color); - *dest_scan = FXDIB_ALPHA_MERGE(src_color, blended, back_alpha); - ++dest_scan; - ++src_scan; - } - if (dest_alpha_scan) - ++dest_alpha_scan; - else - ++dest_scan; - src_scan += src_gap; - } -} - -void CompositeRow_Rgb2Argb_Blend_Clip(uint8_t* dest_scan, - const uint8_t* src_scan, - int width, - int blend_type, - int src_Bpp, - const uint8_t* clip_scan, - uint8_t* dest_alpha_scan) { - int blended_colors[3]; - bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE; - int src_gap = src_Bpp - 3; - bool has_dest = !!dest_alpha_scan; - for (int col = 0; col < width; ++col) { - int src_alpha = *clip_scan++; - uint8_t back_alpha = has_dest ? *dest_alpha_scan : dest_scan[3]; - if (back_alpha == 0) { - for (int i = 0; i < 3; ++i) { - *dest_scan = *src_scan++; - ++dest_scan; - } - src_scan += src_gap; - if (has_dest) - dest_alpha_scan++; - else - dest_scan++; - continue; - } - if (src_alpha == 0) { - dest_scan += has_dest ? 3 : 4; - if (has_dest) - dest_alpha_scan++; - src_scan += src_Bpp; - continue; - } - uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255; - if (has_dest) - *dest_alpha_scan++ = dest_alpha; - else - dest_scan[3] = dest_alpha; - int alpha_ratio = src_alpha * 255 / dest_alpha; - if (bNonseparableBlend) - RGB_Blend(blend_type, src_scan, dest_scan, blended_colors); - for (int color = 0; color < 3; color++) { - int src_color = *src_scan; - int blended = bNonseparableBlend - ? blended_colors[color] - : Blend(blend_type, *dest_scan, src_color); - blended = FXDIB_ALPHA_MERGE(src_color, blended, back_alpha); - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio); - dest_scan++; - src_scan++; - } - src_scan += src_gap; - if (!has_dest) - dest_scan++; - } -} - -void CompositeRow_Rgb2Argb_NoBlend_Clip(uint8_t* dest_scan, - const uint8_t* src_scan, - int width, - int src_Bpp, - const uint8_t* clip_scan, - uint8_t* dest_alpha_scan) { - int src_gap = src_Bpp - 3; - if (dest_alpha_scan) { - for (int col = 0; col < width; col++) { - int src_alpha = clip_scan[col]; - if (src_alpha == 255) { - *dest_scan++ = *src_scan++; - *dest_scan++ = *src_scan++; - *dest_scan++ = *src_scan++; - *dest_alpha_scan++ = 255; - src_scan += src_gap; - continue; - } - if (src_alpha == 0) { - dest_scan += 3; - dest_alpha_scan++; - src_scan += src_Bpp; - continue; - } - int back_alpha = *dest_alpha_scan; - uint8_t dest_alpha = - back_alpha + src_alpha - back_alpha * src_alpha / 255; - *dest_alpha_scan++ = dest_alpha; - int alpha_ratio = src_alpha * 255 / dest_alpha; - for (int color = 0; color < 3; color++) { - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, alpha_ratio); - dest_scan++; - src_scan++; - } - src_scan += src_gap; - } - } else { - for (int col = 0; col < width; col++) { - int src_alpha = clip_scan[col]; - if (src_alpha == 255) { - *dest_scan++ = *src_scan++; - *dest_scan++ = *src_scan++; - *dest_scan++ = *src_scan++; - *dest_scan++ = 255; - src_scan += src_gap; - continue; - } - if (src_alpha == 0) { - dest_scan += 4; - src_scan += src_Bpp; - continue; - } - int back_alpha = dest_scan[3]; - uint8_t dest_alpha = - back_alpha + src_alpha - back_alpha * src_alpha / 255; - dest_scan[3] = dest_alpha; - int alpha_ratio = src_alpha * 255 / dest_alpha; - for (int color = 0; color < 3; color++) { - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, alpha_ratio); - dest_scan++; - src_scan++; - } - dest_scan++; - src_scan += src_gap; - } - } -} - -void CompositeRow_Rgb2Argb_NoBlend_NoClip(uint8_t* dest_scan, - const uint8_t* src_scan, - int width, - int src_Bpp, - uint8_t* dest_alpha_scan) { - if (dest_alpha_scan) { - int src_gap = src_Bpp - 3; - for (int col = 0; col < width; col++) { - *dest_scan++ = *src_scan++; - *dest_scan++ = *src_scan++; - *dest_scan++ = *src_scan++; - *dest_alpha_scan++ = 0xff; - src_scan += src_gap; - } - } else { - for (int col = 0; col < width; col++) { - if (src_Bpp == 4) { - FXARGB_SETDIB(dest_scan, 0xff000000 | FXARGB_GETDIB(src_scan)); - } else { - FXARGB_SETDIB(dest_scan, - FXARGB_MAKE(0xff, src_scan[2], src_scan[1], src_scan[0])); - } - dest_scan += 4; - src_scan += src_Bpp; - } - } -} - -void CompositeRow_Argb2Rgb_Blend(uint8_t* dest_scan, - const uint8_t* src_scan, - int width, - int blend_type, - int dest_Bpp, - const uint8_t* clip_scan, - const uint8_t* src_alpha_scan) { - int blended_colors[3]; - bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE; - int dest_gap = dest_Bpp - 3; - if (src_alpha_scan) { - for (int col = 0; col < width; col++) { - uint8_t src_alpha; - if (clip_scan) { - src_alpha = (*src_alpha_scan++) * (*clip_scan++) / 255; - } else { - src_alpha = *src_alpha_scan++; - } - if (src_alpha == 0) { - dest_scan += dest_Bpp; - src_scan += 3; - continue; - } - if (bNonseparableBlend) { - RGB_Blend(blend_type, src_scan, dest_scan, blended_colors); - } - for (int color = 0; color < 3; color++) { - int back_color = *dest_scan; - int blended = bNonseparableBlend - ? blended_colors[color] - : Blend(blend_type, back_color, *src_scan); - *dest_scan = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha); - dest_scan++; - src_scan++; - } - dest_scan += dest_gap; - } - } else { - for (int col = 0; col < width; col++) { - uint8_t src_alpha; - if (clip_scan) { - src_alpha = src_scan[3] * (*clip_scan++) / 255; - } else { - src_alpha = src_scan[3]; - } - if (src_alpha == 0) { - dest_scan += dest_Bpp; - src_scan += 4; - continue; - } - if (bNonseparableBlend) { - RGB_Blend(blend_type, src_scan, dest_scan, blended_colors); - } - for (int color = 0; color < 3; color++) { - int back_color = *dest_scan; - int blended = bNonseparableBlend - ? blended_colors[color] - : Blend(blend_type, back_color, *src_scan); - *dest_scan = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha); - dest_scan++; - src_scan++; - } - dest_scan += dest_gap; - src_scan++; - } - } -} - -void CompositeRow_Argb2Rgb_NoBlend(uint8_t* dest_scan, - const uint8_t* src_scan, - int width, - int dest_Bpp, - const uint8_t* clip_scan, - const uint8_t* src_alpha_scan) { - int dest_gap = dest_Bpp - 3; - if (src_alpha_scan) { - for (int col = 0; col < width; col++) { - uint8_t src_alpha; - if (clip_scan) { - src_alpha = (*src_alpha_scan++) * (*clip_scan++) / 255; - } else { - src_alpha = *src_alpha_scan++; - } - if (src_alpha == 255) { - *dest_scan++ = *src_scan++; - *dest_scan++ = *src_scan++; - *dest_scan++ = *src_scan++; - dest_scan += dest_gap; - continue; - } - if (src_alpha == 0) { - dest_scan += dest_Bpp; - src_scan += 3; - continue; - } - for (int color = 0; color < 3; color++) { - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, src_alpha); - dest_scan++; - src_scan++; - } - dest_scan += dest_gap; - } - } else { - for (int col = 0; col < width; col++) { - uint8_t src_alpha; - if (clip_scan) { - src_alpha = src_scan[3] * (*clip_scan++) / 255; - } else { - src_alpha = src_scan[3]; - } - if (src_alpha == 255) { - *dest_scan++ = *src_scan++; - *dest_scan++ = *src_scan++; - *dest_scan++ = *src_scan++; - dest_scan += dest_gap; - src_scan++; - continue; - } - if (src_alpha == 0) { - dest_scan += dest_Bpp; - src_scan += 4; - continue; - } - for (int color = 0; color < 3; color++) { - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, src_alpha); - dest_scan++; - src_scan++; - } - dest_scan += dest_gap; - src_scan++; - } - } -} - -void CompositeRow_Rgb2Rgb_Blend_NoClip(uint8_t* dest_scan, - const uint8_t* src_scan, - int width, - int blend_type, - int dest_Bpp, - int src_Bpp) { - int blended_colors[3]; - bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE; - int dest_gap = dest_Bpp - 3; - int src_gap = src_Bpp - 3; - for (int col = 0; col < width; col++) { - if (bNonseparableBlend) { - RGB_Blend(blend_type, src_scan, dest_scan, blended_colors); - } - for (int color = 0; color < 3; color++) { - int back_color = *dest_scan; - int src_color = *src_scan; - int blended = bNonseparableBlend - ? blended_colors[color] - : Blend(blend_type, back_color, src_color); - *dest_scan = blended; - dest_scan++; - src_scan++; - } - dest_scan += dest_gap; - src_scan += src_gap; - } -} - -void CompositeRow_Rgb2Rgb_Blend_Clip(uint8_t* dest_scan, - const uint8_t* src_scan, - int width, - int blend_type, - int dest_Bpp, - int src_Bpp, - const uint8_t* clip_scan) { - int blended_colors[3]; - bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE; - int dest_gap = dest_Bpp - 3; - int src_gap = src_Bpp - 3; - for (int col = 0; col < width; col++) { - uint8_t src_alpha = *clip_scan++; - if (src_alpha == 0) { - dest_scan += dest_Bpp; - src_scan += src_Bpp; - continue; - } - if (bNonseparableBlend) { - RGB_Blend(blend_type, src_scan, dest_scan, blended_colors); - } - for (int color = 0; color < 3; color++) { - int src_color = *src_scan; - int back_color = *dest_scan; - int blended = bNonseparableBlend - ? blended_colors[color] - : Blend(blend_type, back_color, src_color); - *dest_scan = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha); - dest_scan++; - src_scan++; - } - dest_scan += dest_gap; - src_scan += src_gap; - } -} - -void CompositeRow_Rgb2Rgb_NoBlend_NoClip(uint8_t* dest_scan, - const uint8_t* src_scan, - int width, - int dest_Bpp, - int src_Bpp) { - if (dest_Bpp == src_Bpp) { - FXSYS_memcpy(dest_scan, src_scan, width * dest_Bpp); - return; - } - for (int col = 0; col < width; col++) { - dest_scan[0] = src_scan[0]; - dest_scan[1] = src_scan[1]; - dest_scan[2] = src_scan[2]; - dest_scan += dest_Bpp; - src_scan += src_Bpp; - } -} - -void CompositeRow_Rgb2Rgb_NoBlend_Clip(uint8_t* dest_scan, - const uint8_t* src_scan, - int width, - int dest_Bpp, - int src_Bpp, - const uint8_t* clip_scan) { - for (int col = 0; col < width; col++) { - int src_alpha = clip_scan[col]; - if (src_alpha == 255) { - dest_scan[0] = src_scan[0]; - dest_scan[1] = src_scan[1]; - dest_scan[2] = src_scan[2]; - } else if (src_alpha) { - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, src_alpha); - dest_scan++; - src_scan++; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, src_alpha); - dest_scan++; - src_scan++; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, src_alpha); - dest_scan += dest_Bpp - 2; - src_scan += src_Bpp - 2; - continue; - } - dest_scan += dest_Bpp; - src_scan += src_Bpp; - } -} - -void CompositeRow_Argb2Argb_Transform(uint8_t* dest_scan, - const uint8_t* src_scan, - int pixel_count, - int blend_type, - const uint8_t* clip_scan, - uint8_t* dest_alpha_scan, - const uint8_t* src_alpha_scan, - uint8_t* src_cache_scan, - void* pIccTransform) { - uint8_t* dp = src_cache_scan; - CCodec_IccModule* pIccModule = - CFX_GEModule::Get()->GetCodecModule()->GetIccModule(); - if (src_alpha_scan) { - if (dest_alpha_scan) { - pIccModule->TranslateScanline(pIccTransform, dp, src_scan, pixel_count); - } else { - for (int col = 0; col < pixel_count; col++) { - pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1); - dp[3] = *src_alpha_scan++; - src_scan += 3; - dp += 4; - } - src_alpha_scan = nullptr; - } - } else { - if (dest_alpha_scan) { - int blended_colors[3]; - bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE; - for (int col = 0; col < pixel_count; col++) { - pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, - 1); - uint8_t back_alpha = *dest_alpha_scan; - if (back_alpha == 0) { - if (clip_scan) { - int src_alpha = clip_scan[col] * src_scan[3] / 255; - *dest_alpha_scan = src_alpha; - *dest_scan++ = *src_cache_scan++; - *dest_scan++ = *src_cache_scan++; - *dest_scan++ = *src_cache_scan++; - } else { - *dest_alpha_scan = src_scan[3]; - *dest_scan++ = *src_cache_scan++; - *dest_scan++ = *src_cache_scan++; - *dest_scan++ = *src_cache_scan++; - } - dest_alpha_scan++; - src_scan += 4; - continue; - } - uint8_t src_alpha; - if (clip_scan) { - src_alpha = clip_scan[col] * src_scan[3] / 255; - } else { - src_alpha = src_scan[3]; - } - src_scan += 4; - if (src_alpha == 0) { - dest_scan += 3; - src_cache_scan += 3; - dest_alpha_scan++; - continue; - } - uint8_t dest_alpha = - back_alpha + src_alpha - back_alpha * src_alpha / 255; - *dest_alpha_scan++ = dest_alpha; - int alpha_ratio = src_alpha * 255 / dest_alpha; - if (bNonseparableBlend) { - RGB_Blend(blend_type, src_cache_scan, dest_scan, blended_colors); - } - for (int color = 0; color < 3; color++) { - if (blend_type) { - int blended = bNonseparableBlend - ? blended_colors[color] - : Blend(blend_type, *dest_scan, *src_cache_scan); - blended = FXDIB_ALPHA_MERGE(*src_cache_scan, blended, back_alpha); - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio); - } else { - *dest_scan = - FXDIB_ALPHA_MERGE(*dest_scan, *src_cache_scan, alpha_ratio); - } - dest_scan++; - src_cache_scan++; - } - } - return; - } - for (int col = 0; col < pixel_count; col++) { - pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1); - dp[3] = src_scan[3]; - src_scan += 4; - dp += 4; - } - } - CompositeRow_Argb2Argb(dest_scan, src_cache_scan, pixel_count, blend_type, - clip_scan, dest_alpha_scan, src_alpha_scan); -} - -void CompositeRow_Rgb2Argb_Blend_NoClip_Transform(uint8_t* dest_scan, - const uint8_t* src_scan, - int width, - int blend_type, - int src_Bpp, - uint8_t* dest_alpha_scan, - uint8_t* src_cache_scan, - void* pIccTransform) { - CCodec_IccModule* pIccModule = - CFX_GEModule::Get()->GetCodecModule()->GetIccModule(); - if (src_Bpp == 3) { - pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, - width); - } else { - uint8_t* dp = src_cache_scan; - for (int col = 0; col < width; col++) { - pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1); - src_scan += 4; - dp += 3; - } - } - CompositeRow_Rgb2Argb_Blend_NoClip(dest_scan, src_cache_scan, width, - blend_type, 3, dest_alpha_scan); -} - -void CompositeRow_Rgb2Argb_Blend_Clip_Transform(uint8_t* dest_scan, - const uint8_t* src_scan, - int width, - int blend_type, - int src_Bpp, - const uint8_t* clip_scan, - uint8_t* dest_alpha_scan, - uint8_t* src_cache_scan, - void* pIccTransform) { - CCodec_IccModule* pIccModule = - CFX_GEModule::Get()->GetCodecModule()->GetIccModule(); - if (src_Bpp == 3) { - pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, - width); - } else { - uint8_t* dp = src_cache_scan; - for (int col = 0; col < width; col++) { - pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1); - src_scan += 4; - dp += 3; - } - } - CompositeRow_Rgb2Argb_Blend_Clip(dest_scan, src_cache_scan, width, blend_type, - 3, clip_scan, dest_alpha_scan); -} - -void CompositeRow_Rgb2Argb_NoBlend_Clip_Transform(uint8_t* dest_scan, - const uint8_t* src_scan, - int width, - int src_Bpp, - const uint8_t* clip_scan, - uint8_t* dest_alpha_scan, - uint8_t* src_cache_scan, - void* pIccTransform) { - CCodec_IccModule* pIccModule = - CFX_GEModule::Get()->GetCodecModule()->GetIccModule(); - if (src_Bpp == 3) { - pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, - width); - } else { - uint8_t* dp = src_cache_scan; - for (int col = 0; col < width; col++) { - pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1); - src_scan += 4; - dp += 3; - } - } - CompositeRow_Rgb2Argb_NoBlend_Clip(dest_scan, src_cache_scan, width, 3, - clip_scan, dest_alpha_scan); -} - -void CompositeRow_Rgb2Argb_NoBlend_NoClip_Transform(uint8_t* dest_scan, - const uint8_t* src_scan, - int width, - int src_Bpp, - uint8_t* dest_alpha_scan, - uint8_t* src_cache_scan, - void* pIccTransform) { - CCodec_IccModule* pIccModule = - CFX_GEModule::Get()->GetCodecModule()->GetIccModule(); - if (src_Bpp == 3) { - pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, - width); - } else { - uint8_t* dp = src_cache_scan; - for (int col = 0; col < width; col++) { - pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1); - src_scan += 4; - dp += 3; - } - } - CompositeRow_Rgb2Argb_NoBlend_NoClip(dest_scan, src_cache_scan, width, 3, - dest_alpha_scan); -} - -void CompositeRow_Argb2Rgb_Blend_Transform(uint8_t* dest_scan, - const uint8_t* src_scan, - int width, - int blend_type, - int dest_Bpp, - const uint8_t* clip_scan, - const uint8_t* src_alpha_scan, - uint8_t* src_cache_scan, - void* pIccTransform) { - CCodec_IccModule* pIccModule = - CFX_GEModule::Get()->GetCodecModule()->GetIccModule(); - if (src_alpha_scan) { - pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, - width); - } else { - int blended_colors[3]; - bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE; - int dest_gap = dest_Bpp - 3; - for (int col = 0; col < width; col++) { - pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, 1); - uint8_t src_alpha; - if (clip_scan) { - src_alpha = src_scan[3] * (*clip_scan++) / 255; - } else { - src_alpha = src_scan[3]; - } - src_scan += 4; - if (src_alpha == 0) { - dest_scan += dest_Bpp; - src_cache_scan += 3; - continue; - } - if (bNonseparableBlend) { - RGB_Blend(blend_type, src_cache_scan, dest_scan, blended_colors); - } - for (int color = 0; color < 3; color++) { - int back_color = *dest_scan; - int blended = bNonseparableBlend - ? blended_colors[color] - : Blend(blend_type, back_color, *src_cache_scan); - *dest_scan = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha); - dest_scan++; - src_cache_scan++; - } - dest_scan += dest_gap; - } - return; - } - CompositeRow_Argb2Rgb_Blend(dest_scan, src_cache_scan, width, blend_type, - dest_Bpp, clip_scan, src_alpha_scan); -} - -void CompositeRow_Argb2Rgb_NoBlend_Transform(uint8_t* dest_scan, - const uint8_t* src_scan, - int width, - int dest_Bpp, - const uint8_t* clip_scan, - const uint8_t* src_alpha_scan, - uint8_t* src_cache_scan, - void* pIccTransform) { - CCodec_IccModule* pIccModule = - CFX_GEModule::Get()->GetCodecModule()->GetIccModule(); - if (src_alpha_scan) { - pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, - width); - } else { - int dest_gap = dest_Bpp - 3; - for (int col = 0; col < width; col++) { - pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, 1); - uint8_t src_alpha; - if (clip_scan) { - src_alpha = src_scan[3] * (*clip_scan++) / 255; - } else { - src_alpha = src_scan[3]; - } - src_scan += 4; - if (src_alpha == 255) { - *dest_scan++ = *src_cache_scan++; - *dest_scan++ = *src_cache_scan++; - *dest_scan++ = *src_cache_scan++; - dest_scan += dest_gap; - continue; - } - if (src_alpha == 0) { - dest_scan += dest_Bpp; - src_cache_scan += 3; - continue; - } - for (int color = 0; color < 3; color++) { - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_cache_scan, src_alpha); - dest_scan++; - src_cache_scan++; - } - dest_scan += dest_gap; - } - return; - } - CompositeRow_Argb2Rgb_NoBlend(dest_scan, src_cache_scan, width, dest_Bpp, - clip_scan, src_alpha_scan); -} - -void CompositeRow_Rgb2Rgb_Blend_NoClip_Transform(uint8_t* dest_scan, - const uint8_t* src_scan, - int width, - int blend_type, - int dest_Bpp, - int src_Bpp, - uint8_t* src_cache_scan, - void* pIccTransform) { - CCodec_IccModule* pIccModule = - CFX_GEModule::Get()->GetCodecModule()->GetIccModule(); - if (src_Bpp == 3) { - pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, - width); - } else { - uint8_t* dp = src_cache_scan; - for (int col = 0; col < width; col++) { - pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1); - src_scan += 4; - dp += 3; - } - } - CompositeRow_Rgb2Rgb_Blend_NoClip(dest_scan, src_cache_scan, width, - blend_type, dest_Bpp, 3); -} - -void CompositeRow_Rgb2Rgb_Blend_Clip_Transform(uint8_t* dest_scan, - const uint8_t* src_scan, - int width, - int blend_type, - int dest_Bpp, - int src_Bpp, - const uint8_t* clip_scan, - uint8_t* src_cache_scan, - void* pIccTransform) { - CCodec_IccModule* pIccModule = - CFX_GEModule::Get()->GetCodecModule()->GetIccModule(); - if (src_Bpp == 3) { - pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, - width); - } else { - uint8_t* dp = src_cache_scan; - for (int col = 0; col < width; col++) { - pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1); - src_scan += 4; - dp += 3; - } - } - CompositeRow_Rgb2Rgb_Blend_Clip(dest_scan, src_cache_scan, width, blend_type, - dest_Bpp, 3, clip_scan); -} - -void CompositeRow_Rgb2Rgb_NoBlend_NoClip_Transform(uint8_t* dest_scan, - const uint8_t* src_scan, - int width, - int dest_Bpp, - int src_Bpp, - uint8_t* src_cache_scan, - void* pIccTransform) { - CCodec_IccModule* pIccModule = - CFX_GEModule::Get()->GetCodecModule()->GetIccModule(); - if (src_Bpp == 3) { - pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, - width); - } else { - uint8_t* dp = src_cache_scan; - for (int col = 0; col < width; col++) { - pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1); - src_scan += 4; - dp += 3; - } - } - CompositeRow_Rgb2Rgb_NoBlend_NoClip(dest_scan, src_cache_scan, width, - dest_Bpp, 3); -} - -void CompositeRow_Rgb2Rgb_NoBlend_Clip_Transform(uint8_t* dest_scan, - const uint8_t* src_scan, - int width, - int dest_Bpp, - int src_Bpp, - const uint8_t* clip_scan, - uint8_t* src_cache_scan, - void* pIccTransform) { - CCodec_IccModule* pIccModule = - CFX_GEModule::Get()->GetCodecModule()->GetIccModule(); - if (src_Bpp == 3) { - pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, - width); - } else { - uint8_t* dp = src_cache_scan; - for (int col = 0; col < width; col++) { - pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1); - src_scan += 4; - dp += 3; - } - } - CompositeRow_Rgb2Rgb_NoBlend_Clip(dest_scan, src_cache_scan, width, dest_Bpp, - 3, clip_scan); -} - -void CompositeRow_8bppPal2Gray(uint8_t* dest_scan, - const uint8_t* src_scan, - const uint8_t* pPalette, - int pixel_count, - int blend_type, - const uint8_t* clip_scan, - const uint8_t* src_alpha_scan) { - if (src_alpha_scan) { - if (blend_type) { - bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE; - for (int col = 0; col < pixel_count; col++) { - uint8_t gray = pPalette[*src_scan]; - int src_alpha = GetAlpha(*src_alpha_scan++, clip_scan, col); - if (bNonseparableBlend) - gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan; - else - gray = Blend(blend_type, *dest_scan, gray); - if (src_alpha) - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, src_alpha); - else - *dest_scan = gray; - dest_scan++; - src_scan++; - } - return; - } - for (int col = 0; col < pixel_count; col++) { - uint8_t gray = pPalette[*src_scan]; - int src_alpha = GetAlpha(*src_alpha_scan++, clip_scan, col); - if (src_alpha) - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, src_alpha); - else - *dest_scan = gray; - dest_scan++; - src_scan++; - } - } else { - if (blend_type) { - bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE; - for (int col = 0; col < pixel_count; col++) { - uint8_t gray = pPalette[*src_scan]; - if (bNonseparableBlend) - gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan; - else - gray = Blend(blend_type, *dest_scan, gray); - if (clip_scan && clip_scan[col] < 255) - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, clip_scan[col]); - else - *dest_scan = gray; - dest_scan++; - src_scan++; - } - return; - } - for (int col = 0; col < pixel_count; col++) { - uint8_t gray = pPalette[*src_scan]; - if (clip_scan && clip_scan[col] < 255) - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, clip_scan[col]); - else - *dest_scan = gray; - dest_scan++; - src_scan++; - } - } -} - -void CompositeRow_8bppPal2Graya(uint8_t* dest_scan, - const uint8_t* src_scan, - const uint8_t* pPalette, - int pixel_count, - int blend_type, - const uint8_t* clip_scan, - uint8_t* dest_alpha_scan, - const uint8_t* src_alpha_scan) { - if (src_alpha_scan) { - if (blend_type) { - bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE; - for (int col = 0; col < pixel_count; col++) { - uint8_t gray = pPalette[*src_scan]; - src_scan++; - uint8_t back_alpha = *dest_alpha_scan; - if (back_alpha == 0) { - int src_alpha = GetAlpha(*src_alpha_scan++, clip_scan, col); - if (src_alpha) { - *dest_scan = gray; - *dest_alpha_scan = src_alpha; - } - dest_scan++; - dest_alpha_scan++; - continue; - } - uint8_t src_alpha = GetAlpha(*src_alpha_scan++, clip_scan, col); - if (src_alpha == 0) { - dest_scan++; - dest_alpha_scan++; - continue; - } - *dest_alpha_scan = - back_alpha + src_alpha - back_alpha * src_alpha / 255; - int alpha_ratio = src_alpha * 255 / (*dest_alpha_scan); - if (bNonseparableBlend) - gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan; - else - gray = Blend(blend_type, *dest_scan, gray); - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio); - dest_alpha_scan++; - dest_scan++; - } - return; - } - for (int col = 0; col < pixel_count; col++) { - uint8_t gray = pPalette[*src_scan]; - src_scan++; - uint8_t back_alpha = *dest_alpha_scan; - if (back_alpha == 0) { - int src_alpha = GetAlpha(*src_alpha_scan++, clip_scan, col); - if (src_alpha) { - *dest_scan = gray; - *dest_alpha_scan = src_alpha; - } - dest_scan++; - dest_alpha_scan++; - continue; - } - uint8_t src_alpha = GetAlpha(*src_alpha_scan++, clip_scan, col); - if (src_alpha == 0) { - dest_scan++; - dest_alpha_scan++; - continue; - } - *dest_alpha_scan = back_alpha + src_alpha - back_alpha * src_alpha / 255; - int alpha_ratio = src_alpha * 255 / (*dest_alpha_scan); - dest_alpha_scan++; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio); - dest_scan++; - } - } else { - if (blend_type) { - bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE; - for (int col = 0; col < pixel_count; col++) { - uint8_t gray = pPalette[*src_scan]; - src_scan++; - if (!clip_scan || clip_scan[col] == 255) { - *dest_scan++ = gray; - *dest_alpha_scan++ = 255; - continue; - } - int src_alpha = clip_scan[col]; - if (src_alpha == 0) { - dest_scan++; - dest_alpha_scan++; - continue; - } - int back_alpha = *dest_alpha_scan; - uint8_t dest_alpha = - back_alpha + src_alpha - back_alpha * src_alpha / 255; - *dest_alpha_scan++ = dest_alpha; - int alpha_ratio = src_alpha * 255 / dest_alpha; - if (bNonseparableBlend) - gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan; - else - gray = Blend(blend_type, *dest_scan, gray); - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio); - dest_scan++; - } - return; - } - for (int col = 0; col < pixel_count; col++) { - uint8_t gray = pPalette[*src_scan]; - src_scan++; - if (!clip_scan || clip_scan[col] == 255) { - *dest_scan++ = gray; - *dest_alpha_scan++ = 255; - continue; - } - int src_alpha = clip_scan[col]; - if (src_alpha == 0) { - dest_scan++; - dest_alpha_scan++; - continue; - } - int back_alpha = *dest_alpha_scan; - uint8_t dest_alpha = - back_alpha + src_alpha - back_alpha * src_alpha / 255; - *dest_alpha_scan++ = dest_alpha; - int alpha_ratio = src_alpha * 255 / dest_alpha; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio); - dest_scan++; - } - } -} - -void CompositeRow_1bppPal2Gray(uint8_t* dest_scan, - const uint8_t* src_scan, - int src_left, - const uint8_t* pPalette, - int pixel_count, - int blend_type, - const uint8_t* clip_scan) { - int reset_gray = pPalette[0]; - int set_gray = pPalette[1]; - if (blend_type) { - bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE; - for (int col = 0; col < pixel_count; col++) { - uint8_t gray = - (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8))) - ? set_gray - : reset_gray; - if (bNonseparableBlend) - gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan; - else - gray = Blend(blend_type, *dest_scan, gray); - if (clip_scan && clip_scan[col] < 255) { - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, clip_scan[col]); - } else { - *dest_scan = gray; - } - dest_scan++; - } - return; - } - for (int col = 0; col < pixel_count; col++) { - uint8_t gray = - (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8))) - ? set_gray - : reset_gray; - if (clip_scan && clip_scan[col] < 255) { - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, clip_scan[col]); - } else { - *dest_scan = gray; - } - dest_scan++; - } -} - -void CompositeRow_1bppPal2Graya(uint8_t* dest_scan, - const uint8_t* src_scan, - int src_left, - const uint8_t* pPalette, - int pixel_count, - int blend_type, - const uint8_t* clip_scan, - uint8_t* dest_alpha_scan) { - int reset_gray = pPalette[0]; - int set_gray = pPalette[1]; - if (blend_type) { - bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE; - for (int col = 0; col < pixel_count; col++) { - uint8_t gray = - (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8))) - ? set_gray - : reset_gray; - if (!clip_scan || clip_scan[col] == 255) { - *dest_scan++ = gray; - *dest_alpha_scan++ = 255; - continue; - } - int src_alpha = clip_scan[col]; - if (src_alpha == 0) { - dest_scan++; - dest_alpha_scan++; - continue; - } - int back_alpha = *dest_alpha_scan; - uint8_t dest_alpha = - back_alpha + src_alpha - back_alpha * src_alpha / 255; - *dest_alpha_scan++ = dest_alpha; - int alpha_ratio = src_alpha * 255 / dest_alpha; - if (bNonseparableBlend) - gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan; - else - gray = Blend(blend_type, *dest_scan, gray); - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio); - dest_scan++; - } - return; - } - for (int col = 0; col < pixel_count; col++) { - uint8_t gray = - (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8))) - ? set_gray - : reset_gray; - if (!clip_scan || clip_scan[col] == 255) { - *dest_scan++ = gray; - *dest_alpha_scan++ = 255; - continue; - } - int src_alpha = clip_scan[col]; - if (src_alpha == 0) { - dest_scan++; - dest_alpha_scan++; - continue; - } - int back_alpha = *dest_alpha_scan; - uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255; - *dest_alpha_scan++ = dest_alpha; - int alpha_ratio = src_alpha * 255 / dest_alpha; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio); - dest_scan++; - } -} - -void CompositeRow_8bppRgb2Rgb_NoBlend(uint8_t* dest_scan, - const uint8_t* src_scan, - uint32_t* pPalette, - int pixel_count, - int DestBpp, - const uint8_t* clip_scan, - const uint8_t* src_alpha_scan) { - if (src_alpha_scan) { - int dest_gap = DestBpp - 3; - FX_ARGB argb = 0; - for (int col = 0; col < pixel_count; col++) { - argb = pPalette[*src_scan]; - int src_r = FXARGB_R(argb); - int src_g = FXARGB_G(argb); - int src_b = FXARGB_B(argb); - src_scan++; - uint8_t src_alpha = 0; - if (clip_scan) { - src_alpha = (*src_alpha_scan++) * (*clip_scan++) / 255; - } else { - src_alpha = *src_alpha_scan++; - } - if (src_alpha == 255) { - *dest_scan++ = src_b; - *dest_scan++ = src_g; - *dest_scan++ = src_r; - dest_scan += dest_gap; - continue; - } - if (src_alpha == 0) { - dest_scan += DestBpp; - continue; - } - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, src_alpha); - dest_scan++; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, src_alpha); - dest_scan++; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, src_alpha); - dest_scan++; - dest_scan += dest_gap; - } - } else { - FX_ARGB argb = 0; - for (int col = 0; col < pixel_count; col++) { - argb = pPalette[*src_scan]; - int src_r = FXARGB_R(argb); - int src_g = FXARGB_G(argb); - int src_b = FXARGB_B(argb); - if (clip_scan && clip_scan[col] < 255) { - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, clip_scan[col]); - dest_scan++; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, clip_scan[col]); - dest_scan++; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, clip_scan[col]); - dest_scan++; - } else { - *dest_scan++ = src_b; - *dest_scan++ = src_g; - *dest_scan++ = src_r; - } - if (DestBpp == 4) { - dest_scan++; - } - src_scan++; - } - } -} - -void CompositeRow_1bppRgb2Rgb_NoBlend(uint8_t* dest_scan, - const uint8_t* src_scan, - int src_left, - uint32_t* pPalette, - int pixel_count, - int DestBpp, - const uint8_t* clip_scan) { - int reset_r, reset_g, reset_b; - int set_r, set_g, set_b; - reset_r = FXARGB_R(pPalette[0]); - reset_g = FXARGB_G(pPalette[0]); - reset_b = FXARGB_B(pPalette[0]); - set_r = FXARGB_R(pPalette[1]); - set_g = FXARGB_G(pPalette[1]); - set_b = FXARGB_B(pPalette[1]); - for (int col = 0; col < pixel_count; col++) { - int src_r, src_g, src_b; - if (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8))) { - src_r = set_r; - src_g = set_g; - src_b = set_b; - } else { - src_r = reset_r; - src_g = reset_g; - src_b = reset_b; - } - if (clip_scan && clip_scan[col] < 255) { - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, clip_scan[col]); - dest_scan++; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, clip_scan[col]); - dest_scan++; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, clip_scan[col]); - dest_scan++; - } else { - *dest_scan++ = src_b; - *dest_scan++ = src_g; - *dest_scan++ = src_r; - } - if (DestBpp == 4) { - dest_scan++; - } - } -} - -void CompositeRow_8bppRgb2Argb_NoBlend(uint8_t* dest_scan, - const uint8_t* src_scan, - int width, - uint32_t* pPalette, - const uint8_t* clip_scan, - const uint8_t* src_alpha_scan) { - if (src_alpha_scan) { - for (int col = 0; col < width; col++) { - FX_ARGB argb = pPalette[*src_scan]; - src_scan++; - int src_r = FXARGB_R(argb); - int src_g = FXARGB_G(argb); - int src_b = FXARGB_B(argb); - uint8_t back_alpha = dest_scan[3]; - if (back_alpha == 0) { - if (clip_scan) { - int src_alpha = clip_scan[col] * (*src_alpha_scan) / 255; - FXARGB_SETDIB(dest_scan, FXARGB_MAKE(src_alpha, src_r, src_g, src_b)); - } else { - FXARGB_SETDIB(dest_scan, - FXARGB_MAKE(*src_alpha_scan, src_r, src_g, src_b)); - } - dest_scan += 4; - src_alpha_scan++; - continue; - } - uint8_t src_alpha; - if (clip_scan) { - src_alpha = clip_scan[col] * (*src_alpha_scan++) / 255; - } else { - src_alpha = *src_alpha_scan++; - } - if (src_alpha == 0) { - dest_scan += 4; - continue; - } - uint8_t dest_alpha = - back_alpha + src_alpha - back_alpha * src_alpha / 255; - dest_scan[3] = dest_alpha; - int alpha_ratio = src_alpha * 255 / dest_alpha; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio); - dest_scan++; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio); - dest_scan++; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio); - dest_scan++; - dest_scan++; - } - } else { - for (int col = 0; col < width; col++) { - FX_ARGB argb = pPalette[*src_scan]; - int src_r = FXARGB_R(argb); - int src_g = FXARGB_G(argb); - int src_b = FXARGB_B(argb); - if (!clip_scan || clip_scan[col] == 255) { - *dest_scan++ = src_b; - *dest_scan++ = src_g; - *dest_scan++ = src_r; - *dest_scan++ = 255; - src_scan++; - continue; - } - int src_alpha = clip_scan[col]; - if (src_alpha == 0) { - dest_scan += 4; - src_scan++; - continue; - } - int back_alpha = dest_scan[3]; - uint8_t dest_alpha = - back_alpha + src_alpha - back_alpha * src_alpha / 255; - dest_scan[3] = dest_alpha; - int alpha_ratio = src_alpha * 255 / dest_alpha; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio); - dest_scan++; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio); - dest_scan++; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio); - dest_scan++; - dest_scan++; - src_scan++; - } - } -} - -void CompositeRow_1bppRgb2Argb_NoBlend(uint8_t* dest_scan, - const uint8_t* src_scan, - int src_left, - int width, - uint32_t* pPalette, - const uint8_t* clip_scan) { - int reset_r, reset_g, reset_b; - int set_r, set_g, set_b; - reset_r = FXARGB_R(pPalette[0]); - reset_g = FXARGB_G(pPalette[0]); - reset_b = FXARGB_B(pPalette[0]); - set_r = FXARGB_R(pPalette[1]); - set_g = FXARGB_G(pPalette[1]); - set_b = FXARGB_B(pPalette[1]); - for (int col = 0; col < width; col++) { - int src_r, src_g, src_b; - if (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8))) { - src_r = set_r; - src_g = set_g; - src_b = set_b; - } else { - src_r = reset_r; - src_g = reset_g; - src_b = reset_b; - } - if (!clip_scan || clip_scan[col] == 255) { - *dest_scan++ = src_b; - *dest_scan++ = src_g; - *dest_scan++ = src_r; - *dest_scan++ = 255; - continue; - } - int src_alpha = clip_scan[col]; - if (src_alpha == 0) { - dest_scan += 4; - continue; - } - int back_alpha = dest_scan[3]; - uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255; - dest_scan[3] = dest_alpha; - int alpha_ratio = src_alpha * 255 / dest_alpha; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio); - dest_scan++; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio); - dest_scan++; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio); - dest_scan++; - dest_scan++; - } -} - -void CompositeRow_1bppRgb2Rgba_NoBlend(uint8_t* dest_scan, - const uint8_t* src_scan, - int src_left, - int width, - uint32_t* pPalette, - const uint8_t* clip_scan, - uint8_t* dest_alpha_scan) { - int reset_r, reset_g, reset_b; - int set_r, set_g, set_b; - reset_r = FXARGB_R(pPalette[0]); - reset_g = FXARGB_G(pPalette[0]); - reset_b = FXARGB_B(pPalette[0]); - set_r = FXARGB_R(pPalette[1]); - set_g = FXARGB_G(pPalette[1]); - set_b = FXARGB_B(pPalette[1]); - for (int col = 0; col < width; col++) { - int src_r, src_g, src_b; - if (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8))) { - src_r = set_r; - src_g = set_g; - src_b = set_b; - } else { - src_r = reset_r; - src_g = reset_g; - src_b = reset_b; - } - if (!clip_scan || clip_scan[col] == 255) { - *dest_scan++ = src_b; - *dest_scan++ = src_g; - *dest_scan++ = src_r; - *dest_alpha_scan++ = 255; - continue; - } - int src_alpha = clip_scan[col]; - if (src_alpha == 0) { - dest_scan += 3; - dest_alpha_scan++; - continue; - } - int back_alpha = *dest_alpha_scan; - uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255; - *dest_alpha_scan++ = dest_alpha; - int alpha_ratio = src_alpha * 255 / dest_alpha; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio); - dest_scan++; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio); - dest_scan++; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio); - dest_scan++; - } -} - -void CompositeRow_ByteMask2Argb(uint8_t* dest_scan, - const uint8_t* src_scan, - int mask_alpha, - int src_r, - int src_g, - int src_b, - int pixel_count, - int blend_type, - const uint8_t* clip_scan) { - for (int col = 0; col < pixel_count; col++) { - int src_alpha; - if (clip_scan) { - src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255; - } else { - src_alpha = mask_alpha * src_scan[col] / 255; - } - uint8_t back_alpha = dest_scan[3]; - if (back_alpha == 0) { - FXARGB_SETDIB(dest_scan, FXARGB_MAKE(src_alpha, src_r, src_g, src_b)); - dest_scan += 4; - continue; - } - if (src_alpha == 0) { - dest_scan += 4; - continue; - } - uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255; - dest_scan[3] = dest_alpha; - int alpha_ratio = src_alpha * 255 / dest_alpha; - if (blend_type >= FXDIB_BLEND_NONSEPARABLE) { - int blended_colors[3]; - uint8_t scan[3] = {static_cast<uint8_t>(src_b), - static_cast<uint8_t>(src_g), - static_cast<uint8_t>(src_r)}; - RGB_Blend(blend_type, scan, dest_scan, blended_colors); - *dest_scan = - FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[0], alpha_ratio); - dest_scan++; - *dest_scan = - FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[1], alpha_ratio); - dest_scan++; - *dest_scan = - FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[2], alpha_ratio); - } else if (blend_type) { - int blended = Blend(blend_type, *dest_scan, src_b); - blended = FXDIB_ALPHA_MERGE(src_b, blended, back_alpha); - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio); - dest_scan++; - blended = Blend(blend_type, *dest_scan, src_g); - blended = FXDIB_ALPHA_MERGE(src_g, blended, back_alpha); - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio); - dest_scan++; - blended = Blend(blend_type, *dest_scan, src_r); - blended = FXDIB_ALPHA_MERGE(src_r, blended, back_alpha); - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio); - } else { - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio); - dest_scan++; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio); - dest_scan++; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio); - } - dest_scan += 2; - } -} - -void CompositeRow_ByteMask2Rgba(uint8_t* dest_scan, - const uint8_t* src_scan, - int mask_alpha, - int src_r, - int src_g, - int src_b, - int pixel_count, - int blend_type, - const uint8_t* clip_scan, - uint8_t* dest_alpha_scan) { - for (int col = 0; col < pixel_count; col++) { - int src_alpha; - if (clip_scan) { - src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255; - } else { - src_alpha = mask_alpha * src_scan[col] / 255; - } - uint8_t back_alpha = *dest_alpha_scan; - if (back_alpha == 0) { - *dest_scan++ = src_b; - *dest_scan++ = src_g; - *dest_scan++ = src_r; - *dest_alpha_scan++ = src_alpha; - continue; - } - if (src_alpha == 0) { - dest_scan += 3; - dest_alpha_scan++; - continue; - } - uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255; - *dest_alpha_scan++ = dest_alpha; - int alpha_ratio = src_alpha * 255 / dest_alpha; - if (blend_type >= FXDIB_BLEND_NONSEPARABLE) { - int blended_colors[3]; - uint8_t scan[3] = {static_cast<uint8_t>(src_b), - static_cast<uint8_t>(src_g), - static_cast<uint8_t>(src_r)}; - RGB_Blend(blend_type, scan, dest_scan, blended_colors); - *dest_scan = - FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[0], alpha_ratio); - dest_scan++; - *dest_scan = - FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[1], alpha_ratio); - dest_scan++; - *dest_scan = - FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[2], alpha_ratio); - dest_scan++; - } else if (blend_type) { - int blended = Blend(blend_type, *dest_scan, src_b); - blended = FXDIB_ALPHA_MERGE(src_b, blended, back_alpha); - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio); - dest_scan++; - blended = Blend(blend_type, *dest_scan, src_g); - blended = FXDIB_ALPHA_MERGE(src_g, blended, back_alpha); - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio); - dest_scan++; - blended = Blend(blend_type, *dest_scan, src_r); - blended = FXDIB_ALPHA_MERGE(src_r, blended, back_alpha); - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio); - dest_scan++; - } else { - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio); - dest_scan++; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio); - dest_scan++; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio); - dest_scan++; - } - } -} - -void CompositeRow_ByteMask2Rgb(uint8_t* dest_scan, - const uint8_t* src_scan, - int mask_alpha, - int src_r, - int src_g, - int src_b, - int pixel_count, - int blend_type, - int Bpp, - const uint8_t* clip_scan) { - for (int col = 0; col < pixel_count; col++) { - int src_alpha; - if (clip_scan) { - src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255; - } else { - src_alpha = mask_alpha * src_scan[col] / 255; - } - if (src_alpha == 0) { - dest_scan += Bpp; - continue; - } - if (blend_type >= FXDIB_BLEND_NONSEPARABLE) { - int blended_colors[3]; - uint8_t scan[3] = {static_cast<uint8_t>(src_b), - static_cast<uint8_t>(src_g), - static_cast<uint8_t>(src_r)}; - RGB_Blend(blend_type, scan, dest_scan, blended_colors); - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[0], src_alpha); - dest_scan++; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[1], src_alpha); - dest_scan++; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[2], src_alpha); - } else if (blend_type) { - int blended = Blend(blend_type, *dest_scan, src_b); - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, src_alpha); - dest_scan++; - blended = Blend(blend_type, *dest_scan, src_g); - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, src_alpha); - dest_scan++; - blended = Blend(blend_type, *dest_scan, src_r); - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, src_alpha); - } else { - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, src_alpha); - dest_scan++; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, src_alpha); - dest_scan++; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, src_alpha); - } - dest_scan += Bpp - 2; - } -} - -void CompositeRow_ByteMask2Mask(uint8_t* dest_scan, - const uint8_t* src_scan, - int mask_alpha, - int pixel_count, - const uint8_t* clip_scan) { - for (int col = 0; col < pixel_count; col++) { - int src_alpha; - if (clip_scan) { - src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255; - } else { - src_alpha = mask_alpha * src_scan[col] / 255; - } - uint8_t back_alpha = *dest_scan; - if (!back_alpha) { - *dest_scan = src_alpha; - } else if (src_alpha) { - *dest_scan = back_alpha + src_alpha - back_alpha * src_alpha / 255; - } - dest_scan++; - } -} - -void CompositeRow_ByteMask2Gray(uint8_t* dest_scan, - const uint8_t* src_scan, - int mask_alpha, - int src_gray, - int pixel_count, - const uint8_t* clip_scan) { - for (int col = 0; col < pixel_count; col++) { - int src_alpha; - if (clip_scan) { - src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255; - } else { - src_alpha = mask_alpha * src_scan[col] / 255; - } - if (src_alpha) { - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_gray, src_alpha); - } - dest_scan++; - } -} - -void CompositeRow_ByteMask2Graya(uint8_t* dest_scan, - const uint8_t* src_scan, - int mask_alpha, - int src_gray, - int pixel_count, - const uint8_t* clip_scan, - uint8_t* dest_alpha_scan) { - for (int col = 0; col < pixel_count; col++) { - int src_alpha; - if (clip_scan) { - src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255; - } else { - src_alpha = mask_alpha * src_scan[col] / 255; - } - uint8_t back_alpha = *dest_alpha_scan; - if (back_alpha == 0) { - *dest_scan++ = src_gray; - *dest_alpha_scan++ = src_alpha; - continue; - } - if (src_alpha == 0) { - dest_scan++; - dest_alpha_scan++; - continue; - } - uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255; - *dest_alpha_scan++ = dest_alpha; - int alpha_ratio = src_alpha * 255 / dest_alpha; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_gray, alpha_ratio); - dest_scan++; - } -} - -void CompositeRow_BitMask2Argb(uint8_t* dest_scan, - const uint8_t* src_scan, - int mask_alpha, - int src_r, - int src_g, - int src_b, - int src_left, - int pixel_count, - int blend_type, - const uint8_t* clip_scan) { - if (blend_type == FXDIB_BLEND_NORMAL && !clip_scan && mask_alpha == 255) { - FX_ARGB argb = FXARGB_MAKE(0xff, src_r, src_g, src_b); - for (int col = 0; col < pixel_count; col++) { - if (src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8))) { - FXARGB_SETDIB(dest_scan, argb); - } - dest_scan += 4; - } - return; - } - for (int col = 0; col < pixel_count; col++) { - if (!(src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8)))) { - dest_scan += 4; - continue; - } - int src_alpha; - if (clip_scan) { - src_alpha = mask_alpha * clip_scan[col] / 255; - } else { - src_alpha = mask_alpha; - } - uint8_t back_alpha = dest_scan[3]; - if (back_alpha == 0) { - FXARGB_SETDIB(dest_scan, FXARGB_MAKE(src_alpha, src_r, src_g, src_b)); - dest_scan += 4; - continue; - } - uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255; - dest_scan[3] = dest_alpha; - int alpha_ratio = src_alpha * 255 / dest_alpha; - if (blend_type >= FXDIB_BLEND_NONSEPARABLE) { - int blended_colors[3]; - uint8_t scan[3] = {static_cast<uint8_t>(src_b), - static_cast<uint8_t>(src_g), - static_cast<uint8_t>(src_r)}; - RGB_Blend(blend_type, scan, dest_scan, blended_colors); - *dest_scan = - FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[0], alpha_ratio); - dest_scan++; - *dest_scan = - FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[1], alpha_ratio); - dest_scan++; - *dest_scan = - FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[2], alpha_ratio); - } else if (blend_type) { - int blended = Blend(blend_type, *dest_scan, src_b); - blended = FXDIB_ALPHA_MERGE(src_b, blended, back_alpha); - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio); - dest_scan++; - blended = Blend(blend_type, *dest_scan, src_g); - blended = FXDIB_ALPHA_MERGE(src_g, blended, back_alpha); - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio); - dest_scan++; - blended = Blend(blend_type, *dest_scan, src_r); - blended = FXDIB_ALPHA_MERGE(src_r, blended, back_alpha); - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio); - } else { - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio); - dest_scan++; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio); - dest_scan++; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio); - } - dest_scan += 2; - } -} - -void CompositeRow_BitMask2Rgb(uint8_t* dest_scan, - const uint8_t* src_scan, - int mask_alpha, - int src_r, - int src_g, - int src_b, - int src_left, - int pixel_count, - int blend_type, - int Bpp, - const uint8_t* clip_scan) { - if (blend_type == FXDIB_BLEND_NORMAL && !clip_scan && mask_alpha == 255) { - for (int col = 0; col < pixel_count; col++) { - if (src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8))) { - dest_scan[2] = src_r; - dest_scan[1] = src_g; - dest_scan[0] = src_b; - } - dest_scan += Bpp; - } - return; - } - for (int col = 0; col < pixel_count; col++) { - if (!(src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8)))) { - dest_scan += Bpp; - continue; - } - int src_alpha; - if (clip_scan) { - src_alpha = mask_alpha * clip_scan[col] / 255; - } else { - src_alpha = mask_alpha; - } - if (src_alpha == 0) { - dest_scan += Bpp; - continue; - } - if (blend_type >= FXDIB_BLEND_NONSEPARABLE) { - int blended_colors[3]; - uint8_t scan[3] = {static_cast<uint8_t>(src_b), - static_cast<uint8_t>(src_g), - static_cast<uint8_t>(src_r)}; - RGB_Blend(blend_type, scan, dest_scan, blended_colors); - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[0], src_alpha); - dest_scan++; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[1], src_alpha); - dest_scan++; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[2], src_alpha); - } else if (blend_type) { - int blended = Blend(blend_type, *dest_scan, src_b); - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, src_alpha); - dest_scan++; - blended = Blend(blend_type, *dest_scan, src_g); - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, src_alpha); - dest_scan++; - blended = Blend(blend_type, *dest_scan, src_r); - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, src_alpha); - } else { - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, src_alpha); - dest_scan++; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, src_alpha); - dest_scan++; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, src_alpha); - } - dest_scan += Bpp - 2; - } -} - -void CompositeRow_BitMask2Mask(uint8_t* dest_scan, - const uint8_t* src_scan, - int mask_alpha, - int src_left, - int pixel_count, - const uint8_t* clip_scan) { - for (int col = 0; col < pixel_count; col++) { - if (!(src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8)))) { - dest_scan++; - continue; - } - int src_alpha; - if (clip_scan) { - src_alpha = mask_alpha * clip_scan[col] / 255; - } else { - src_alpha = mask_alpha; - } - uint8_t back_alpha = *dest_scan; - if (!back_alpha) { - *dest_scan = src_alpha; - } else if (src_alpha) { - *dest_scan = back_alpha + src_alpha - back_alpha * src_alpha / 255; - } - dest_scan++; - } -} - -void CompositeRow_BitMask2Gray(uint8_t* dest_scan, - const uint8_t* src_scan, - int mask_alpha, - int src_gray, - int src_left, - int pixel_count, - const uint8_t* clip_scan) { - for (int col = 0; col < pixel_count; col++) { - if (!(src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8)))) { - dest_scan++; - continue; - } - int src_alpha; - if (clip_scan) { - src_alpha = mask_alpha * clip_scan[col] / 255; - } else { - src_alpha = mask_alpha; - } - if (src_alpha) { - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_gray, src_alpha); - } - dest_scan++; - } -} - -void CompositeRow_BitMask2Graya(uint8_t* dest_scan, - const uint8_t* src_scan, - int mask_alpha, - int src_gray, - int src_left, - int pixel_count, - const uint8_t* clip_scan, - uint8_t* dest_alpha_scan) { - for (int col = 0; col < pixel_count; col++) { - if (!(src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8)))) { - dest_scan++; - dest_alpha_scan++; - continue; - } - int src_alpha; - if (clip_scan) { - src_alpha = mask_alpha * clip_scan[col] / 255; - } else { - src_alpha = mask_alpha; - } - uint8_t back_alpha = *dest_alpha_scan; - if (back_alpha == 0) { - *dest_scan++ = src_gray; - *dest_alpha_scan++ = src_alpha; - continue; - } - if (src_alpha == 0) { - dest_scan++; - dest_alpha_scan++; - continue; - } - uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255; - *dest_alpha_scan++ = dest_alpha; - int alpha_ratio = src_alpha * 255 / dest_alpha; - *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_gray, alpha_ratio); - dest_scan++; - } -} - -void CompositeRow_Argb2Argb_RgbByteOrder(uint8_t* dest_scan, - const uint8_t* src_scan, - int pixel_count, - int blend_type, - const uint8_t* clip_scan) { - int blended_colors[3]; - bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE; - for (int col = 0; col < pixel_count; col++) { - uint8_t back_alpha = dest_scan[3]; - if (back_alpha == 0) { - if (clip_scan) { - int src_alpha = clip_scan[col] * src_scan[3] / 255; - dest_scan[3] = src_alpha; - dest_scan[0] = src_scan[2]; - dest_scan[1] = src_scan[1]; - dest_scan[2] = src_scan[0]; - } else { - FXARGB_RGBORDERCOPY(dest_scan, src_scan); - } - dest_scan += 4; - src_scan += 4; - continue; - } - uint8_t src_alpha; - if (clip_scan) { - src_alpha = clip_scan[col] * src_scan[3] / 255; - } else { - src_alpha = src_scan[3]; - } - if (src_alpha == 0) { - dest_scan += 4; - src_scan += 4; - continue; - } - uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255; - dest_scan[3] = dest_alpha; - int alpha_ratio = src_alpha * 255 / dest_alpha; - if (bNonseparableBlend) { - uint8_t dest_scan_o[3]; - dest_scan_o[0] = dest_scan[2]; - dest_scan_o[1] = dest_scan[1]; - dest_scan_o[2] = dest_scan[0]; - RGB_Blend(blend_type, src_scan, dest_scan_o, blended_colors); - } - for (int color = 0; color < 3; color++) { - int index = 2 - color; - if (blend_type) { - int blended = bNonseparableBlend - ? blended_colors[color] - : Blend(blend_type, dest_scan[index], *src_scan); - blended = FXDIB_ALPHA_MERGE(*src_scan, blended, back_alpha); - dest_scan[index] = - FXDIB_ALPHA_MERGE(dest_scan[index], blended, alpha_ratio); - } else { - dest_scan[index] = - FXDIB_ALPHA_MERGE(dest_scan[index], *src_scan, alpha_ratio); - } - src_scan++; - } - dest_scan += 4; - src_scan++; - } -} - -void CompositeRow_Rgb2Argb_Blend_NoClip_RgbByteOrder(uint8_t* dest_scan, - const uint8_t* src_scan, - int width, - int blend_type, - int src_Bpp) { - int blended_colors[3]; - bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE; - int src_gap = src_Bpp - 3; - for (int col = 0; col < width; col++) { - uint8_t back_alpha = dest_scan[3]; - if (back_alpha == 0) { - if (src_Bpp == 4) { - FXARGB_SETRGBORDERDIB(dest_scan, 0xff000000 | FXARGB_GETDIB(src_scan)); - } else { - FXARGB_SETRGBORDERDIB(dest_scan, FXARGB_MAKE(0xff, src_scan[2], - src_scan[1], src_scan[0])); - } - dest_scan += 4; - src_scan += src_Bpp; - continue; - } - dest_scan[3] = 0xff; - if (bNonseparableBlend) { - uint8_t dest_scan_o[3]; - dest_scan_o[0] = dest_scan[2]; - dest_scan_o[1] = dest_scan[1]; - dest_scan_o[2] = dest_scan[0]; - RGB_Blend(blend_type, src_scan, dest_scan_o, blended_colors); - } - for (int color = 0; color < 3; color++) { - int index = 2 - color; - int src_color = *src_scan; - int blended = bNonseparableBlend - ? blended_colors[color] - : Blend(blend_type, dest_scan[index], src_color); - dest_scan[index] = FXDIB_ALPHA_MERGE(src_color, blended, back_alpha); - src_scan++; - } - dest_scan += 4; - src_scan += src_gap; - } -} - -void CompositeRow_Argb2Rgb_Blend_RgbByteOrder(uint8_t* dest_scan, - const uint8_t* src_scan, - int width, - int blend_type, - int dest_Bpp, - const uint8_t* clip_scan) { - int blended_colors[3]; - bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE; - for (int col = 0; col < width; col++) { - uint8_t src_alpha; - if (clip_scan) { - src_alpha = src_scan[3] * (*clip_scan++) / 255; - } else { - src_alpha = src_scan[3]; - } - if (src_alpha == 0) { - dest_scan += dest_Bpp; - src_scan += 4; - continue; - } - if (bNonseparableBlend) { - uint8_t dest_scan_o[3]; - dest_scan_o[0] = dest_scan[2]; - dest_scan_o[1] = dest_scan[1]; - dest_scan_o[2] = dest_scan[0]; - RGB_Blend(blend_type, src_scan, dest_scan_o, blended_colors); - } - for (int color = 0; color < 3; color++) { - int index = 2 - color; - int back_color = dest_scan[index]; - int blended = bNonseparableBlend - ? blended_colors[color] - : Blend(blend_type, back_color, *src_scan); - dest_scan[index] = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha); - src_scan++; - } - dest_scan += dest_Bpp; - src_scan++; - } -} - -void CompositeRow_Rgb2Argb_NoBlend_NoClip_RgbByteOrder(uint8_t* dest_scan, - const uint8_t* src_scan, - int width, - int src_Bpp) { - for (int col = 0; col < width; col++) { - if (src_Bpp == 4) { - FXARGB_SETRGBORDERDIB(dest_scan, 0xff000000 | FXARGB_GETDIB(src_scan)); - } else { - FXARGB_SETRGBORDERDIB( - dest_scan, FXARGB_MAKE(0xff, src_scan[2], src_scan[1], src_scan[0])); - } - dest_scan += 4; - src_scan += src_Bpp; - } -} - -void CompositeRow_Rgb2Rgb_Blend_NoClip_RgbByteOrder(uint8_t* dest_scan, - const uint8_t* src_scan, - int width, - int blend_type, - int dest_Bpp, - int src_Bpp) { - int blended_colors[3]; - bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE; - int src_gap = src_Bpp - 3; - for (int col = 0; col < width; col++) { - if (bNonseparableBlend) { - uint8_t dest_scan_o[3]; - dest_scan_o[0] = dest_scan[2]; - dest_scan_o[1] = dest_scan[1]; - dest_scan_o[2] = dest_scan[0]; - RGB_Blend(blend_type, src_scan, dest_scan_o, blended_colors); - } - for (int color = 0; color < 3; color++) { - int index = 2 - color; - int back_color = dest_scan[index]; - int src_color = *src_scan; - int blended = bNonseparableBlend - ? blended_colors[color] - : Blend(blend_type, back_color, src_color); - dest_scan[index] = blended; - src_scan++; - } - dest_scan += dest_Bpp; - src_scan += src_gap; - } -} - -void CompositeRow_Argb2Rgb_NoBlend_RgbByteOrder(uint8_t* dest_scan, - const uint8_t* src_scan, - int width, - int dest_Bpp, - const uint8_t* clip_scan) { - for (int col = 0; col < width; col++) { - uint8_t src_alpha; - if (clip_scan) { - src_alpha = src_scan[3] * (*clip_scan++) / 255; - } else { - src_alpha = src_scan[3]; - } - if (src_alpha == 255) { - dest_scan[2] = *src_scan++; - dest_scan[1] = *src_scan++; - dest_scan[0] = *src_scan++; - dest_scan += dest_Bpp; - src_scan++; - continue; - } - if (src_alpha == 0) { - dest_scan += dest_Bpp; - src_scan += 4; - continue; - } - for (int color = 0; color < 3; color++) { - int index = 2 - color; - dest_scan[index] = - FXDIB_ALPHA_MERGE(dest_scan[index], *src_scan, src_alpha); - src_scan++; - } - dest_scan += dest_Bpp; - src_scan++; - } -} - -void CompositeRow_Rgb2Rgb_NoBlend_NoClip_RgbByteOrder(uint8_t* dest_scan, - const uint8_t* src_scan, - int width, - int dest_Bpp, - int src_Bpp) { - for (int col = 0; col < width; col++) { - dest_scan[2] = src_scan[0]; - dest_scan[1] = src_scan[1]; - dest_scan[0] = src_scan[2]; - dest_scan += dest_Bpp; - src_scan += src_Bpp; - } -} - -void CompositeRow_Rgb2Argb_Blend_Clip_RgbByteOrder(uint8_t* dest_scan, - const uint8_t* src_scan, - int width, - int blend_type, - int src_Bpp, - const uint8_t* clip_scan) { - int blended_colors[3]; - bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE; - int src_gap = src_Bpp - 3; - for (int col = 0; col < width; col++) { - int src_alpha = *clip_scan++; - uint8_t back_alpha = dest_scan[3]; - if (back_alpha == 0) { - dest_scan[2] = *src_scan++; - dest_scan[1] = *src_scan++; - dest_scan[0] = *src_scan++; - src_scan += src_gap; - dest_scan += 4; - continue; - } - if (src_alpha == 0) { - dest_scan += 4; - src_scan += src_Bpp; - continue; - } - uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255; - dest_scan[3] = dest_alpha; - int alpha_ratio = src_alpha * 255 / dest_alpha; - if (bNonseparableBlend) { - uint8_t dest_scan_o[3]; - dest_scan_o[0] = dest_scan[2]; - dest_scan_o[1] = dest_scan[1]; - dest_scan_o[2] = dest_scan[0]; - RGB_Blend(blend_type, src_scan, dest_scan_o, blended_colors); - } - for (int color = 0; color < 3; color++) { - int index = 2 - color; - int src_color = *src_scan; - int blended = bNonseparableBlend - ? blended_colors[color] - : Blend(blend_type, dest_scan[index], src_color); - blended = FXDIB_ALPHA_MERGE(src_color, blended, back_alpha); - dest_scan[index] = - FXDIB_ALPHA_MERGE(dest_scan[index], blended, alpha_ratio); - src_scan++; - } - dest_scan += 4; - src_scan += src_gap; - } -} - -void CompositeRow_Rgb2Rgb_Blend_Clip_RgbByteOrder(uint8_t* dest_scan, - const uint8_t* src_scan, - int width, - int blend_type, - int dest_Bpp, - int src_Bpp, - const uint8_t* clip_scan) { - int blended_colors[3]; - bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE; - int src_gap = src_Bpp - 3; - for (int col = 0; col < width; col++) { - uint8_t src_alpha = *clip_scan++; - if (src_alpha == 0) { - dest_scan += dest_Bpp; - src_scan += src_Bpp; - continue; - } - if (bNonseparableBlend) { - uint8_t dest_scan_o[3]; - dest_scan_o[0] = dest_scan[2]; - dest_scan_o[1] = dest_scan[1]; - dest_scan_o[2] = dest_scan[0]; - RGB_Blend(blend_type, src_scan, dest_scan_o, blended_colors); - } - for (int color = 0; color < 3; color++) { - int index = 2 - color; - int src_color = *src_scan; - int back_color = dest_scan[index]; - int blended = bNonseparableBlend - ? blended_colors[color] - : Blend(blend_type, back_color, src_color); - dest_scan[index] = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha); - src_scan++; - } - dest_scan += dest_Bpp; - src_scan += src_gap; - } -} - -void CompositeRow_Rgb2Argb_NoBlend_Clip_RgbByteOrder(uint8_t* dest_scan, - const uint8_t* src_scan, - int width, - int src_Bpp, - const uint8_t* clip_scan) { - int src_gap = src_Bpp - 3; - for (int col = 0; col < width; col++) { - int src_alpha = clip_scan[col]; - if (src_alpha == 255) { - dest_scan[2] = *src_scan++; - dest_scan[1] = *src_scan++; - dest_scan[0] = *src_scan++; - dest_scan[3] = 255; - dest_scan += 4; - src_scan += src_gap; - continue; - } - if (src_alpha == 0) { - dest_scan += 4; - src_scan += src_Bpp; - continue; - } - int back_alpha = dest_scan[3]; - uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255; - dest_scan[3] = dest_alpha; - int alpha_ratio = src_alpha * 255 / dest_alpha; - for (int color = 0; color < 3; color++) { - int index = 2 - color; - dest_scan[index] = - FXDIB_ALPHA_MERGE(dest_scan[index], *src_scan, alpha_ratio); - src_scan++; - } - dest_scan += 4; - src_scan += src_gap; - } -} - -void CompositeRow_Rgb2Rgb_NoBlend_Clip_RgbByteOrder(uint8_t* dest_scan, - const uint8_t* src_scan, - int width, - int dest_Bpp, - int src_Bpp, - const uint8_t* clip_scan) { - for (int col = 0; col < width; col++) { - int src_alpha = clip_scan[col]; - if (src_alpha == 255) { - dest_scan[2] = src_scan[0]; - dest_scan[1] = src_scan[1]; - dest_scan[0] = src_scan[2]; - } else if (src_alpha) { - dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], *src_scan, src_alpha); - src_scan++; - dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], *src_scan, src_alpha); - src_scan++; - dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], *src_scan, src_alpha); - dest_scan += dest_Bpp; - src_scan += src_Bpp - 2; - continue; - } - dest_scan += dest_Bpp; - src_scan += src_Bpp; - } -} - -void CompositeRow_8bppRgb2Rgb_NoBlend_RgbByteOrder(uint8_t* dest_scan, - const uint8_t* src_scan, - FX_ARGB* pPalette, - int pixel_count, - int DestBpp, - const uint8_t* clip_scan) { - for (int col = 0; col < pixel_count; col++) { - FX_ARGB argb = pPalette ? pPalette[*src_scan] : (*src_scan) * 0x010101; - int src_r = FXARGB_R(argb); - int src_g = FXARGB_G(argb); - int src_b = FXARGB_B(argb); - if (clip_scan && clip_scan[col] < 255) { - dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], src_b, clip_scan[col]); - dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], src_g, clip_scan[col]); - dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], src_r, clip_scan[col]); - } else { - dest_scan[2] = src_b; - dest_scan[1] = src_g; - dest_scan[0] = src_r; - } - dest_scan += DestBpp; - src_scan++; - } -} - -void CompositeRow_1bppRgb2Rgb_NoBlend_RgbByteOrder(uint8_t* dest_scan, - const uint8_t* src_scan, - int src_left, - FX_ARGB* pPalette, - int pixel_count, - int DestBpp, - const uint8_t* clip_scan) { - int reset_r, reset_g, reset_b; - int set_r, set_g, set_b; - if (pPalette) { - reset_r = FXARGB_R(pPalette[0]); - reset_g = FXARGB_G(pPalette[0]); - reset_b = FXARGB_B(pPalette[0]); - set_r = FXARGB_R(pPalette[1]); - set_g = FXARGB_G(pPalette[1]); - set_b = FXARGB_B(pPalette[1]); - } else { - reset_r = reset_g = reset_b = 0; - set_r = set_g = set_b = 255; - } - for (int col = 0; col < pixel_count; col++) { - int src_r, src_g, src_b; - if (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8))) { - src_r = set_r; - src_g = set_g; - src_b = set_b; - } else { - src_r = reset_r; - src_g = reset_g; - src_b = reset_b; - } - if (clip_scan && clip_scan[col] < 255) { - dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], src_b, clip_scan[col]); - dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], src_g, clip_scan[col]); - dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], src_r, clip_scan[col]); - } else { - dest_scan[2] = src_b; - dest_scan[1] = src_g; - dest_scan[0] = src_r; - } - dest_scan += DestBpp; - } -} - -void CompositeRow_8bppRgb2Argb_NoBlend_RgbByteOrder(uint8_t* dest_scan, - const uint8_t* src_scan, - int width, - FX_ARGB* pPalette, - const uint8_t* clip_scan) { - for (int col = 0; col < width; col++) { - int src_r, src_g, src_b; - if (pPalette) { - FX_ARGB argb = pPalette[*src_scan]; - src_r = FXARGB_R(argb); - src_g = FXARGB_G(argb); - src_b = FXARGB_B(argb); - } else { - src_r = src_g = src_b = *src_scan; - } - if (!clip_scan || clip_scan[col] == 255) { - dest_scan[2] = src_b; - dest_scan[1] = src_g; - dest_scan[0] = src_r; - dest_scan[3] = 255; - src_scan++; - dest_scan += 4; - continue; - } - int src_alpha = clip_scan[col]; - if (src_alpha == 0) { - dest_scan += 4; - src_scan++; - continue; - } - int back_alpha = dest_scan[3]; - uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255; - dest_scan[3] = dest_alpha; - int alpha_ratio = src_alpha * 255 / dest_alpha; - dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], src_b, alpha_ratio); - dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], src_g, alpha_ratio); - dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], src_r, alpha_ratio); - dest_scan += 4; - src_scan++; - } -} - -void CompositeRow_1bppRgb2Argb_NoBlend_RgbByteOrder(uint8_t* dest_scan, - const uint8_t* src_scan, - int src_left, - int width, - FX_ARGB* pPalette, - const uint8_t* clip_scan) { - int reset_r, reset_g, reset_b; - int set_r, set_g, set_b; - if (pPalette) { - reset_r = FXARGB_R(pPalette[0]); - reset_g = FXARGB_G(pPalette[0]); - reset_b = FXARGB_B(pPalette[0]); - set_r = FXARGB_R(pPalette[1]); - set_g = FXARGB_G(pPalette[1]); - set_b = FXARGB_B(pPalette[1]); - } else { - reset_r = reset_g = reset_b = 0; - set_r = set_g = set_b = 255; - } - for (int col = 0; col < width; col++) { - int src_r, src_g, src_b; - if (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8))) { - src_r = set_r; - src_g = set_g; - src_b = set_b; - } else { - src_r = reset_r; - src_g = reset_g; - src_b = reset_b; - } - if (!clip_scan || clip_scan[col] == 255) { - dest_scan[2] = src_b; - dest_scan[1] = src_g; - dest_scan[0] = src_r; - dest_scan[3] = 255; - dest_scan += 4; - continue; - } - int src_alpha = clip_scan[col]; - if (src_alpha == 0) { - dest_scan += 4; - continue; - } - int back_alpha = dest_scan[3]; - uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255; - dest_scan[3] = dest_alpha; - int alpha_ratio = src_alpha * 255 / dest_alpha; - dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], src_b, alpha_ratio); - dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], src_g, alpha_ratio); - dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], src_r, alpha_ratio); - dest_scan += 4; - } -} - -void CompositeRow_ByteMask2Argb_RgbByteOrder(uint8_t* dest_scan, - const uint8_t* src_scan, - int mask_alpha, - int src_r, - int src_g, - int src_b, - int pixel_count, - int blend_type, - const uint8_t* clip_scan) { - for (int col = 0; col < pixel_count; col++) { - int src_alpha; - if (clip_scan) { - src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255; - } else { - src_alpha = mask_alpha * src_scan[col] / 255; - } - uint8_t back_alpha = dest_scan[3]; - if (back_alpha == 0) { - FXARGB_SETRGBORDERDIB(dest_scan, - FXARGB_MAKE(src_alpha, src_r, src_g, src_b)); - dest_scan += 4; - continue; - } - if (src_alpha == 0) { - dest_scan += 4; - continue; - } - uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255; - dest_scan[3] = dest_alpha; - int alpha_ratio = src_alpha * 255 / dest_alpha; - if (blend_type >= FXDIB_BLEND_NONSEPARABLE) { - int blended_colors[3]; - uint8_t scan[3] = {static_cast<uint8_t>(src_b), - static_cast<uint8_t>(src_g), - static_cast<uint8_t>(src_r)}; - uint8_t dest_scan_o[3] = {dest_scan[2], dest_scan[1], dest_scan[0]}; - RGB_Blend(blend_type, scan, dest_scan_o, blended_colors); - dest_scan[2] = - FXDIB_ALPHA_MERGE(dest_scan[2], blended_colors[0], alpha_ratio); - dest_scan[1] = - FXDIB_ALPHA_MERGE(dest_scan[1], blended_colors[1], alpha_ratio); - dest_scan[0] = - FXDIB_ALPHA_MERGE(dest_scan[0], blended_colors[2], alpha_ratio); - } else if (blend_type) { - int blended = Blend(blend_type, dest_scan[2], src_b); - blended = FXDIB_ALPHA_MERGE(src_b, blended, back_alpha); - dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], blended, alpha_ratio); - blended = Blend(blend_type, dest_scan[1], src_g); - blended = FXDIB_ALPHA_MERGE(src_g, blended, back_alpha); - dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], blended, alpha_ratio); - blended = Blend(blend_type, dest_scan[0], src_r); - blended = FXDIB_ALPHA_MERGE(src_r, blended, back_alpha); - dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], blended, alpha_ratio); - } else { - dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], src_b, alpha_ratio); - dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], src_g, alpha_ratio); - dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], src_r, alpha_ratio); - } - dest_scan += 4; - } -} - -void CompositeRow_ByteMask2Rgb_RgbByteOrder(uint8_t* dest_scan, - const uint8_t* src_scan, - int mask_alpha, - int src_r, - int src_g, - int src_b, - int pixel_count, - int blend_type, - int Bpp, - const uint8_t* clip_scan) { - for (int col = 0; col < pixel_count; col++) { - int src_alpha; - if (clip_scan) { - src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255; - } else { - src_alpha = mask_alpha * src_scan[col] / 255; - } - if (src_alpha == 0) { - dest_scan += Bpp; - continue; - } - if (blend_type >= FXDIB_BLEND_NONSEPARABLE) { - int blended_colors[3]; - uint8_t scan[3] = {static_cast<uint8_t>(src_b), - static_cast<uint8_t>(src_g), - static_cast<uint8_t>(src_r)}; - uint8_t dest_scan_o[3] = {dest_scan[2], dest_scan[1], dest_scan[0]}; - RGB_Blend(blend_type, scan, dest_scan_o, blended_colors); - dest_scan[2] = - FXDIB_ALPHA_MERGE(dest_scan[2], blended_colors[0], src_alpha); - dest_scan[1] = - FXDIB_ALPHA_MERGE(dest_scan[1], blended_colors[1], src_alpha); - dest_scan[0] = - FXDIB_ALPHA_MERGE(dest_scan[0], blended_colors[2], src_alpha); - } else if (blend_type) { - int blended = Blend(blend_type, dest_scan[2], src_b); - dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], blended, src_alpha); - blended = Blend(blend_type, dest_scan[1], src_g); - dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], blended, src_alpha); - blended = Blend(blend_type, dest_scan[0], src_r); - dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], blended, src_alpha); - } else { - dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], src_b, src_alpha); - dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], src_g, src_alpha); - dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], src_r, src_alpha); - } - dest_scan += Bpp; - } -} - -void CompositeRow_BitMask2Argb_RgbByteOrder(uint8_t* dest_scan, - const uint8_t* src_scan, - int mask_alpha, - int src_r, - int src_g, - int src_b, - int src_left, - int pixel_count, - int blend_type, - const uint8_t* clip_scan) { - if (blend_type == FXDIB_BLEND_NORMAL && !clip_scan && mask_alpha == 255) { - FX_ARGB argb = FXARGB_MAKE(0xff, src_r, src_g, src_b); - for (int col = 0; col < pixel_count; col++) { - if (src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8))) { - FXARGB_SETRGBORDERDIB(dest_scan, argb); - } - dest_scan += 4; - } - return; - } - for (int col = 0; col < pixel_count; col++) { - if (!(src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8)))) { - dest_scan += 4; - continue; - } - int src_alpha; - if (clip_scan) { - src_alpha = mask_alpha * clip_scan[col] / 255; - } else { - src_alpha = mask_alpha; - } - uint8_t back_alpha = dest_scan[3]; - if (back_alpha == 0) { - FXARGB_SETRGBORDERDIB(dest_scan, - FXARGB_MAKE(src_alpha, src_r, src_g, src_b)); - dest_scan += 4; - continue; - } - uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255; - dest_scan[3] = dest_alpha; - int alpha_ratio = src_alpha * 255 / dest_alpha; - if (blend_type >= FXDIB_BLEND_NONSEPARABLE) { - int blended_colors[3]; - uint8_t scan[3] = {static_cast<uint8_t>(src_b), - static_cast<uint8_t>(src_g), - static_cast<uint8_t>(src_r)}; - uint8_t dest_scan_o[3] = {dest_scan[2], dest_scan[1], dest_scan[0]}; - RGB_Blend(blend_type, scan, dest_scan_o, blended_colors); - dest_scan[2] = - FXDIB_ALPHA_MERGE(dest_scan[2], blended_colors[0], alpha_ratio); - dest_scan[1] = - FXDIB_ALPHA_MERGE(dest_scan[1], blended_colors[1], alpha_ratio); - dest_scan[0] = - FXDIB_ALPHA_MERGE(dest_scan[0], blended_colors[2], alpha_ratio); - } else if (blend_type) { - int blended = Blend(blend_type, dest_scan[2], src_b); - blended = FXDIB_ALPHA_MERGE(src_b, blended, back_alpha); - dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], blended, alpha_ratio); - blended = Blend(blend_type, dest_scan[1], src_g); - blended = FXDIB_ALPHA_MERGE(src_g, blended, back_alpha); - dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], blended, alpha_ratio); - blended = Blend(blend_type, dest_scan[0], src_r); - blended = FXDIB_ALPHA_MERGE(src_r, blended, back_alpha); - dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], blended, alpha_ratio); - } else { - dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], src_b, alpha_ratio); - dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], src_g, alpha_ratio); - dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], src_r, alpha_ratio); - } - dest_scan += 4; - } -} - -void CompositeRow_BitMask2Rgb_RgbByteOrder(uint8_t* dest_scan, - const uint8_t* src_scan, - int mask_alpha, - int src_r, - int src_g, - int src_b, - int src_left, - int pixel_count, - int blend_type, - int Bpp, - const uint8_t* clip_scan) { - if (blend_type == FXDIB_BLEND_NORMAL && !clip_scan && mask_alpha == 255) { - for (int col = 0; col < pixel_count; col++) { - if (src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8))) { - dest_scan[2] = src_b; - dest_scan[1] = src_g; - dest_scan[0] = src_r; - } - dest_scan += Bpp; - } - return; - } - for (int col = 0; col < pixel_count; col++) { - if (!(src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8)))) { - dest_scan += Bpp; - continue; - } - int src_alpha; - if (clip_scan) { - src_alpha = mask_alpha * clip_scan[col] / 255; - } else { - src_alpha = mask_alpha; - } - if (src_alpha == 0) { - dest_scan += Bpp; - continue; - } - if (blend_type >= FXDIB_BLEND_NONSEPARABLE) { - int blended_colors[3]; - uint8_t scan[3] = {static_cast<uint8_t>(src_b), - static_cast<uint8_t>(src_g), - static_cast<uint8_t>(src_r)}; - uint8_t dest_scan_o[3] = {dest_scan[2], dest_scan[1], dest_scan[0]}; - RGB_Blend(blend_type, scan, dest_scan_o, blended_colors); - dest_scan[2] = - FXDIB_ALPHA_MERGE(dest_scan[2], blended_colors[0], src_alpha); - dest_scan[1] = - FXDIB_ALPHA_MERGE(dest_scan[1], blended_colors[1], src_alpha); - dest_scan[0] = - FXDIB_ALPHA_MERGE(dest_scan[0], blended_colors[2], src_alpha); - } else if (blend_type) { - int back_color = dest_scan[2]; - int blended = Blend(blend_type, back_color, src_b); - dest_scan[2] = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha); - back_color = dest_scan[1]; - blended = Blend(blend_type, back_color, src_g); - dest_scan[1] = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha); - back_color = dest_scan[0]; - blended = Blend(blend_type, back_color, src_r); - dest_scan[0] = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha); - } else { - dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], src_b, src_alpha); - dest_scan[1] = FXDIB_ALPHA_MERGE(dest_scan[1], src_g, src_alpha); - dest_scan[0] = FXDIB_ALPHA_MERGE(dest_scan[0], src_r, src_alpha); - } - dest_scan += Bpp; - } -} - -bool ScanlineCompositor_InitSourceMask(FXDIB_Format dest_format, - int alpha_flag, - uint32_t mask_color, - int& mask_alpha, - int& mask_red, - int& mask_green, - int& mask_blue, - int& mask_black, - CCodec_IccModule* pIccModule, - void* pIccTransform) { - if (alpha_flag >> 8) { - mask_alpha = alpha_flag & 0xff; - mask_red = FXSYS_GetCValue(mask_color); - mask_green = FXSYS_GetMValue(mask_color); - mask_blue = FXSYS_GetYValue(mask_color); - mask_black = FXSYS_GetKValue(mask_color); - } else { - mask_alpha = FXARGB_A(mask_color); - mask_red = FXARGB_R(mask_color); - mask_green = FXARGB_G(mask_color); - mask_blue = FXARGB_B(mask_color); - } - if (dest_format == FXDIB_8bppMask) { - return true; - } - if ((dest_format & 0xff) == 8) { - if (pIccTransform) { - mask_color = (alpha_flag >> 8) ? FXCMYK_TODIB(mask_color) - : FXARGB_TODIB(mask_color); - uint8_t* gray_p = (uint8_t*)&mask_color; - pIccModule->TranslateScanline(pIccTransform, gray_p, gray_p, 1); - mask_red = dest_format & 0x0400 ? FX_CCOLOR(gray_p[0]) : gray_p[0]; - } else { - if (alpha_flag >> 8) { - uint8_t r, g, b; - AdobeCMYK_to_sRGB1(mask_red, mask_green, mask_blue, mask_black, r, g, - b); - mask_red = FXRGB2GRAY(r, g, b); - } else { - mask_red = FXRGB2GRAY(mask_red, mask_green, mask_blue); - } - if (dest_format & 0x0400) { - mask_red = FX_CCOLOR(mask_red); - } - } - } else { - uint8_t* mask_color_p = (uint8_t*)&mask_color; - mask_color = - (alpha_flag >> 8) ? FXCMYK_TODIB(mask_color) : FXARGB_TODIB(mask_color); - if (pIccTransform) { - pIccModule->TranslateScanline(pIccTransform, mask_color_p, mask_color_p, - 1); - mask_red = mask_color_p[2]; - mask_green = mask_color_p[1]; - mask_blue = mask_color_p[0]; - } else if (alpha_flag >> 8) { - AdobeCMYK_to_sRGB1(mask_color_p[0], mask_color_p[1], mask_color_p[2], - mask_color_p[3], mask_color_p[2], mask_color_p[1], - mask_color_p[0]); - mask_red = mask_color_p[2]; - mask_green = mask_color_p[1]; - mask_blue = mask_color_p[0]; - } - } - return true; -} - -void ScanlineCompositor_InitSourcePalette(FXDIB_Format src_format, - FXDIB_Format dest_format, - uint32_t*& pDestPalette, - uint32_t* pSrcPalette, - CCodec_IccModule* pIccModule, - void* pIccTransform) { - bool isSrcCmyk = !!(src_format & 0x0400); - bool isDstCmyk = !!(dest_format & 0x0400); - pDestPalette = nullptr; - if (pIccTransform) { - if (pSrcPalette) { - if ((dest_format & 0xff) == 8) { - int pal_count = 1 << (src_format & 0xff); - uint8_t* gray_pal = FX_Alloc(uint8_t, pal_count); - pDestPalette = (uint32_t*)gray_pal; - for (int i = 0; i < pal_count; i++) { - uint32_t color = isSrcCmyk ? FXCMYK_TODIB(pSrcPalette[i]) - : FXARGB_TODIB(pSrcPalette[i]); - pIccModule->TranslateScanline(pIccTransform, gray_pal, - (const uint8_t*)&color, 1); - gray_pal++; - } - } else { - int palsize = 1 << (src_format & 0xff); - pDestPalette = FX_Alloc(uint32_t, palsize); - for (int i = 0; i < palsize; i++) { - uint32_t color = isSrcCmyk ? FXCMYK_TODIB(pSrcPalette[i]) - : FXARGB_TODIB(pSrcPalette[i]); - pIccModule->TranslateScanline(pIccTransform, (uint8_t*)&color, - (const uint8_t*)&color, 1); - pDestPalette[i] = - isDstCmyk ? FXCMYK_TODIB(color) : FXARGB_TODIB(color); - } - } - } else { - int pal_count = 1 << (src_format & 0xff); - uint8_t* gray_pal = FX_Alloc(uint8_t, pal_count); - if (pal_count == 2) { - gray_pal[0] = 0; - gray_pal[1] = 255; - } else { - for (int i = 0; i < pal_count; i++) { - gray_pal[i] = i; - } - } - if ((dest_format & 0xff) == 8) { - pIccModule->TranslateScanline(pIccTransform, gray_pal, gray_pal, - pal_count); - pDestPalette = (uint32_t*)gray_pal; - } else { - pDestPalette = FX_Alloc(uint32_t, pal_count); - for (int i = 0; i < pal_count; i++) { - pIccModule->TranslateScanline( - pIccTransform, (uint8_t*)&pDestPalette[i], &gray_pal[i], 1); - pDestPalette[i] = isDstCmyk ? FXCMYK_TODIB(pDestPalette[i]) - : FXARGB_TODIB(pDestPalette[i]); - } - FX_Free(gray_pal); - } - } - } else { - if (pSrcPalette) { - if ((dest_format & 0xff) == 8) { - int pal_count = 1 << (src_format & 0xff); - uint8_t* gray_pal = FX_Alloc(uint8_t, pal_count); - pDestPalette = (uint32_t*)gray_pal; - if (isSrcCmyk) { - for (int i = 0; i < pal_count; i++) { - FX_CMYK cmyk = pSrcPalette[i]; - uint8_t r, g, b; - AdobeCMYK_to_sRGB1(FXSYS_GetCValue(cmyk), FXSYS_GetMValue(cmyk), - FXSYS_GetYValue(cmyk), FXSYS_GetKValue(cmyk), r, - g, b); - *gray_pal++ = FXRGB2GRAY(r, g, b); - } - } else { - for (int i = 0; i < pal_count; i++) { - FX_ARGB argb = pSrcPalette[i]; - *gray_pal++ = - FXRGB2GRAY(FXARGB_R(argb), FXARGB_G(argb), FXARGB_B(argb)); - } - } - } else { - int palsize = 1 << (src_format & 0xff); - pDestPalette = FX_Alloc(uint32_t, palsize); - if (isDstCmyk == isSrcCmyk) { - FXSYS_memcpy(pDestPalette, pSrcPalette, palsize * sizeof(uint32_t)); - } else { - for (int i = 0; i < palsize; i++) { - FX_CMYK cmyk = pSrcPalette[i]; - uint8_t r, g, b; - AdobeCMYK_to_sRGB1(FXSYS_GetCValue(cmyk), FXSYS_GetMValue(cmyk), - FXSYS_GetYValue(cmyk), FXSYS_GetKValue(cmyk), r, - g, b); - pDestPalette[i] = FXARGB_MAKE(0xff, r, g, b); - } - } - } - } else { - if ((dest_format & 0xff) == 8) { - int pal_count = 1 << (src_format & 0xff); - uint8_t* gray_pal = FX_Alloc(uint8_t, pal_count); - if (pal_count == 2) { - gray_pal[0] = 0; - gray_pal[1] = 255; - } else { - for (int i = 0; i < pal_count; i++) { - gray_pal[i] = i; - } - } - pDestPalette = (uint32_t*)gray_pal; - } else { - int palsize = 1 << (src_format & 0xff); - pDestPalette = FX_Alloc(uint32_t, palsize); - if (palsize == 2) { - pDestPalette[0] = isSrcCmyk ? 255 : 0xff000000; - pDestPalette[1] = isSrcCmyk ? 0 : 0xffffffff; - } else { - for (int i = 0; i < palsize; i++) { - pDestPalette[i] = isSrcCmyk ? FX_CCOLOR(i) : (i * 0x10101); - } - } - if (isSrcCmyk != isDstCmyk) { - for (int i = 0; i < palsize; i++) { - FX_CMYK cmyk = pDestPalette[i]; - uint8_t r, g, b; - AdobeCMYK_to_sRGB1(FXSYS_GetCValue(cmyk), FXSYS_GetMValue(cmyk), - FXSYS_GetYValue(cmyk), FXSYS_GetKValue(cmyk), r, - g, b); - pDestPalette[i] = FXARGB_MAKE(0xff, r, g, b); - } - } - } - } - } -} - -} // namespace - -CFX_ScanlineCompositor::CFX_ScanlineCompositor() { - m_pSrcPalette = nullptr; - m_pCacheScanline = nullptr; - m_CacheSize = 0; - m_bRgbByteOrder = false; - m_BlendType = FXDIB_BLEND_NORMAL; - m_pIccTransform = nullptr; -} - -CFX_ScanlineCompositor::~CFX_ScanlineCompositor() { - FX_Free(m_pSrcPalette); - FX_Free(m_pCacheScanline); -} - -bool CFX_ScanlineCompositor::Init(FXDIB_Format dest_format, - FXDIB_Format src_format, - int32_t width, - uint32_t* pSrcPalette, - uint32_t mask_color, - int blend_type, - bool bClip, - bool bRgbByteOrder, - int alpha_flag, - void* pIccTransform) { - m_SrcFormat = src_format; - m_DestFormat = dest_format; - m_BlendType = blend_type; - m_bRgbByteOrder = bRgbByteOrder; - CCodec_IccModule* pIccModule = nullptr; - if (CFX_GEModule::Get()->GetCodecModule()) { - pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule(); - } - if (!pIccModule) { - pIccTransform = nullptr; - } - m_pIccTransform = pIccTransform; - if ((dest_format & 0xff) == 1) { - return false; - } - if (m_SrcFormat == FXDIB_1bppMask || m_SrcFormat == FXDIB_8bppMask) { - return ScanlineCompositor_InitSourceMask( - dest_format, alpha_flag, mask_color, m_MaskAlpha, m_MaskRed, - m_MaskGreen, m_MaskBlue, m_MaskBlack, pIccModule, pIccTransform); - } - if (!pIccTransform && (~src_format & 0x0400) && (dest_format & 0x0400)) { - return false; - } - if ((m_SrcFormat & 0xff) <= 8) { - if (dest_format == FXDIB_8bppMask) { - return true; - } - ScanlineCompositor_InitSourcePalette(src_format, dest_format, m_pSrcPalette, - pSrcPalette, pIccModule, - pIccTransform); - m_Transparency = - (dest_format == FXDIB_Argb ? 1 : 0) + (dest_format & 0x0200 ? 2 : 0) + - (dest_format & 0x0400 ? 4 : 0) + ((src_format & 0xff) == 1 ? 8 : 0); - return true; - } - m_Transparency = (src_format & 0x0200 ? 0 : 1) + - (dest_format & 0x0200 ? 0 : 2) + - (blend_type == FXDIB_BLEND_NORMAL ? 4 : 0) + - (bClip ? 8 : 0) + (src_format & 0x0400 ? 16 : 0) + - (dest_format & 0x0400 ? 32 : 0) + (pIccTransform ? 64 : 0); - return true; -} - -void CFX_ScanlineCompositor::CompositeRgbBitmapLine( - uint8_t* dest_scan, - const uint8_t* src_scan, - int width, - const uint8_t* clip_scan, - const uint8_t* src_extra_alpha, - uint8_t* dst_extra_alpha) { - int src_Bpp = (m_SrcFormat & 0xff) >> 3; - int dest_Bpp = (m_DestFormat & 0xff) >> 3; - if (m_bRgbByteOrder) { - switch (m_Transparency) { - case 0: - case 4: - case 8: - case 12: - CompositeRow_Argb2Argb_RgbByteOrder(dest_scan, src_scan, width, - m_BlendType, clip_scan); - break; - case 1: - CompositeRow_Rgb2Argb_Blend_NoClip_RgbByteOrder( - dest_scan, src_scan, width, m_BlendType, src_Bpp); - break; - case 2: - case 10: - CompositeRow_Argb2Rgb_Blend_RgbByteOrder( - dest_scan, src_scan, width, m_BlendType, dest_Bpp, clip_scan); - break; - case 3: - CompositeRow_Rgb2Rgb_Blend_NoClip_RgbByteOrder( - dest_scan, src_scan, width, m_BlendType, dest_Bpp, src_Bpp); - break; - case 5: - CompositeRow_Rgb2Argb_NoBlend_NoClip_RgbByteOrder(dest_scan, src_scan, - width, src_Bpp); - break; - case 6: - case 14: - CompositeRow_Argb2Rgb_NoBlend_RgbByteOrder(dest_scan, src_scan, width, - dest_Bpp, clip_scan); - break; - case 7: - CompositeRow_Rgb2Rgb_NoBlend_NoClip_RgbByteOrder( - dest_scan, src_scan, width, dest_Bpp, src_Bpp); - break; - case 9: - CompositeRow_Rgb2Argb_Blend_Clip_RgbByteOrder( - dest_scan, src_scan, width, m_BlendType, src_Bpp, clip_scan); - break; - case 11: - CompositeRow_Rgb2Rgb_Blend_Clip_RgbByteOrder(dest_scan, src_scan, width, - m_BlendType, dest_Bpp, - src_Bpp, clip_scan); - break; - case 13: - CompositeRow_Rgb2Argb_NoBlend_Clip_RgbByteOrder( - dest_scan, src_scan, width, src_Bpp, clip_scan); - break; - case 15: - CompositeRow_Rgb2Rgb_NoBlend_Clip_RgbByteOrder( - dest_scan, src_scan, width, dest_Bpp, src_Bpp, clip_scan); - break; - } - return; - } - if (m_DestFormat == FXDIB_8bppMask) { - if (m_SrcFormat & 0x0200) { - if (m_SrcFormat == FXDIB_Argb) { - CompositeRow_AlphaToMask(dest_scan, src_scan, width, clip_scan, 4); - } else { - CompositeRow_AlphaToMask(dest_scan, src_extra_alpha, width, clip_scan, - 1); - } - } else { - CompositeRow_Rgb2Mask(dest_scan, src_scan, width, clip_scan); - } - } else if ((m_DestFormat & 0xff) == 8) { - if (m_DestFormat & 0x0400) { - for (int i = 0; i < width; i++) { - *dest_scan = ~*dest_scan; - dest_scan++; - } - } - if (m_SrcFormat & 0x0200) { - if (m_DestFormat & 0x0200) { - CompositeRow_Argb2Graya(dest_scan, src_scan, width, m_BlendType, - clip_scan, src_extra_alpha, dst_extra_alpha, - m_pIccTransform); - } else { - CompositeRow_Argb2Gray(dest_scan, src_scan, width, m_BlendType, - clip_scan, src_extra_alpha, m_pIccTransform); - } - } else { - if (m_DestFormat & 0x0200) { - CompositeRow_Rgb2Graya(dest_scan, src_scan, src_Bpp, width, m_BlendType, - clip_scan, dst_extra_alpha, m_pIccTransform); - } else { - CompositeRow_Rgb2Gray(dest_scan, src_scan, src_Bpp, width, m_BlendType, - clip_scan, m_pIccTransform); - } - } - if (m_DestFormat & 0x0400) { - for (int i = 0; i < width; i++) { - *dest_scan = ~*dest_scan; - dest_scan++; - } - } - } else { - int dest_Size = width * dest_Bpp + 4; - if (dest_Size > m_CacheSize) { - m_pCacheScanline = FX_Realloc(uint8_t, m_pCacheScanline, dest_Size); - if (!m_pCacheScanline) { - return; - } - m_CacheSize = dest_Size; - } - switch (m_Transparency) { - case 0: - case 4: - case 8: - case 4 + 8: { - CompositeRow_Argb2Argb(dest_scan, src_scan, width, m_BlendType, - clip_scan, dst_extra_alpha, src_extra_alpha); - } break; - case 64: - case 4 + 64: - case 8 + 64: - case 4 + 8 + 64: { - CompositeRow_Argb2Argb_Transform( - dest_scan, src_scan, width, m_BlendType, clip_scan, dst_extra_alpha, - src_extra_alpha, m_pCacheScanline, m_pIccTransform); - } break; - case 1: - CompositeRow_Rgb2Argb_Blend_NoClip( - dest_scan, src_scan, width, m_BlendType, src_Bpp, dst_extra_alpha); - break; - case 1 + 64: - CompositeRow_Rgb2Argb_Blend_NoClip_Transform( - dest_scan, src_scan, width, m_BlendType, src_Bpp, dst_extra_alpha, - m_pCacheScanline, m_pIccTransform); - break; - case 1 + 8: - CompositeRow_Rgb2Argb_Blend_Clip(dest_scan, src_scan, width, - m_BlendType, src_Bpp, clip_scan, - dst_extra_alpha); - break; - case 1 + 8 + 64: - CompositeRow_Rgb2Argb_Blend_Clip_Transform( - dest_scan, src_scan, width, m_BlendType, src_Bpp, clip_scan, - dst_extra_alpha, m_pCacheScanline, m_pIccTransform); - break; - case 1 + 4: - CompositeRow_Rgb2Argb_NoBlend_NoClip(dest_scan, src_scan, width, - src_Bpp, dst_extra_alpha); - break; - case 1 + 4 + 64: - CompositeRow_Rgb2Argb_NoBlend_NoClip_Transform( - dest_scan, src_scan, width, src_Bpp, dst_extra_alpha, - m_pCacheScanline, m_pIccTransform); - break; - case 1 + 4 + 8: - CompositeRow_Rgb2Argb_NoBlend_Clip(dest_scan, src_scan, width, src_Bpp, - clip_scan, dst_extra_alpha); - break; - case 1 + 4 + 8 + 64: - CompositeRow_Rgb2Argb_NoBlend_Clip_Transform( - dest_scan, src_scan, width, src_Bpp, clip_scan, dst_extra_alpha, - m_pCacheScanline, m_pIccTransform); - break; - case 2: - case 2 + 8: - CompositeRow_Argb2Rgb_Blend(dest_scan, src_scan, width, m_BlendType, - dest_Bpp, clip_scan, src_extra_alpha); - break; - case 2 + 64: - case 2 + 8 + 64: - CompositeRow_Argb2Rgb_Blend_Transform( - dest_scan, src_scan, width, m_BlendType, dest_Bpp, clip_scan, - src_extra_alpha, m_pCacheScanline, m_pIccTransform); - break; - case 2 + 4: - case 2 + 4 + 8: - CompositeRow_Argb2Rgb_NoBlend(dest_scan, src_scan, width, dest_Bpp, - clip_scan, src_extra_alpha); - break; - case 2 + 4 + 64: - case 2 + 4 + 8 + 64: - CompositeRow_Argb2Rgb_NoBlend_Transform( - dest_scan, src_scan, width, dest_Bpp, clip_scan, src_extra_alpha, - m_pCacheScanline, m_pIccTransform); - break; - case 1 + 2: - CompositeRow_Rgb2Rgb_Blend_NoClip(dest_scan, src_scan, width, - m_BlendType, dest_Bpp, src_Bpp); - break; - case 1 + 2 + 64: - CompositeRow_Rgb2Rgb_Blend_NoClip_Transform( - dest_scan, src_scan, width, m_BlendType, dest_Bpp, src_Bpp, - m_pCacheScanline, m_pIccTransform); - break; - case 1 + 2 + 8: - CompositeRow_Rgb2Rgb_Blend_Clip(dest_scan, src_scan, width, m_BlendType, - dest_Bpp, src_Bpp, clip_scan); - break; - case 1 + 2 + 8 + 64: - CompositeRow_Rgb2Rgb_Blend_Clip_Transform( - dest_scan, src_scan, width, m_BlendType, dest_Bpp, src_Bpp, - clip_scan, m_pCacheScanline, m_pIccTransform); - break; - case 1 + 2 + 4: - CompositeRow_Rgb2Rgb_NoBlend_NoClip(dest_scan, src_scan, width, - dest_Bpp, src_Bpp); - break; - case 1 + 2 + 4 + 64: - CompositeRow_Rgb2Rgb_NoBlend_NoClip_Transform( - dest_scan, src_scan, width, dest_Bpp, src_Bpp, m_pCacheScanline, - m_pIccTransform); - break; - case 1 + 2 + 4 + 8: - CompositeRow_Rgb2Rgb_NoBlend_Clip(dest_scan, src_scan, width, dest_Bpp, - src_Bpp, clip_scan); - break; - case 1 + 2 + 4 + 8 + 64: - CompositeRow_Rgb2Rgb_NoBlend_Clip_Transform( - dest_scan, src_scan, width, dest_Bpp, src_Bpp, clip_scan, - m_pCacheScanline, m_pIccTransform); - break; - } - } -} - -void CFX_ScanlineCompositor::CompositePalBitmapLine( - uint8_t* dest_scan, - const uint8_t* src_scan, - int src_left, - int width, - const uint8_t* clip_scan, - const uint8_t* src_extra_alpha, - uint8_t* dst_extra_alpha) { - if (m_bRgbByteOrder) { - if (m_SrcFormat == FXDIB_1bppRgb) { - if (m_DestFormat == FXDIB_8bppRgb) { - return; - } - if (m_DestFormat == FXDIB_Argb) { - CompositeRow_1bppRgb2Argb_NoBlend_RgbByteOrder( - dest_scan, src_scan, src_left, width, m_pSrcPalette, clip_scan); - } else { - CompositeRow_1bppRgb2Rgb_NoBlend_RgbByteOrder( - dest_scan, src_scan, src_left, m_pSrcPalette, width, - (m_DestFormat & 0xff) >> 3, clip_scan); - } - } else { - if (m_DestFormat == FXDIB_8bppRgb) { - return; - } - if (m_DestFormat == FXDIB_Argb) { - CompositeRow_8bppRgb2Argb_NoBlend_RgbByteOrder( - dest_scan, src_scan, width, m_pSrcPalette, clip_scan); - } else { - CompositeRow_8bppRgb2Rgb_NoBlend_RgbByteOrder( - dest_scan, src_scan, m_pSrcPalette, width, - (m_DestFormat & 0xff) >> 3, clip_scan); - } - } - return; - } - if (m_DestFormat == FXDIB_8bppMask) { - CompositeRow_Rgb2Mask(dest_scan, src_scan, width, clip_scan); - return; - } - if ((m_DestFormat & 0xff) == 8) { - if (m_Transparency & 8) { - if (m_DestFormat & 0x0200) { - CompositeRow_1bppPal2Graya(dest_scan, src_scan, src_left, - (const uint8_t*)m_pSrcPalette, width, - m_BlendType, clip_scan, dst_extra_alpha); - } else { - CompositeRow_1bppPal2Gray(dest_scan, src_scan, src_left, - (const uint8_t*)m_pSrcPalette, width, - m_BlendType, clip_scan); - } - } else { - if (m_DestFormat & 0x0200) - CompositeRow_8bppPal2Graya( - dest_scan, src_scan, (const uint8_t*)m_pSrcPalette, width, - m_BlendType, clip_scan, dst_extra_alpha, src_extra_alpha); - else - CompositeRow_8bppPal2Gray(dest_scan, src_scan, - (const uint8_t*)m_pSrcPalette, width, - m_BlendType, clip_scan, src_extra_alpha); - } - } else { - switch (m_Transparency) { - case 1 + 2: - CompositeRow_8bppRgb2Argb_NoBlend(dest_scan, src_scan, width, - m_pSrcPalette, clip_scan, - src_extra_alpha); - break; - case 1 + 2 + 8: - CompositeRow_1bppRgb2Argb_NoBlend(dest_scan, src_scan, src_left, width, - m_pSrcPalette, clip_scan); - break; - case 0: - CompositeRow_8bppRgb2Rgb_NoBlend(dest_scan, src_scan, m_pSrcPalette, - width, (m_DestFormat & 0xff) >> 3, - clip_scan, src_extra_alpha); - break; - case 0 + 8: - CompositeRow_1bppRgb2Rgb_NoBlend(dest_scan, src_scan, src_left, - m_pSrcPalette, width, - (m_DestFormat & 0xff) >> 3, clip_scan); - break; - case 0 + 2: - CompositeRow_8bppRgb2Rgb_NoBlend(dest_scan, src_scan, m_pSrcPalette, - width, (m_DestFormat & 0xff) >> 3, - clip_scan, src_extra_alpha); - break; - case 0 + 2 + 8: - CompositeRow_1bppRgb2Rgba_NoBlend(dest_scan, src_scan, src_left, width, - m_pSrcPalette, clip_scan, - dst_extra_alpha); - break; - break; - } - } -} - -void CFX_ScanlineCompositor::CompositeByteMaskLine(uint8_t* dest_scan, - const uint8_t* src_scan, - int width, - const uint8_t* clip_scan, - uint8_t* dst_extra_alpha) { - if (m_DestFormat == FXDIB_8bppMask) { - CompositeRow_ByteMask2Mask(dest_scan, src_scan, m_MaskAlpha, width, - clip_scan); - } else if ((m_DestFormat & 0xff) == 8) { - if (m_DestFormat & 0x0200) { - CompositeRow_ByteMask2Graya(dest_scan, src_scan, m_MaskAlpha, m_MaskRed, - width, clip_scan, dst_extra_alpha); - } else { - CompositeRow_ByteMask2Gray(dest_scan, src_scan, m_MaskAlpha, m_MaskRed, - width, clip_scan); - } - } else if (m_bRgbByteOrder) { - if (m_DestFormat == FXDIB_Argb) { - CompositeRow_ByteMask2Argb_RgbByteOrder( - dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue, - width, m_BlendType, clip_scan); - } else { - CompositeRow_ByteMask2Rgb_RgbByteOrder( - dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue, - width, m_BlendType, (m_DestFormat & 0xff) >> 3, clip_scan); - } - return; - } else if (m_DestFormat == FXDIB_Argb) { - CompositeRow_ByteMask2Argb(dest_scan, src_scan, m_MaskAlpha, m_MaskRed, - m_MaskGreen, m_MaskBlue, width, m_BlendType, - clip_scan); - } else if (m_DestFormat == FXDIB_Rgb || m_DestFormat == FXDIB_Rgb32) { - CompositeRow_ByteMask2Rgb(dest_scan, src_scan, m_MaskAlpha, m_MaskRed, - m_MaskGreen, m_MaskBlue, width, m_BlendType, - (m_DestFormat & 0xff) >> 3, clip_scan); - } else if (m_DestFormat == FXDIB_Rgba) { - CompositeRow_ByteMask2Rgba(dest_scan, src_scan, m_MaskAlpha, m_MaskRed, - m_MaskGreen, m_MaskBlue, width, m_BlendType, - clip_scan, dst_extra_alpha); - } -} - -void CFX_ScanlineCompositor::CompositeBitMaskLine(uint8_t* dest_scan, - const uint8_t* src_scan, - int src_left, - int width, - const uint8_t* clip_scan, - uint8_t* dst_extra_alpha) { - if (m_DestFormat == FXDIB_8bppMask) { - CompositeRow_BitMask2Mask(dest_scan, src_scan, m_MaskAlpha, src_left, width, - clip_scan); - } else if ((m_DestFormat & 0xff) == 8) { - if (m_DestFormat & 0x0200) { - CompositeRow_BitMask2Graya(dest_scan, src_scan, m_MaskAlpha, m_MaskRed, - src_left, width, clip_scan, dst_extra_alpha); - } else { - CompositeRow_BitMask2Gray(dest_scan, src_scan, m_MaskAlpha, m_MaskRed, - src_left, width, clip_scan); - } - } else if (m_bRgbByteOrder) { - if (m_DestFormat == FXDIB_Argb) { - CompositeRow_BitMask2Argb_RgbByteOrder( - dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue, - src_left, width, m_BlendType, clip_scan); - } else { - CompositeRow_BitMask2Rgb_RgbByteOrder( - dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue, - src_left, width, m_BlendType, (m_DestFormat & 0xff) >> 3, clip_scan); - } - return; - } else if (m_DestFormat == FXDIB_Argb) { - CompositeRow_BitMask2Argb(dest_scan, src_scan, m_MaskAlpha, m_MaskRed, - m_MaskGreen, m_MaskBlue, src_left, width, - m_BlendType, clip_scan); - } else if (m_DestFormat == FXDIB_Rgb || m_DestFormat == FXDIB_Rgb32) { - CompositeRow_BitMask2Rgb( - dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue, - src_left, width, m_BlendType, (m_DestFormat & 0xff) >> 3, clip_scan); - } -} - bool CFX_DIBitmap::CompositeBitmap( int dest_left, int dest_top, |