Rename some functions that start with underscore.

core/src/fxge/dib/fx_dib_convert.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "core/include/fxcodec/fx_codec.h"
 #include "core/include/fxge/fx_dib.h"
 #include "core/include/fxge/fx_ge.h"
 
@@ skipping 235 matching lines @@
   _Qsort(m_aLut, m_cLut, 0, m_lut - 1);
   FX_DWORD* win_mac_pal = NULL;
   if (pal_type == FXDIB_PALETTE_WIN) {
     win_mac_pal = (FX_DWORD*)g_dwWinPalette;
   } else if (pal_type == FXDIB_PALETTE_MAC) {
     win_mac_pal = (FX_DWORD*)g_dwMacPalette;
   }
   _Obtain_Pal(m_aLut, m_cLut, m_pPalette, pal_type, win_mac_pal, m_lut);
   return TRUE;
 }
-FX_BOOL _ConvertBuffer_1bppMask2Gray(uint8_t* dest_buf,
-                                     int dest_pitch,
-                                     int width,
-                                     int height,
-                                     const CFX_DIBSource* pSrcBitmap,
-                                     int src_left,
-                                     int src_top) {
+FX_BOOL ConvertBuffer_1bppMask2Gray(uint8_t* dest_buf,
+                                    int dest_pitch,
+                                    int width,
+                                    int height,
+                                    const CFX_DIBSource* pSrcBitmap,
+                                    int src_left,
+                                    int src_top) {
   uint8_t set_gray, reset_gray;
   set_gray = 0xff;
   reset_gray = 0x00;
   for (int row = 0; row < height; row++) {
     uint8_t* dest_scan = dest_buf + row * dest_pitch;
     FXSYS_memset(dest_scan, reset_gray, width);
     const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row);
     for (int col = src_left; col < src_left + width; col++) {
       if (src_scan[col / 8] & (1 << (7 - col % 8))) {
         *dest_scan = set_gray;
       }
       dest_scan++;
     }
   }
   return TRUE;
 }
