diff --git a/core/fpdfapi/page/cpdf_dib.cpp b/core/fpdfapi/page/cpdf_dib.cpp
index bedfd4d..6678267 100644
--- a/core/fpdfapi/page/cpdf_dib.cpp
+++ b/core/fpdfapi/page/cpdf_dib.cpp
@@ -195,18 +195,18 @@
   if (m_bImageMask)
     SetMaskProperties();
   else
-    m_bpp = CalculateBitsPerPixel(m_bpc, m_nComponents);
+    m_Format = MakeRGBFormat(CalculateBitsPerPixel(m_bpc, m_nComponents));
 
-  FX_SAFE_UINT32 pitch = fxcodec::CalculatePitch32(m_bpp, m_Width);
+  FX_SAFE_UINT32 pitch =
+      fxcodec::CalculatePitch32(GetBppFromFormat(m_Format), m_Width);
   if (!pitch.IsValid())
     return false;
 
   m_pLineBuf.reset(FX_Alloc(uint8_t, pitch.ValueOrDie()));
   LoadPalette();
   if (m_bColorKey) {
-    m_bpp = 32;
-    m_AlphaFlag = 2;
-    pitch = fxcodec::CalculatePitch32(m_bpp, m_Width);
+    m_Format = FXDIB_Format::kArgb;
+    pitch = fxcodec::CalculatePitch32(GetBppFromFormat(m_Format), m_Width);
     if (!pitch.IsValid())
       return false;
 
@@ -223,10 +223,11 @@
     if (!m_bpc || !m_nComponents)
       return false;
 
-    m_bpp = CalculateBitsPerPixel(m_bpc, m_nComponents);
+    m_Format = MakeRGBFormat(CalculateBitsPerPixel(m_bpc, m_nComponents));
   }
 
-  FX_SAFE_UINT32 pitch = fxcodec::CalculatePitch32(m_bpp, m_Width);
+  FX_SAFE_UINT32 pitch =
+      fxcodec::CalculatePitch32(GetBppFromFormat(m_Format), m_Width);
   if (!pitch.IsValid())
     return false;
 
