diff --git a/core/fxge/dib/cfx_dibbase.cpp b/core/fxge/dib/cfx_dibbase.cpp
index e8662f2..0a973ad 100644
--- a/core/fxge/dib/cfx_dibbase.cpp
+++ b/core/fxge/dib/cfx_dibbase.cpp
@@ -1167,8 +1167,7 @@
       }
       return false;
     }
-    case FXDIB_Format::kRgb:
-    case FXDIB_Format::kRgba: {
+    case FXDIB_Format::kRgb: {
       return ConvertBuffer_Rgb(bpp, dest_format, dest_buf, dest_pitch, width,
                                height, pSrcBitmap, src_left, src_top);
     }
diff --git a/core/fxge/dib/cfx_dibitmap.cpp b/core/fxge/dib/cfx_dibitmap.cpp
index 6ce40bb..98abe25 100644
--- a/core/fxge/dib/cfx_dibitmap.cpp
+++ b/core/fxge/dib/cfx_dibitmap.cpp
@@ -135,8 +135,7 @@
       memset(pBuffer, index, m_Pitch * m_Height);
       break;
     }
-    case FXDIB_Format::kRgb:
-    case FXDIB_Format::kRgba: {
+    case FXDIB_Format::kRgb: {
       int a;
       int r;
       int g;
@@ -547,7 +546,6 @@
       return HasPalette() ? GetPaletteSpan()[*pos]
                           : (0xff000000 | ((*pos) * 0x10101));
     case FXDIB_Format::kRgb:
-    case FXDIB_Format::kRgba:
     case FXDIB_Format::kRgb32:
       return FXARGB_GETDIB(pos) | 0xff000000;
     case FXDIB_Format::kArgb:
@@ -617,12 +615,6 @@
       pos[2] = (FXARGB_R(color) * alpha + pos[2] * (255 - alpha)) / 255;
       break;
     }
-    case FXDIB_Format::kRgba: {
-      pos[0] = FXARGB_B(color);
-      pos[1] = FXARGB_G(color);
-      pos[2] = FXARGB_R(color);
-      break;
-    }
     case FXDIB_Format::kArgb:
       FXARGB_SETDIB(pos, color);
       break;
diff --git a/core/fxge/dib/cfx_imagetransformer.cpp b/core/fxge/dib/cfx_imagetransformer.cpp
index ebf898f..4604955 100644
--- a/core/fxge/dib/cfx_imagetransformer.cpp
+++ b/core/fxge/dib/cfx_imagetransformer.cpp
@@ -101,24 +101,8 @@
   v_w[3] = SDP_Table[512 - res_y];
 }
 
