| // Copyright 2014 PDFium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com |
| |
| #include "core/fxcodec/include/fx_codec.h" |
| #include "core/fxge/dib/dib_int.h" |
| #include "core/fxge/include/cfx_gemodule.h" |
| #include "core/fxge/include/fx_ge.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; |
| } |
| int result = back_color * 255 / (255 - src_color); |
| if (result > 255) { |
| return 255; |
| } |
| return result; |
| } |
| case FXDIB_BLEND_COLORBURN: { |
| if (src_color == 0) { |
| return src_color; |
| } |
| int result = (255 - back_color) * 255 / src_color; |
| if (result > 255) { |
| result = 255; |
| } |
| return 255 - result; |
| } |
| 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 = color.red; |
| if (color.green < n) { |
| n = color.green; |
| } |
| if (color.blue < n) { |
| n = color.blue; |
| } |
| int x = color.red; |
| if (color.green > x) { |
| x = color.green; |
| } |
| if (color.blue > x) { |
| x = 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) { |
| int n = color.red; |
| if (color.green < n) { |
| n = color.green; |
| } |
| if (color.blue < n) { |
| n = color.blue; |
| } |
| int x = color.red; |
| if (color.green > x) { |
| x = color.green; |
| } |
| if (color.blue > x) { |
| x = color.blue; |
| } |
| return x - n; |
| } |
| |
| RGB SetSat(RGB color, int s) { |
| int* max = &color.red; |
| int* mid = &color.red; |
| int* min = &color.red; |
| if (color.green > *max) { |
| max = &color.green; |
| } |
| if (color.blue > *max) { |
| max = &color.blue; |
| } |
| if (color.green < *min) { |
| min = &color.green; |
| } |
| if (color.blue < *min) { |
| min = &color.blue; |
| } |
| if (*max == *min) { |
| color.red = 0; |
| color.green = 0; |
| color.blue = 0; |
| return color; |
| } |
| if (max == &color.red) { |
| if (min == &color.green) { |
| mid = &color.blue; |
| } else { |
| mid = &color.green; |
| } |
| } else if (max == &color.green) { |
| if (min == &color.red) { |
| mid = &color.blue; |
| } else { |
| mid = &color.red; |
| } |
| } else { |
| if (min == &color.green) { |
| mid = &color.red; |
| } else { |
| mid = &color.green; |
| } |
| } |
| if (*max > *min) { |
| *mid = (*mid - *min) * s / (*max - *min); |
| *max = s; |
| *min = 0; |
| } |
| return color; |
| } |
| |
| void RGB_Blend(int blend_mode, |
| const uint8_t* src_scan, |
| uint8_t* dest_scan, |
| int results[3]) { |
| RGB src; |
| RGB back; |
| RGB result = {0, 0, 0}; |
| src.red = src_scan[2]; |
| src.green = src_scan[1]; |
| src.blue = src_scan[0]; |
| 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; |
| } |
| |
| void CompositeRow_Argb2Mask(uint8_t* dest_scan, |
| const uint8_t* src_scan, |
| int pixel_count, |
| const uint8_t* clip_scan) { |
| src_scan += 3; |
| for (int col = 0; col < pixel_count; col++) { |
| int src_alpha = *src_scan; |
| if (clip_scan) { |
| src_alpha = clip_scan[col] * src_alpha / 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++; |
| src_scan += 4; |
| } |
| } |
| |
| void CompositeRow_Rgba2Mask(uint8_t* dest_scan, |
| const uint8_t* src_alpha_scan, |
| int pixel_count, |
| const uint8_t* clip_scan) { |
| for (int col = 0; col < pixel_count; col++) { |
| int src_alpha = *src_alpha_scan++; |
| if (clip_scan) { |
| src_alpha = clip_scan[col] * src_alpha / 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_Rgb2Mask(uint8_t* dest_scan, |
| const uint8_t* src_scan, |
| int width, |
| const uint8_t* clip_scan) { |
| if (clip_scan) { |
| for (int i = 0; i < width; i++) { |
| *dest_scan = FXDIB_ALPHA_UNION(*dest_scan, *clip_scan); |
| dest_scan++; |
| clip_scan++; |
| } |
| } else { |
| FXSYS_memset(dest_scan, 0xff, width); |
| } |
| } |
| |
| 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(); |
| |
| if (blend_type) { |
| FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE; |
| if (src_alpha_scan) { |
| for (int col = 0; col < pixel_count; col++) { |
| uint8_t back_alpha = *dst_alpha_scan; |
| if (back_alpha == 0) { |
| int src_alpha = *src_alpha_scan++; |
| if (clip_scan) |
| src_alpha = clip_scan[col] * src_alpha / 255; |
| |
| if (src_alpha) { |
| if (pIccTransform) { |
| pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan, |
| 1); |
| } else { |
| *dest_scan = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan); |
| } |
| *dst_alpha_scan = src_alpha; |
| } |
| dest_scan++; |
| dst_alpha_scan++; |
| src_scan += 3; |
| continue; |
| } |
| uint8_t src_alpha = *src_alpha_scan++; |
| if (clip_scan) |
| src_alpha = clip_scan[col] * src_alpha / 255; |
| |
| if (src_alpha == 0) { |
| dest_scan++; |
| dst_alpha_scan++; |
| src_scan += 3; |
| continue; |
| } |
| *dst_alpha_scan = FXDIB_ALPHA_UNION(back_alpha, src_alpha); |
| int alpha_ratio = src_alpha * 255 / (*dst_alpha_scan); |
| uint8_t gray; |
| if (pIccTransform) { |
| pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1); |
| } else { |
| gray = FXRGB2GRAY(src_scan[2], src_scan[1], *src_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_scan++; |
| dst_alpha_scan++; |
| src_scan += 3; |
| } |
| } else { |
| for (int col = 0; col < pixel_count; col++) { |
| uint8_t back_alpha = *dst_alpha_scan; |
| if (back_alpha == 0) { |
| int src_alpha = src_scan[3]; |
| if (clip_scan) |
| src_alpha = clip_scan[col] * src_alpha / 255; |
| |
| if (src_alpha) { |
| if (pIccTransform) { |
| pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan, |
| 1); |
| } else { |
| *dest_scan = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan); |
| } |
| *dst_alpha_scan = src_alpha; |
| } |
| dest_scan++; |
| dst_alpha_scan++; |
| src_scan += 4; |
| continue; |
| } |
| uint8_t src_alpha = src_scan[3]; |
| if (clip_scan) |
| src_alpha = clip_scan[col] * src_alpha / 255; |
| |
| if (src_alpha == 0) { |
| dest_scan++; |
| dst_alpha_scan++; |
| src_scan += 4; |
| continue; |
| } |
| *dst_alpha_scan = FXDIB_ALPHA_UNION(back_alpha, src_alpha); |
| int alpha_ratio = src_alpha * 255 / (*dst_alpha_scan); |
| uint8_t gray; |
| if (pIccTransform) |
| pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1); |
| else |
| gray = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan); |
| |
| *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio); |
| dest_scan++; |
| dst_alpha_scan++; |
| src_scan += 4; |
| } |
| } |
| return; |
| } |
| if (src_alpha_scan) { |
| for (int col = 0; col < pixel_count; col++) { |
| uint8_t back_alpha = *dst_alpha_scan; |
| if (back_alpha == 0) { |
| int src_alpha = *src_alpha_scan++; |
| if (clip_scan) |
| src_alpha = clip_scan[col] * src_alpha / 255; |
| |
| if (src_alpha) { |
| if (pIccTransform) { |
| pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan, |
| 1); |
| } else { |
| *dest_scan = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan); |
| } |
| *dst_alpha_scan = src_alpha; |
| } |
| dest_scan++; |
| dst_alpha_scan++; |
| src_scan += 3; |
| continue; |
| } |
| uint8_t src_alpha = *src_alpha_scan++; |
| if (clip_scan) |
| src_alpha = clip_scan[col] * src_alpha / 255; |
| |
| if (src_alpha == 0) { |
| dest_scan++; |
| dst_alpha_scan++; |
| src_scan += 3; |
| continue; |
| } |
| *dst_alpha_scan = FXDIB_ALPHA_UNION(back_alpha, src_alpha); |
| int alpha_ratio = src_alpha * 255 / (*dst_alpha_scan); |
| uint8_t gray; |
| if (pIccTransform) |
| pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1); |
| else |
| gray = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan); |
| |
| *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio); |
| dest_scan++; |
| dst_alpha_scan++; |
| src_scan += 3; |
| } |
| } else { |
| for (int col = 0; col < pixel_count; col++) { |
| uint8_t back_alpha = *dst_alpha_scan; |
| if (back_alpha == 0) { |
| int src_alpha = src_scan[3]; |
| if (clip_scan) |
| src_alpha = clip_scan[col] * src_alpha / 255; |
| |
| if (src_alpha) { |
| if (pIccTransform) { |
| pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan, |
| 1); |
| } else { |
| *dest_scan = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan); |
| } |
| *dst_alpha_scan = src_alpha; |
| } |
| dest_scan++; |
| dst_alpha_scan++; |
| src_scan += 4; |
| continue; |
| } |
| uint8_t src_alpha = src_scan[3]; |
| if (clip_scan) |
| src_alpha = clip_scan[col] * src_alpha / 255; |
| |
| if (src_alpha == 0) { |
| dest_scan++; |
| dst_alpha_scan++; |
| src_scan += 4; |
| continue; |
| } |
| *dst_alpha_scan = FXDIB_ALPHA_UNION(back_alpha, src_alpha); |
| int alpha_ratio = src_alpha * 255 / (*dst_alpha_scan); |
| uint8_t gray; |
| if (pIccTransform) |
| pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1); |
| else |
| gray = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan); |
| |
| *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio); |
| dest_scan++; |
| dst_alpha_scan++; |
| src_scan += 4; |
| } |
| } |
| } |
| |
| 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(); |
| |
| if (blend_type) { |
| FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE; |
| if (src_alpha_scan) { |
| for (int col = 0; col < pixel_count; col++) { |
| int src_alpha = *src_alpha_scan++; |
| if (clip_scan) |
| src_alpha = clip_scan[col] * src_alpha / 255; |
| |
| if (src_alpha) { |
| if (pIccTransform) |
| pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1); |
| else |
| gray = FXRGB2GRAY(src_scan[2], src_scan[1], *src_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, src_alpha); |
| } |
| dest_scan++; |
| src_scan += 3; |
| } |
| } else { |
| for (int col = 0; col < pixel_count; col++) { |
| int src_alpha = src_scan[3]; |
| if (clip_scan) |
| src_alpha = clip_scan[col] * src_alpha / 255; |
| |
| if (src_alpha) { |
| if (pIccTransform) |
| pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1); |
| else |
| gray = FXRGB2GRAY(src_scan[2], src_scan[1], *src_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, src_alpha); |
| } |
| dest_scan++; |
| src_scan += 4; |
| } |
| } |
| return; |
| } |
| if (src_alpha_scan) { |
| for (int col = 0; col < pixel_count; col++) { |
| int src_alpha = *src_alpha_scan++; |
| if (clip_scan) |
| src_alpha = clip_scan[col] * src_alpha / 255; |
| |
| if (src_alpha) { |
| if (pIccTransform) |
| pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1); |
| else |
| gray = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan); |
| |
| *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, src_alpha); |
| } |
| dest_scan++; |
| src_scan += 3; |
| } |
| } else { |
| for (int col = 0; col < pixel_count; col++) { |
| int src_alpha = src_scan[3]; |
| if (clip_scan) |
| src_alpha = clip_scan[col] * src_alpha / 255; |
| |
| if (src_alpha) { |
| if (pIccTransform) |
| pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1); |
| else |
| gray = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan); |
| |
| *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, src_alpha); |
| } |
| dest_scan++; |
| src_scan += 4; |
| } |
| } |
| } |
| |
| 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(); |
| } |
| if (blend_type) { |
| FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE; |
| for (int col = 0; col < pixel_count; col++) { |
| if (pIccTransform) { |
| pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1); |
| } else { |
| gray = FXRGB2GRAY(src_scan[2], src_scan[1], *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 += src_Bpp; |
| } |
| return; |
| } |
| for (int col = 0; col < pixel_count; col++) { |
| if (pIccTransform) { |
| pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1); |
| } else { |
| gray = FXRGB2GRAY(src_scan[2], src_scan[1], *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 += 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(); |
| } |
| if (blend_type) { |
| FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE; |
| for (int col = 0; col < pixel_count; col++) { |
| int back_alpha = *dest_alpha_scan; |
| if (back_alpha == 0) { |
| if (pIccTransform) { |
| pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan, 1); |
| } else { |
| *dest_scan = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan); |
| } |
| dest_scan++; |
| dest_alpha_scan++; |
| src_scan += src_Bpp; |
| continue; |
| } |
| int src_alpha = 255; |
| if (clip_scan) { |
| src_alpha = clip_scan[col]; |
| } |
| if (src_alpha == 0) { |
| dest_scan++; |
| dest_alpha_scan++; |
| src_scan += src_Bpp; |
| 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; |
| uint8_t gray; |
| if (pIccTransform) { |
| pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1); |
| } else { |
| gray = FXRGB2GRAY(src_scan[2], src_scan[1], *src_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_scan++; |
| src_scan += src_Bpp; |
| } |
| return; |
| } |
| for (int col = 0; col < pixel_count; col++) { |
| int src_alpha = 255; |
| if (clip_scan) { |
| src_alpha = clip_scan[col]; |
| } |
| if (src_alpha == 255) { |
| if (pIccTransform) { |
| pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan, 1); |
| } else { |
| *dest_scan = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan); |
| } |
| dest_scan++; |
| *dest_alpha_scan++ = 255; |
| 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; |
| int alpha_ratio = src_alpha * 255 / dest_alpha; |
| uint8_t gray; |
| if (pIccTransform) { |
| pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1); |
| } else { |
| gray = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan); |
| } |
| *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]; |
| FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE; |
| if (!dest_alpha_scan) { |
| if (!src_alpha_scan) { |
| uint8_t back_alpha = 0; |
| for (int col = 0; col < pixel_count; col++) { |
| back_alpha = dest_scan[3]; |
| if (back_alpha == 0) { |
| if (clip_scan) { |
| int src_alpha = clip_scan[col] * src_scan[3] / 255; |
| FXARGB_SETDIB(dest_scan, (FXARGB_GETDIB(src_scan) & 0xffffff) | |
| (src_alpha << 24)); |
| } else { |
| FXARGB_COPY(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) { |
| 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++; |
| } |
| dest_scan++; |
| src_scan++; |
| } |
| } else { |
| 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_alpha_scan) / 255; |
| FXARGB_SETDIB(dest_scan, FXARGB_MAKE((src_alpha << 24), src_scan[2], |
| src_scan[1], *src_scan)); |
| } else { |
| FXARGB_SETDIB(dest_scan, |
| FXARGB_MAKE((*src_alpha_scan << 24), src_scan[2], |
| src_scan[1], *src_scan)); |
| } |
| dest_scan += 4; |
| src_scan += 3; |
| 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; |
| src_scan += 3; |
| 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) { |
| 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++; |
| } |
| dest_scan++; |
| } |
| } |
| } else { |
| if (src_alpha_scan) { |
| for (int col = 0; col < pixel_count; col++) { |
| uint8_t back_alpha = *dest_alpha_scan; |
| if (back_alpha == 0) { |
| if (clip_scan) { |
| int src_alpha = clip_scan[col] * (*src_alpha_scan) / 255; |
| *dest_alpha_scan = src_alpha; |
| *dest_scan++ = *src_scan++; |
| *dest_scan++ = *src_scan++; |
| *dest_scan++ = *src_scan++; |
| } else { |
| *dest_alpha_scan = *src_alpha_scan; |
| *dest_scan++ = *src_scan++; |
| *dest_scan++ = *src_scan++; |
| *dest_scan++ = *src_scan++; |
| } |
| dest_alpha_scan++; |
| 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 += 3; |
| src_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_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++; |
| } |
| } |
| } else { |
| for (int col = 0; col < pixel_count; col++) { |
| 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_scan++; |
| *dest_scan++ = *src_scan++; |
| *dest_scan++ = *src_scan++; |
| } else { |
| *dest_alpha_scan = src_scan[3]; |
| *dest_scan++ = *src_scan++; |
| *dest_scan++ = *src_scan++; |
| *dest_scan++ = *src_scan++; |
| } |
| dest_alpha_scan++; |
| src_scan++; |
| 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 += 3; |
| src_scan += 4; |
| 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_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++; |
| } |
| 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]; |
| FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE; |
| int src_gap = src_Bpp - 3; |
| if (dest_alpha_scan) { |
| for (int col = 0; col < width; col++) { |
| uint8_t back_alpha = *dest_alpha_scan; |
| if (back_alpha == 0) { |
| *dest_scan++ = *src_scan++; |
| *dest_scan++ = *src_scan++; |
| *dest_scan++ = *src_scan++; |
| *dest_alpha_scan++ = 0xff; |
| src_scan += src_gap; |
| continue; |
| } |
| *dest_alpha_scan++ = 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++; |
| } |
| src_scan += src_gap; |
| } |
| } else { |
| for (int col = 0; col < width; col++) { |
| uint8_t back_alpha = dest_scan[3]; |
| if (back_alpha == 0) { |
| 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_scan[3] = 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++; |
| } |
| 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]; |
| FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE; |
| int src_gap = src_Bpp - 3; |
| if (dest_alpha_scan) { |
| for (int col = 0; col < width; col++) { |
| int src_alpha = *clip_scan++; |
| uint8_t back_alpha = *dest_alpha_scan; |
| if (back_alpha == 0) { |
| *dest_scan++ = *src_scan++; |
| *dest_scan++ = *src_scan++; |
| *dest_scan++ = *src_scan++; |
| src_scan += src_gap; |
| dest_alpha_scan++; |
| continue; |
| } |
| if (src_alpha == 0) { |
| dest_scan += 3; |
| dest_alpha_scan++; |
| src_scan += src_Bpp; |
| 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_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; |
| } |
| } else { |
| 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++ = *src_scan++; |
| *dest_scan++ = *src_scan++; |
| *dest_scan++ = *src_scan++; |
| src_scan += src_gap; |
| dest_scan++; |
| 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) { |
| 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++; |
| } |
| dest_scan++; |
| src_scan += src_gap; |
| } |
| } |
| } |
| |
| 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]; |
| FX_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]; |
| FX_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]; |
| FX_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]; |
| FX_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]; |
| FX_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) { |
| FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE; |
| for (int col = 0; col < pixel_count; col++) { |
| uint8_t gray = pPalette[*src_scan]; |
| int src_alpha = *src_alpha_scan++; |
| if (clip_scan) { |
| src_alpha = clip_scan[col] * src_alpha / 255; |
| } |
| 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 = *src_alpha_scan++; |
| if (clip_scan) { |
| src_alpha = clip_scan[col] * src_alpha / 255; |
| } |
| 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) { |
| FX_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) { |
| FX_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 = *src_alpha_scan++; |
| if (clip_scan) { |
| src_alpha = clip_scan[col] * src_alpha / 255; |
| } |
| if (src_alpha) { |
| *dest_scan = gray; |
| *dest_alpha_scan = src_alpha; |
| } |
| dest_scan++; |
| dest_alpha_scan++; |
| continue; |
| } |
| uint8_t src_alpha = *src_alpha_scan++; |
| if (clip_scan) { |
| src_alpha = clip_scan[col] * src_alpha / 255; |
| } |
| 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 = *src_alpha_scan++; |
| if (clip_scan) { |
| src_alpha = clip_scan[col] * src_alpha / 255; |
| } |
| if (src_alpha) { |
| *dest_scan = gray; |
| *dest_alpha_scan = src_alpha; |
| } |
| dest_scan++; |
| dest_alpha_scan++; |
| continue; |
| } |
| uint8_t src_alpha = *src_alpha_scan++; |
| if (clip_scan) { |
| src_alpha = clip_scan[col] * src_alpha / 255; |
| } |
| 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) { |
| FX_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) { |
| FX_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) { |
| FX_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, |
|
