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,