@@ -236,9 +237,8 @@
   }
   LoadPalette();
   if (m_bColorKey) {
-    m_bpp = 32;
-    m_AlphaFlag = 2;
-    pitch = fxcodec::CalculatePitch32(m_bpp, m_Width);
+    m_Format = FXDIB_Format::kArgb;
+    pitch = fxcodec::CalculatePitch32(GetBppFromFormat(m_Format), m_Width);
     if (!pitch.IsValid())
       return false;
     m_pMaskedLine.reset(FX_Alloc(uint8_t, pitch.ValueOrDie()));
@@ -512,7 +512,8 @@
   if (decoder == "JBIG2Decode") {
     m_pCachedBitmap = pdfium::MakeRetain<CFX_DIBitmap>();
     if (!m_pCachedBitmap->Create(
-            m_Width, m_Height, m_bImageMask ? FXDIB_1bppMask : FXDIB_1bppRgb)) {
+            m_Width, m_Height,
+            m_bImageMask ? FXDIB_Format::k1bppMask : FXDIB_Format::k1bppRgb)) {
       m_pCachedBitmap.Reset();
       return LoadState::kFail;
     }
@@ -676,14 +677,14 @@
 
   FXDIB_Format format;
   if (image_info.components == 1) {
-    format = FXDIB_8bppRgb;
+    format = FXDIB_Format::k8bppRgb;
   } else if (image_info.components <= 3) {
-    format = FXDIB_Rgb;
+    format = FXDIB_Format::kRgb;
   } else if (image_info.components == 4) {
-    format = FXDIB_Rgb32;
+    format = FXDIB_Format::kRgb32;
   } else {
     image_info.width = (image_info.width * image_info.components + 2) / 3;
-    format = FXDIB_Rgb;
+    format = FXDIB_Format::kRgb;
   }
 
   auto result_bitmap = pdfium::MakeRetain<CFX_DIBitmap>();
@@ -699,9 +700,10 @@
   if (convert_argb_to_rgb) {
     DCHECK_EQ(3, m_nComponents);
     auto rgb_bitmap = pdfium::MakeRetain<CFX_DIBitmap>();
-    if (!rgb_bitmap->Create(image_info.width, image_info.height, FXDIB_Rgb))
+    if (!rgb_bitmap->Create(image_info.width, image_info.height,
+                            FXDIB_Format::kRgb)) {
       return nullptr;
-
+    }
     if (m_pDict->GetIntegerFor("SMaskInData") == 1) {
       // TODO(thestig): Acrobat does not support "/SMaskInData 1" combined with
       // filters. Check for that and fail early.
@@ -1456,10 +1458,9 @@
 }
 
 void CPDF_DIB::SetMaskProperties() {
-  m_bpp = 1;
   m_bpc = 1;
   m_nComponents = 1;
-  m_AlphaFlag = 1;
+  m_Format = FXDIB_Format::k1bppMask;
 }
 
 uint32_t CPDF_DIB::Get1BitSetValue() const {
diff --git a/core/fpdfapi/page/cpdf_image.cpp b/core/fpdfapi/page/cpdf_image.cpp
index 0262bce..14b46e5 100644
--- a/core/fpdfapi/page/cpdf_image.cpp
+++ b/core/fpdfapi/page/cpdf_image.cpp
@@ -264,7 +264,7 @@
         CreateXObjectImageDict(maskWidth, maskHeight);
     pMaskDict->SetNewFor<CPDF_Name>("ColorSpace", "DeviceGray");
     pMaskDict->SetNewFor<CPDF_Number>("BitsPerComponent", 8);
-    if (pMaskBitmap->GetFormat() != FXDIB_1bppMask) {
+    if (pMaskBitmap->GetFormat() != FXDIB_Format::k1bppMask) {
       mask_buf.reset(FX_AllocUninit2D(uint8_t, maskHeight, maskWidth));
       mask_size = maskHeight * maskWidth;  // Safe since checked alloc returned.
       for (int32_t a = 0; a < maskHeight; a++) {
diff --git a/core/fpdfapi/page/cpdf_transferfuncdib.cpp b/core/fpdfapi/page/cpdf_transferfuncdib.cpp
index 0bd1c59..50e181f 100644
--- a/core/fpdfapi/page/cpdf_transferfuncdib.cpp
+++ b/core/fpdfapi/page/cpdf_transferfuncdib.cpp
@@ -24,10 +24,8 @@
       m_RampB(pTransferFunc->GetSamplesB()) {
   m_Width = pSrc->GetWidth();
   m_Height = pSrc->GetHeight();
-  FXDIB_Format format = GetDestFormat();
-  m_bpp = GetBppFromFormat(format);
-  m_AlphaFlag = GetAlphaFlagFromFormat(format);
-  m_Pitch = (m_Width * m_bpp + 31) / 32 * 4;
+  m_Format = GetDestFormat();
+  m_Pitch = (m_Width * GetBppFromFormat(m_Format) + 31) / 32 * 4;
   m_Scanline.resize(m_Pitch);
   DCHECK(m_palette.empty());
 }
@@ -36,12 +34,12 @@
 
 FXDIB_Format CPDF_TransferFuncDIB::GetDestFormat() const {
   if (m_pSrc->IsAlphaMask())
-    return FXDIB_8bppMask;
+    return FXDIB_Format::k8bppMask;
 
 #if defined(OS_APPLE)
-  return m_pSrc->HasAlpha() ? FXDIB_Argb : FXDIB_Rgb32;
+  return m_pSrc->HasAlpha() ? FXDIB_Format::kArgb : FXDIB_Format::kRgb32;
 #else
-  return m_pSrc->HasAlpha() ? FXDIB_Argb : FXDIB_Rgb;
+  return m_pSrc->HasAlpha() ? FXDIB_Format::kArgb : FXDIB_Format::kRgb;
 #endif
 }
 
@@ -50,7 +48,7 @@
     std::vector<uint8_t, FxAllocAllocator<uint8_t>>* dest_buf) const {
   bool bSkip = false;
   switch (m_pSrc->GetFormat()) {
-    case FXDIB_1bppRgb: {
+    case FXDIB_Format::k1bppRgb: {
       int r0 = m_RampR[0];
       int g0 = m_RampG[0];
       int b0 = m_RampB[0];
@@ -74,7 +72,7 @@
       }
       break;
     }
-    case FXDIB_1bppMask: {
+    case FXDIB_Format::k1bppMask: {
       int m0 = m_RampR[0];
       int m1 = m_RampR[255];
       int index = 0;
@@ -86,7 +84,7 @@
       }
       break;
     }
-    case FXDIB_8bppRgb: {
+    case FXDIB_Format::k8bppRgb: {
       pdfium::span<const uint32_t> src_palette = m_pSrc->GetPaletteSpan();
       int index = 0;
       for (int i = 0; i < m_Width; i++) {
@@ -108,13 +106,13 @@
       }
       break;
     }
-    case FXDIB_8bppMask: {
+    case FXDIB_Format::k8bppMask: {
       int index = 0;
       for (int i = 0; i < m_Width; i++)
         (*dest_buf)[index++] = m_RampR[*(src_buf++)];
       break;
     }
-    case FXDIB_Rgb: {
+    case FXDIB_Format::kRgb: {
       int index = 0;
       for (int i = 0; i < m_Width; i++) {
         (*dest_buf)[index++] = m_RampB[*(src_buf++)];
@@ -126,10 +124,10 @@
       }
       break;
     }
-    case FXDIB_Rgb32:
+    case FXDIB_Format::kRgb32:
       bSkip = true;
       FALLTHROUGH;
-    case FXDIB_Argb: {
+    case FXDIB_Format::kArgb: {
       int index = 0;
       for (int i = 0; i < m_Width; i++) {
         (*dest_buf)[index++] = m_RampB[*(src_buf++)];
diff --git a/core/fpdfapi/render/cpdf_devicebuffer.cpp b/core/fpdfapi/render/cpdf_devicebuffer.cpp
index 3fffb89..a07c61ff 100644
--- a/core/fpdfapi/render/cpdf_devicebuffer.cpp
+++ b/core/fpdfapi/render/cpdf_devicebuffer.cpp
@@ -67,7 +67,7 @@
   FX_RECT bitmap_rect =
       m_Matrix.TransformRect(CFX_FloatRect(m_Rect)).GetOuterRect();
   return m_pBitmap->Create(bitmap_rect.Width(), bitmap_rect.Height(),
-                           FXDIB_Argb);
+                           FXDIB_Format::kArgb);
 }
 
 void CPDF_DeviceBuffer::OutputToDevice() {
diff --git a/core/fpdfapi/render/cpdf_imagerenderer.cpp b/core/fpdfapi/render/cpdf_imagerenderer.cpp
index 8a27e02..2aa8466 100644
--- a/core/fpdfapi/render/cpdf_imagerenderer.cpp
+++ b/core/fpdfapi/render/cpdf_imagerenderer.cpp
@@ -275,9 +275,10 @@
 
   CFX_Matrix new_matrix = GetDrawMatrix(rect);
   CFX_DefaultRenderDevice bitmap_device1;
-  if (!bitmap_device1.Create(rect.Width(), rect.Height(), FXDIB_Rgb32, nullptr))
+  if (!bitmap_device1.Create(rect.Width(), rect.Height(), FXDIB_Format::kRgb32,
+                             nullptr)) {
     return true;
-
+  }
   bitmap_device1.GetBitmap()->Clear(0xffffff);
 
   CPDF_RenderStatus bitmap_render(m_pRenderStatus->GetContext(),
@@ -300,14 +301,14 @@
   }
 
   CFX_DefaultRenderDevice bitmap_device2;
-  if (!bitmap_device2.Create(rect.Width(), rect.Height(), FXDIB_8bppRgb,
-                             nullptr)) {
+  if (!bitmap_device2.Create(rect.Width(), rect.Height(),
+                             FXDIB_Format::k8bppRgb, nullptr)) {
     return true;
   }
   bitmap_device2.GetBitmap()->Clear(0);
   CalculateDrawImage(&bitmap_device1, &bitmap_device2, m_pDIBBase, new_matrix,
                      rect);
-  bitmap_device2.GetBitmap()->ConvertFormat(FXDIB_8bppMask);
+  bitmap_device2.GetBitmap()->ConvertFormat(FXDIB_Format::k8bppMask);
   bitmap_device1.GetBitmap()->MultiplyAlpha(bitmap_device2.GetBitmap());
   bitmap_device1.GetBitmap()->MultiplyAlpha(255);
   m_pRenderStatus->GetRenderDevice()->SetDIBitsWithBlend(
@@ -327,9 +328,10 @@
 
   CFX_Matrix new_matrix = GetDrawMatrix(rect);
   CFX_DefaultRenderDevice bitmap_device1;
-  if (!bitmap_device1.Create(rect.Width(), rect.Height(), FXDIB_Rgb32, nullptr))
+  if (!bitmap_device1.Create(rect.Width(), rect.Height(), FXDIB_Format::kRgb32,
+                             nullptr)) {
     return true;
-
+  }
 #if defined(_SKIA_SUPPORT_)
   bitmap_device1.Clear(0xffffff);
 #else
@@ -346,10 +348,10 @@
     image_render.Continue(nullptr);
   }
   CFX_DefaultRenderDevice bitmap_device2;
-  if (!bitmap_device2.Create(rect.Width(), rect.Height(), FXDIB_8bppRgb,
-                             nullptr))
+  if (!bitmap_device2.Create(rect.Width(), rect.Height(),
+                             FXDIB_Format::k8bppRgb, nullptr)) {
     return true;
-
+  }
 #if defined(_SKIA_SUPPORT_)
   bitmap_device2.Clear(0);
 #else
@@ -362,7 +364,7 @@
       bitmap_device1.GetBitmap(), bitmap_device2.GetBitmap(), rect.left,
       rect.top, m_BitmapAlpha, m_BlendType);
 #else
-  bitmap_device2.GetBitmap()->ConvertFormat(FXDIB_8bppMask);
+  bitmap_device2.GetBitmap()->ConvertFormat(FXDIB_Format::k8bppMask);
   bitmap_device1.GetBitmap()->MultiplyAlpha(bitmap_device2.GetBitmap());
   if (m_BitmapAlpha < 255)
     bitmap_device1.GetBitmap()->MultiplyAlpha(m_BitmapAlpha);
diff --git a/core/fpdfapi/render/cpdf_rendershading.cpp b/core/fpdfapi/render/cpdf_rendershading.cpp
index 7e02ed5..d079aac 100644
--- a/core/fpdfapi/render/cpdf_rendershading.cpp
+++ b/core/fpdfapi/render/cpdf_rendershading.cpp
@@ -91,7 +91,7 @@
                       const std::vector<std::unique_ptr<CPDF_Function>>& funcs,
                       const RetainPtr<CPDF_ColorSpace>& pCS,
                       int alpha) {
-  ASSERT(pBitmap->GetFormat() == FXDIB_Argb);
+  ASSERT(pBitmap->GetFormat() == FXDIB_Format::kArgb);
 
   const uint32_t total_results = GetValidatedOutputsCount(funcs, pCS);
   if (total_results == 0)
@@ -159,7 +159,7 @@
                        const std::vector<std::unique_ptr<CPDF_Function>>& funcs,
                        const RetainPtr<CPDF_ColorSpace>& pCS,
                        int alpha) {
-  ASSERT(pBitmap->GetFormat() == FXDIB_Argb);
+  ASSERT(pBitmap->GetFormat() == FXDIB_Format::kArgb);
 
   const uint32_t total_results = GetValidatedOutputsCount(funcs, pCS);
   if (total_results == 0)
@@ -258,7 +258,7 @@
                      const std::vector<std::unique_ptr<CPDF_Function>>& funcs,
                      const RetainPtr<CPDF_ColorSpace>& pCS,
                      int alpha) {
-  ASSERT(pBitmap->GetFormat() == FXDIB_Argb);
+  ASSERT(pBitmap->GetFormat() == FXDIB_Format::kArgb);
 
   const uint32_t total_results = GetValidatedOutputsCount(funcs, pCS);
   if (total_results == 0)
@@ -418,7 +418,7 @@
     const std::vector<std::unique_ptr<CPDF_Function>>& funcs,
     const RetainPtr<CPDF_ColorSpace>& pCS,
     int alpha) {
-  ASSERT(pBitmap->GetFormat() == FXDIB_Argb);
+  ASSERT(pBitmap->GetFormat() == FXDIB_Format::kArgb);
 
   CPDF_MeshStream stream(kFreeFormGouraudTriangleMeshShading, funcs,
                          pShadingStream, pCS);
@@ -457,7 +457,7 @@
     const std::vector<std::unique_ptr<CPDF_Function>>& funcs,
     const RetainPtr<CPDF_ColorSpace>& pCS,
     int alpha) {
-  ASSERT(pBitmap->GetFormat() == FXDIB_Argb);
+  ASSERT(pBitmap->GetFormat() == FXDIB_Format::kArgb);
 
   int row_verts = pShadingStream->GetDict()->GetIntegerFor("VerticesPerRow");
   if (row_verts < 2)
@@ -770,7 +770,7 @@
     const RetainPtr<CPDF_ColorSpace>& pCS,
     bool bNoPathSmooth,
     int alpha) {
-  ASSERT(pBitmap->GetFormat() == FXDIB_Argb);
+  ASSERT(pBitmap->GetFormat() == FXDIB_Format::kArgb);
   ASSERT(type == kCoonsPatchMeshShading ||
          type == kTensorProductPatchMeshShading);
 
diff --git a/core/fpdfapi/render/cpdf_renderstatus.cpp b/core/fpdfapi/render/cpdf_renderstatus.cpp
index 6fd93a8..192d6d6 100644
--- a/core/fpdfapi/render/cpdf_renderstatus.cpp
+++ b/core/fpdfapi/render/cpdf_renderstatus.cpp
@@ -649,7 +649,7 @@
       return true;
     m_pDevice->GetDIBits(backdrop, rect.left, rect.top);
   }
-  if (!bitmap_device.Create(width, height, FXDIB_Argb, backdrop))
+  if (!bitmap_device.Create(width, height, FXDIB_Format::kArgb, backdrop))
     return true;
 
   RetainPtr<CFX_DIBitmap> bitmap = bitmap_device.GetBitmap();
@@ -661,7 +661,7 @@
   RetainPtr<CFX_DIBitmap> pTextMask;
   if (bTextClip) {
     pTextMask = pdfium::MakeRetain<CFX_DIBitmap>();
-    if (!pTextMask->Create(width, height, FXDIB_8bppMask))
+    if (!pTextMask->Create(width, height, FXDIB_Format::k8bppMask))
       return true;
 
     pTextMask->Clear(0);
@@ -740,7 +740,7 @@
   int height = bbox.Height();
   auto pBackdrop = pdfium::MakeRetain<CFX_DIBitmap>();
   if (bBackAlphaRequired && !m_bDropObjects)
-    pBackdrop->Create(width, height, FXDIB_Argb);
+    pBackdrop->Create(width, height, FXDIB_Format::kArgb);
   else
     m_pDevice->CreateCompatibleBitmap(pBackdrop, width, height);
 
@@ -981,8 +981,8 @@
           continue;
 
         CFX_DefaultRenderDevice bitmap_device;
-        if (!bitmap_device.Create(rect.Width(), rect.Height(), FXDIB_Argb,
-                                  nullptr)) {
+        if (!bitmap_device.Create(rect.Width(), rect.Height(),
+                                  FXDIB_Format::kArgb, nullptr)) {
           return true;
         }
         bitmap_device.GetBitmap()->Clear(0);
@@ -1049,7 +1049,7 @@
 
   FX_RECT rect = GetGlyphsBBox(glyphs, 0);
   auto pBitmap = pdfium::MakeRetain<CFX_DIBitmap>();
-  if (!pBitmap->Create(rect.Width(), rect.Height(), FXDIB_8bppMask))
+  if (!pBitmap->Create(rect.Width(), rect.Height(), FXDIB_Format::k8bppMask))
     return true;
 
   pBitmap->Clear(0);
@@ -1358,7 +1358,7 @@
 
   auto pBackdrop1 = pdfium::MakeRetain<CFX_DIBitmap>();
   pBackdrop1->Create(pBackdrop->GetWidth(), pBackdrop->GetHeight(),
-                     FXDIB_Rgb32);
+                     FXDIB_Format::kRgb32);
   pBackdrop1->Clear((uint32_t)-1);
   pBackdrop1->CompositeBitmap(0, 0, pBackdrop->GetWidth(),
                               pBackdrop->GetHeight(), pBackdrop, 0, 0,
@@ -1400,9 +1400,9 @@
   FXDIB_Format format;
 #if defined(OS_APPLE) || defined(_SKIA_SUPPORT_) || \
     defined(_SKIA_SUPPORT_PATHS_)
-  format = bLuminosity ? FXDIB_Rgb32 : FXDIB_8bppMask;
+  format = bLuminosity ? FXDIB_Format::kRgb32 : FXDIB_Format::k8bppMask;
 #else
-  format = bLuminosity ? FXDIB_Rgb : FXDIB_8bppMask;
+  format = bLuminosity ? FXDIB_Format::kRgb : FXDIB_Format::k8bppMask;
 #endif
   if (!bitmap_device.Create(width, height, format, nullptr))
     return nullptr;
@@ -1433,7 +1433,7 @@
   status.RenderObjectList(&form, matrix);
 
   auto pMask = pdfium::MakeRetain<CFX_DIBitmap>();
-  if (!pMask->Create(width, height, FXDIB_8bppMask))
+  if (!pMask->Create(width, height, FXDIB_Format::k8bppMask))
     return nullptr;
 
   uint8_t* dest_buf = pMask->GetBuffer();
diff --git a/core/fpdfapi/render/cpdf_rendertiling.cpp b/core/fpdfapi/render/cpdf_rendertiling.cpp
index 87181d3..c00e75e 100644
--- a/core/fpdfapi/render/cpdf_rendertiling.cpp
+++ b/core/fpdfapi/render/cpdf_rendertiling.cpp
@@ -32,7 +32,8 @@
     const CPDF_RenderOptions::Options& draw_options) {
   auto pBitmap = pdfium::MakeRetain<CFX_DIBitmap>();
   if (!pBitmap->Create(width, height,
-                       pPattern->colored() ? FXDIB_Argb : FXDIB_8bppMask)) {
+                       pPattern->colored() ? FXDIB_Format::kArgb
+                                           : FXDIB_Format::k8bppMask)) {
     return nullptr;
   }
   CFX_DefaultRenderDevice bitmap_device;
@@ -189,7 +190,7 @@
   int clip_width = clip_box.right - clip_box.left;
   int clip_height = clip_box.bottom - clip_box.top;
   auto pScreen = pdfium::MakeRetain<CFX_DIBitmap>();
-  if (!pScreen->Create(clip_width, clip_height, FXDIB_Argb))
+  if (!pScreen->Create(clip_width, clip_height, FXDIB_Format::kArgb))
     return nullptr;
 
   pScreen->Clear(0);
diff --git a/core/fpdfapi/render/cpdf_scaledrenderbuffer.cpp b/core/fpdfapi/render/cpdf_scaledrenderbuffer.cpp
index 34ef308..567e2d3 100644
--- a/core/fpdfapi/render/cpdf_scaledrenderbuffer.cpp
+++ b/core/fpdfapi/render/cpdf_scaledrenderbuffer.cpp
@@ -39,7 +39,7 @@
   m_pBitmapDevice = std::make_unique<CFX_DefaultRenderDevice>();
   bool bIsAlpha =
       !!(m_pDevice->GetDeviceCaps(FXDC_RENDER_CAPS) & FXRC_ALPHA_OUTPUT);
-  FXDIB_Format dibFormat = bIsAlpha ? FXDIB_Argb : FXDIB_Rgb;
+  FXDIB_Format dibFormat = bIsAlpha ? FXDIB_Format::kArgb : FXDIB_Format::kRgb;
   while (1) {
     FX_RECT bitmap_rect =
         m_Matrix.TransformRect(CFX_FloatRect(rect)).GetOuterRect();
diff --git a/core/fxcodec/progressive_decoder.cpp b/core/fxcodec/progressive_decoder.cpp
index df6ab72..1433040 100644
--- a/core/fxcodec/progressive_decoder.cpp
+++ b/core/fxcodec/progressive_decoder.cpp
@@ -284,19 +284,19 @@
   }
   FXDIB_Format format = m_pDeviceBitmap->GetFormat();
   switch (format) {
-    case FXDIB_1bppMask:
-    case FXDIB_1bppRgb:
+    case FXDIB_Format::k1bppMask:
+    case FXDIB_Format::k1bppRgb:
       NOTREACHED();
       return false;
-    case FXDIB_8bppMask:
-    case FXDIB_8bppRgb:
+    case FXDIB_Format::k8bppMask:
+    case FXDIB_Format::k8bppRgb:
       *color_type = 0;
       break;
-    case FXDIB_Rgb:
+    case FXDIB_Format::kRgb:
       *color_type = 2;
       break;
-    case FXDIB_Rgb32:
-    case FXDIB_Argb:
+    case FXDIB_Format::kRgb32:
+    case FXDIB_Format::kArgb:
       *color_type = 6;
       break;
     default:
@@ -331,12 +331,12 @@
         continue;
       }
       switch (pDIBitmap->GetFormat()) {
-        case FXDIB_1bppMask:
-        case FXDIB_1bppRgb:
+        case FXDIB_Format::k1bppMask:
+        case FXDIB_Format::k1bppRgb:
           NOTREACHED();
           return false;
-        case FXDIB_8bppMask:
-        case FXDIB_8bppRgb: {
+        case FXDIB_Format::k8bppMask:
+        case FXDIB_Format::k8bppRgb: {
           if (pDIBitmap->HasPalette())
             return false;
 
@@ -344,8 +344,8 @@
           dest_g += pPixelWeights->m_Weights[0] * src_scan[src_col];
           dest_scan[pPixelWeights->m_SrcStart] = (uint8_t)(dest_g >> 16);
         } break;
-        case FXDIB_Rgb:
-        case FXDIB_Rgb32: {
+        case FXDIB_Format::kRgb:
+        case FXDIB_Format::kRgb32: {
           uint32_t dest_b = 0;
           uint32_t dest_g = 0;
           uint32_t dest_r = 0;
@@ -358,7 +358,7 @@
           *pDes++ = (uint8_t)((dest_g) >> 16);
           *pDes = (uint8_t)((dest_r) >> 16);
         } break;
-        case FXDIB_Argb: {
+        case FXDIB_Format::kArgb: {
           uint32_t dest_r = 0;
           uint32_t dest_g = 0;
           uint32_t dest_b = 0;
@@ -641,12 +641,12 @@
         dest_ScanOffet;
     for (int dest_col = 0; dest_col < m_sizeX; dest_col++) {
       switch (pDeviceBitmap->GetFormat()) {
-        case FXDIB_Invalid:
-        case FXDIB_1bppMask:
-        case FXDIB_1bppRgb:
+        case FXDIB_Format::kInvalid:
+        case FXDIB_Format::k1bppMask:
+        case FXDIB_Format::k1bppRgb:
           return;
-        case FXDIB_8bppMask:
-        case FXDIB_8bppRgb: {
+        case FXDIB_Format::k8bppMask:
+        case FXDIB_Format::k8bppRgb: {
           if (pDeviceBitmap->HasPalette())
             return;
 
@@ -655,8 +655,8 @@
           dest_g += pWeight->m_Weights[1] * (*scan_src2++);
           *scan_des++ = (uint8_t)(dest_g >> 16);
         } break;
-        case FXDIB_Rgb:
-        case FXDIB_Rgb32: {
+        case FXDIB_Format::kRgb:
+        case FXDIB_Format::kRgb32: {
           uint32_t dest_b = 0;
           uint32_t dest_g = 0;
           uint32_t dest_r = 0;
@@ -673,7 +673,7 @@
           *scan_des++ = (uint8_t)((dest_r) >> 16);
           scan_des += dest_Bpp - 3;
         } break;
-        case FXDIB_Argb: {
+        case FXDIB_Format::kArgb: {
           uint32_t dest_a = 0;
           uint32_t dest_b = 0;
           uint32_t dest_g = 0;
@@ -724,19 +724,19 @@
     return false;
   }
 
-  FXDIB_Format format = FXDIB_Invalid;
+  FXDIB_Format format = FXDIB_Format::kInvalid;
   switch (m_SrcComponents) {
     case 1:
       m_SrcFormat = FXCodec_8bppRgb;
-      format = FXDIB_8bppRgb;
+      format = FXDIB_Format::k8bppRgb;
       break;
     case 3:
       m_SrcFormat = FXCodec_Rgb;
-      format = FXDIB_Rgb;
+      format = FXDIB_Format::kRgb;
       break;
     case 4:
       m_SrcFormat = FXCodec_Rgb32;
-      format = FXDIB_Rgb32;
+      format = FXDIB_Format::kRgb32;
       break;
     default:
       m_status = FXCODEC_STATUS_ERR_FORMAT;
@@ -916,12 +916,12 @@
         dest_ScanOffet;
     for (int dest_col = 0; dest_col < m_sizeX; dest_col++) {
       switch (pDeviceBitmap->GetFormat()) {
-        case FXDIB_Invalid:
-        case FXDIB_1bppMask:
-        case FXDIB_1bppRgb:
+        case FXDIB_Format::kInvalid:
+        case FXDIB_Format::k1bppMask:
+        case FXDIB_Format::k1bppRgb:
           return;
-        case FXDIB_8bppMask:
-        case FXDIB_8bppRgb: {
+        case FXDIB_Format::k8bppMask:
+        case FXDIB_Format::k8bppRgb: {
           if (pDeviceBitmap->HasPalette())
             return;
 
@@ -930,8 +930,8 @@
           dest_g += pWeight->m_Weights[1] * (*scan_src2++);
           *scan_des++ = (uint8_t)(dest_g >> 16);
         } break;
-        case FXDIB_Rgb:
-        case FXDIB_Rgb32: {
+        case FXDIB_Format::kRgb:
+        case FXDIB_Format::kRgb32: {
           uint32_t dest_b = 0;
           uint32_t dest_g = 0;
           uint32_t dest_r = 0;
@@ -948,7 +948,7 @@
           *scan_des++ = (uint8_t)((dest_r) >> 16);
           scan_des += dest_Bpp - 3;
         } break;
-        case FXDIB_Argb: {
+        case FXDIB_Format::kArgb: {
           uint32_t dest_a = 0;
           uint32_t dest_b = 0;
           uint32_t dest_g = 0;
@@ -1126,12 +1126,12 @@
   for (int32_t dest_col = 0; dest_col < m_sizeX; dest_col++) {
     PixelWeight* pPixelWeights = m_WeightHorzOO.GetPixelWeight(dest_col);
     switch (pDeviceBitmap->GetFormat()) {
-      case FXDIB_1bppMask:
-      case FXDIB_1bppRgb:
+      case FXDIB_Format::k1bppMask:
+      case FXDIB_Format::k1bppRgb:
         NOTREACHED();
         return;
-      case FXDIB_8bppMask:
-      case FXDIB_8bppRgb: {
+      case FXDIB_Format::k8bppMask:
+      case FXDIB_Format::k8bppRgb: {
         if (pDeviceBitmap->HasPalette())
           return;
 
@@ -1142,8 +1142,8 @@
             pPixelWeights->m_Weights[1] * src_scan[pPixelWeights->m_SrcEnd];
         *dest_scan++ = (uint8_t)(dest_g >> 16);
       } break;
-      case FXDIB_Rgb:
-      case FXDIB_Rgb32: {
+      case FXDIB_Format::kRgb:
+      case FXDIB_Format::kRgb32: {
         uint32_t dest_b = 0;
         uint32_t dest_g = 0;
         uint32_t dest_r = 0;
@@ -1161,7 +1161,7 @@
         *dest_scan++ = (uint8_t)((dest_r) >> 16);
         dest_scan += dest_Bpp - 3;
       } break;
-      case FXDIB_Argb: {
+      case FXDIB_Format::kArgb: {
         uint32_t dest_a = 0;
         uint32_t dest_b = 0;
         uint32_t dest_g = 0;
@@ -1233,17 +1233,17 @@
   }
   m_offSet = 0;
   switch (m_pDeviceBitmap->GetFormat()) {
-    case FXDIB_8bppMask:
-    case FXDIB_8bppRgb:
+    case FXDIB_Format::k8bppMask:
+    case FXDIB_Format::k8bppRgb:
       m_SrcComponents = 1;
       m_SrcFormat = FXCodec_8bppGray;
       break;
-    case FXDIB_Rgb:
+    case FXDIB_Format::kRgb:
       m_SrcComponents = 3;
       m_SrcFormat = FXCodec_Rgb;
       break;
-    case FXDIB_Rgb32:
-    case FXDIB_Argb:
+    case FXDIB_Format::kRgb32:
+    case FXDIB_Format::kArgb:
       m_SrcComponents = 4;
       m_SrcFormat = FXCodec_Argb;
       break;
@@ -1340,7 +1340,7 @@
   }
 
   auto pDIBitmap = pdfium::MakeRetain<CFX_DIBitmap>();
-  pDIBitmap->Create(m_SrcWidth, m_SrcHeight, FXDIB_Argb);
+  pDIBitmap->Create(m_SrcWidth, m_SrcHeight, FXDIB_Format::kArgb);
   if (!pDIBitmap->GetBuffer()) {
     m_pDeviceBitmap = nullptr;
     m_pFile = nullptr;
@@ -1367,35 +1367,35 @@
   }
   RetainPtr<CFX_DIBitmap> pFormatBitmap;
   switch (m_pDeviceBitmap->GetFormat()) {
-    case FXDIB_8bppRgb:
+    case FXDIB_Format::k8bppRgb:
       pFormatBitmap = pdfium::MakeRetain<CFX_DIBitmap>();
       pFormatBitmap->Create(pClipBitmap->GetWidth(), pClipBitmap->GetHeight(),
-                            FXDIB_8bppRgb);
+                            FXDIB_Format::k8bppRgb);
       break;
-    case FXDIB_8bppMask:
+    case FXDIB_Format::k8bppMask:
       pFormatBitmap = pdfium::MakeRetain<CFX_DIBitmap>();
       pFormatBitmap->Create(pClipBitmap->GetWidth(), pClipBitmap->GetHeight(),
-                            FXDIB_8bppMask);
+                            FXDIB_Format::k8bppMask);
       break;
-    case FXDIB_Rgb:
+    case FXDIB_Format::kRgb:
       pFormatBitmap = pdfium::MakeRetain<CFX_DIBitmap>();
       pFormatBitmap->Create(pClipBitmap->GetWidth(), pClipBitmap->GetHeight(),
-                            FXDIB_Rgb);
+                            FXDIB_Format::kRgb);
       break;
-    case FXDIB_Rgb32:
+    case FXDIB_Format::kRgb32:
       pFormatBitmap = pdfium::MakeRetain<CFX_DIBitmap>();
       pFormatBitmap->Create(pClipBitmap->GetWidth(), pClipBitmap->GetHeight(),
-                            FXDIB_Rgb32);
+                            FXDIB_Format::kRgb32);
       break;
-    case FXDIB_Argb:
+    case FXDIB_Format::kArgb:
       pFormatBitmap = pClipBitmap;
       break;
     default:
       break;
   }
   switch (m_pDeviceBitmap->GetFormat()) {
-    case FXDIB_8bppRgb:
-    case FXDIB_8bppMask: {
+    case FXDIB_Format::k8bppRgb:
+    case FXDIB_Format::k8bppMask: {
       for (int32_t row = 0; row < pClipBitmap->GetHeight(); row++) {
         const uint8_t* src_line = pClipBitmap->GetScanline(row);
         uint8_t* dest_line = pFormatBitmap->GetWritableScanline(row);
@@ -1409,9 +1409,10 @@
         }
       }
     } break;
-    case FXDIB_Rgb:
-    case FXDIB_Rgb32: {
-      int32_t desBpp = (m_pDeviceBitmap->GetFormat() == FXDIB_Rgb) ? 3 : 4;
+    case FXDIB_Format::kRgb:
+    case FXDIB_Format::kRgb32: {
+      int32_t desBpp =
+          (m_pDeviceBitmap->GetFormat() == FXDIB_Format::kRgb) ? 3 : 4;
       for (int32_t row = 0; row < pClipBitmap->GetHeight(); row++) {
         const uint8_t* src_line = pClipBitmap->GetScanline(row);
         uint8_t* dest_line = pFormatBitmap->GetWritableScanline(row);
@@ -1644,8 +1645,8 @@
 void ProgressiveDecoder::GetTransMethod(FXDIB_Format dest_format,
                                         FXCodec_Format src_format) {
   switch (dest_format) {
-    case FXDIB_1bppMask:
-    case FXDIB_1bppRgb: {
+    case FXDIB_Format::k1bppMask:
+    case FXDIB_Format::k1bppRgb: {
       switch (src_format) {
         case FXCodec_1bppGray:
           m_TransMethod = 0;
@@ -1654,8 +1655,8 @@
           m_TransMethod = -1;
       }
     } break;
-    case FXDIB_8bppMask:
-    case FXDIB_8bppRgb: {
+    case FXDIB_Format::k8bppMask:
+    case FXDIB_Format::k8bppRgb: {
       switch (src_format) {
         case FXCodec_1bppGray:
           m_TransMethod = 1;
@@ -1679,7 +1680,7 @@
           m_TransMethod = -1;
       }
     } break;
-    case FXDIB_Rgb: {
+    case FXDIB_Format::kRgb: {
       switch (src_format) {
         case FXCodec_1bppGray:
           m_TransMethod = 6;
@@ -1703,8 +1704,8 @@
           m_TransMethod = -1;
       }
     } break;
-    case FXDIB_Rgb32:
-    case FXDIB_Argb: {
+    case FXDIB_Format::kRgb32:
+    case FXDIB_Format::kArgb: {
       switch (src_format) {
         case FXCodec_1bppGray:
           m_TransMethod = 6;
@@ -1714,7 +1715,7 @@
           break;
         case FXCodec_1bppRgb:
         case FXCodec_8bppRgb:
-          if (dest_format == FXDIB_Argb) {
+          if (dest_format == FXDIB_Format::kArgb) {
             m_TransMethod = 12;
           } else {
             m_TransMethod = 8;
@@ -2002,12 +2003,12 @@
         dest_ScanOffet;
     for (int dest_col = 0; dest_col < m_sizeX; dest_col++) {
       switch (pDeviceBitmap->GetFormat()) {
-        case FXDIB_Invalid:
-        case FXDIB_1bppMask:
-        case FXDIB_1bppRgb:
+        case FXDIB_Format::kInvalid:
+        case FXDIB_Format::k1bppMask:
+        case FXDIB_Format::k1bppRgb:
           return;
-        case FXDIB_8bppMask:
-        case FXDIB_8bppRgb: {
+        case FXDIB_Format::k8bppMask:
+        case FXDIB_Format::k8bppRgb: {
           if (pDeviceBitmap->HasPalette())
             return;
 
@@ -2016,8 +2017,8 @@
           dest_g += pWeight->m_Weights[1] * (*scan_src2++);
           *scan_des++ = (uint8_t)(dest_g >> 16);
         } break;
-        case FXDIB_Rgb:
-        case FXDIB_Rgb32: {
+        case FXDIB_Format::kRgb:
+        case FXDIB_Format::kRgb32: {
           uint32_t dest_b = 0;
           uint32_t dest_g = 0;
           uint32_t dest_r = 0;
@@ -2034,7 +2035,7 @@
           *scan_des++ = (uint8_t)((dest_r) >> 16);
           scan_des += dest_Bpp - 3;
         } break;
-        case FXDIB_Argb: {
+        case FXDIB_Format::kArgb: {
           uint32_t dest_a = 0;
           uint32_t dest_b = 0;
           uint32_t dest_g = 0;
diff --git a/core/fxcodec/progressive_decoder_unittest.cpp b/core/fxcodec/progressive_decoder_unittest.cpp
index 867c3db..d0c66ac 100644
--- a/core/fxcodec/progressive_decoder_unittest.cpp
+++ b/core/fxcodec/progressive_decoder_unittest.cpp
@@ -382,7 +382,8 @@
     ASSERT_EQ(6945, decoder->GetHeight());
 
     auto bitmap = pdfium::MakeRetain<CFX_DIBitmap>();
-    bitmap->Create(decoder->GetWidth(), decoder->GetHeight(), FXDIB_Argb);
+    bitmap->Create(decoder->GetWidth(), decoder->GetHeight(),
+                   FXDIB_Format::kArgb);
 
     size_t frames;
     std::tie(status, frames) = decoder->GetFrames();
diff --git a/core/fxge/agg/fx_agg_driver.cpp b/core/fxge/agg/fx_agg_driver.cpp
index aefa448..6fcbb8c 100644
--- a/core/fxge/agg/fx_agg_driver.cpp
+++ b/core/fxge/agg/fx_agg_driver.cpp
@@ -169,8 +169,8 @@
   }
 
   uint8_t* dest_buf = buffer + dest_top * pitch + dest_left * Bpp;
-  if (dest_format == FXDIB_Rgb) {
-    ASSERT(src_format == FXDIB_Rgb32);
+  if (dest_format == FXDIB_Format::kRgb) {
+    ASSERT(src_format == FXDIB_Format::kRgb32);
     for (int row = 0; row < height; row++) {
       uint8_t* dest_scan = dest_buf + row * pitch;
       const uint8_t* src_scan =
@@ -185,8 +185,9 @@
     return;
   }
 
-  ASSERT(dest_format == FXDIB_Argb || dest_format == FXDIB_Rgb32);
-  if (src_format == FXDIB_Rgb) {
+  ASSERT(dest_format == FXDIB_Format::kArgb ||
+         dest_format == FXDIB_Format::kRgb32);
+  if (src_format == FXDIB_Format::kRgb) {
     for (int row = 0; row < height; row++) {
       uint8_t* dest_scan = dest_buf + row * pitch;
       const uint8_t* src_scan =
@@ -200,9 +201,9 @@
     }
     return;
   }
-  if (src_format != FXDIB_Rgb32)
+  if (src_format != FXDIB_Format::kRgb32)
     return;
-  ASSERT(dest_format == FXDIB_Argb);
+  ASSERT(dest_format == FXDIB_Format::kArgb);
   for (int row = 0; row < height; row++) {
     uint8_t* dest_scan = dest_buf + row * pitch;
     const uint8_t* src_scan =
@@ -392,7 +393,7 @@
       return &CFX_Renderer::CompositeSpan1bpp;
     if (device->GetBPP() == 8)
       return &CFX_Renderer::CompositeSpanGray;
-    if (device->GetFormat() == FXDIB_Argb)
+    if (device->GetFormat() == FXDIB_Format::kArgb)
       return &CFX_Renderer::CompositeSpanARGB;
     return &CFX_Renderer::CompositeSpanRGB;
   }
@@ -1106,7 +1107,8 @@
                     rasterizer.max_x() + 1, rasterizer.max_y() + 1);
   path_rect.Intersect(m_pClipRgn->GetBox());
   auto pThisLayer = pdfium::MakeRetain<CFX_DIBitmap>();
-  pThisLayer->Create(path_rect.Width(), path_rect.Height(), FXDIB_8bppMask);
+  pThisLayer->Create(path_rect.Width(), path_rect.Height(),
+                     FXDIB_Format::k8bppMask);
   pThisLayer->Clear(0);
   agg::rendering_buffer raw_buf(pThisLayer->GetBuffer(), pThisLayer->GetWidth(),
                                 pThisLayer->GetHeight(),
diff --git a/core/fxge/apple/fx_quartz_device.cpp b/core/fxge/apple/fx_quartz_device.cpp
index e65ad7f..b89dbdf 100644
--- a/core/fxge/apple/fx_quartz_device.cpp
+++ b/core/fxge/apple/fx_quartz_device.cpp
@@ -26,10 +26,10 @@
     return nullptr;
   CGBitmapInfo bmpInfo = kCGBitmapByteOrder32Little;
   switch (pBitmap->GetFormat()) {
-    case FXDIB_Rgb32:
+    case FXDIB_Format::kRgb32:
       bmpInfo |= kCGImageAlphaNoneSkipFirst;
       break;
-    case FXDIB_Argb:
+    case FXDIB_Format::kArgb:
     default:
       return nullptr;
   }
diff --git a/core/fxge/cfx_cliprgn.cpp b/core/fxge/cfx_cliprgn.cpp
index 35f6839..5cb9692 100644
--- a/core/fxge/cfx_cliprgn.cpp
+++ b/core/fxge/cfx_cliprgn.cpp
@@ -45,7 +45,7 @@
   }
   RetainPtr<CFX_DIBitmap> pOldMask(pMask);
   m_Mask = pdfium::MakeRetain<CFX_DIBitmap>();
-  m_Mask->Create(m_Box.Width(), m_Box.Height(), FXDIB_8bppMask);
+  m_Mask->Create(m_Box.Width(), m_Box.Height(), FXDIB_Format::k8bppMask);
   for (int row = m_Box.top; row < m_Box.bottom; row++) {
     uint8_t* dest_scan =
         m_Mask->GetBuffer() + m_Mask->GetPitch() * (row - m_Box.top);
@@ -59,7 +59,7 @@
 void CFX_ClipRgn::IntersectMaskF(int left,
                                  int top,
                                  const RetainPtr<CFX_DIBitmap>& pMask) {
-  ASSERT(pMask->GetFormat() == FXDIB_8bppMask);
+  ASSERT(pMask->GetFormat() == FXDIB_Format::k8bppMask);
   FX_RECT mask_box(left, top, left + pMask->GetWidth(),
                    top + pMask->GetHeight());
   if (m_Type == RectI) {
@@ -76,7 +76,7 @@
       return;
     }
     auto new_dib = pdfium::MakeRetain<CFX_DIBitmap>();
-    new_dib->Create(new_box.Width(), new_box.Height(), FXDIB_8bppMask);
+    new_dib->Create(new_box.Width(), new_box.Height(), FXDIB_Format::k8bppMask);
     for (int row = new_box.top; row < new_box.bottom; row++) {
       uint8_t* old_scan =
           m_Mask->GetBuffer() + (row - m_Box.top) * m_Mask->GetPitch();
diff --git a/core/fxge/cfx_glyphcache.cpp b/core/fxge/cfx_glyphcache.cpp
index 0c81edc..4c20bf3 100644
--- a/core/fxge/cfx_glyphcache.cpp
+++ b/core/fxge/cfx_glyphcache.cpp
@@ -189,9 +189,10 @@
   auto pGlyphBitmap =
       std::make_unique<CFX_GlyphBitmap>(FXFT_Get_Glyph_BitmapLeft(GetFaceRec()),
                                         FXFT_Get_Glyph_BitmapTop(GetFaceRec()));
-  pGlyphBitmap->GetBitmap()->Create(
-      dib_width, bmheight,
-      anti_alias == FT_RENDER_MODE_MONO ? FXDIB_1bppMask : FXDIB_8bppMask);
+  pGlyphBitmap->GetBitmap()->Create(dib_width, bmheight,
+                                    anti_alias == FT_RENDER_MODE_MONO
+                                        ? FXDIB_Format::k1bppMask
+                                        : FXDIB_Format::k8bppMask);
   int dest_pitch = pGlyphBitmap->GetBitmap()->GetPitch();
   int src_pitch = FXFT_Get_Bitmap_Pitch(FXFT_Get_Glyph_Bitmap(GetFaceRec()));
   uint8_t* pDestBuf = pGlyphBitmap->GetBitmap()->GetBuffer();
diff --git a/core/fxge/cfx_renderdevice.cpp b/core/fxge/cfx_renderdevice.cpp
index 7a22a55..f5baedb 100644
--- a/core/fxge/cfx_renderdevice.cpp
+++ b/core/fxge/cfx_renderdevice.cpp
@@ -220,7 +220,7 @@
                           int r,
                           int g,
                           int b) {
-  const bool has_alpha = bitmap->GetFormat() == FXDIB_Argb;
+  const bool has_alpha = bitmap->GetFormat() == FXDIB_Format::kArgb;
   uint8_t* src_buf = pGlyph->GetBuffer();
   int src_pitch = pGlyph->GetPitch();
   uint8_t* dest_buf = bitmap->GetBuffer();
@@ -391,15 +391,15 @@
     int width,
     int height) const {
   if (m_RenderCaps & FXRC_BYTEMASK_OUTPUT)
-    return pDIB->Create(width, height, FXDIB_8bppMask);
+    return pDIB->Create(width, height, FXDIB_Format::k8bppMask);
 #if defined(OS_APPLE) || defined(_SKIA_SUPPORT_PATHS_)
-  constexpr FXDIB_Format kPlatformFormat = FXDIB_Rgb32;
+  constexpr FXDIB_Format kPlatformFormat = FXDIB_Format::kRgb32;
 #else
-  constexpr FXDIB_Format kPlatformFormat = FXDIB_Rgb;
+  constexpr FXDIB_Format kPlatformFormat = FXDIB_Format::kRgb;
 #endif
   return pDIB->Create(
       width, height,
-      m_RenderCaps & FXRC_ALPHA_OUTPUT ? FXDIB_Argb : kPlatformFormat);
+      m_RenderCaps & FXRC_ALPHA_OUTPUT ? FXDIB_Format::kArgb : kPlatformFormat);
 }
 
 void CFX_RenderDevice::SetBaseClip(const FX_RECT& rect) {
@@ -711,9 +711,10 @@
   int bg_pixel_width = dest_rect.Width();
   int bg_pixel_height = dest_rect.Height();
   auto background = pdfium::MakeRetain<CFX_DIBitmap>();
-  if (!background->Create(bg_pixel_width, bg_pixel_height, FXDIB_Rgb32))
+  if (!background->Create(bg_pixel_width, bg_pixel_height,
+                          FXDIB_Format::kRgb32)) {
     return false;
-
+  }
   if (!m_pDeviceDriver->GetDIBits(background, dest_rect.left, dest_rect.top))
     return false;
 
@@ -932,7 +933,7 @@
   int pixel_top = bmp_rect.top;
   if (anti_alias == FT_RENDER_MODE_MONO) {
     auto bitmap = pdfium::MakeRetain<CFX_DIBitmap>();
-    if (!bitmap->Create(pixel_width, pixel_height, FXDIB_1bppMask))
+    if (!bitmap->Create(pixel_width, pixel_height, FXDIB_Format::k1bppMask))
       return false;
     bitmap->Clear(0);
     for (const TextGlyphPos& glyph : glyphs) {
@@ -952,7 +953,7 @@
   }
   auto bitmap = pdfium::MakeRetain<CFX_DIBitmap>();
   if (m_bpp == 8) {
-    if (!bitmap->Create(pixel_width, pixel_height, FXDIB_8bppMask))
+    if (!bitmap->Create(pixel_width, pixel_height, FXDIB_Format::k8bppMask))
       return false;
   } else {
     if (!CreateCompatibleBitmap(bitmap, pixel_width, pixel_height))
diff --git a/core/fxge/dib/cfx_bitmapcomposer.cpp b/core/fxge/dib/cfx_bitmapcomposer.cpp
index a2556aa..10cfa69 100644
--- a/core/fxge/dib/cfx_bitmapcomposer.cpp
+++ b/core/fxge/dib/cfx_bitmapcomposer.cpp
@@ -81,7 +81,7 @@
     }
     clip_scan = pAddClipScan;
   }
-  if (m_SrcFormat == FXDIB_8bppMask) {
+  if (m_SrcFormat == FXDIB_Format::k8bppMask) {
     m_Compositor.CompositeByteMaskLine(dest_scan, src_scan, dest_width,
                                        clip_scan, dst_extra_alpha);
   } else if (GetBppFromFormat(m_SrcFormat) == 8) {
diff --git a/core/fxge/dib/cfx_dibbase.cpp b/core/fxge/dib/cfx_dibbase.cpp
index d40de46..a3c1fe1 100644
--- a/core/fxge/dib/cfx_dibbase.cpp
+++ b/core/fxge/dib/cfx_dibbase.cpp
@@ -699,8 +699,7 @@
 
 }  // namespace
 
-CFX_DIBBase::CFX_DIBBase()
-    : m_Width(0), m_Height(0), m_bpp(0), m_AlphaFlag(0), m_Pitch(0) {}
+CFX_DIBBase::CFX_DIBBase() = default;
 
 CFX_DIBBase::~CFX_DIBBase() = default;
 
@@ -745,7 +744,8 @@
       copy_len = m_Pitch;
 
     for (int row = rect.top; row < rect.bottom; ++row) {
-      const uint8_t* src_scan = GetScanline(row) + rect.left * m_bpp / 8;
+      const uint8_t* src_scan =
+          GetScanline(row) + rect.left * GetBppFromFormat(m_Format) / 8;
       uint8_t* dest_scan = pNewBitmap->GetWritableScanline(row - rect.top);
       memcpy(dest_scan, src_scan, copy_len);
     }
@@ -779,7 +779,7 @@
     return true;
 
   m_pAlphaMask = pdfium::MakeRetain<CFX_DIBitmap>();
-  if (!m_pAlphaMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
+  if (!m_pAlphaMask->Create(m_Width, m_Height, FXDIB_Format::k8bppMask)) {
     m_pAlphaMask = nullptr;
     return false;
   }
@@ -792,7 +792,7 @@
   if (IsAlphaMask())
     return 0;
 
-  switch (m_bpp) {
+  switch (GetBppFromFormat(m_Format)) {
     case 1:
       return 2;
     case 8:
@@ -935,10 +935,10 @@
 }
 
 RetainPtr<CFX_DIBitmap> CFX_DIBBase::CloneAlphaMask() const {
-  ASSERT(GetFormat() == FXDIB_Argb);
+  ASSERT(GetFormat() == FXDIB_Format::kArgb);
   FX_RECT rect(0, 0, m_Width, m_Height);
   auto pMask = pdfium::MakeRetain<CFX_DIBitmap>();
-  if (!pMask->Create(rect.Width(), rect.Height(), FXDIB_8bppMask))
+  if (!pMask->Create(rect.Width(), rect.Height(), FXDIB_Format::k8bppMask))
     return nullptr;
 
   for (int row = rect.top; row < rect.bottom; ++row) {
@@ -954,7 +954,7 @@
 
 bool CFX_DIBBase::SetAlphaMask(const RetainPtr<CFX_DIBBase>& pAlphaMask,
                                const FX_RECT* pClip) {
-  if (!HasAlpha() || GetFormat() == FXDIB_Argb)
+  if (!HasAlpha() || GetFormat() == FXDIB_Format::kArgb)
     return false;
 
   if (!pAlphaMask) {
@@ -987,7 +987,7 @@
 
   pFlipped->SetPalette(GetPaletteSpan());
   uint8_t* pDestBuffer = pFlipped->GetBuffer();
-  int Bpp = m_bpp / 8;
+  int Bpp = GetBppFromFormat(m_Format) / 8;
   for (int row = 0; row < m_Height; ++row) {
     const uint8_t* src_scan = GetScanline(row);
     uint8_t* dest_scan =
@@ -996,7 +996,7 @@
       memcpy(dest_scan, src_scan, m_Pitch);
       continue;
     }
-    if (m_bpp == 1) {
+    if (GetBppFromFormat(m_Format) == 1) {
       memset(dest_scan, 0, m_Pitch);
       for (int col = 0; col < m_Width; ++col) {
         if (src_scan[col / 8] & (1 << (7 - col % 8))) {
@@ -1063,13 +1063,14 @@
 
   RetainPtr<CFX_DIBitmap> pSrcAlpha;
   if (HasAlpha()) {
-    pSrcAlpha = (GetFormat() == FXDIB_Argb) ? CloneAlphaMask() : m_pAlphaMask;
+    pSrcAlpha =
+        (GetFormat() == FXDIB_Format::kArgb) ? CloneAlphaMask() : m_pAlphaMask;
     if (!pSrcAlpha)
       return nullptr;
   }
   if (GetIsAlphaFromFormat(dest_format)) {
     bool ret;
-    if (dest_format == FXDIB_Argb) {
+    if (dest_format == FXDIB_Format::kArgb) {
       ret = pSrcAlpha ? pClone->LoadChannelFromAlpha(FXDIB_Alpha, pSrcAlpha)
                       : pClone->LoadChannel(FXDIB_Alpha, 0xff);
     } else {
@@ -1232,16 +1233,16 @@
   FXDIB_Format src_format = pSrcBitmap->GetFormat();
   const int bpp = GetBppFromFormat(src_format);
   switch (dest_format) {
-    case FXDIB_8bppMask: {
+    case FXDIB_Format::k8bppMask: {
       return ConvertBuffer_8bppMask(bpp, dest_buf, dest_pitch, width, height,
                                     pSrcBitmap, src_left, src_top);
     }
-    case FXDIB_8bppRgb:
-    case FXDIB_8bppRgba: {
+    case FXDIB_Format::k8bppRgb:
+    case FXDIB_Format::k8bppRgba: {
       const bool bpp_1_or_8 = (bpp == 1 || bpp == 8);
       if (bpp_1_or_8 && !pSrcBitmap->HasPalette()) {
-        return ConvertBuffer(FXDIB_8bppMask, dest_buf, dest_pitch, width,
-                             height, pSrcBitmap, src_left, src_top, pal);
+        return ConvertBuffer(FXDIB_Format::k8bppMask, dest_buf, dest_pitch,
+                             width, height, pSrcBitmap, src_left, src_top, pal);
       }
       pal->resize(256);
       if (bpp_1_or_8 && pSrcBitmap->HasPalette()) {
@@ -1256,13 +1257,13 @@
       }
       return false;
     }
-    case FXDIB_Rgb:
-    case FXDIB_Rgba: {
+    case FXDIB_Format::kRgb:
+    case FXDIB_Format::kRgba: {
       return ConvertBuffer_Rgb(bpp, dest_format, dest_buf, dest_pitch, width,
                                height, pSrcBitmap, src_left, src_top);
     }
-    case FXDIB_Argb:
-    case FXDIB_Rgb32: {
+    case FXDIB_Format::kArgb:
+    case FXDIB_Format::kRgb32: {
       return ConvertBuffer_Argb(bpp, GetIsCmykFromFormat(src_format),
                                 dest_format, dest_buf, dest_pitch, width,
                                 height, pSrcBitmap, src_left, src_top);
diff --git a/core/fxge/dib/cfx_dibbase.h b/core/fxge/dib/cfx_dibbase.h
index 80f9ef3..49b0572 100644
--- a/core/fxge/dib/cfx_dibbase.h
+++ b/core/fxge/dib/cfx_dibbase.h
@@ -52,18 +52,16 @@
   int GetWidth() const { return m_Width; }
   int GetHeight() const { return m_Height; }
 
-  FXDIB_Format GetFormat() const {
-    return static_cast<FXDIB_Format>(m_AlphaFlag * 0x100 + m_bpp);
-  }
+  FXDIB_Format GetFormat() const { return m_Format; }
   uint32_t GetPitch() const { return m_Pitch; }
   bool HasPalette() const { return !m_palette.empty(); }
   pdfium::span<const uint32_t> GetPaletteSpan() const { return m_palette; }
   const uint32_t* GetPaletteData() const { return m_palette.data(); }
-  int GetBPP() const { return m_bpp; }
+  int GetBPP() const { return GetBppFromFormat(m_Format); }
 
-  bool IsAlphaMask() const { return !!(m_AlphaFlag & 1); }
-  bool HasAlpha() const { return !!(m_AlphaFlag & 2); }
-  bool IsCmykImage() const { return !!(m_AlphaFlag & 4); }
+  bool IsAlphaMask() const { return GetIsMaskFromFormat(m_Format); }
+  bool HasAlpha() const { return GetIsAlphaFromFormat(m_Format); }
+  bool IsCmykImage() const { return GetIsCmykFromFormat(m_Format); }
   bool IsOpaqueImage() const { return !IsAlphaMask() && !HasAlpha(); }
 
   size_t GetPaletteSize() const;
@@ -127,11 +125,10 @@
   int FindPalette(uint32_t color) const;
   void GetPalette(uint32_t* pal, int alpha) const;
 
-  int m_Width;
-  int m_Height;
-  int m_bpp;
-  uint32_t m_AlphaFlag;
-  uint32_t m_Pitch;
+  int m_Width = 0;
+  int m_Height = 0;
+  uint32_t m_Pitch = 0;
+  FXDIB_Format m_Format = FXDIB_Format::kInvalid;
   std::vector<uint32_t, FxAllocAllocator<uint32_t>> m_palette;
 };
 
diff --git a/core/fxge/dib/cfx_dibitmap.cpp b/core/fxge/dib/cfx_dibitmap.cpp
index 07fd27e..3b3cbe3 100644
--- a/core/fxge/dib/cfx_dibitmap.cpp
+++ b/core/fxge/dib/cfx_dibitmap.cpp
@@ -35,8 +35,7 @@
                           uint8_t* pBuffer,
                           uint32_t pitch) {
   m_pBuffer = nullptr;
-  m_bpp = GetBppFromFormat(format);
-  m_AlphaFlag = GetAlphaFlagFromFormat(format);
+  m_Format = format;
   m_Width = 0;
   m_Height = 0;
   m_Pitch = 0;
@@ -62,7 +61,7 @@
   m_Width = width;
   m_Height = height;
   m_Pitch = pitch_size.value().pitch;
-  if (!HasAlpha() || format == FXDIB_Argb)
+  if (!HasAlpha() || format == FXDIB_Format::kArgb)
     return true;
 
   if (BuildAlphaMask())
@@ -108,8 +107,7 @@
   m_pAlphaMask = pSrcBitmap->m_pAlphaMask;
   pSrcBitmap->m_pBuffer = nullptr;
   pSrcBitmap->m_pAlphaMask = nullptr;
-  m_bpp = pSrcBitmap->m_bpp;
-  m_AlphaFlag = pSrcBitmap->m_AlphaFlag;
+  m_Format = pSrcBitmap->m_Format;
   m_Width = pSrcBitmap->m_Width;
   m_Height = pSrcBitmap->m_Height;
   m_Pitch = pSrcBitmap->m_Pitch;
@@ -121,24 +119,24 @@
 
   uint8_t* pBuffer = m_pBuffer.Get();
   switch (GetFormat()) {
-    case FXDIB_1bppMask:
+    case FXDIB_Format::k1bppMask:
       memset(pBuffer, (color & 0xff000000) ? 0xff : 0, m_Pitch * m_Height);
       break;
-    case FXDIB_1bppRgb: {
+    case FXDIB_Format::k1bppRgb: {
       int index = FindPalette(color);
       memset(pBuffer, index ? 0xff : 0, m_Pitch * m_Height);
       break;
     }
-    case FXDIB_8bppMask:
+    case FXDIB_Format::k8bppMask:
       memset(pBuffer, color >> 24, m_Pitch * m_Height);
       break;
-    case FXDIB_8bppRgb: {
+    case FXDIB_Format::k8bppRgb: {
       int index = FindPalette(color);
       memset(pBuffer, index, m_Pitch * m_Height);
       break;
     }
-    case FXDIB_Rgb:
-    case FXDIB_Rgba: {
+    case FXDIB_Format::kRgb:
+    case FXDIB_Format::kRgba: {
       int a;
       int r;
       int g;
@@ -159,11 +157,11 @@
       }
       break;
     }
-    case FXDIB_Rgb32:
-    case FXDIB_Argb: {
+    case FXDIB_Format::kRgb32:
+    case FXDIB_Format::kArgb: {
       color = IsCmykImage() ? FXCMYK_TODIB(color) : color;
 #if defined(_SKIA_SUPPORT_)
-      if (FXDIB_Rgb32 == GetFormat() && !IsCmykImage())
+      if (FXDIB_Format::kRgb32 == GetFormat() && !IsCmykImage())
         color |= 0xFF000000;
 #endif
       for (int i = 0; i < m_Width; i++)
@@ -223,8 +221,8 @@
   if (HasPalette())
     return false;
 
-  if (m_bpp == 8)
-    dest_format = FXDIB_8bppMask;
+  if (GetBppFromFormat(m_Format) == 8)
+    dest_format = FXDIB_Format::k8bppMask;
 
   uint8_t* dest_buf =
       m_pBuffer.Get() + dest_top * m_Pitch + dest_left * GetBPP() / 8;
@@ -284,21 +282,22 @@
     return false;
 
   if (pSrcBitmap->GetBPP() == 1) {
-    pSrcClone = pSrcBitmap->CloneConvert(FXDIB_8bppMask);
+    pSrcClone = pSrcBitmap->CloneConvert(FXDIB_Format::k8bppMask);
     if (!pSrcClone)
       return false;
   }
-  int srcOffset = pSrcBitmap->GetFormat() == FXDIB_Argb ? 3 : 0;
+  int srcOffset = pSrcBitmap->GetFormat() == FXDIB_Format::kArgb ? 3 : 0;
   int destOffset = 0;
   if (destChannel == FXDIB_Alpha) {
     if (IsAlphaMask()) {
-      if (!ConvertFormat(FXDIB_8bppMask))
+      if (!ConvertFormat(FXDIB_Format::k8bppMask))
         return false;
     } else {
-      if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyka : FXDIB_Argb))
+      if (!ConvertFormat(IsCmykImage() ? FXDIB_Format::kCmyka
+                                       : FXDIB_Format::kArgb)) {
         return false;
-
-      if (GetFormat() == FXDIB_Argb)
+      }
+      if (GetFormat() == FXDIB_Format::kArgb)
         destOffset = 3;
     }
   } else {
@@ -307,16 +306,19 @@
 
     if (GetBPP() < 24) {
       if (HasAlpha()) {
-        if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyka : FXDIB_Argb))
+        if (!ConvertFormat(IsCmykImage() ? FXDIB_Format::kCmyka
+                                         : FXDIB_Format::kArgb))
           return false;
       } else {
 #if defined(OS_APPLE)
-        constexpr FXDIB_Format kPlatformFormat = FXDIB_Rgb32;
+        constexpr FXDIB_Format kPlatformFormat = FXDIB_Format::kRgb32;
 #else
-        constexpr FXDIB_Format kPlatformFormat = FXDIB_Rgb;
+        constexpr FXDIB_Format kPlatformFormat = FXDIB_Format::kRgb;
 #endif
-        if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyk : kPlatformFormat))
+        if (!ConvertFormat(IsCmykImage() ? FXDIB_Format::kCmyk
+                                         : kPlatformFormat)) {
           return false;
+        }
       }
     }
     destOffset = kChannelOffset[destChannel];
@@ -369,16 +371,17 @@
   int destOffset;
   if (destChannel == FXDIB_Alpha) {
     if (IsAlphaMask()) {
-      if (!ConvertFormat(FXDIB_8bppMask)) {
+      if (!ConvertFormat(FXDIB_Format::k8bppMask)) {
         return false;
       }
       destOffset = 0;
     } else {
       destOffset = 0;
-      if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyka : FXDIB_Argb)) {
+      if (!ConvertFormat(IsCmykImage() ? FXDIB_Format::kCmyka
+                                       : FXDIB_Format::kArgb)) {
         return false;
       }
-      if (GetFormat() == FXDIB_Argb) {
+      if (GetFormat() == FXDIB_Format::kArgb) {
         destOffset = 3;
       }
     }
@@ -388,17 +391,20 @@
     }
     if (GetBPP() < 24) {
       if (HasAlpha()) {
-        if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyka : FXDIB_Argb)) {
+        if (!ConvertFormat(IsCmykImage() ? FXDIB_Format::kCmyka
+                                         : FXDIB_Format::kArgb)) {
           return false;
         }
       } else {
 #if defined(OS_APPLE)
-        constexpr FXDIB_Format kPlatformFormat = FXDIB_Rgb;
+        constexpr FXDIB_Format kPlatformFormat = FXDIB_Format::kRgb;
 #else
-        constexpr FXDIB_Format kPlatformFormat = FXDIB_Rgb32;
+        constexpr FXDIB_Format kPlatformFormat = FXDIB_Format::kRgb32;
 #endif
-        if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyk : kPlatformFormat))
+        if (!ConvertFormat(IsCmykImage() ? FXDIB_Format::kCmyk
+                                         : kPlatformFormat)) {
           return false;
+        }
       }
     }
     destOffset = kChannelOffset[destChannel];
@@ -444,7 +450,7 @@
       return false;
   }
   if (IsAlphaMask()) {
-    if (!ConvertFormat(FXDIB_8bppMask))
+    if (!ConvertFormat(FXDIB_Format::k8bppMask))
       return false;
 
     for (int row = 0; row < m_Height; row++) {
@@ -463,7 +469,7 @@
       }
     }
   } else {
-    if (GetFormat() == FXDIB_Argb) {
+    if (GetFormat() == FXDIB_Format::kArgb) {
       if (pSrcClone->GetBPP() == 1)
         return false;
 
@@ -488,13 +494,13 @@
     return false;
 
   switch (GetFormat()) {
-    case FXDIB_1bppMask:
-      if (!ConvertFormat(FXDIB_8bppMask)) {
+    case FXDIB_Format::k1bppMask:
+      if (!ConvertFormat(FXDIB_Format::k8bppMask)) {
         return false;
       }
       MultiplyAlpha(alpha);
       break;
-    case FXDIB_8bppMask: {
+    case FXDIB_Format::k8bppMask: {
       for (int row = 0; row < m_Height; row++) {
         uint8_t* scan_line = m_pBuffer.Get() + row * m_Pitch;
         for (int col = 0; col < m_Width; col++) {
@@ -503,7 +509,7 @@
       }
       break;
     }
-    case FXDIB_Argb: {
+    case FXDIB_Format::kArgb: {
       for (int row = 0; row < m_Height; row++) {
         uint8_t* scan_line = m_pBuffer.Get() + row * m_Pitch + 3;
         for (int col = 0; col < m_Width; col++) {
@@ -517,12 +523,12 @@
       if (HasAlpha()) {
         m_pAlphaMask->MultiplyAlpha(alpha);
       } else if (IsCmykImage()) {
-        if (!ConvertFormat((FXDIB_Format)(GetFormat() | 0x0200))) {
+        if (!ConvertFormat(AddAlphaToCmykFormat(GetFormat()))) {
           return false;
         }
         m_pAlphaMask->MultiplyAlpha(alpha);
       } else {
-        if (!ConvertFormat(FXDIB_Argb)) {
+        if (!ConvertFormat(FXDIB_Format::kArgb)) {
           return false;
         }
         MultiplyAlpha(alpha);
@@ -539,28 +545,28 @@
 
   uint8_t* pos = m_pBuffer.Get() + y * m_Pitch + x * GetBPP() / 8;
   switch (GetFormat()) {
-    case FXDIB_1bppMask: {
+    case FXDIB_Format::k1bppMask: {
       if ((*pos) & (1 << (7 - x % 8))) {
         return 0xff000000;
       }
       return 0;
     }
-    case FXDIB_1bppRgb: {
+    case FXDIB_Format::k1bppRgb: {
       if ((*pos) & (1 << (7 - x % 8))) {
         return HasPalette() ? GetPaletteSpan()[1] : 0xffffffff;
       }
       return HasPalette() ? GetPaletteSpan()[0] : 0xff000000;
     }
-    case FXDIB_8bppMask:
+    case FXDIB_Format::k8bppMask:
       return (*pos) << 24;
-    case FXDIB_8bppRgb:
+    case FXDIB_Format::k8bppRgb:
       return HasPalette() ? GetPaletteSpan()[*pos]
                           : (0xff000000 | ((*pos) * 0x10101));
-    case FXDIB_Rgb:
-    case FXDIB_Rgba:
-    case FXDIB_Rgb32:
+    case FXDIB_Format::kRgb:
+    case FXDIB_Format::kRgba:
+    case FXDIB_Format::kRgb32:
       return FXARGB_GETDIB(pos) | 0xff000000;
-    case FXDIB_Argb:
+    case FXDIB_Format::kArgb:
       return FXARGB_GETDIB(pos);
     default:
       break;
@@ -579,14 +585,14 @@
 
   uint8_t* pos = m_pBuffer.Get() + y * m_Pitch + x * GetBPP() / 8;
   switch (GetFormat()) {
-    case FXDIB_1bppMask:
+    case FXDIB_Format::k1bppMask:
       if (color >> 24) {
         *pos |= 1 << (7 - x % 8);
       } else {
         *pos &= ~(1 << (7 - x % 8));
       }
       break;
-    case FXDIB_1bppRgb:
+    case FXDIB_Format::k1bppRgb:
       if (HasPalette()) {
         if (color == GetPaletteSpan()[1]) {
           *pos |= 1 << (7 - x % 8);
@@ -601,10 +607,10 @@
         }
       }
       break;
-    case FXDIB_8bppMask:
+    case FXDIB_Format::k8bppMask:
       *pos = (uint8_t)(color >> 24);
       break;
-    case FXDIB_8bppRgb: {
+    case FXDIB_Format::k8bppRgb: {
       if (HasPalette()) {
         pdfium::span<const uint32_t> palette = GetPaletteSpan();
         for (int i = 0; i < 256; i++) {
@@ -619,21 +625,21 @@
       }
       break;
     }
-    case FXDIB_Rgb:
-    case FXDIB_Rgb32: {
+    case FXDIB_Format::kRgb:
+    case FXDIB_Format::kRgb32: {
       int alpha = FXARGB_A(color);
       pos[0] = (FXARGB_B(color) * alpha + pos[0] * (255 - alpha)) / 255;
       pos[1] = (FXARGB_G(color) * alpha + pos[1] * (255 - alpha)) / 255;
       pos[2] = (FXARGB_R(color) * alpha + pos[2] * (255 - alpha)) / 255;
       break;
     }
-    case FXDIB_Rgba: {
+    case FXDIB_Format::kRgba: {
       pos[0] = FXARGB_B(color);
       pos[1] = FXARGB_G(color);
       pos[2] = FXARGB_R(color);
       break;
     }
-    case FXDIB_Argb:
+    case FXDIB_Format::kArgb:
       FXARGB_SETDIB(pos, color);
       break;
     default:
@@ -652,7 +658,7 @@
   if (!m_pBuffer)
     return;
 
-  int src_Bpp = m_bpp / 8;
+  int src_Bpp = GetBppFromFormat(m_Format) / 8;
   uint8_t* scanline = m_pBuffer.Get() + line * m_Pitch;
   if (src_Bpp == 0) {
     for (int i = 0; i < clip_width; i++) {
@@ -716,12 +722,12 @@
   int br = FXSYS_GetRValue(backcolor);
   int bg = FXSYS_GetGValue(backcolor);
   int bb = FXSYS_GetBValue(backcolor);
-  if (m_bpp <= 8) {
+  if (GetBppFromFormat(m_Format) <= 8) {
     if (forecolor == 0 && backcolor == 0xffffff && !HasPalette())
       return;
 
     BuildPalette();
-    int size = 1 << m_bpp;
+    int size = 1 << GetBppFromFormat(m_Format);
     for (int i = 0; i < size; ++i) {
       int gray = FXRGB2GRAY(FXARGB_R(m_palette[i]), FXARGB_G(m_palette[i]),
                             FXARGB_B(m_palette[i]));
@@ -734,7 +740,7 @@
   if (forecolor == 0 && backcolor == 0xffffff) {
     for (int row = 0; row < m_Height; ++row) {
       uint8_t* scanline = m_pBuffer.Get() + row * m_Pitch;
-      int gap = m_bpp / 8 - 2;
+      int gap = GetBppFromFormat(m_Format) / 8 - 2;
       for (int col = 0; col < m_Width; ++col) {
         int gray = FXRGB2GRAY(scanline[2], scanline[1], scanline[0]);
         *scanline++ = gray;
@@ -747,7 +753,7 @@
   }
   for (int row = 0; row < m_Height; ++row) {
     uint8_t* scanline = m_pBuffer.Get() + row * m_Pitch;
-    int gap = m_bpp / 8 - 2;
+    int gap = GetBppFromFormat(m_Format) / 8 - 2;
     for (int col = 0; col < m_Width; ++col) {
       int gray = FXRGB2GRAY(scanline[2], scanline[1], scanline[0]);
       *scanline++ = bb + (fb - bb) * gray / 255;
@@ -768,12 +774,12 @@
   int bm = FXSYS_GetMValue(backcolor);
   int by = FXSYS_GetYValue(backcolor);
   int bk = FXSYS_GetKValue(backcolor);
-  if (m_bpp <= 8) {
+  if (GetBppFromFormat(m_Format) <= 8) {
     if (forecolor == 0xff && backcolor == 0 && !HasPalette())
       return;
 
     BuildPalette();
-    int size = 1 << m_bpp;
+    int size = 1 << GetBppFromFormat(m_Format);
     for (int i = 0; i < size; ++i) {
       uint8_t r;
       uint8_t g;
@@ -887,7 +893,7 @@
   if (!m_pBuffer)
     return false;
 
-  if (m_bpp < 8)
+  if (GetBppFromFormat(m_Format) < 8)
     return false;
 
   if (!GetOverlapRect(dest_left, dest_top, width, height,
@@ -909,7 +915,7 @@
                        pClipMask != nullptr, bRgbByteOrder)) {
     return false;
   }
-  const int dest_Bpp = m_bpp / 8;
+  const int dest_Bpp = GetBppFromFormat(m_Format) / 8;
   const int src_Bpp = pSrcBitmap->GetBPP() / 8;
   const bool bRgb = src_Bpp > 1 && !pSrcBitmap->IsCmykImage();
   if (!bRgb && !pSrcBitmap->HasPalette())
@@ -967,7 +973,7 @@
   if (!m_pBuffer)
     return false;
 
-  if (m_bpp < 8)
+  if (GetBppFromFormat(m_Format) < 8)
     return false;
 
   if (!GetOverlapRect(dest_left, dest_top, width, height, pMask->GetWidth(),
@@ -1043,7 +1049,7 @@
   else
     dst_color = color;
   uint8_t* color_p = reinterpret_cast<uint8_t*>(&dst_color);
-  if (m_bpp == 8) {
+  if (GetBppFromFormat(m_Format) == 8) {
     uint8_t gray = 255;
     if (!IsAlphaMask()) {
       if (alpha_flag >> 8) {
@@ -1073,7 +1079,7 @@
     }
     return true;
   }
-  if (m_bpp == 1) {
+  if (GetBppFromFormat(m_Format) == 1) {
     ASSERT(!IsCmykImage());
     ASSERT(static_cast<uint8_t>(alpha_flag >> 8) == 0);
 
@@ -1114,7 +1120,7 @@
     return true;
   }
 
-  if (m_bpp < 24) {
+  if (GetBppFromFormat(m_Format) < 24) {
     NOTREACHED();
     return false;
   }
@@ -1129,9 +1135,9 @@
   }
   if (!IsCmykImage())
     color_p[3] = static_cast<uint8_t>(src_alpha);
-  int Bpp = m_bpp / 8;
+  int Bpp = GetBppFromFormat(m_Format) / 8;
   bool bAlpha = HasAlpha();
-  bool bArgb = GetFormat() == FXDIB_Argb;
+  bool bArgb = GetFormat() == FXDIB_Format::kArgb;
   if (src_alpha == 255) {
     for (int row = rect.top; row < rect.bottom; row++) {
       uint8_t* dest_scan = m_pBuffer.Get() + row * m_Pitch + rect.left * Bpp;
@@ -1217,17 +1223,16 @@
 }
 
 bool CFX_DIBitmap::ConvertFormat(FXDIB_Format dest_format) {
-  FXDIB_Format src_format = GetFormat();
-  if (dest_format == src_format)
+  if (dest_format == m_Format)
     return true;
 
-  if (dest_format == FXDIB_8bppMask && src_format == FXDIB_8bppRgb &&
-      !HasPalette()) {
-    m_AlphaFlag = 1;
+  if (dest_format == FXDIB_Format::k8bppMask &&
+      m_Format == FXDIB_Format::k8bppRgb && !HasPalette()) {
+    m_Format = FXDIB_Format::k8bppMask;
     return true;
   }
-  if (dest_format == FXDIB_Argb && src_format == FXDIB_Rgb32) {
-    m_AlphaFlag = 2;
+  if (dest_format == FXDIB_Format::kArgb && m_Format == FXDIB_Format::kRgb32) {
+    m_Format = FXDIB_Format::kArgb;
     for (int row = 0; row < m_Height; row++) {
       uint8_t* scanline = m_pBuffer.Get() + row * m_Pitch + 3;
       for (int col = 0; col < m_Width; col++) {
@@ -1245,7 +1250,7 @@
     return false;
 
   RetainPtr<CFX_DIBitmap> pAlphaMask;
-  if (dest_format == FXDIB_Argb) {
+  if (dest_format == FXDIB_Format::kArgb) {
     memset(dest_buf.get(), 0xff, dest_pitch * m_Height + 4);
     if (m_pAlphaMask) {
       for (int row = 0; row < m_Height; row++) {
@@ -1258,7 +1263,7 @@
       }
     }
   } else if (GetIsAlphaFromFormat(dest_format)) {
-    if (src_format == FXDIB_Argb) {
+    if (m_Format == FXDIB_Format::kArgb) {
       pAlphaMask = CloneAlphaMask();
       if (!pAlphaMask)
         return false;
@@ -1283,8 +1288,7 @@
   m_pAlphaMask = pAlphaMask;
   m_palette = std::move(pal_8bpp);
   m_pBuffer = std::move(dest_buf);
-  m_bpp = GetBppFromFormat(dest_format);
-  m_AlphaFlag = GetAlphaFlagFromFormat(dest_format);
+  m_Format = dest_format;
   m_Pitch = dest_pitch;
   return true;
 }
diff --git a/core/fxge/dib/cfx_dibitmap_unittest.cpp b/core/fxge/dib/cfx_dibitmap_unittest.cpp
index 08d5ad9..48c7019 100644
--- a/core/fxge/dib/cfx_dibitmap_unittest.cpp
+++ b/core/fxge/dib/cfx_dibitmap_unittest.cpp
@@ -8,34 +8,37 @@
 
 TEST(CFX_DIBitmap, Create) {
   auto pBitmap = pdfium::MakeRetain<CFX_DIBitmap>();
-  EXPECT_FALSE(pBitmap->Create(400, 300, FXDIB_Invalid));
+  EXPECT_FALSE(pBitmap->Create(400, 300, FXDIB_Format::kInvalid));
 
   pBitmap = pdfium::MakeRetain<CFX_DIBitmap>();
-  EXPECT_TRUE(pBitmap->Create(400, 300, FXDIB_1bppRgb));
+  EXPECT_TRUE(pBitmap->Create(400, 300, FXDIB_Format::k1bppRgb));
 }
 
 TEST(CFX_DIBitmap, CalculatePitchAndSizeGood) {
   // Simple case with no provided pitch.
   Optional<CFX_DIBitmap::PitchAndSize> result =
-      CFX_DIBitmap::CalculatePitchAndSize(100, 200, FXDIB_Argb, 0);
+      CFX_DIBitmap::CalculatePitchAndSize(100, 200, FXDIB_Format::kArgb, 0);
   ASSERT_TRUE(result.has_value());
   EXPECT_EQ(400u, result.value().pitch);
   EXPECT_EQ(80000u, result.value().size);
 
   // Simple case with no provided pitch and different format.
-  result = CFX_DIBitmap::CalculatePitchAndSize(100, 200, FXDIB_8bppRgb, 0);
+  result =
+      CFX_DIBitmap::CalculatePitchAndSize(100, 200, FXDIB_Format::k8bppRgb, 0);
   ASSERT_TRUE(result.has_value());
   EXPECT_EQ(100u, result.value().pitch);
   EXPECT_EQ(20000u, result.value().size);
 
   // Simple case with provided pitch.
-  result = CFX_DIBitmap::CalculatePitchAndSize(100, 200, FXDIB_Argb, 400);
+  result =
+      CFX_DIBitmap::CalculatePitchAndSize(100, 200, FXDIB_Format::kArgb, 400);
   ASSERT_TRUE(result.has_value());
   EXPECT_EQ(400u, result.value().pitch);
   EXPECT_EQ(80000u, result.value().size);
 
   // Simple case with provided pitch, but pitch does not match width * bpp.
-  result = CFX_DIBitmap::CalculatePitchAndSize(100, 200, FXDIB_Argb, 355);
+  result =
+      CFX_DIBitmap::CalculatePitchAndSize(100, 200, FXDIB_Format::kArgb, 355);
   ASSERT_TRUE(result.has_value());
   EXPECT_EQ(355u, result.value().pitch);
   EXPECT_EQ(71000u, result.value().size);
@@ -49,48 +52,51 @@
   };
   for (const auto& dimension : kBadDimensions) {
     EXPECT_FALSE(CFX_DIBitmap::CalculatePitchAndSize(
-        dimension.width, dimension.height, FXDIB_Argb, 0));
+        dimension.width, dimension.height, FXDIB_Format::kArgb, 0));
     EXPECT_FALSE(CFX_DIBitmap::CalculatePitchAndSize(
-        dimension.width, dimension.height, FXDIB_Argb, 1));
+        dimension.width, dimension.height, FXDIB_Format::kArgb, 1));
   }
 
   // Bad format.
-  EXPECT_FALSE(CFX_DIBitmap::CalculatePitchAndSize(100, 200, FXDIB_Invalid, 0));
   EXPECT_FALSE(
-      CFX_DIBitmap::CalculatePitchAndSize(100, 200, FXDIB_Invalid, 800));
+      CFX_DIBitmap::CalculatePitchAndSize(100, 200, FXDIB_Format::kInvalid, 0));
+  EXPECT_FALSE(CFX_DIBitmap::CalculatePitchAndSize(
+      100, 200, FXDIB_Format::kInvalid, 800));
 
   // Overflow cases with calculated pitch.
-  EXPECT_FALSE(
-      CFX_DIBitmap::CalculatePitchAndSize(1073747000, 1, FXDIB_Argb, 0));
-  EXPECT_FALSE(
-      CFX_DIBitmap::CalculatePitchAndSize(1048576, 1024, FXDIB_Argb, 0));
-  EXPECT_FALSE(
-      CFX_DIBitmap::CalculatePitchAndSize(4194304, 1024, FXDIB_8bppRgb, 0));
+  EXPECT_FALSE(CFX_DIBitmap::CalculatePitchAndSize(1073747000, 1,
+                                                   FXDIB_Format::kArgb, 0));
+  EXPECT_FALSE(CFX_DIBitmap::CalculatePitchAndSize(1048576, 1024,
+                                                   FXDIB_Format::kArgb, 0));
+  EXPECT_FALSE(CFX_DIBitmap::CalculatePitchAndSize(4194304, 1024,
+                                                   FXDIB_Format::k8bppRgb, 0));
 
   // Overflow cases with provided pitch.
-  EXPECT_FALSE(CFX_DIBitmap::CalculatePitchAndSize(2147484000u, 1, FXDIB_Argb,
-                                                   2147484000u));
-  EXPECT_FALSE(
-      CFX_DIBitmap::CalculatePitchAndSize(1048576, 1024, FXDIB_Argb, 4194304));
-  EXPECT_FALSE(CFX_DIBitmap::CalculatePitchAndSize(4194304, 1024, FXDIB_8bppRgb,
-                                                   4194304));
+  EXPECT_FALSE(CFX_DIBitmap::CalculatePitchAndSize(
+      2147484000u, 1, FXDIB_Format::kArgb, 2147484000u));
+  EXPECT_FALSE(CFX_DIBitmap::CalculatePitchAndSize(
+      1048576, 1024, FXDIB_Format::kArgb, 4194304));
+  EXPECT_FALSE(CFX_DIBitmap::CalculatePitchAndSize(
+      4194304, 1024, FXDIB_Format::k8bppRgb, 4194304));
 }
 
 TEST(CFX_DIBitmap, CalculatePitchAndSizeBoundary) {
   // Test boundary condition for pitch overflow.
   Optional<CFX_DIBitmap::PitchAndSize> result =
-      CFX_DIBitmap::CalculatePitchAndSize(536870908, 4, FXDIB_8bppRgb, 0);
+      CFX_DIBitmap::CalculatePitchAndSize(536870908, 4, FXDIB_Format::k8bppRgb,
+                                          0);
   ASSERT_TRUE(result);
   EXPECT_EQ(536870908u, result.value().pitch);
   EXPECT_EQ(2147483632u, result.value().size);
-  EXPECT_FALSE(
-      CFX_DIBitmap::CalculatePitchAndSize(536870909, 4, FXDIB_8bppRgb, 0));
+  EXPECT_FALSE(CFX_DIBitmap::CalculatePitchAndSize(536870909, 4,
+                                                   FXDIB_Format::k8bppRgb, 0));
 
   // Test boundary condition for size overflow.
-  result = CFX_DIBitmap::CalculatePitchAndSize(68174084, 63, FXDIB_8bppRgb, 0);
+  result = CFX_DIBitmap::CalculatePitchAndSize(68174084, 63,
+                                               FXDIB_Format::k8bppRgb, 0);
   ASSERT_TRUE(result);
   EXPECT_EQ(68174084u, result.value().pitch);
   EXPECT_EQ(4294967292u, result.value().size);
-  EXPECT_FALSE(
-      CFX_DIBitmap::CalculatePitchAndSize(68174085, 63, FXDIB_8bppRgb, 0));
+  EXPECT_FALSE(CFX_DIBitmap::CalculatePitchAndSize(68174085, 63,
+                                                   FXDIB_Format::k8bppRgb, 0));
 }
diff --git a/core/fxge/dib/cfx_imagestretcher.cpp b/core/fxge/dib/cfx_imagestretcher.cpp
index 73cfc13..2d97950 100644
--- a/core/fxge/dib/cfx_imagestretcher.cpp
+++ b/core/fxge/dib/cfx_imagestretcher.cpp
@@ -26,12 +26,12 @@
 
 FXDIB_Format GetStretchedFormat(const CFX_DIBBase& src) {
   FXDIB_Format format = src.GetFormat();
-  if (format == FXDIB_1bppMask)
-    return FXDIB_8bppMask;
-  if (format == FXDIB_1bppRgb)
-    return FXDIB_8bppRgb;
-  if (format == FXDIB_8bppRgb && src.HasPalette())
-    return FXDIB_Rgb;
+  if (format == FXDIB_Format::k1bppMask)
+    return FXDIB_Format::k8bppMask;
+  if (format == FXDIB_Format::k1bppRgb)
+    return FXDIB_Format::k8bppRgb;
+  if (format == FXDIB_Format::k8bppRgb && src.HasPalette())
+    return FXDIB_Format::kRgb;
   return format;
 }
 
@@ -66,7 +66,8 @@
   if (m_DestWidth == 0 || m_DestHeight == 0)
     return false;
 
-  if (m_pSource->GetFormat() == FXDIB_1bppRgb && m_pSource->HasPalette()) {
+  if (m_pSource->GetFormat() == FXDIB_Format::k1bppRgb &&
+      m_pSource->HasPalette()) {
     FX_ARGB pal[256];
     int a0;
     int r0;
@@ -89,7 +90,7 @@
                           pal)) {
       return false;
     }
-  } else if (m_pSource->GetFormat() == FXDIB_1bppCmyk &&
+  } else if (m_pSource->GetFormat() == FXDIB_Format::k1bppCmyk &&
              m_pSource->HasPalette()) {
     FX_CMYK pal[256];
     int c0;
diff --git a/core/fxge/dib/cfx_imagetransformer.cpp b/core/fxge/dib/cfx_imagetransformer.cpp
index 44c3ede..e0514ec 100644
--- a/core/fxge/dib/cfx_imagetransformer.cpp
+++ b/core/fxge/dib/cfx_imagetransformer.cpp
@@ -103,18 +103,18 @@
 
 FXDIB_Format GetTransformedFormat(const RetainPtr<CFX_DIBBase>& pDrc) {
   if (pDrc->IsAlphaMask())
-    return FXDIB_8bppMask;
+    return FXDIB_Format::k8bppMask;
 
   FXDIB_Format format = pDrc->GetFormat();
-  if (format >= 1025)
-    return FXDIB_Cmyka;
-  if (format <= 32 || format == FXDIB_Argb)
-    return FXDIB_Argb;
-  return FXDIB_Rgba;
+  if (GetIsCmykFromFormat(format))
+    return FXDIB_Format::kCmyka;
+  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_Rgba) {
+  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);
@@ -136,9 +136,9 @@
 
   uint32_t* dest32 = reinterpret_cast<uint32_t*>(dest);
   if (bHasAlpha) {
-    if (format == FXDIB_Argb) {
+    if (format == FXDIB_Format::kArgb) {
       *dest32 = ArgbEncode(func(3), red_y, green_m, blue_c);
-    } else if (format == FXDIB_Rgba) {
+    } else if (format == FXDIB_Format::kRgba) {
       dest[0] = blue_c;
       dest[1] = green_m;
       dest[2] = red_y;
@@ -148,7 +148,7 @@
     return;
   }
 
-  if (format == FXDIB_Cmyka) {
+  if (format == FXDIB_Format::kCmyka) {
     *dest32 = FXCMYK_TODIB(CmykEncode(blue_c, green_m, red_y, func(3)));
   } else {
     *dest32 = ArgbEncode(kOpaqueAlpha, red_y, green_m, blue_c);
diff --git a/core/fxge/dib/cfx_scanlinecompositor.cpp b/core/fxge/dib/cfx_scanlinecompositor.cpp
index 7ac2241..93afceb 100644
--- a/core/fxge/dib/cfx_scanlinecompositor.cpp
+++ b/core/fxge/dib/cfx_scanlinecompositor.cpp
@@ -2753,21 +2753,22 @@
   if (GetBppFromFormat(dest_format) == 1)
     return false;
 
-  if (m_bRgbByteOrder && m_DestFormat == FXDIB_8bppMask)
+  if (m_bRgbByteOrder && m_DestFormat == FXDIB_Format::k8bppMask)
     return false;
 
-  if (m_SrcFormat == FXDIB_1bppMask || m_SrcFormat == FXDIB_8bppMask) {
+  if (m_SrcFormat == FXDIB_Format::k1bppMask ||
+      m_SrcFormat == FXDIB_Format::k8bppMask) {
     InitSourceMask(mask_color);
     return true;
   }
   if (!GetIsCmykFromFormat(src_format) && GetIsCmykFromFormat(dest_format))
     return false;
   if (GetBppFromFormat(m_SrcFormat) <= 8) {
-    if (dest_format == FXDIB_8bppMask)
+    if (dest_format == FXDIB_Format::k8bppMask)
       return true;
 
     InitSourcePalette(src_format, dest_format, src_palette);
-    m_iTransparency = (dest_format == FXDIB_Argb ? 1 : 0) +
+    m_iTransparency = (dest_format == FXDIB_Format::kArgb ? 1 : 0) +
                       (GetIsAlphaFromFormat(dest_format) ? 2 : 0) +
                       (GetIsCmykFromFormat(dest_format) ? 4 : 0) +
                       (GetBppFromFormat(src_format) == 1 ? 8 : 0);
@@ -2787,7 +2788,7 @@
   m_MaskRed = FXARGB_R(mask_color);
   m_MaskGreen = FXARGB_G(mask_color);
   m_MaskBlue = FXARGB_B(mask_color);
-  if (m_DestFormat == FXDIB_8bppMask)
+  if (m_DestFormat == FXDIB_Format::k8bppMask)
     return;
 
   if (GetBppFromFormat(m_DestFormat) == 8) {
@@ -2946,9 +2947,9 @@
     }
     return;
   }
-  if (m_DestFormat == FXDIB_8bppMask) {
+  if (m_DestFormat == FXDIB_Format::k8bppMask) {
     if (GetIsAlphaFromFormat(m_SrcFormat)) {
-      if (m_SrcFormat == FXDIB_Argb) {
+      if (m_SrcFormat == FXDIB_Format::kArgb) {
         CompositeRow_AlphaToMask(dest_scan, src_scan, width, clip_scan, 4);
       } else {
         CompositeRow_AlphaToMask(dest_scan, src_extra_alpha, width, clip_scan,
@@ -3052,11 +3053,11 @@
     const uint8_t* src_extra_alpha,
     uint8_t* dst_extra_alpha) {
   if (m_bRgbByteOrder) {
-    if (m_SrcFormat == FXDIB_1bppRgb) {
-      if (m_DestFormat == FXDIB_8bppRgb) {
+    if (m_SrcFormat == FXDIB_Format::k1bppRgb) {
+      if (m_DestFormat == FXDIB_Format::k8bppRgb) {
         return;
       }
-      if (m_DestFormat == FXDIB_Argb) {
+      if (m_DestFormat == FXDIB_Format::kArgb) {
         CompositeRow_1bppRgb2Argb_NoBlend_RgbByteOrder(
             dest_scan, src_scan, src_left, width,
             m_SrcPalette.Get32BitPalette().data(), clip_scan);
@@ -3067,10 +3068,10 @@
             GetCompsFromFormat(m_DestFormat), clip_scan);
       }
     } else {
-      if (m_DestFormat == FXDIB_8bppRgb) {
+      if (m_DestFormat == FXDIB_Format::k8bppRgb) {
         return;
       }
-      if (m_DestFormat == FXDIB_Argb) {
+      if (m_DestFormat == FXDIB_Format::kArgb) {
         CompositeRow_8bppRgb2Argb_NoBlend_RgbByteOrder(
             dest_scan, src_scan, width, m_SrcPalette.Get32BitPalette().data(),
             clip_scan);
@@ -3082,7 +3083,7 @@
     }
     return;
   }
-  if (m_DestFormat == FXDIB_8bppMask) {
+  if (m_DestFormat == FXDIB_Format::k8bppMask) {
     CompositeRow_Rgb2Mask(dest_scan, src_scan, width, clip_scan);
     return;
   }
@@ -3150,7 +3151,7 @@
                                                    int width,
                                                    const uint8_t* clip_scan,
                                                    uint8_t* dst_extra_alpha) {
-  if (m_DestFormat == FXDIB_8bppMask) {
+  if (m_DestFormat == FXDIB_Format::k8bppMask) {
     CompositeRow_ByteMask2Mask(dest_scan, src_scan, m_MaskAlpha, width,
                                clip_scan);
   } else if (GetBppFromFormat(m_DestFormat) == 8) {
@@ -3162,7 +3163,7 @@
                                  width, clip_scan);
     }
   } else if (m_bRgbByteOrder) {
-    if (m_DestFormat == FXDIB_Argb) {
+    if (m_DestFormat == FXDIB_Format::kArgb) {
       CompositeRow_ByteMask2Argb_RgbByteOrder(
           dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue,
           width, m_BlendType, clip_scan);
@@ -3171,15 +3172,16 @@
           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_Argb) {
+  } else if (m_DestFormat == FXDIB_Format::kArgb) {
     CompositeRow_ByteMask2Argb(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
                                m_MaskGreen, m_MaskBlue, width, m_BlendType,
                                clip_scan);
-  } else if (m_DestFormat == FXDIB_Rgb || m_DestFormat == FXDIB_Rgb32) {
+  } else if (m_DestFormat == FXDIB_Format::kRgb ||
+             m_DestFormat == FXDIB_Format::kRgb32) {
     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_Rgba) {
+  } 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);
@@ -3192,7 +3194,7 @@
                                                   int width,
                                                   const uint8_t* clip_scan,
                                                   uint8_t* dst_extra_alpha) {
-  if (m_DestFormat == FXDIB_8bppMask) {
+  if (m_DestFormat == FXDIB_Format::k8bppMask) {
     CompositeRow_BitMask2Mask(dest_scan, src_scan, m_MaskAlpha, src_left, width,
                               clip_scan);
   } else if (GetBppFromFormat(m_DestFormat) == 8) {
@@ -3204,7 +3206,7 @@
                                 src_left, width, clip_scan);
     }
   } else if (m_bRgbByteOrder) {
-    if (m_DestFormat == FXDIB_Argb) {
+    if (m_DestFormat == FXDIB_Format::kArgb) {
       CompositeRow_BitMask2Argb_RgbByteOrder(
           dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue,
           src_left, width, m_BlendType, clip_scan);
@@ -3214,11 +3216,12 @@
           src_left, width, m_BlendType, GetCompsFromFormat(m_DestFormat),
           clip_scan);
     }
-  } else if (m_DestFormat == FXDIB_Argb) {
+  } else if (m_DestFormat == FXDIB_Format::kArgb) {
     CompositeRow_BitMask2Argb(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
                               m_MaskGreen, m_MaskBlue, src_left, width,
                               m_BlendType, clip_scan);
-  } else if (m_DestFormat == FXDIB_Rgb || m_DestFormat == FXDIB_Rgb32) {
+  } else if (m_DestFormat == FXDIB_Format::kRgb ||
+             m_DestFormat == FXDIB_Format::kRgb32) {
     CompositeRow_BitMask2Rgb(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
                              m_MaskGreen, m_MaskBlue, src_left, width,
                              m_BlendType, GetCompsFromFormat(m_DestFormat),
diff --git a/core/fxge/dib/cstretchengine.cpp b/core/fxge/dib/cstretchengine.cpp
index 86622ae..3b1404b 100644
--- a/core/fxge/dib/cstretchengine.cpp
+++ b/core/fxge/dib/cstretchengine.cpp
@@ -253,7 +253,7 @@
 
   size = GetPitchRoundUpTo4Bytes(size);
   m_DestScanline.resize(size);
-  if (dest_format == FXDIB_Rgb32)
+  if (dest_format == FXDIB_Format::kRgb32)
     std::fill(m_DestScanline.begin(), m_DestScanline.end(), 255);
   m_InterPitch = GetPitchRoundUpTo4Bytes(m_DestClip.Width() * m_DestBpp);
   m_ExtraMaskPitch = GetPitchRoundUpTo4Bytes(m_DestClip.Width() * 8);
@@ -455,7 +455,7 @@
 
             int pixel_weight = *pWeight;
             unsigned long argb_cmyk = m_pSrcPalette[src_scan[j]];
-            if (m_DestFormat == FXDIB_Rgb) {
+            if (m_DestFormat == FXDIB_Format::kRgb) {
               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);
@@ -491,7 +491,7 @@
             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_Rgba) {
+            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);
@@ -558,7 +558,7 @@
 
             int pixel_weight = *pWeight;
             const uint8_t* src_pixel = src_scan + j * Bpp;
-            if (m_DestFormat == FXDIB_Argb) {
+            if (m_DestFormat == FXDIB_Format::kArgb) {
               pixel_weight = pixel_weight * src_pixel[3] / 255;
             } else {
               pixel_weight = pixel_weight * src_scan_mask[j] / 255;
@@ -577,7 +577,7 @@
           *dest_scan++ = static_cast<uint8_t>((dest_b_c) >> 16);
           *dest_scan++ = static_cast<uint8_t>((dest_g_m) >> 16);
           *dest_scan++ = static_cast<uint8_t>((dest_r_y) >> 16);
-          if (m_DestFormat == FXDIB_Argb)
+          if (m_DestFormat == FXDIB_Format::kArgb)
             *dest_scan = static_cast<uint8_t>((dest_a * 255) >> 16);
           if (dest_scan_mask)
             *dest_scan_mask++ = static_cast<uint8_t>((dest_a * 255) >> 16);
@@ -701,7 +701,7 @@
           unsigned char* src_scan =
               m_InterBuf.data() + (col - m_DestClip.left) * DestBpp;
           unsigned char* src_scan_mask = nullptr;
-          if (m_DestFormat != FXDIB_Argb)
+          if (m_DestFormat != FXDIB_Format::kArgb)
             src_scan_mask = m_ExtraAlphaBuf.data() + (col - m_DestClip.left);
           int dest_a = 0;
           int dest_r_y = 0;
@@ -721,7 +721,7 @@
             dest_b_c += pixel_weight * (*src_pixel++);
             dest_g_m += pixel_weight * (*src_pixel++);
             dest_r_y += pixel_weight * (*src_pixel);
-            if (m_DestFormat == FXDIB_Argb)
+            if (m_DestFormat == FXDIB_Format::kArgb)
               dest_a += pixel_weight * (*(src_pixel + 1));
             else
               dest_a += pixel_weight * mask_v;
@@ -740,7 +740,7 @@
             dest_scan[1] = pdfium::clamp(g, 0, 255);
             dest_scan[2] = pdfium::clamp(r, 0, 255);
           }
-          if (m_DestFormat == FXDIB_Argb)
+          if (m_DestFormat == FXDIB_Format::kArgb)
             dest_scan[3] = static_cast<uint8_t>((dest_a) >> 16);
           else
             *dest_scan_mask = static_cast<uint8_t>((dest_a) >> 16);
diff --git a/core/fxge/dib/cstretchengine_unittest.cpp b/core/fxge/dib/cstretchengine_unittest.cpp
index f945c58..80a3a74 100644
--- a/core/fxge/dib/cstretchengine_unittest.cpp
+++ b/core/fxge/dib/cstretchengine_unittest.cpp
@@ -23,8 +23,8 @@
       pdfium::MakeRetain<CPDF_Stream>(nullptr, 0, std::move(dict_obj));
   auto dib_source = pdfium::MakeRetain<CPDF_DIB>();
   dib_source->Load(nullptr, stream.Get());
-  CStretchEngine engine(nullptr, FXDIB_8bppRgb, 500, 500, clip_rect, dib_source,
-                        FXDIB_ResampleOptions());
+  CStretchEngine engine(nullptr, FXDIB_Format::k8bppRgb, 500, 500, clip_rect,
+                        dib_source, FXDIB_ResampleOptions());
   EXPECT_TRUE(engine.m_ResampleOptions.bInterpolateBilinear);
   EXPECT_FALSE(engine.m_ResampleOptions.bInterpolateBicubic);
   EXPECT_FALSE(engine.m_ResampleOptions.bHalftone);
diff --git a/core/fxge/fx_dib.h b/core/fxge/fx_dib.h
index bf47a13..86643de 100644
--- a/core/fxge/fx_dib.h
+++ b/core/fxge/fx_dib.h
@@ -13,22 +13,22 @@
 #include "core/fxcrt/fx_coordinates.h"
 #include "core/fxcrt/widestring.h"
 
-enum FXDIB_Format {
-  FXDIB_Invalid = 0,
-  FXDIB_1bppRgb = 0x001,
-  FXDIB_8bppRgb = 0x008,
-  FXDIB_Rgb = 0x018,
-  FXDIB_Rgb32 = 0x020,
-  FXDIB_1bppMask = 0x101,
-  FXDIB_8bppMask = 0x108,
-  FXDIB_8bppRgba = 0x208,
-  FXDIB_Rgba = 0x218,
-  FXDIB_Argb = 0x220,
-  FXDIB_1bppCmyk = 0x401,
-  FXDIB_8bppCmyk = 0x408,
-  FXDIB_Cmyk = 0x420,
-  FXDIB_8bppCmyka = 0x608,
-  FXDIB_Cmyka = 0x620,
+enum class FXDIB_Format : uint16_t {
+  kInvalid = 0,
+  k1bppRgb = 0x001,
+  k8bppRgb = 0x008,
+  kRgb = 0x018,
+  kRgb32 = 0x020,
+  k1bppMask = 0x101,
+  k8bppMask = 0x108,
+  k8bppRgba = 0x208,
+  kRgba = 0x218,
+  kArgb = 0x220,
+  k1bppCmyk = 0x401,
+  k8bppCmyk = 0x408,
+  kCmyk = 0x420,
+  k8bppCmyka = 0x608,
+  kCmyka = 0x620,
 };
 
 struct PixelWeight {
@@ -38,12 +38,11 @@
 };
 
 using FX_ARGB = uint32_t;
+using FX_CMYK = uint32_t;
 
 // FX_COLORREF, like win32 COLORREF, is BGR.
 using FX_COLORREF = uint32_t;
 
-using FX_CMYK = uint32_t;
-
 extern const int16_t SDP_Table[513];
 
 struct FXDIB_ResampleOptions {
@@ -107,24 +106,75 @@
 
 // Bits per pixel, not bytes.
 inline int GetBppFromFormat(FXDIB_Format format) {
-  return format & 0xff;
+  return static_cast<uint16_t>(format) & 0xff;
 }
 
 // AKA bytes per pixel, assuming 8-bits per component.
 inline int GetCompsFromFormat(FXDIB_Format format) {
-  return (format & 0xff) / 8;
+  return (static_cast<uint16_t>(format) & 0xff) / 8;
 }
 
-inline uint32_t GetAlphaFlagFromFormat(FXDIB_Format format) {
-  return (format >> 8) & 0xff;
+inline bool GetIsMaskFromFormat(FXDIB_Format format) {
+  return !!(static_cast<uint16_t>(format) & 0x100);
 }
 
 inline bool GetIsAlphaFromFormat(FXDIB_Format format) {
-  return format & 0x200;
+  return !!(static_cast<uint16_t>(format) & 0x200);
 }
 
 inline bool GetIsCmykFromFormat(FXDIB_Format format) {
-  return format & 0x400;
+  return !!(static_cast<uint16_t>(format) & 0x400);
+}
+
+inline bool HasNoFlags(FXDIB_Format format) {
+  return (static_cast<uint16_t>(format) & 0x700) == 0;
+}
+
+inline FXDIB_Format AddAlphaToCmykFormat(FXDIB_Format format) {
+  switch (format) {
+    case FXDIB_Format::k8bppCmyk:
+      return FXDIB_Format::k8bppCmyka;
+    case FXDIB_Format::kCmyk:
+      return FXDIB_Format::kCmyka;
+    case FXDIB_Format::k8bppCmyka:
+      return FXDIB_Format::k8bppCmyka;
+    case FXDIB_Format::kCmyka:
+      return FXDIB_Format::kCmyka;
+    default:
+      return FXDIB_Format::kInvalid;
+  }
+}
+
+inline FXDIB_Format MakeRGBFormat(int bpp) {
+  switch (bpp) {
+    case 1:
+      return FXDIB_Format::k1bppRgb;
+    case 8:
+      return FXDIB_Format::k8bppRgb;
+    case 24:
+      return FXDIB_Format::kRgb;
+    case 32:
+      return FXDIB_Format::kRgb32;
+    default:
+      return FXDIB_Format::kInvalid;
+  }
+}
+
+inline FXDIB_Format MakeARGBFormat(int bpp) {
+  switch (bpp) {
+    case 8:
+      return FXDIB_Format::k8bppRgba;
+    case 24:
+      return FXDIB_Format::kRgba;
+    case 32:
+      return FXDIB_Format::kArgb;
+    default:
+      return FXDIB_Format::kInvalid;
+  }
+}
+
+inline FXDIB_Format MakeMaybeAlphaRGBFormat(bool alpha, int bpp) {
+  return alpha ? MakeARGBFormat(bpp) : MakeRGBFormat(bpp);
 }
 
 inline FX_CMYK CmykEncode(int c, int m, int y, int k) {
diff --git a/core/fxge/skia/fx_skia_device.cpp b/core/fxge/skia/fx_skia_device.cpp
index 64be78b..520ae98 100644
--- a/core/fxge/skia/fx_skia_device.cpp
+++ b/core/fxge/skia/fx_skia_device.cpp
@@ -113,8 +113,8 @@
   }
 
   uint8_t* dest_buf = buffer + dest_top * pitch + dest_left * Bpp;
-  if (dest_format == FXDIB_Rgb) {
-    if (src_format == FXDIB_Rgb32) {
+  if (dest_format == FXDIB_Format::kRgb) {
+    if (src_format == FXDIB_Format::kRgb32) {
       for (int row = 0; row < height; row++) {
         uint8_t* dest_scan = dest_buf + row * pitch;
         const uint8_t* src_scan =
@@ -132,8 +132,9 @@
     return;
   }
 
-  if (dest_format == FXDIB_Argb || dest_format == FXDIB_Rgb32) {
-    if (src_format == FXDIB_Rgb) {
+  if (dest_format == FXDIB_Format::kArgb ||
+      dest_format == FXDIB_Format::kRgb32) {
+    if (src_format == FXDIB_Format::kRgb) {
       for (int row = 0; row < height; row++) {
         uint8_t* dest_scan = (uint8_t*)(dest_buf + row * pitch);
         const uint8_t* src_scan =
@@ -145,8 +146,8 @@
           src_scan += 3;
         }
       }
-    } else if (src_format == FXDIB_Rgb32) {
-      ASSERT(dest_format == FXDIB_Argb);
+    } else if (src_format == FXDIB_Format::kRgb32) {
+      ASSERT(dest_format == FXDIB_Format::kArgb);
       for (int row = 0; row < height; row++) {
         uint8_t* dest_scan = dest_buf + row * pitch;
         const uint8_t* src_scan =
@@ -1951,7 +1952,8 @@
                     clipBox.bottom + 1);
   path_rect.Intersect(m_pClipRgn->GetBox());
   auto pThisLayer = pdfium::MakeRetain<CFX_DIBitmap>();
-  pThisLayer->Create(path_rect.Width(), path_rect.Height(), FXDIB_8bppMask);
+  pThisLayer->Create(path_rect.Width(), path_rect.Height(),
+                     FXDIB_Format::k8bppMask);
   pThisLayer->Clear(0);
 
   SkImageInfo imageInfo =
diff --git a/core/fxge/win32/cfx_psrenderer.cpp b/core/fxge/win32/cfx_psrenderer.cpp
index b2553f6..d1694fc 100644
--- a/core/fxge/win32/cfx_psrenderer.cpp
+++ b/core/fxge/win32/cfx_psrenderer.cpp
@@ -366,20 +366,20 @@
     if (!pConverted)
       return false;
     switch (pSource->GetFormat()) {
-      case FXDIB_1bppRgb:
-      case FXDIB_Rgb32:
-        pConverted = pConverted->CloneConvert(FXDIB_Rgb);
+      case FXDIB_Format::k1bppRgb:
+      case FXDIB_Format::kRgb32:
+        pConverted = pConverted->CloneConvert(FXDIB_Format::kRgb);
         break;
-      case FXDIB_8bppRgb:
+      case FXDIB_Format::k8bppRgb:
         if (pSource->HasPalette())
-          pConverted = pConverted->CloneConvert(FXDIB_Rgb);
+          pConverted = pConverted->CloneConvert(FXDIB_Format::kRgb);
         break;
-      case FXDIB_1bppCmyk:
-        pConverted = pConverted->CloneConvert(FXDIB_Cmyk);
+      case FXDIB_Format::k1bppCmyk:
+        pConverted = pConverted->CloneConvert(FXDIB_Format::kCmyk);
         break;
-      case FXDIB_8bppCmyk:
+      case FXDIB_Format::k8bppCmyk:
         if (pSource->HasPalette())
-          pConverted = pConverted->CloneConvert(FXDIB_Cmyk);
+          pConverted = pConverted->CloneConvert(FXDIB_Format::kCmyk);
         break;
       default:
         break;
diff --git a/core/fxge/win32/cfx_windowsdib.cpp b/core/fxge/win32/cfx_windowsdib.cpp
index 2d531a4..1d9df24 100644
--- a/core/fxge/win32/cfx_windowsdib.cpp
+++ b/core/fxge/win32/cfx_windowsdib.cpp
@@ -86,9 +86,8 @@
   }
   int pitch = (width * pbmi->bmiHeader.biBitCount + 31) / 32 * 4;
   auto pBitmap = pdfium::MakeRetain<CFX_DIBitmap>();
-  FXDIB_Format format = bAlpha
-                            ? (FXDIB_Format)(pbmi->bmiHeader.biBitCount + 0x200)
-                            : (FXDIB_Format)pbmi->bmiHeader.biBitCount;
+  FXDIB_Format format =
+      MakeMaybeAlphaRGBFormat(bAlpha, pbmi->bmiHeader.biBitCount);
   if (!pBitmap->Create(width, height, format))
     return nullptr;
 
@@ -146,7 +145,7 @@
   int height;
   GetBitmapSize(hBitmap, width, height);
   auto pDIBitmap = pdfium::MakeRetain<CFX_DIBitmap>();
-  if (!pDIBitmap->Create(width, height, FXDIB_Rgb)) {
+  if (!pDIBitmap->Create(width, height, FXDIB_Format::kRgb)) {
     DeleteDC(hDC);
     return nullptr;
   }
@@ -183,7 +182,7 @@
   int width, height;
   GetBitmapSize(hBitmap, width, height);
   auto pDIBitmap = pdfium::MakeRetain<CFX_DIBitmap>();
-  if (!pDIBitmap->Create(width, height, FXDIB_Rgb)) {
+  if (!pDIBitmap->Create(width, height, FXDIB_Format::kRgb)) {
     DeleteDC(hDC);
     return nullptr;
   }
@@ -197,7 +196,7 @@
 }
 
 CFX_WindowsDIB::CFX_WindowsDIB(HDC hDC, int width, int height) {
-  Create(width, height, FXDIB_Rgb, (uint8_t*)1, 0);
+  Create(width, height, FXDIB_Format::kRgb, (uint8_t*)1, 0);
   BITMAPINFOHEADER bmih;
   memset(&bmih, 0, sizeof bmih);
   bmih.biSize = sizeof bmih;
diff --git a/core/fxge/win32/cgdi_device_driver.cpp b/core/fxge/win32/cgdi_device_driver.cpp
index 6c177ee..5811b5a 100644
--- a/core/fxge/win32/cgdi_device_driver.cpp
+++ b/core/fxge/win32/cgdi_device_driver.cpp
@@ -326,7 +326,7 @@
     if (!pBitmap)
       return false;
 
-    if (pBitmap->IsCmykImage() && !pBitmap->ConvertFormat(FXDIB_Rgb))
+    if (pBitmap->IsCmykImage() && !pBitmap->ConvertFormat(FXDIB_Format::kRgb))
       return false;
 
     LPBYTE pBuffer = pBitmap->GetBuffer();
@@ -344,7 +344,7 @@
 
   RetainPtr<CFX_DIBitmap> pBitmap = pBitmap1;
   if (pBitmap->IsCmykImage()) {
-    pBitmap = pBitmap->CloneConvert(FXDIB_Rgb);
+    pBitmap = pBitmap->CloneConvert(FXDIB_Format::kRgb);
     if (!pBitmap)
       return false;
   }
@@ -368,7 +368,7 @@
   if (!pBitmap || dest_width == 0 || dest_height == 0)
     return false;
 
-  if (pBitmap->IsCmykImage() && !pBitmap->ConvertFormat(FXDIB_Rgb))
+  if (pBitmap->IsCmykImage() && !pBitmap->ConvertFormat(FXDIB_Format::kRgb))
     return false;
 
   ByteString info = CFX_WindowsDIB::GetBitmapInfo(pBitmap);
diff --git a/core/fxge/win32/cgdi_display_driver.cpp b/core/fxge/win32/cgdi_display_driver.cpp
index c72fac5..9e9a968 100644
--- a/core/fxge/win32/cgdi_display_driver.cpp
+++ b/core/fxge/win32/cgdi_display_driver.cpp
@@ -53,7 +53,7 @@
                       DIB_RGB_COLORS) == height;
   } else {
     auto bitmap = pdfium::MakeRetain<CFX_DIBitmap>();
-    if (bitmap->Create(width, height, FXDIB_Rgb)) {
+    if (bitmap->Create(width, height, FXDIB_Format::kRgb)) {
       bmi.bmiHeader.biBitCount = 24;
       ::GetDIBits(hDCMemory, hbmp, 0, height, bitmap->GetBuffer(), &bmi,
                   DIB_RGB_COLORS);
@@ -82,7 +82,7 @@
     int alpha = FXARGB_A(color);
     if (pSource->GetBPP() != 1 || alpha != 255) {
       auto background = pdfium::MakeRetain<CFX_DIBitmap>();
-      if (!background->Create(width, height, FXDIB_Rgb32) ||
+      if (!background->Create(width, height, FXDIB_Format::kRgb32) ||
           !GetDIBits(background, left, top) ||
           !background->CompositeMask(0, 0, width, height, pSource, color, 0, 0,
                                      BlendMode::kNormal, nullptr, false)) {
@@ -102,7 +102,7 @@
   int height = src_rect.Height();
   if (pSource->HasAlpha()) {
     auto bitmap = pdfium::MakeRetain<CFX_DIBitmap>();
-    if (!bitmap->Create(width, height, FXDIB_Rgb) ||
+    if (!bitmap->Create(width, height, FXDIB_Format::kRgb) ||
         !GetDIBits(bitmap, left, top) ||
         !bitmap->CompositeBitmap(0, 0, width, height, pSource, src_rect.left,
                                  src_rect.top, BlendMode::kNormal, nullptr,
@@ -179,7 +179,7 @@
       return true;
 
     auto background = pdfium::MakeRetain<CFX_DIBitmap>();
-    if (!background->Create(clip_width, clip_height, FXDIB_Rgb32) ||
+    if (!background->Create(clip_width, clip_height, FXDIB_Format::kRgb32) ||
         !GetDIBits(background, image_rect.left + clip_rect.left,
                    image_rect.top + clip_rect.top) ||
         !background->CompositeMask(0, 0, clip_width, clip_height, pStretched,
diff --git a/core/fxge/win32/cgdi_plus_ext.cpp b/core/fxge/win32/cgdi_plus_ext.cpp
index 253a1ba..9a0171f 100644
--- a/core/fxge/win32/cgdi_plus_ext.cpp
+++ b/core/fxge/win32/cgdi_plus_ext.cpp
@@ -344,19 +344,19 @@
                    pBitmap->GetBPP() * pSrcRect->left / 8;
   Gdiplus::GpBitmap* bitmap = nullptr;
   switch (pBitmap->GetFormat()) {
-    case FXDIB_Argb:
+    case FXDIB_Format::kArgb:
       CallFunc(GdipCreateBitmapFromScan0)(src_width, src_height, src_pitch,
                                           PixelFormat32bppARGB, scan0, &bitmap);
       break;
-    case FXDIB_Rgb32:
+    case FXDIB_Format::kRgb32:
       CallFunc(GdipCreateBitmapFromScan0)(src_width, src_height, src_pitch,
                                           PixelFormat32bppRGB, scan0, &bitmap);
       break;
-    case FXDIB_Rgb:
+    case FXDIB_Format::kRgb:
       CallFunc(GdipCreateBitmapFromScan0)(src_width, src_height, src_pitch,
                                           PixelFormat24bppRGB, scan0, &bitmap);
       break;
-    case FXDIB_8bppRgb: {
+    case FXDIB_Format::k8bppRgb: {
       CallFunc(GdipCreateBitmapFromScan0)(src_width, src_height, src_pitch,
                                           PixelFormat8bppIndexed, scan0,
                                           &bitmap);
@@ -368,7 +368,7 @@
       CallFunc(GdipSetImagePalette)(bitmap, (Gdiplus::ColorPalette*)pal);
       break;
     }
-    case FXDIB_1bppRgb: {
+    case FXDIB_Format::k1bppRgb: {
       CallFunc(GdipCreateBitmapFromScan0)(src_width, src_height, src_pitch,
                                           PixelFormat1bppIndexed, scan0,
                                           &bitmap);
diff --git a/fpdfsdk/fpdf_editimg.cpp b/fpdfsdk/fpdf_editimg.cpp
index 6d10ea6..e76c77e 100644
--- a/fpdfsdk/fpdf_editimg.cpp
+++ b/fpdfsdk/fpdf_editimg.cpp
@@ -211,7 +211,7 @@
   // concept of bits. Otherwise, convert the source image to a bitmap directly,
   // retaining its color representation.
   if (pSource->GetBPP() == 1)
-    pBitmap = pSource->CloneConvert(FXDIB_8bppRgb);
+    pBitmap = pSource->CloneConvert(FXDIB_Format::k8bppRgb);
   else
     pBitmap = pSource->Clone(nullptr);
 
@@ -239,7 +239,7 @@
   int output_width = image_matrix.a;
   int output_height = image_matrix.d;
   auto result_bitmap = pdfium::MakeRetain<CFX_DIBitmap>();
-  if (!result_bitmap->Create(output_width, output_height, FXDIB_Argb))
+  if (!result_bitmap->Create(output_width, output_height, FXDIB_Format::kArgb))
     return nullptr;
 
   // Set up all the rendering code.
diff --git a/fpdfsdk/fpdf_view.cpp b/fpdfsdk/fpdf_view.cpp
index e627ede..0d8f687 100644
--- a/fpdfsdk/fpdf_view.cpp
+++ b/fpdfsdk/fpdf_view.cpp
@@ -450,9 +450,10 @@
 
   // Create a new bitmap to transfer part of the page bitmap to.
   RetainPtr<CFX_DIBitmap> pDst = pdfium::MakeRetain<CFX_DIBitmap>();
-  if (!pDst->Create(bitmap_area->Width(), bitmap_area->Height(), FXDIB_Argb))
+  if (!pDst->Create(bitmap_area->Width(), bitmap_area->Height(),
+                    FXDIB_Format::kArgb)) {
     return nullptr;
-
+  }
   pDst->Clear(0x00ffffff);
   pDst->TransferBitmap(0, 0, bitmap_area->Width(), bitmap_area->Height(), pSrc,
                        bitmap_area->left, bitmap_area->top);
@@ -469,7 +470,7 @@
 
   // Create a new bitmap from the old one
   RetainPtr<CFX_DIBitmap> pDst = pdfium::MakeRetain<CFX_DIBitmap>();
-  if (!pDst->Create(size_x_bm, size_y_bm, FXDIB_Rgb32))
+  if (!pDst->Create(size_x_bm, size_y_bm, FXDIB_Format::kRgb32))
     return;
 
   pDst->Clear(0xffffffff);
@@ -526,7 +527,7 @@
   RetainPtr<CFX_DIBitmap> pBitmap = pdfium::MakeRetain<CFX_DIBitmap>();
   // Create will probably work fine even if it fails here: we will just attach
   // a zero-sized bitmap to |pDevice|.
-  pBitmap->Create(size_x, size_y, FXDIB_Argb);
+  pBitmap->Create(size_x, size_y, FXDIB_Format::kArgb);
   pBitmap->Clear(0x00ffffff);
   CFX_DefaultRenderDevice* pDevice = new CFX_DefaultRenderDevice;
   pContext->m_pDevice = pdfium::WrapUnique(pDevice);
@@ -546,7 +547,7 @@
     bool bitsStretched = false;
     if (WinDC.GetDeviceType() == DeviceType::kPrinter) {
       auto pDst = pdfium::MakeRetain<CFX_DIBitmap>();
-      if (pDst->Create(size_x, size_y, FXDIB_Rgb32)) {
+      if (pDst->Create(size_x, size_y, FXDIB_Format::kRgb32)) {
         memset(pDst->GetBuffer(), -1, pBitmap->GetPitch() * size_y);
         pDst->CompositeBitmap(0, 0, size_x, size_y, pBitmap, 0, 0,
                               BlendMode::kNormal, nullptr, false);
@@ -786,9 +787,10 @@
                                                         int height,
                                                         int alpha) {
   auto pBitmap = pdfium::MakeRetain<CFX_DIBitmap>();
-  if (!pBitmap->Create(width, height, alpha ? FXDIB_Argb : FXDIB_Rgb32))
+  if (!pBitmap->Create(width, height,
+                       alpha ? FXDIB_Format::kArgb : FXDIB_Format::kRgb32)) {
     return nullptr;
-
+  }
   return FPDFBitmapFromCFXDIBitmap(pBitmap.Leak());
 }
 
@@ -800,16 +802,16 @@
   FXDIB_Format fx_format;
   switch (format) {
     case FPDFBitmap_Gray:
-      fx_format = FXDIB_8bppRgb;
+      fx_format = FXDIB_Format::k8bppRgb;
       break;
     case FPDFBitmap_BGR:
-      fx_format = FXDIB_Rgb;
+      fx_format = FXDIB_Format::kRgb;
       break;
     case FPDFBitmap_BGRx:
-      fx_format = FXDIB_Rgb32;
+      fx_format = FXDIB_Format::kRgb32;
       break;
     case FPDFBitmap_BGRA:
-      fx_format = FXDIB_Argb;
+      fx_format = FXDIB_Format::kArgb;
       break;
     default:
       return nullptr;
@@ -830,14 +832,14 @@
 
   FXDIB_Format format = CFXDIBitmapFromFPDFBitmap(bitmap)->GetFormat();
   switch (format) {
-    case FXDIB_8bppRgb:
-    case FXDIB_8bppMask:
+    case FXDIB_Format::k8bppRgb:
+    case FXDIB_Format::k8bppMask:
       return FPDFBitmap_Gray;
-    case FXDIB_Rgb:
+    case FXDIB_Format::kRgb:
       return FPDFBitmap_BGR;
-    case FXDIB_Rgb32:
+    case FXDIB_Format::kRgb32:
       return FPDFBitmap_BGRx;
-    case FXDIB_Argb:
+    case FXDIB_Format::kArgb:
       return FPDFBitmap_BGRA;
     default:
       return FPDFBitmap_Unknown;
diff --git a/fxbarcode/BC_Writer.h b/fxbarcode/BC_Writer.h
index cf7f43b..fb057c9 100644
--- a/fxbarcode/BC_Writer.h
+++ b/fxbarcode/BC_Writer.h
@@ -34,7 +34,7 @@
   int32_t m_ModuleWidth = 1;
   int32_t m_Height = 320;
   int32_t m_Width = 640;
-  FXDIB_Format m_colorSpace = FXDIB_Argb;
+  FXDIB_Format m_colorSpace = FXDIB_Format::kArgb;
 };
 
 #endif  // FXBARCODE_BC_WRITER_H_
diff --git a/fxbarcode/cfx_barcode_unittest.cpp b/fxbarcode/cfx_barcode_unittest.cpp
index f4c0304..ab644cb 100644
--- a/fxbarcode/cfx_barcode_unittest.cpp
+++ b/fxbarcode/cfx_barcode_unittest.cpp
@@ -24,7 +24,7 @@
 
     auto device = std::make_unique<CFX_DefaultRenderDevice>();
     auto bitmap = pdfium::MakeRetain<CFX_DIBitmap>();
-    if (bitmap->Create(640, 480, FXDIB_Rgb32))
+    if (bitmap->Create(640, 480, FXDIB_Format::kRgb32))
       bitmap_ = bitmap;
     ASSERT_TRUE(bitmap_);
     ASSERT_TRUE(device->Attach(bitmap_, false, nullptr, false));
diff --git a/testing/fuzzers/pdf_codec_jbig2_fuzzer.cc b/testing/fuzzers/pdf_codec_jbig2_fuzzer.cc
index 1a8ba61..b0342e7 100644
--- a/testing/fuzzers/pdf_codec_jbig2_fuzzer.cc
+++ b/testing/fuzzers/pdf_codec_jbig2_fuzzer.cc
@@ -31,7 +31,7 @@
     return 0;
 
   auto bitmap = pdfium::MakeRetain<CFX_DIBitmap>();
-  if (!bitmap->Create(width, height, FXDIB_1bppRgb))
+  if (!bitmap->Create(width, height, FXDIB_Format::k1bppRgb))
     return 0;
 
   Jbig2Context jbig2_context;
diff --git a/testing/fuzzers/pdf_jpx_fuzzer.cc b/testing/fuzzers/pdf_jpx_fuzzer.cc
index e880802..d7d82c4 100644
--- a/testing/fuzzers/pdf_jpx_fuzzer.cc
+++ b/testing/fuzzers/pdf_jpx_fuzzer.cc
@@ -51,14 +51,14 @@
 
   FXDIB_Format format;
   if (image_info.components == 1) {
-    format = FXDIB_8bppRgb;
+    format = FXDIB_Format::k8bppRgb;
   } else if (image_info.components <= 3) {
-    format = FXDIB_Rgb;
+    format = FXDIB_Format::kRgb;
   } else if (image_info.components == 4) {
-    format = FXDIB_Rgb32;
+    format = FXDIB_Format::kRgb32;
   } else {
     image_info.width = (image_info.width * image_info.components + 2) / 3;
-    format = FXDIB_Rgb;
+    format = FXDIB_Format::kRgb;
   }
   auto bitmap = pdfium::MakeRetain<CFX_DIBitmap>();
   if (!bitmap->Create(image_info.width, image_info.height, format))
diff --git a/testing/fuzzers/pdf_scanlinecompositor_fuzzer.cc b/testing/fuzzers/pdf_scanlinecompositor_fuzzer.cc
index deb6bfc..abb216f 100644
--- a/testing/fuzzers/pdf_scanlinecompositor_fuzzer.cc
+++ b/testing/fuzzers/pdf_scanlinecompositor_fuzzer.cc
@@ -14,10 +14,11 @@
 namespace {
 
 constexpr FXDIB_Format kFormat[] = {
-    FXDIB_Invalid, FXDIB_1bppRgb,   FXDIB_8bppRgb,  FXDIB_Rgb,
-    FXDIB_Rgb32,   FXDIB_1bppMask,  FXDIB_8bppMask, FXDIB_8bppRgba,
-    FXDIB_Rgba,    FXDIB_Argb,      FXDIB_1bppCmyk, FXDIB_8bppCmyk,
-    FXDIB_Cmyk,    FXDIB_8bppCmyka, FXDIB_Cmyka};
+    FXDIB_Format::kInvalid,  FXDIB_Format::k1bppRgb,   FXDIB_Format::k8bppRgb,
+    FXDIB_Format::kRgb,      FXDIB_Format::kRgb32,     FXDIB_Format::k1bppMask,
+    FXDIB_Format::k8bppMask, FXDIB_Format::k8bppRgba,  FXDIB_Format::kRgba,
+    FXDIB_Format::kArgb,     FXDIB_Format::k1bppCmyk,  FXDIB_Format::k8bppCmyk,
+    FXDIB_Format::kCmyk,     FXDIB_Format::k8bppCmyka, FXDIB_Format::kCmyka};
 
 }  // namespace
 
diff --git a/testing/fuzzers/xfa_codec_fuzzer.h b/testing/fuzzers/xfa_codec_fuzzer.h
index 275a636..2979710 100644
--- a/testing/fuzzers/xfa_codec_fuzzer.h
+++ b/testing/fuzzers/xfa_codec_fuzzer.h
@@ -40,7 +40,8 @@
     }
 
     auto bitmap = pdfium::MakeRetain<CFX_DIBitmap>();
-    bitmap->Create(decoder->GetWidth(), decoder->GetHeight(), FXDIB_Argb);
+    bitmap->Create(decoder->GetWidth(), decoder->GetHeight(),
+                   FXDIB_Format::kArgb);
 
     size_t frames;
     std::tie(status, frames) = decoder->GetFrames();
diff --git a/xfa/fgas/graphics/cfgas_gegraphics.cpp b/xfa/fgas/graphics/cfgas_gegraphics.cpp
index 79cb365..ae2c0c7 100644
--- a/xfa/fgas/graphics/cfgas_gegraphics.cpp
+++ b/xfa/fgas/graphics/cfgas_gegraphics.cpp
@@ -250,7 +250,7 @@
   int32_t width = bitmap->GetWidth();
   int32_t height = bitmap->GetHeight();
   auto bmp = pdfium::MakeRetain<CFX_DIBitmap>();
-  bmp->Create(width, height, FXDIB_Argb);
+  bmp->Create(width, height, FXDIB_Format::kArgb);
   m_renderDevice->GetDIBits(bmp, 0, 0);
 
   FX_HatchStyle hatchStyle = m_info.fillColor.GetPattern()->m_hatchStyle;
@@ -258,7 +258,7 @@
       GetHatchBitmapData(static_cast<size_t>(hatchStyle));
 
   auto mask = pdfium::MakeRetain<CFX_DIBitmap>();
-  mask->Create(data.width, data.height, FXDIB_1bppMask);
+  mask->Create(data.width, data.height, FXDIB_Format::k1bppMask);
   memcpy(mask->GetBuffer(), data.maskBits, mask->GetPitch() * data.height);
   const CFX_FloatRect rectf =
       matrix.TransformRect(path->GetPathData()->GetBoundingBox());
@@ -288,7 +288,7 @@
   float end_x = m_info.fillColor.GetShading()->m_endPoint.x;
   float end_y = m_info.fillColor.GetShading()->m_endPoint.y;
   auto bmp = pdfium::MakeRetain<CFX_DIBitmap>();
-  bmp->Create(width, height, FXDIB_Argb);
+  bmp->Create(width, height, FXDIB_Format::kArgb);
   m_renderDevice->GetDIBits(bmp, 0, 0);
   int32_t pitch = bmp->GetPitch();
   bool result = false;
diff --git a/xfa/fxfa/cxfa_ffwidget.cpp b/xfa/fxfa/cxfa_ffwidget.cpp
index 011b856..ccc604a 100644
--- a/xfa/fxfa/cxfa_ffwidget.cpp
+++ b/xfa/fxfa/cxfa_ffwidget.cpp
@@ -41,7 +41,7 @@
 FXDIB_Format XFA_GetDIBFormat(FXCODEC_IMAGE_TYPE type,
                               int32_t iComponents,
                               int32_t iBitsPerComponent) {
-  FXDIB_Format dibFormat = FXDIB_Argb;
+  FXDIB_Format dibFormat = FXDIB_Format::kArgb;
   switch (type) {
     case FXCODEC_IMAGE_JPG:
 #ifdef PDF_ENABLE_XFA_BMP
@@ -51,10 +51,10 @@
     case FXCODEC_IMAGE_TIFF:
 #endif  // PDF_ENABLE_XFA_TIFF
     {
-      dibFormat = FXDIB_Rgb32;
+      dibFormat = FXDIB_Format::kRgb32;
       int32_t bpp = iComponents * iBitsPerComponent;
       if (bpp <= 24) {
-        dibFormat = FXDIB_Rgb;
+        dibFormat = FXDIB_Format::kRgb;
       }
     } break;
 #ifdef PDF_ENABLE_XFA_PNG
diff --git a/xfa/fxfa/cxfa_imagerenderer.cpp b/xfa/fxfa/cxfa_imagerenderer.cpp
index e2a04aa..8b96e3a 100644
--- a/xfa/fxfa/cxfa_imagerenderer.cpp
+++ b/xfa/fxfa/cxfa_imagerenderer.cpp
@@ -40,7 +40,7 @@
     if (m_pDIBBase->HasAlpha() &&
         !(m_pDevice->GetRenderCaps() & FXRC_ALPHA_IMAGE) &&
         !(m_pDevice->GetRenderCaps() & FXRC_GET_BITS)) {
-      m_pCloneConvert = m_pDIBBase->CloneConvert(FXDIB_Rgb);
+      m_pCloneConvert = m_pDIBBase->CloneConvert(FXDIB_Format::kRgb);
       if (!m_pCloneConvert)
         return false;
 
@@ -143,7 +143,8 @@
     return;
   }
 
-  RetainPtr<CFX_DIBitmap> pCloneConvert = pDIBitmap->CloneConvert(FXDIB_Rgb);
+  RetainPtr<CFX_DIBitmap> pCloneConvert =
+      pDIBitmap->CloneConvert(FXDIB_Format::kRgb);
   if (!pCloneConvert)
     return;