Remove more dead code in CFX_ScanlineCompositor.
Remove alpha channel span parameters from various CompositeRow functions
when the span is always empty. Then remove dead code in the CompositeRow
functions.
Change-Id: Ib0e05dd0eb2c89f2ff975ae0067c54ddd1e2cdc6
Reviewed-on: https://pdfium-review.googlesource.com/c/pdfium/+/101892
Reviewed-by: Tom Sepez <tsepez@chromium.org>
Commit-Queue: Lei Zhang <thestig@chromium.org>
diff --git a/core/fxge/dib/cfx_scanlinecompositor.cpp b/core/fxge/dib/cfx_scanlinecompositor.cpp
index 70b7936..b8b3ac4 100644
--- a/core/fxge/dib/cfx_scanlinecompositor.cpp
+++ b/core/fxge/dib/cfx_scanlinecompositor.cpp
@@ -264,23 +264,19 @@
pdfium::span<const uint8_t> src_span,
int pixel_count,
BlendMode blend_type,
- pdfium::span<const uint8_t> clip_span,
- pdfium::span<const uint8_t> src_alpha_span) {
+ pdfium::span<const uint8_t> clip_span) {
uint8_t* dest_scan = dest_span.data();
const uint8_t* src_scan = src_span.data();
const uint8_t* clip_scan = clip_span.data();
- const uint8_t* src_alpha_scan = src_alpha_span.data();
- uint8_t offset = src_alpha_scan ? 3 : 4;
+ constexpr size_t kOffset = 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);
+ int src_alpha = GetAlpha(src_scan[3], clip_scan, col);
if (src_alpha) {
uint8_t gray = GetGrayWithBlend(src_scan, dest_scan, blend_type);
*dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, src_alpha);
}
++dest_scan;
- src_scan += offset;
+ src_scan += kOffset;
}
}
@@ -308,64 +304,34 @@
pdfium::span<const uint8_t> src_span,
int pixel_count,
BlendMode blend_type,
- pdfium::span<const uint8_t> clip_span,
- pdfium::span<uint8_t> dest_alpha_span,
- pdfium::span<const uint8_t> src_alpha_span) {
+ pdfium::span<const uint8_t> clip_span) {
uint8_t* dest_scan = dest_span.data();
const uint8_t* src_scan = src_span.data();
const uint8_t* clip_scan = clip_span.data();
- uint8_t* dest_alpha_scan = dest_alpha_span.data();
- const uint8_t* src_alpha_scan = src_alpha_span.data();
int blended_colors[3];
- uint8_t dest_offset = dest_alpha_scan ? 3 : 4;
- uint8_t src_offset = src_alpha_scan ? 3 : 4;
+ constexpr size_t kOffset = 4;
bool bNonseparableBlend = IsNonSeparableBlendMode(blend_type);
- 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);
+ uint8_t back_alpha = dest_scan[3];
+ uint8_t src_alpha = GetAlpha(src_scan[3], 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 {
- memcpy(dest_scan, src_scan, 4);
- }
- } else if (has_dest) {
- *dest_alpha_scan = src_alpha;
- memcpy(dest_scan, src_scan, 3);
- dest_scan += 3;
- src_scan += 3;
- ++dest_alpha_scan;
- if (!has_src)
- ++src_scan;
+ if (clip_scan) {
+ FXARGB_SETDIB(dest_scan,
+ (FXARGB_GETDIB(src_scan) & 0xffffff) | (src_alpha << 24));
} else {
- FXARGB_SETDIB(dest_scan, ArgbEncode((src_alpha << 24), src_scan[2],
- src_scan[1], *src_scan));
+ memcpy(dest_scan, src_scan, 4);
}
- if (!has_dest) {
- dest_scan += dest_offset;
- src_scan += src_offset;
- }
+ dest_scan += kOffset;
+ src_scan += kOffset;
continue;
}
if (src_alpha == 0) {
- dest_scan += dest_offset;
- src_scan += src_offset;
- if (has_dest)
- ++dest_alpha_scan;
+ dest_scan += kOffset;
+ src_scan += kOffset;
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;
- }
+ 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);
@@ -382,10 +348,8 @@
++dest_scan;
++src_scan;
}
- if (!has_dest)
- ++dest_scan;
- if (!has_src)
- ++src_scan;
+ ++dest_scan;
+ ++src_scan;
}
}
@@ -393,33 +357,23 @@
pdfium::span<const uint8_t> src_span,
int width,
BlendMode blend_type,
- int src_Bpp,
- pdfium::span<uint8_t> dest_alpha_span) {
+ int src_Bpp) {
uint8_t* dest_scan = dest_span.data();
const uint8_t* src_scan = src_span.data();
- uint8_t* dest_alpha_scan = dest_alpha_span.data();
int blended_colors[3];
bool bNonseparableBlend = IsNonSeparableBlendMode(blend_type);
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* dest_alpha = &dest_scan[3];
uint8_t back_alpha = *dest_alpha;
if (back_alpha == 0) {
- if (dest_alpha_scan) {
- memcpy(dest_scan, src_scan, 3);
- dest_scan += 3;
- src_scan += 3;
- *dest_alpha_scan = 0xff;
- ++dest_alpha_scan;
+ if (src_Bpp == 4) {
+ FXARGB_SETDIB(dest_scan, 0xff000000 | FXARGB_GETDIB(src_scan));
} else {
- if (src_Bpp == 4) {
- FXARGB_SETDIB(dest_scan, 0xff000000 | FXARGB_GETDIB(src_scan));
- } else {
- FXARGB_SETDIB(dest_scan, ArgbEncode(0xff, src_scan[2], src_scan[1],
- src_scan[0]));
- }
- dest_scan += 4;
+ FXARGB_SETDIB(dest_scan,
+ ArgbEncode(0xff, src_scan[2], src_scan[1], src_scan[0]));
}
+ dest_scan += 4;
src_scan += src_Bpp;
continue;
}
@@ -435,10 +389,7 @@
++dest_scan;
++src_scan;
}
- if (dest_alpha_scan)
- ++dest_alpha_scan;
- else
- ++dest_scan;
+ ++dest_scan;
src_scan += src_gap;
}
}
@@ -448,41 +399,30 @@
int width,
BlendMode blend_type,
int src_Bpp,
- pdfium::span<const uint8_t> clip_span,
- pdfium::span<uint8_t> dest_alpha_span) {
+ pdfium::span<const uint8_t> clip_span) {
uint8_t* dest_scan = dest_span.data();
const uint8_t* src_scan = src_span.data();
const uint8_t* clip_scan = clip_span.data();
- uint8_t* dest_alpha_scan = dest_alpha_span.data();
int blended_colors[3];
bool bNonseparableBlend = IsNonSeparableBlendMode(blend_type);
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];
+ uint8_t back_alpha = dest_scan[3];
if (back_alpha == 0) {
memcpy(dest_scan, src_scan, 3);
dest_scan += 3;
src_scan += src_Bpp;
- if (has_dest)
- dest_alpha_scan++;
- else
- dest_scan++;
+ dest_scan++;
continue;
}
if (src_alpha == 0) {
- dest_scan += has_dest ? 3 : 4;
- if (has_dest)
- dest_alpha_scan++;
+ dest_scan += 4;
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;
+ 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);
@@ -497,8 +437,7 @@
src_scan++;
}
src_scan += src_gap;
- if (!has_dest)
- dest_scan++;
+ dest_scan++;
}
}
@@ -506,99 +445,54 @@
pdfium::span<const uint8_t> src_span,
int width,
int src_Bpp,
- pdfium::span<const uint8_t> clip_span,
- pdfium::span<uint8_t> dest_alpha_span) {
+ pdfium::span<const uint8_t> clip_span) {
uint8_t* dest_scan = dest_span.data();
const uint8_t* src_scan = src_span.data();
const uint8_t* clip_scan = clip_span.data();
- uint8_t* dest_alpha_scan = dest_alpha_span.data();
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) {
- memcpy(dest_scan, src_scan, 3);
- dest_scan += 3;
- src_scan += src_Bpp;
- *dest_alpha_scan++ = 255;
- 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;
+ for (int col = 0; col < width; col++) {
+ int src_alpha = clip_scan[col];
+ if (src_alpha == 255) {
+ memcpy(dest_scan, src_scan, 3);
+ dest_scan += 3;
+ *dest_scan++ = 255;
+ src_scan += src_Bpp;
+ continue;
}
- } else {
- for (int col = 0; col < width; col++) {
- int src_alpha = clip_scan[col];
- if (src_alpha == 255) {
- memcpy(dest_scan, src_scan, 3);
- dest_scan += 3;
- *dest_scan++ = 255;
- src_scan += src_Bpp;
- 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++;
- }
+ 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 += src_gap;
+ src_scan++;
}
+ dest_scan++;
+ src_scan += src_gap;
}
}
-void CompositeRow_Rgb2Argb_NoBlend_NoClip(
- pdfium::span<uint8_t> dest_span,
- pdfium::span<const uint8_t> src_span,
- int width,
- int src_Bpp,
- pdfium::span<uint8_t> dest_alpha_span) {
+void CompositeRow_Rgb2Argb_NoBlend_NoClip(pdfium::span<uint8_t> dest_span,
+ pdfium::span<const uint8_t> src_span,
+ int width,
+ int src_Bpp) {
uint8_t* dest_scan = dest_span.data();
const uint8_t* src_scan = src_span.data();
- uint8_t* dest_alpha_scan = dest_alpha_span.data();
- if (dest_alpha_scan) {
- for (int col = 0; col < width; col++) {
- memcpy(dest_scan, src_scan, 3);
- dest_scan += 3;
- src_scan += src_Bpp;
- *dest_alpha_scan++ = 255;
+ 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,
+ ArgbEncode(0xff, src_scan[2], src_scan[1], src_scan[0]));
}
- } 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,
- ArgbEncode(0xff, src_scan[2], src_scan[1], src_scan[0]));
- }
- dest_scan += 4;
- src_scan += src_Bpp;
- }
+ dest_scan += 4;
+ src_scan += src_Bpp;
}
}
@@ -607,70 +501,39 @@
int width,
BlendMode blend_type,
int dest_Bpp,
- pdfium::span<const uint8_t> clip_span,
- pdfium::span<const uint8_t> src_alpha_span) {
+ pdfium::span<const uint8_t> clip_span) {
uint8_t* dest_scan = dest_span.data();
const uint8_t* src_scan = src_span.data();
const uint8_t* clip_scan = clip_span.data();
- const uint8_t* src_alpha_scan = src_alpha_span.data();
int blended_colors[3];
bool bNonseparableBlend = IsNonSeparableBlendMode(blend_type);
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;
+ 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];
}
- } 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;
+ 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++;
}
}
@@ -678,66 +541,36 @@
pdfium::span<const uint8_t> src_span,
int width,
int dest_Bpp,
- pdfium::span<const uint8_t> clip_span,
- pdfium::span<const uint8_t> src_alpha_span) {
+ pdfium::span<const uint8_t> clip_span) {
uint8_t* dest_scan = dest_span.data();
const uint8_t* src_scan = src_span.data();
const uint8_t* clip_scan = clip_span.data();
- const uint8_t* src_alpha_scan = src_alpha_span.data();
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) {
- memcpy(dest_scan, src_scan, 3);
- dest_scan += dest_Bpp;
- src_scan += 3;
- 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;
+ 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];
}
- } 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) {
- memcpy(dest_scan, src_scan, 3);
- dest_scan += dest_Bpp;
- src_scan += 4;
- 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;
+ if (src_alpha == 255) {
+ memcpy(dest_scan, src_scan, 3);
+ dest_scan += dest_Bpp;
+ src_scan += 4;
+ 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++;
}
}
@@ -864,62 +697,19 @@
pdfium::span<const uint8_t> palette_span,
int pixel_count,
BlendMode blend_type,
- pdfium::span<const uint8_t> clip_span,
- pdfium::span<const uint8_t> src_alpha_span) {
+ pdfium::span<const uint8_t> clip_span) {
uint8_t* dest_scan = dest_span.data();
const uint8_t* src_scan = src_span.data();
const uint8_t* clip_scan = clip_span.data();
- const uint8_t* src_alpha_scan = src_alpha_span.data();
const uint8_t* pPalette = palette_span.data();
- if (src_alpha_scan) {
- if (blend_type != BlendMode::kNormal) {
- bool bNonseparableBlend = IsNonSeparableBlendMode(blend_type);
- 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 == BlendMode::kLuminosity ? 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;
- }
+ if (blend_type != BlendMode::kNormal) {
+ bool bNonseparableBlend = IsNonSeparableBlendMode(blend_type);
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);
+ if (bNonseparableBlend)
+ gray = blend_type == BlendMode::kLuminosity ? gray : *dest_scan;
else
- *dest_scan = gray;
- dest_scan++;
- src_scan++;
- }
- } else {
- if (blend_type != BlendMode::kNormal) {
- bool bNonseparableBlend = IsNonSeparableBlendMode(blend_type);
- for (int col = 0; col < pixel_count; col++) {
- uint8_t gray = pPalette[*src_scan];
- if (bNonseparableBlend)
- gray = blend_type == BlendMode::kLuminosity ? 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];
+ 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
@@ -927,6 +717,16 @@
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++;
}
}
@@ -976,77 +776,38 @@
}
}
-void CompositeRow_8bppRgb2Rgb_NoBlend(
- pdfium::span<uint8_t> dest_span,
- pdfium::span<const uint8_t> src_span,
- pdfium::span<const uint32_t> palette_span,
- int pixel_count,
- int DestBpp,
- pdfium::span<const uint8_t> clip_span,
- pdfium::span<const uint8_t> src_alpha_span) {
+void CompositeRow_8bppRgb2Rgb_NoBlend(pdfium::span<uint8_t> dest_span,
+ pdfium::span<const uint8_t> src_span,
+ pdfium::span<const uint32_t> palette_span,
+ int pixel_count,
+ int DestBpp,
+ pdfium::span<const uint8_t> clip_span) {
uint8_t* dest_scan = dest_span.data();
const uint8_t* src_scan = src_span.data();
const uint8_t* clip_scan = clip_span.data();
- const uint8_t* src_alpha_scan = src_alpha_span.data();
const uint32_t* pPalette = palette_span.data();
- 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);
+ 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, src_alpha);
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, clip_scan[col]);
dest_scan++;
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, src_alpha);
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, clip_scan[col]);
dest_scan++;
- dest_scan += dest_gap;
+ } else {
+ *dest_scan++ = src_b;
+ *dest_scan++ = src_g;
+ *dest_scan++ = src_r;
}
- } 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++;
+ if (DestBpp == 4) {
+ dest_scan++;
}
+ src_scan++;
}
}
@@ -1102,85 +863,42 @@
pdfium::span<const uint8_t> src_span,
int width,
pdfium::span<const uint32_t> palette_span,
- pdfium::span<const uint8_t> clip_span,
- pdfium::span<const uint8_t> src_alpha_span) {
+ pdfium::span<const uint8_t> clip_span) {
uint8_t* dest_scan = dest_span.data();
const uint8_t* src_scan = src_span.data();
const uint8_t* clip_scan = clip_span.data();
- const uint8_t* src_alpha_scan = src_alpha_span.data();
const uint32_t* pPalette = palette_span.data();
- if (src_alpha_scan) {
- for (int col = 0; col < width; col++) {
- FX_ARGB argb = pPalette[*src_scan];
+ 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++;
- 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, ArgbEncode(src_alpha, src_r, src_g, src_b));
- } else {
- FXARGB_SETDIB(dest_scan,
- ArgbEncode(*src_alpha_scan, src_r, src_g, src_b));
- }
- dest_scan += 4;
- src_alpha_scan++;
- continue;
- }
- uint8_t src_alpha = GetAlpha(*src_alpha_scan, clip_scan, col);
- ++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++;
+ continue;
}
- } 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++;
+ 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++;
}
}
@@ -2673,9 +2391,8 @@
} else if (GetBppFromFormat(m_DestFormat) == 8) {
DCHECK(!GetIsAlphaFromFormat(m_DestFormat));
if (GetIsAlphaFromFormat(m_SrcFormat)) {
- // TODO(thestig): Check if empty span argument is always empty.
- CompositeRow_Argb2Gray(dest_scan, src_scan, width, m_BlendType, clip_scan,
- {});
+ CompositeRow_Argb2Gray(dest_scan, src_scan, width, m_BlendType,
+ clip_scan);
} else {
CompositeRow_Rgb2Gray(dest_scan, src_scan, src_Bpp, width, m_BlendType,
clip_scan);
@@ -2686,41 +2403,34 @@
case 4:
case 8:
case 4 + 8: {
- // TODO(thestig): Check if empty span arguments are always empty.
CompositeRow_Argb2Argb(dest_scan, src_scan, width, m_BlendType,
- clip_scan, {}, {});
+ clip_scan);
} break;
case 1:
- // TODO(thestig): Check if empty span argument is always empty.
CompositeRow_Rgb2Argb_Blend_NoClip(dest_scan, src_scan, width,
- m_BlendType, src_Bpp, {});
+ m_BlendType, src_Bpp);
break;
case 1 + 8:
- // TODO(thestig): Check if empty span argument is always empty.
CompositeRow_Rgb2Argb_Blend_Clip(dest_scan, src_scan, width,
- m_BlendType, src_Bpp, clip_scan, {});
+ m_BlendType, src_Bpp, clip_scan);
break;
case 1 + 4:
- // TODO(thestig): Check if empty span argument is always empty.
CompositeRow_Rgb2Argb_NoBlend_NoClip(dest_scan, src_scan, width,
- src_Bpp, {});
+ src_Bpp);
break;
case 1 + 4 + 8:
- // TODO(thestig): Check if empty span argument is always empty.
CompositeRow_Rgb2Argb_NoBlend_Clip(dest_scan, src_scan, width, src_Bpp,
- clip_scan, {});
+ clip_scan);
break;
case 2:
case 2 + 8:
- // TODO(thestig): Check if empty span argument is always empty.
CompositeRow_Argb2Rgb_Blend(dest_scan, src_scan, width, m_BlendType,
- dest_Bpp, clip_scan, {});
+ dest_Bpp, clip_scan);
break;
case 2 + 4:
case 2 + 4 + 8:
- // TODO(thestig): Check if empty span argument is always empty.
CompositeRow_Argb2Rgb_NoBlend(dest_scan, src_scan, width, dest_Bpp,
- clip_scan, {});
+ clip_scan);
break;
case 1 + 2:
CompositeRow_Rgb2Rgb_Blend_NoClip(dest_scan, src_scan, width,
@@ -2789,18 +2499,16 @@
m_SrcPalette.Get8BitPalette(), width,
m_BlendType, clip_scan);
} else {
- // TODO(thestig): Check if empty span argument is always empty.
CompositeRow_8bppPal2Gray(dest_scan, src_scan,
m_SrcPalette.Get8BitPalette(), width,
- m_BlendType, clip_scan, {});
+ m_BlendType, clip_scan);
}
} else {
switch (m_iTransparency) {
case 1 + 2:
- // TODO(thestig): Check if empty span argument is always empty.
CompositeRow_8bppRgb2Argb_NoBlend(dest_scan, src_scan, width,
m_SrcPalette.Get32BitPalette(),
- clip_scan, {});
+ clip_scan);
break;
case 1 + 2 + 8:
CompositeRow_1bppRgb2Argb_NoBlend(dest_scan, src_scan, src_left, width,
@@ -2808,22 +2516,16 @@
clip_scan);
break;
case 0:
- // TODO(thestig): Check if empty span argument is always empty.
+ case 0 + 2:
CompositeRow_8bppRgb2Rgb_NoBlend(
dest_scan, src_scan, m_SrcPalette.Get32BitPalette(), width,
- GetCompsFromFormat(m_DestFormat), clip_scan, {});
+ GetCompsFromFormat(m_DestFormat), clip_scan);
break;
case 0 + 8:
CompositeRow_1bppRgb2Rgb_NoBlend(
dest_scan, src_scan, src_left, m_SrcPalette.Get32BitPalette(),
width, GetCompsFromFormat(m_DestFormat), clip_scan);
break;
- case 0 + 2:
- // TODO(thestig): Check if empty span argument is always empty.
- CompositeRow_8bppRgb2Rgb_NoBlend(
- dest_scan, src_scan, m_SrcPalette.Get32BitPalette(), width,
- GetCompsFromFormat(m_DestFormat), clip_scan, {});
- break;
case 0 + 2 + 8:
// TODO(thestig): Check if empty span argument is always empty.
CompositeRow_1bppRgb2Rgba_NoBlend(dest_scan, src_scan, src_left, width,