-FXDIB_Format GetTransformedFormat(const RetainPtr<CFX_DIBBase>& pDrc) {
-  if (pDrc->IsMask())
-    return FXDIB_Format::k8bppMask;
-
-  FXDIB_Format format = pDrc->GetFormat();
-  if (HasNoFlags(format) || format == FXDIB_Format::kArgb)
-    return FXDIB_Format::kArgb;
-  return FXDIB_Format::kRgba;
-}
-
-void WriteMonoResult(uint32_t r_bgra_cmyk, FXDIB_Format format, uint8_t* dest) {
-  if (format == FXDIB_Format::kRgba) {
-    dest[0] = static_cast<uint8_t>(r_bgra_cmyk >> 24);
-    dest[1] = static_cast<uint8_t>(r_bgra_cmyk >> 16);
-    dest[2] = static_cast<uint8_t>(r_bgra_cmyk >> 8);
-  } else {
-    *reinterpret_cast<uint32_t*>(dest) = r_bgra_cmyk;
-  }
+FXDIB_Format GetTransformedFormat(const RetainPtr<CFX_DIBBase>& pSrc) {
+  return pSrc->IsMask() ? FXDIB_Format::k8bppMask : FXDIB_Format::kArgb;
 }
 
 // Let the compiler deduce the type for |func|, which cheaper than specifying it
@@ -136,10 +120,6 @@
   if (bHasAlpha) {
     if (format == FXDIB_Format::kArgb) {
       *dest32 = ArgbEncode(func(3), red_y, green_m, blue_c);
-    } else if (format == FXDIB_Format::kRgba) {
-      dest[0] = blue_c;
-      dest[1] = green_m;
-      dest[2] = red_y;
     } else {
       *dest32 = FXCMYK_TODIB(CmykEncode(blue_c, green_m, red_y, func(3)));
     }
@@ -518,30 +498,27 @@
   }
   int destBpp = cdata.bitmap->GetBPP() / 8;
   if (IsBilinear()) {
-    auto func = [&cdata, format, &argb](const BilinearData& data,
-                                        uint8_t* dest) {
+    auto func = [&cdata, &argb](const BilinearData& data, uint8_t* dest) {
       uint8_t idx = bilinear_interpol(
           cdata.buf, data.row_offset_l, data.row_offset_r, data.src_col_l,
           data.src_col_r, data.res_x, data.res_y, 1, 0);
       uint32_t r_bgra_cmyk = argb[idx];
-      WriteMonoResult(r_bgra_cmyk, format, dest);
+      *reinterpret_cast<uint32_t*>(dest) = r_bgra_cmyk;
     };
     DoBilinearLoop(cdata, m_result, m_StretchClip, destBpp, func);
   } else if (IsBiCubic()) {
-    auto func = [&cdata, format, &argb](const BicubicData& data,
-                                        uint8_t* dest) {
+    auto func = [&cdata, &argb](const BicubicData& data, uint8_t* dest) {
       uint32_t r_bgra_cmyk = argb[bicubic_interpol(
           cdata.buf, cdata.pitch, data.pos_pixel, data.u_w, data.v_w,
           data.res_x, data.res_y, 1, 0)];
-      WriteMonoResult(r_bgra_cmyk, format, dest);
+      *reinterpret_cast<uint32_t*>(dest) = r_bgra_cmyk;
     };
     DoBicubicLoop(cdata, m_result, m_StretchClip, destBpp, func);
   } else {
-    auto func = [&cdata, format, &argb](const DownSampleData& data,
-                                        uint8_t* dest) {
+    auto func = [&cdata, &argb](const DownSampleData& data, uint8_t* dest) {
       uint32_t r_bgra_cmyk =
           argb[cdata.buf[data.src_row * cdata.pitch + data.src_col]];
-      WriteMonoResult(r_bgra_cmyk, format, dest);
+      *reinterpret_cast<uint32_t*>(dest) = r_bgra_cmyk;
     };
     DoDownSampleLoop(cdata, m_result, m_StretchClip, destBpp, func);
   }
diff --git a/core/fxge/dib/cfx_scanlinecompositor.cpp b/core/fxge/dib/cfx_scanlinecompositor.cpp
index 8c49e29..cb116ea 100644
--- a/core/fxge/dib/cfx_scanlinecompositor.cpp
+++ b/core/fxge/dib/cfx_scanlinecompositor.cpp
@@ -1558,73 +1558,6 @@
   }
 }
 
-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,
-                                BlendMode blend_type,
-                                const uint8_t* clip_scan,
-                                uint8_t* dest_alpha_scan) {
-  for (int col = 0; col < pixel_count; col++) {
-    int src_alpha = GetAlphaWithSrc(mask_alpha, clip_scan, src_scan, col);
-    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 (IsNonSeparableBlendMode(blend_type)) {
-      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 != BlendMode::kNormal) {
-      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,
@@ -3120,10 +3053,6 @@
     CompositeRow_ByteMask2Rgb(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
                               m_MaskGreen, m_MaskBlue, width, m_BlendType,
                               GetCompsFromFormat(m_DestFormat), clip_scan);
-  } else if (m_DestFormat == FXDIB_Format::kRgba) {
-    CompositeRow_ByteMask2Rgba(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
-                               m_MaskGreen, m_MaskBlue, width, m_BlendType,
-                               clip_scan, dst_extra_alpha);
   }
 }
 
diff --git a/core/fxge/dib/cstretchengine.cpp b/core/fxge/dib/cstretchengine.cpp
index 819496e..4649009 100644
--- a/core/fxge/dib/cstretchengine.cpp
+++ b/core/fxge/dib/cstretchengine.cpp
@@ -491,15 +491,9 @@
             int pixel_weight = *pWeight;
             pixel_weight = pixel_weight * src_scan_mask[j] / 255;
             unsigned long argb_cmyk = m_pSrcPalette[src_scan[j]];
-            if (m_DestFormat == FXDIB_Format::kRgba) {
-              dest_r_y += pixel_weight * static_cast<uint8_t>(argb_cmyk >> 16);
-              dest_g_m += pixel_weight * static_cast<uint8_t>(argb_cmyk >> 8);
-              dest_b_c += pixel_weight * static_cast<uint8_t>(argb_cmyk);
-            } else {
-              dest_b_c += pixel_weight * static_cast<uint8_t>(argb_cmyk >> 24);
-              dest_g_m += pixel_weight * static_cast<uint8_t>(argb_cmyk >> 16);
-              dest_r_y += pixel_weight * static_cast<uint8_t>(argb_cmyk >> 8);
-            }
+            dest_b_c += pixel_weight * static_cast<uint8_t>(argb_cmyk >> 24);
+            dest_g_m += pixel_weight * static_cast<uint8_t>(argb_cmyk >> 16);
+            dest_r_y += pixel_weight * static_cast<uint8_t>(argb_cmyk >> 8);
             dest_a += pixel_weight;
           }
           if (bicubic) {
diff --git a/core/fxge/dib/fx_dib.h b/core/fxge/dib/fx_dib.h
index bc87785..2f4fcb2 100644
--- a/core/fxge/dib/fx_dib.h
+++ b/core/fxge/dib/fx_dib.h
@@ -21,7 +21,6 @@
   kRgb32 = 0x020,
   k1bppMask = 0x101,
   k8bppMask = 0x108,
-  kRgba = 0x218,
   kArgb = 0x220,
 };
 
@@ -116,10 +115,6 @@
   return !!(static_cast<uint16_t>(format) & 0x200);
 }
 
-inline bool HasNoFlags(FXDIB_Format format) {
-  return (static_cast<uint16_t>(format) & 0x300) == 0;
-}
-
 FXDIB_Format MakeRGBFormat(int bpp);
 
 inline FX_CMYK CmykEncode(int c, int m, int y, int k) {
diff --git a/testing/fuzzers/pdf_scanlinecompositor_fuzzer.cc b/testing/fuzzers/pdf_scanlinecompositor_fuzzer.cc
index 6ffcf65..b0109a1 100644
--- a/testing/fuzzers/pdf_scanlinecompositor_fuzzer.cc
+++ b/testing/fuzzers/pdf_scanlinecompositor_fuzzer.cc
@@ -24,7 +24,7 @@
     FXDIB_Format::k1bppMask,
     FXDIB_Format::k8bppMask,
     FXDIB_Format::kInvalid /* Was FXDIB_Format::k8bppRgba */,
-    FXDIB_Format::kRgba,
+    FXDIB_Format::kInvalid /* Was FXDIB_Format::kRgba */,
     FXDIB_Format::kArgb,
     FXDIB_Format::kInvalid /* Was FXDIB_Format::k1bppCmyk */,
     FXDIB_Format::kInvalid /* Was FXDIB_Format::k8bppCmyk */,