-FX_BOOL _ConvertBuffer_8bppMask2Gray(uint8_t* dest_buf,
-                                     int dest_pitch,
-                                     int width,
-                                     int height,
-                                     const CFX_DIBSource* pSrcBitmap,
-                                     int src_left,
-                                     int src_top) {
+FX_BOOL ConvertBuffer_8bppMask2Gray(uint8_t* dest_buf,
+                                    int dest_pitch,
+                                    int width,
+                                    int height,
+                                    const CFX_DIBSource* pSrcBitmap,
+                                    int src_left,
+                                    int src_top) {
   for (int row = 0; row < height; row++) {
     uint8_t* dest_scan = dest_buf + row * dest_pitch;
     const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left;
     FXSYS_memcpy(dest_scan, src_scan, width);
   }
   return TRUE;
 }
-FX_BOOL _ConvertBuffer_1bppPlt2Gray(uint8_t* dest_buf,
-                                    int dest_pitch,
-                                    int width,
-                                    int height,
-                                    const CFX_DIBSource* pSrcBitmap,
-                                    int src_left,
-                                    int src_top,
-                                    void* pIccTransform) {
+FX_BOOL ConvertBuffer_1bppPlt2Gray(uint8_t* dest_buf,
+                                   int dest_pitch,
+                                   int width,
+                                   int height,
+                                   const CFX_DIBSource* pSrcBitmap,
+                                   int src_left,
+                                   int src_top,
+                                   void* pIccTransform) {
   FX_DWORD* src_plt = pSrcBitmap->GetPalette();
   uint8_t gray[2];
   if (pIccTransform) {
     FX_DWORD plt[2];
     if (pSrcBitmap->IsCmykImage()) {
       plt[0] = FXCMYK_TODIB(src_plt[0]);
       plt[1] = FXCMYK_TODIB(src_plt[1]);
     } else {
       uint8_t* bgr_ptr = (uint8_t*)plt;
       bgr_ptr[0] = FXARGB_B(src_plt[0]);
@@ skipping 34 matching lines @@
     const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row);
     for (int col = src_left; col < src_left + width; col++) {
       if (src_scan[col / 8] & (1 << (7 - col % 8))) {
         *dest_scan = gray[1];
       }
       dest_scan++;
     }
   }
   return TRUE;
 }
-FX_BOOL _ConvertBuffer_8bppPlt2Gray(uint8_t* dest_buf,
-                                    int dest_pitch,
-                                    int width,
-                                    int height,
-                                    const CFX_DIBSource* pSrcBitmap,
-                                    int src_left,
-                                    int src_top,
-                                    void* pIccTransform) {
+FX_BOOL ConvertBuffer_8bppPlt2Gray(uint8_t* dest_buf,
+                                   int dest_pitch,
+                                   int width,
+                                   int height,
+                                   const CFX_DIBSource* pSrcBitmap,
+                                   int src_left,
+                                   int src_top,
+                                   void* pIccTransform) {
   FX_DWORD* src_plt = pSrcBitmap->GetPalette();
   uint8_t gray[256];
   if (pIccTransform) {
     FX_DWORD plt[256];
     if (pSrcBitmap->IsCmykImage()) {
       for (int i = 0; i < 256; i++) {
         plt[i] = FXCMYK_TODIB(src_plt[i]);
       }
     } else {
       uint8_t* bgr_ptr = (uint8_t*)plt;
@@ skipping 24 matching lines @@
   }
   for (int row = 0; row < height; row++) {
     uint8_t* dest_scan = dest_buf + row * dest_pitch;
     const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left;
     for (int col = 0; col < width; col++) {
       *dest_scan++ = gray[*src_scan++];
     }
   }
   return TRUE;
 }
-FX_BOOL _ConvertBuffer_RgbOrCmyk2Gray(uint8_t* dest_buf,
-                                      int dest_pitch,
-                                      int width,
-                                      int height,
-                                      const CFX_DIBSource* pSrcBitmap,
-                                      int src_left,
-                                      int src_top,
-                                      void* pIccTransform) {
+FX_BOOL ConvertBuffer_RgbOrCmyk2Gray(uint8_t* dest_buf,
+                                     int dest_pitch,
+                                     int width,
+                                     int height,
+                                     const CFX_DIBSource* pSrcBitmap,
+                                     int src_left,
+                                     int src_top,
+                                     void* pIccTransform) {
   int Bpp = pSrcBitmap->GetBPP() / 8;
   if (pIccTransform) {
     ICodec_IccModule* pIccModule =
         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     if (Bpp == 3 || pSrcBitmap->IsCmykImage()) {
       for (int row = 0; row < height; row++) {
         uint8_t* dest_scan = dest_buf + row * dest_pitch;
         const uint8_t* src_scan =
             pSrcBitmap->GetScanline(src_top + row) + src_left * Bpp;
         pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan,
@@ skipping 34 matching lines @@
             pSrcBitmap->GetScanline(src_top + row) + src_left * Bpp;
         for (int col = 0; col < width; col++) {
           *dest_scan++ = FXRGB2GRAY(src_scan[2], src_scan[1], src_scan[0]);
           src_scan += Bpp;
         }
       }
     }
   }
   return TRUE;
 }
-inline void _ConvertBuffer_IndexCopy(uint8_t* dest_buf,
-                                     int dest_pitch,
-                                     int width,
-                                     int height,
-                                     const CFX_DIBSource* pSrcBitmap,
-                                     int src_left,
-                                     int src_top) {
+inline void ConvertBuffer_IndexCopy(uint8_t* dest_buf,
+                                    int dest_pitch,
+                                    int width,
+                                    int height,
+                                    const CFX_DIBSource* pSrcBitmap,
+                                    int src_left,
+                                    int src_top) {
   if (pSrcBitmap->GetBPP() == 1) {
     for (int row = 0; row < height; row++) {
       uint8_t* dest_scan = dest_buf + row * dest_pitch;
       FXSYS_memset(dest_scan, 0, width);
       const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row);
       for (int col = src_left; col < src_left + width; col++) {
         if (src_scan[col / 8] & (1 << (7 - col % 8))) {
           *dest_scan = 1;
         }
         dest_scan++;
       }
     }
   } else {
     for (int row = 0; row < height; row++) {
       uint8_t* dest_scan = dest_buf + row * dest_pitch;
       const uint8_t* src_scan =
           pSrcBitmap->GetScanline(src_top + row) + src_left;
       FXSYS_memcpy(dest_scan, src_scan, width);
     }
   }
 }
-FX_BOOL _ConvertBuffer_Plt2PltRgb8(uint8_t* dest_buf,
-                                   int dest_pitch,
-                                   int width,
-                                   int height,
-                                   const CFX_DIBSource* pSrcBitmap,
-                                   int src_left,
-                                   int src_top,
-                                   FX_DWORD* dst_plt,
-                                   void* pIccTransform) {
-  _ConvertBuffer_IndexCopy(dest_buf, dest_pitch, width, height, pSrcBitmap,
-                           src_left, src_top);
+FX_BOOL ConvertBuffer_Plt2PltRgb8(uint8_t* dest_buf,
+                                  int dest_pitch,
+                                  int width,
+                                  int height,
+                                  const CFX_DIBSource* pSrcBitmap,
+                                  int src_left,
+                                  int src_top,
+                                  FX_DWORD* dst_plt,
+                                  void* pIccTransform) {
+  ConvertBuffer_IndexCopy(dest_buf, dest_pitch, width, height, pSrcBitmap,
+                          src_left, src_top);
   FX_DWORD* src_plt = pSrcBitmap->GetPalette();
   int plt_size = pSrcBitmap->GetPaletteSize();
   if (pIccTransform) {
     FX_DWORD plt[256];
     uint8_t* bgr_ptr = (uint8_t*)plt;
     if (pSrcBitmap->IsCmykImage()) {
       for (int i = 0; i < plt_size; i++) {
         plt[i] = FXCMYK_TODIB(src_plt[i]);
       }
     } else {
@@ skipping 20 matching lines @@
             FXSYS_GetCValue(src_plt[i]), FXSYS_GetMValue(src_plt[i]),
             FXSYS_GetYValue(src_plt[i]), FXSYS_GetKValue(src_plt[i]), r, g, b);
         dst_plt[i] = FXARGB_MAKE(0xff, r, g, b);
       }
     } else {
       FXSYS_memcpy(dst_plt, src_plt, plt_size * 4);
     }
   }
   return TRUE;
 }
-inline FX_BOOL _ConvertBuffer_Rgb2PltRgb8_NoTransform(
-    uint8_t* dest_buf,
-    int dest_pitch,
-    int width,
-    int height,
-    const CFX_DIBSource* pSrcBitmap,
-    int src_left,
-    int src_top,
-    FX_DWORD* dst_plt) {
+FX_BOOL ConvertBuffer_Rgb2PltRgb8_NoTransform(uint8_t* dest_buf,
+                                              int dest_pitch,
+                                              int width,
+                                              int height,
+                                              const CFX_DIBSource* pSrcBitmap,
+                                              int src_left,
+                                              int src_top,
+                                              FX_DWORD* dst_plt) {
   int bpp = pSrcBitmap->GetBPP() / 8;
   int row, col;
   CFX_Palette palette;
   palette.BuildPalette(pSrcBitmap, FXDIB_PALETTE_LOC);
   FX_DWORD* cLut = palette.GetColorLut();
   FX_DWORD* aLut = palette.GetAmountLut();
   if (!cLut || !aLut) {
     return FALSE;
   }
   int lut = palette.Getlut();
@@ skipping 34 matching lines @@
       for (int i = lut_1; i >= 0; i--)
         if (clrindex == cLut[i]) {
           *(dest_scan + col) = (uint8_t)(aLut[i]);
           break;
         }
     }
   }
   FXSYS_memcpy(dst_plt, pPalette, sizeof(FX_DWORD) * 256);
   return TRUE;
 }
-FX_BOOL _ConvertBuffer_Rgb2PltRgb8(uint8_t* dest_buf,
-                                   int dest_pitch,
-                                   int width,
-                                   int height,
-                                   const CFX_DIBSource* pSrcBitmap,
-                                   int src_left,
-                                   int src_top,
-                                   FX_DWORD* dst_plt,
-                                   void* pIccTransform) {
-#ifdef PDF_ENABLE_XFA
-  ICodec_IccModule* pIccModule = NULL;
-  if (pIccTransform) {
-    pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
-  }
-#endif  // PDF_ENABLE_XFA
-  FX_BOOL ret = _ConvertBuffer_Rgb2PltRgb8_NoTransform(
+FX_BOOL ConvertBuffer_Rgb2PltRgb8(uint8_t* dest_buf,
+                                  int dest_pitch,
+                                  int width,
+                                  int height,
+                                  const CFX_DIBSource* pSrcBitmap,
+                                  int src_left,
+                                  int src_top,
+                                  FX_DWORD* dst_plt,
+                                  void* pIccTransform) {
+  FX_BOOL ret = ConvertBuffer_Rgb2PltRgb8_NoTransform(
       dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top,
       dst_plt);
   if (ret && pIccTransform) {
     ICodec_IccModule* pIccModule =
         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     for (int i = 0; i < 256; i++) {
       FX_ARGB* plt = dst_plt + i;
       FX_ARGB plt_entry = FXARGB_TODIB(*plt);
       pIccModule->TranslateScanline(pIccTransform, (uint8_t*)&plt_entry,
                                     (const uint8_t*)&plt_entry, 1);
       *plt = FXARGB_TODIB(plt_entry);
     }
   }
   return ret;
 }
-FX_BOOL _ConvertBuffer_1bppMask2Rgb(FXDIB_Format dst_format,
-                                    uint8_t* dest_buf,
-                                    int dest_pitch,
-                                    int width,
-                                    int height,
-                                    const CFX_DIBSource* pSrcBitmap,
-                                    int src_left,
-                                    int src_top) {
+FX_BOOL ConvertBuffer_1bppMask2Rgb(FXDIB_Format dst_format,
+                                   uint8_t* dest_buf,
+                                   int dest_pitch,
+                                   int width,
+                                   int height,
+                                   const CFX_DIBSource* pSrcBitmap,
+                                   int src_left,
+                                   int src_top) {
   int comps = (dst_format & 0xff) / 8;
   uint8_t set_gray, reset_gray;
   set_gray = 0xff;
   reset_gray = 0x00;
   for (int row = 0; row < height; row++) {
     uint8_t* dest_scan = dest_buf + row * dest_pitch;
     const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row);
     for (int col = src_left; col < src_left + width; col++) {
       if (src_scan[col / 8] & (1 << (7 - col % 8))) {
         dest_scan[0] = set_gray;
         dest_scan[1] = set_gray;
         dest_scan[2] = set_gray;
       } else {
         dest_scan[0] = reset_gray;
         dest_scan[1] = reset_gray;
         dest_scan[2] = reset_gray;
       }
       dest_scan += comps;
     }
   }
   return TRUE;
 }
-FX_BOOL _ConvertBuffer_8bppMask2Rgb(FXDIB_Format dst_format,
-                                    uint8_t* dest_buf,
-                                    int dest_pitch,
-                                    int width,
-                                    int height,
-                                    const CFX_DIBSource* pSrcBitmap,
-                                    int src_left,
-                                    int src_top) {
+FX_BOOL ConvertBuffer_8bppMask2Rgb(FXDIB_Format dst_format,
+                                   uint8_t* dest_buf,
+                                   int dest_pitch,
+                                   int width,
+                                   int height,
+                                   const CFX_DIBSource* pSrcBitmap,
+                                   int src_left,
+                                   int src_top) {
   int comps = (dst_format & 0xff) / 8;
   for (int row = 0; row < height; row++) {
     uint8_t* dest_scan = dest_buf + row * dest_pitch;
     const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left;
     uint8_t src_pixel;
     for (int col = 0; col < width; col++) {
       src_pixel = *src_scan++;
       *dest_scan++ = src_pixel;
       *dest_scan++ = src_pixel;
       *dest_scan = src_pixel;
       dest_scan += comps - 2;
     }
   }
   return TRUE;
 }
-FX_BOOL _ConvertBuffer_1bppPlt2Rgb(FXDIB_Format dst_format,
-                                   uint8_t* dest_buf,
-                                   int dest_pitch,
-                                   int width,
-                                   int height,
-                                   const CFX_DIBSource* pSrcBitmap,
-                                   int src_left,
-                                   int src_top,
-                                   void* pIccTransform) {
+FX_BOOL ConvertBuffer_1bppPlt2Rgb(FXDIB_Format dst_format,
+                                  uint8_t* dest_buf,
+                                  int dest_pitch,
+                                  int width,
+                                  int height,
+                                  const CFX_DIBSource* pSrcBitmap,
+                                  int src_left,
+                                  int src_top,
+                                  void* pIccTransform) {
   int comps = (dst_format & 0xff) / 8;
   FX_DWORD* src_plt = pSrcBitmap->GetPalette();
   FX_DWORD plt[2];
   uint8_t* bgr_ptr = (uint8_t*)plt;
   if (pSrcBitmap->IsCmykImage()) {
     plt[0] = FXCMYK_TODIB(src_plt[0]);
     plt[1] = FXCMYK_TODIB(src_plt[1]);
   } else {
     bgr_ptr[0] = FXARGB_B(src_plt[0]);
     bgr_ptr[1] = FXARGB_G(src_plt[0]);
@@ skipping 30 matching lines @@
       } else {
         *dest_scan++ = bgr_ptr[0];
         *dest_scan++ = bgr_ptr[1];
         *dest_scan = bgr_ptr[2];
       }
       dest_scan += comps - 2;
     }
   }
   return TRUE;
 }
-FX_BOOL _ConvertBuffer_8bppPlt2Rgb(FXDIB_Format dst_format,
-                                   uint8_t* dest_buf,
-                                   int dest_pitch,
-                                   int width,
-                                   int height,
-                                   const CFX_DIBSource* pSrcBitmap,
-                                   int src_left,
-                                   int src_top,
-                                   void* pIccTransform) {
+FX_BOOL ConvertBuffer_8bppPlt2Rgb(FXDIB_Format dst_format,
+                                  uint8_t* dest_buf,
+                                  int dest_pitch,
+                                  int width,
+                                  int height,
+                                  const CFX_DIBSource* pSrcBitmap,
+                                  int src_left,
+                                  int src_top,
+                                  void* pIccTransform) {
   int comps = (dst_format & 0xff) / 8;
   FX_DWORD* src_plt = pSrcBitmap->GetPalette();
   FX_DWORD plt[256];
   uint8_t* bgr_ptr = (uint8_t*)plt;
   if (!pSrcBitmap->IsCmykImage()) {
     for (int i = 0; i < 256; i++) {
       *bgr_ptr++ = FXARGB_B(src_plt[i]);
       *bgr_ptr++ = FXARGB_G(src_plt[i]);
       *bgr_ptr++ = FXARGB_R(src_plt[i]);
     }
@@ skipping 27 matching lines @@
     for (int col = 0; col < width; col++) {
       uint8_t* src_pixel = bgr_ptr + 3 * (*src_scan++);
       *dest_scan++ = *src_pixel++;
       *dest_scan++ = *src_pixel++;
       *dest_scan = *src_pixel++;
       dest_scan += comps - 2;
     }
   }
   return TRUE;
 }
-FX_BOOL _ConvertBuffer_24bppRgb2Rgb24(uint8_t* dest_buf,
-                                      int dest_pitch,
-                                      int width,
-                                      int height,
-                                      const CFX_DIBSource* pSrcBitmap,
-                                      int src_left,
-                                      int src_top,
-                                      void* pIccTransform) {
+FX_BOOL ConvertBuffer_24bppRgb2Rgb24(uint8_t* dest_buf,
+                                     int dest_pitch,
+                                     int width,
+                                     int height,
+                                     const CFX_DIBSource* pSrcBitmap,
+                                     int src_left,
+                                     int src_top,
+                                     void* pIccTransform) {
   if (pIccTransform) {
     ICodec_IccModule* pIccModule =
         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     for (int row = 0; row < height; row++) {
       uint8_t* dest_scan = dest_buf + row * dest_pitch;
       const uint8_t* src_scan =
           pSrcBitmap->GetScanline(src_top + row) + src_left * 3;
       pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan, width);
     }
   } else {
     for (int row = 0; row < height; row++) {
       uint8_t* dest_scan = dest_buf + row * dest_pitch;
       const uint8_t* src_scan =
           pSrcBitmap->GetScanline(src_top + row) + src_left * 3;
       FXSYS_memcpy(dest_scan, src_scan, width * 3);
     }
   }
   return TRUE;
 }
-FX_BOOL _ConvertBuffer_32bppRgb2Rgb24(uint8_t* dest_buf,
-                                      int dest_pitch,
-                                      int width,
-                                      int height,
-                                      const CFX_DIBSource* pSrcBitmap,
-                                      int src_left,
-                                      int src_top,
-                                      void* pIccTransform) {
+FX_BOOL ConvertBuffer_32bppRgb2Rgb24(uint8_t* dest_buf,
+                                     int dest_pitch,
+                                     int width,
+                                     int height,
+                                     const CFX_DIBSource* pSrcBitmap,
+                                     int src_left,
+                                     int src_top,
+                                     void* pIccTransform) {
   for (int row = 0; row < height; row++) {
     uint8_t* dest_scan = dest_buf + row * dest_pitch;
     const uint8_t* src_scan =
         pSrcBitmap->GetScanline(src_top + row) + src_left * 4;
     for (int col = 0; col < width; col++) {
       *dest_scan++ = *src_scan++;
       *dest_scan++ = *src_scan++;
       *dest_scan++ = *src_scan++;
       src_scan++;
     }
   }
   if (pIccTransform) {
     ICodec_IccModule* pIccModule =
         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     for (int row = 0; row < height; row++) {
       uint8_t* dest_scan = dest_buf + row * dest_pitch;
       pIccModule->TranslateScanline(pIccTransform, dest_scan, dest_scan, width);
     }
   }
   return TRUE;
 }
-FX_BOOL _ConvertBuffer_Rgb2Rgb32(uint8_t* dest_buf,
-                                 int dest_pitch,
-                                 int width,
-                                 int height,
-                                 const CFX_DIBSource* pSrcBitmap,
-                                 int src_left,
-                                 int src_top,
-                                 void* pIccTransform) {
+FX_BOOL ConvertBuffer_Rgb2Rgb32(uint8_t* dest_buf,
+                                int dest_pitch,
+                                int width,
+                                int height,
+                                const CFX_DIBSource* pSrcBitmap,
+                                int src_left,
+                                int src_top,
+                                void* pIccTransform) {
   int comps = pSrcBitmap->GetBPP() / 8;
   if (pIccTransform) {
     ICodec_IccModule* pIccModule =
         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     for (int row = 0; row < height; row++) {
       uint8_t* dest_scan = dest_buf + row * dest_pitch;
       const uint8_t* src_scan =
           pSrcBitmap->GetScanline(src_top + row) + src_left * comps;
       for (int col = 0; col < width; col++) {
         pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan, 1);
@@ skipping 10 matching lines @@
         *dest_scan++ = *src_scan++;
         *dest_scan++ = *src_scan++;
         *dest_scan++ = *src_scan++;
         dest_scan++;
         src_scan += comps - 3;
       }
     }
   }
   return TRUE;
 }
-FX_BOOL _ConvertBuffer_32bppCmyk2Rgb32(uint8_t* dest_buf,
-                                       int dest_pitch,
-                                       int width,
-                                       int height,
-                                       const CFX_DIBSource* pSrcBitmap,
-                                       int src_left,
-                                       int src_top,
-                                       void* pIccTransform) {
+FX_BOOL ConvertBuffer_32bppCmyk2Rgb32(uint8_t* dest_buf,
+                                      int dest_pitch,
+                                      int width,
+                                      int height,
+                                      const CFX_DIBSource* pSrcBitmap,
+                                      int src_left,
+                                      int src_top,
+                                      void* pIccTransform) {
   if (pIccTransform) {
     ICodec_IccModule* pIccModule =
         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     for (int row = 0; row < height; row++) {
       uint8_t* dest_scan = dest_buf + row * dest_pitch;
       const uint8_t* src_scan =
           pSrcBitmap->GetScanline(src_top + row) + src_left * 4;
       for (int col = 0; col < width; col++) {
         pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan, 1);
         dest_scan += 4;
@@ skipping 33 matching lines @@
   switch (dest_format) {
     case FXDIB_Invalid:
     case FXDIB_1bppCmyk:
     case FXDIB_1bppMask:
     case FXDIB_1bppRgb:
       ASSERT(FALSE);
       return FALSE;
     case FXDIB_8bppMask: {
       if ((src_format & 0xff) == 1) {
         if (pSrcBitmap->GetPalette()) {
-          return _ConvertBuffer_1bppPlt2Gray(dest_buf, dest_pitch, width,
-                                             height, pSrcBitmap, src_left,
-                                             src_top, pIccTransform);
+          return ConvertBuffer_1bppPlt2Gray(dest_buf, dest_pitch, width, height,
+                                            pSrcBitmap, src_left, src_top,
+                                            pIccTransform);
         }
-        return _ConvertBuffer_1bppMask2Gray(dest_buf, dest_pitch, width, height,
-                                            pSrcBitmap, src_left, src_top);
+        return ConvertBuffer_1bppMask2Gray(dest_buf, dest_pitch, width, height,
+                                           pSrcBitmap, src_left, src_top);
       }
       if ((src_format & 0xff) == 8) {
         if (pSrcBitmap->GetPalette()) {
-          return _ConvertBuffer_8bppPlt2Gray(dest_buf, dest_pitch, width,
-                                             height, pSrcBitmap, src_left,
-                                             src_top, pIccTransform);
+          return ConvertBuffer_8bppPlt2Gray(dest_buf, dest_pitch, width, height,
+                                            pSrcBitmap, src_left, src_top,
+                                            pIccTransform);
         }
-        return _ConvertBuffer_8bppMask2Gray(dest_buf, dest_pitch, width, height,
-                                            pSrcBitmap, src_left, src_top);
+        return ConvertBuffer_8bppMask2Gray(dest_buf, dest_pitch, width, height,
+                                           pSrcBitmap, src_left, src_top);
       }
       if ((src_format & 0xff) >= 24) {
-        return _ConvertBuffer_RgbOrCmyk2Gray(dest_buf, dest_pitch, width,
-                                             height, pSrcBitmap, src_left,
-                                             src_top, pIccTransform);
+        return ConvertBuffer_RgbOrCmyk2Gray(dest_buf, dest_pitch, width, height,
+                                            pSrcBitmap, src_left, src_top,
+                                            pIccTransform);
       }
       return FALSE;
     }
     case FXDIB_8bppRgb:
     case FXDIB_8bppRgba: {
       if ((src_format & 0xff) == 8 && !pSrcBitmap->GetPalette()) {
         return ConvertBuffer(FXDIB_8bppMask, dest_buf, dest_pitch, width,
                              height, pSrcBitmap, src_left, src_top, d_pal,
                              pIccTransform);
       }
       d_pal = FX_Alloc(FX_DWORD, 256);
       if (((src_format & 0xff) == 1 || (src_format & 0xff) == 8) &&
           pSrcBitmap->GetPalette()) {
-        return _ConvertBuffer_Plt2PltRgb8(dest_buf, dest_pitch, width, height,
-                                          pSrcBitmap, src_left, src_top, d_pal,
-                                          pIccTransform);
+        return ConvertBuffer_Plt2PltRgb8(dest_buf, dest_pitch, width, height,
+                                         pSrcBitmap, src_left, src_top, d_pal,
+                                         pIccTransform);
       }
       if ((src_format & 0xff) >= 24) {
-        return _ConvertBuffer_Rgb2PltRgb8(dest_buf, dest_pitch, width, height,
-                                          pSrcBitmap, src_left, src_top, d_pal,
-                                          pIccTransform);
+        return ConvertBuffer_Rgb2PltRgb8(dest_buf, dest_pitch, width, height,
+                                         pSrcBitmap, src_left, src_top, d_pal,
+                                         pIccTransform);
       }
       return FALSE;
     }
     case FXDIB_Rgb:
     case FXDIB_Rgba: {
       if ((src_format & 0xff) == 1) {
         if (pSrcBitmap->GetPalette()) {
-          return _ConvertBuffer_1bppPlt2Rgb(dest_format, dest_buf, dest_pitch,
-                                            width, height, pSrcBitmap, src_left,
-                                            src_top, pIccTransform);
+          return ConvertBuffer_1bppPlt2Rgb(dest_format, dest_buf, dest_pitch,
+                                           width, height, pSrcBitmap, src_left,
+                                           src_top, pIccTransform);
         }
-        return _ConvertBuffer_1bppMask2Rgb(dest_format, dest_buf, dest_pitch,
-                                           width, height, pSrcBitmap, src_left,
-                                           src_top);
+        return ConvertBuffer_1bppMask2Rgb(dest_format, dest_buf, dest_pitch,
+                                          width, height, pSrcBitmap, src_left,
+                                          src_top);
       }
       if ((src_format & 0xff) == 8) {
         if (pSrcBitmap->GetPalette()) {
-          return _ConvertBuffer_8bppPlt2Rgb(dest_format, dest_buf, dest_pitch,
-                                            width, height, pSrcBitmap, src_left,
-                                            src_top, pIccTransform);
+          return ConvertBuffer_8bppPlt2Rgb(dest_format, dest_buf, dest_pitch,
+                                           width, height, pSrcBitmap, src_left,
+                                           src_top, pIccTransform);
         }
-        return _ConvertBuffer_8bppMask2Rgb(dest_format, dest_buf, dest_pitch,
-                                           width, height, pSrcBitmap, src_left,
-                                           src_top);
+        return ConvertBuffer_8bppMask2Rgb(dest_format, dest_buf, dest_pitch,
+                                          width, height, pSrcBitmap, src_left,
+                                          src_top);
       }
       if ((src_format & 0xff) == 24) {
-        return _ConvertBuffer_24bppRgb2Rgb24(dest_buf, dest_pitch, width,
-                                             height, pSrcBitmap, src_left,
-                                             src_top, pIccTransform);
+        return ConvertBuffer_24bppRgb2Rgb24(dest_buf, dest_pitch, width, height,
+                                            pSrcBitmap, src_left, src_top,
+                                            pIccTransform);
       }
       if ((src_format & 0xff) == 32) {
-        return _ConvertBuffer_32bppRgb2Rgb24(dest_buf, dest_pitch, width,
-                                             height, pSrcBitmap, src_left,
-                                             src_top, pIccTransform);
+        return ConvertBuffer_32bppRgb2Rgb24(dest_buf, dest_pitch, width, height,
+                                            pSrcBitmap, src_left, src_top,
+                                            pIccTransform);
       }
       return FALSE;
     }
     case FXDIB_Argb:
     case FXDIB_Rgb32: {
       if ((src_format & 0xff) == 1) {
         if (pSrcBitmap->GetPalette()) {
-          return _ConvertBuffer_1bppPlt2Rgb(dest_format, dest_buf, dest_pitch,
-                                            width, height, pSrcBitmap, src_left,
-                                            src_top, pIccTransform);
+          return ConvertBuffer_1bppPlt2Rgb(dest_format, dest_buf, dest_pitch,
+                                           width, height, pSrcBitmap, src_left,
+                                           src_top, pIccTransform);
         }
-        return _ConvertBuffer_1bppMask2Rgb(dest_format, dest_buf, dest_pitch,
-                                           width, height, pSrcBitmap, src_left,
-                                           src_top);
+        return ConvertBuffer_1bppMask2Rgb(dest_format, dest_buf, dest_pitch,
+                                          width, height, pSrcBitmap, src_left,
+                                          src_top);
       }
       if ((src_format & 0xff) == 8) {
         if (pSrcBitmap->GetPalette()) {
-          return _ConvertBuffer_8bppPlt2Rgb(dest_format, dest_buf, dest_pitch,
-                                            width, height, pSrcBitmap, src_left,
-                                            src_top, pIccTransform);
+          return ConvertBuffer_8bppPlt2Rgb(dest_format, dest_buf, dest_pitch,
+                                           width, height, pSrcBitmap, src_left,
+                                           src_top, pIccTransform);
         }
-        return _ConvertBuffer_8bppMask2Rgb(dest_format, dest_buf, dest_pitch,
-                                           width, height, pSrcBitmap, src_left,
-                                           src_top);
+        return ConvertBuffer_8bppMask2Rgb(dest_format, dest_buf, dest_pitch,
+                                          width, height, pSrcBitmap, src_left,
+                                          src_top);
       }
       if ((src_format & 0xff) >= 24) {
         if (src_format & 0x0400) {
-          return _ConvertBuffer_32bppCmyk2Rgb32(dest_buf, dest_pitch, width,
-                                                height, pSrcBitmap, src_left,
-                                                src_top, pIccTransform);
+          return ConvertBuffer_32bppCmyk2Rgb32(dest_buf, dest_pitch, width,
+                                               height, pSrcBitmap, src_left,
+                                               src_top, pIccTransform);
         }
-        return _ConvertBuffer_Rgb2Rgb32(dest_buf, dest_pitch, width, height,
-                                        pSrcBitmap, src_left, src_top,
-                                        pIccTransform);
+        return ConvertBuffer_Rgb2Rgb32(dest_buf, dest_pitch, width, height,
+                                       pSrcBitmap, src_left, src_top,
+                                       pIccTransform);
       }
       return FALSE;
     }
     default:
       return FALSE;
   }
   return FALSE;
 }
 CFX_DIBitmap* CFX_DIBSource::CloneConvert(FXDIB_Format dest_format,
                                           const FX_RECT* pClip,
@@ skipping 140 matching lines @@
   if (!m_bExtBuf) {
     FX_Free(m_pBuffer);
   }
   m_bExtBuf = FALSE;
   m_pBuffer = dest_buf;
   m_bpp = (uint8_t)dest_format;
   m_AlphaFlag = (uint8_t)(dest_format >> 8);
   m_Pitch = dest_pitch;
   return TRUE;
 }