Remove ICodec_* Interfaces.

core/fxge/dib/fx_dib_composite.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/fxcodec/include/fx_codec.h"
 #include "core/fxge/dib/dib_int.h"
 #include "core/fxge/include/fx_ge.h"
 
@@ skipping 269 matching lines @@
   }
 }
 void _CompositeRow_Argb2Graya(uint8_t* dest_scan,
                               const uint8_t* src_scan,
                               int pixel_count,
                               int blend_type,
                               const uint8_t* clip_scan,
                               const uint8_t* src_alpha_scan,
                               uint8_t* dst_alpha_scan,
                               void* pIccTransform) {
-  ICodec_IccModule* pIccModule = nullptr;
+  CCodec_IccModule* pIccModule = nullptr;
   if (pIccTransform)
     pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
 
   if (blend_type) {
     FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     if (src_alpha_scan) {
       for (int col = 0; col < pixel_count; col++) {
         uint8_t back_alpha = *dst_alpha_scan;
         if (back_alpha == 0) {
           int src_alpha = *src_alpha_scan++;
@@ skipping 182 matching lines @@
   }
 }
 
 inline void _CompositeRow_Argb2Gray(uint8_t* dest_scan,
                                     const uint8_t* src_scan,
                                     int pixel_count,
                                     int blend_type,
                                     const uint8_t* clip_scan,
                                     const uint8_t* src_alpha_scan,
                                     void* pIccTransform) {
-  ICodec_IccModule* pIccModule = NULL;
+  CCodec_IccModule* pIccModule = nullptr;
   uint8_t gray;
   if (pIccTransform)
     pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
 
   if (blend_type) {
     FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     if (src_alpha_scan) {
       for (int col = 0; col < pixel_count; col++) {
         int src_alpha = *src_alpha_scan++;
         if (clip_scan)
@@ skipping 75 matching lines @@
   }
 }
 
 inline void _CompositeRow_Rgb2Gray(uint8_t* dest_scan,
                                    const uint8_t* src_scan,
                                    int src_Bpp,
                                    int pixel_count,
                                    int blend_type,
                                    const uint8_t* clip_scan,
                                    void* pIccTransform) {
-  ICodec_IccModule* pIccModule = NULL;
+  CCodec_IccModule* pIccModule = nullptr;
   uint8_t gray;
   if (pIccTransform) {
     pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
   }
   if (blend_type) {
     FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     for (int col = 0; col < pixel_count; col++) {
       if (pIccTransform) {
         pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1);
       } else {
@@ skipping 29 matching lines @@
   }
 }
 void _CompositeRow_Rgb2Graya(uint8_t* dest_scan,
                              const uint8_t* src_scan,
                              int src_Bpp,
                              int pixel_count,
                              int blend_type,
                              const uint8_t* clip_scan,
                              uint8_t* dest_alpha_scan,
                              void* pIccTransform) {
-  ICodec_IccModule* pIccModule = NULL;
+  CCodec_IccModule* pIccModule = nullptr;
   if (pIccTransform) {
     pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
   }
   if (blend_type) {
     FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     for (int col = 0; col < pixel_count; col++) {
       int back_alpha = *dest_alpha_scan;
       if (back_alpha == 0) {
         if (pIccTransform) {
           pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan, 1);
@@ skipping 785 matching lines @@
 void _CompositeRow_Argb2Argb_Transform(uint8_t* dest_scan,
                                        const uint8_t* src_scan,
                                        int pixel_count,
                                        int blend_type,
                                        const uint8_t* clip_scan,
                                        uint8_t* dest_alpha_scan,
                                        const uint8_t* src_alpha_scan,
                                        uint8_t* src_cache_scan,
                                        void* pIccTransform) {
   uint8_t* dp = src_cache_scan;
-  ICodec_IccModule* pIccModule =
+  CCodec_IccModule* pIccModule =
       CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
   if (src_alpha_scan) {
     if (dest_alpha_scan) {
       pIccModule->TranslateScanline(pIccTransform, dp, src_scan, pixel_count);
     } else {
       for (int col = 0; col < pixel_count; col++) {
         pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
         dp[3] = *src_alpha_scan++;
         src_scan += 3;
         dp += 4;
@@ skipping 73 matching lines @@
                           clip_scan, dest_alpha_scan, src_alpha_scan);
 }
 void _CompositeRow_Rgb2Argb_Blend_NoClip_Transform(uint8_t* dest_scan,
                                                    const uint8_t* src_scan,
                                                    int width,
                                                    int blend_type,
                                                    int src_Bpp,
                                                    uint8_t* dest_alpha_scan,
                                                    uint8_t* src_cache_scan,
                                                    void* pIccTransform) {
-  ICodec_IccModule* pIccModule =
+  CCodec_IccModule* pIccModule =
       CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
   if (src_Bpp == 3) {
     pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan,
                                   width);
   } else {
     uint8_t* dp = src_cache_scan;
     for (int col = 0; col < width; col++) {
       pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
       src_scan += 4;
       dp += 3;
     }
   }
   _CompositeRow_Rgb2Argb_Blend_NoClip(dest_scan, src_cache_scan, width,
                                       blend_type, 3, dest_alpha_scan);
 }
 inline void _CompositeRow_Rgb2Argb_Blend_Clip_Transform(
     uint8_t* dest_scan,
     const uint8_t* src_scan,
     int width,
     int blend_type,
     int src_Bpp,
     const uint8_t* clip_scan,
     uint8_t* dest_alpha_scan,
     uint8_t* src_cache_scan,
     void* pIccTransform) {
-  ICodec_IccModule* pIccModule =
+  CCodec_IccModule* pIccModule =
       CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
   if (src_Bpp == 3) {
     pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan,
                                   width);
   } else {
     uint8_t* dp = src_cache_scan;
     for (int col = 0; col < width; col++) {
       pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
       src_scan += 4;
       dp += 3;
     }
   }
   _CompositeRow_Rgb2Argb_Blend_Clip(dest_scan, src_cache_scan, width,
                                     blend_type, 3, clip_scan, dest_alpha_scan);
 }
 inline void _CompositeRow_Rgb2Argb_NoBlend_Clip_Transform(
     uint8_t* dest_scan,
     const uint8_t* src_scan,
     int width,
     int src_Bpp,
     const uint8_t* clip_scan,
     uint8_t* dest_alpha_scan,
     uint8_t* src_cache_scan,
     void* pIccTransform) {
-  ICodec_IccModule* pIccModule =
+  CCodec_IccModule* pIccModule =
       CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
   if (src_Bpp == 3) {
     pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan,
                                   width);
   } else {
     uint8_t* dp = src_cache_scan;
     for (int col = 0; col < width; col++) {
       pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
       src_scan += 4;
       dp += 3;
     }
   }
   _CompositeRow_Rgb2Argb_NoBlend_Clip(dest_scan, src_cache_scan, width, 3,
                                       clip_scan, dest_alpha_scan);
 }
 inline void _CompositeRow_Rgb2Argb_NoBlend_NoClip_Transform(
     uint8_t* dest_scan,
     const uint8_t* src_scan,
     int width,
     int src_Bpp,
     uint8_t* dest_alpha_scan,
     uint8_t* src_cache_scan,
     void* pIccTransform) {
-  ICodec_IccModule* pIccModule =
+  CCodec_IccModule* pIccModule =
       CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
   if (src_Bpp == 3) {
     pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan,
                                   width);
   } else {
     uint8_t* dp = src_cache_scan;
     for (int col = 0; col < width; col++) {
       pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
       src_scan += 4;
       dp += 3;
     }
   }
   _CompositeRow_Rgb2Argb_NoBlend_NoClip(dest_scan, src_cache_scan, width, 3,
                                         dest_alpha_scan);
 }
 inline void _CompositeRow_Argb2Rgb_Blend_Transform(
     uint8_t* dest_scan,
     const uint8_t* src_scan,
     int width,
     int blend_type,
     int dest_Bpp,
     const uint8_t* clip_scan,
     const uint8_t* src_alpha_scan,
     uint8_t* src_cache_scan,
     void* pIccTransform) {
-  ICodec_IccModule* pIccModule =
+  CCodec_IccModule* pIccModule =
       CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
   if (src_alpha_scan) {
     pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan,
                                   width);
   } else {
     int blended_colors[3];
     FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     int dest_gap = dest_Bpp - 3;
     for (int col = 0; col < width; col++) {
       pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, 1);
@@ skipping 30 matching lines @@
 }
 inline void _CompositeRow_Argb2Rgb_NoBlend_Transform(
     uint8_t* dest_scan,
     const uint8_t* src_scan,
     int width,
     int dest_Bpp,
     const uint8_t* clip_scan,
     const uint8_t* src_alpha_scan,
     uint8_t* src_cache_scan,
     void* pIccTransform) {
-  ICodec_IccModule* pIccModule =
+  CCodec_IccModule* pIccModule =
       CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
   if (src_alpha_scan) {
     pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan,
                                   width);
   } else {
     int dest_gap = dest_Bpp - 3;
     for (int col = 0; col < width; col++) {
       pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, 1);
       uint8_t src_alpha;
       if (clip_scan) {
@@ skipping 28 matching lines @@
 }
 inline void _CompositeRow_Rgb2Rgb_Blend_NoClip_Transform(
     uint8_t* dest_scan,
     const uint8_t* src_scan,
     int width,
     int blend_type,
     int dest_Bpp,
     int src_Bpp,
     uint8_t* src_cache_scan,
     void* pIccTransform) {
-  ICodec_IccModule* pIccModule =
+  CCodec_IccModule* pIccModule =
       CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
   if (src_Bpp == 3) {
     pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan,
                                   width);
   } else {
     uint8_t* dp = src_cache_scan;
     for (int col = 0; col < width; col++) {
       pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
       src_scan += 4;
       dp += 3;
     }
   }
   _CompositeRow_Rgb2Rgb_Blend_NoClip(dest_scan, src_cache_scan, width,
                                      blend_type, dest_Bpp, 3);
 }
 inline void _CompositeRow_Rgb2Rgb_Blend_Clip_Transform(uint8_t* dest_scan,
                                                        const uint8_t* src_scan,
                                                        int width,
                                                        int blend_type,
                                                        int dest_Bpp,
                                                        int src_Bpp,
                                                        const uint8_t* clip_scan,
                                                        uint8_t* src_cache_scan,
                                                        void* pIccTransform) {
-  ICodec_IccModule* pIccModule =
+  CCodec_IccModule* pIccModule =
       CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
   if (src_Bpp == 3) {
     pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan,
                                   width);
   } else {
     uint8_t* dp = src_cache_scan;
     for (int col = 0; col < width; col++) {
       pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
       src_scan += 4;
       dp += 3;
     }
   }
   _CompositeRow_Rgb2Rgb_Blend_Clip(dest_scan, src_cache_scan, width, blend_type,
                                    dest_Bpp, 3, clip_scan);
 }
 inline void _CompositeRow_Rgb2Rgb_NoBlend_NoClip_Transform(
     uint8_t* dest_scan,
     const uint8_t* src_scan,
     int width,
     int dest_Bpp,
     int src_Bpp,
     uint8_t* src_cache_scan,
     void* pIccTransform) {
-  ICodec_IccModule* pIccModule =
+  CCodec_IccModule* pIccModule =
       CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
   if (src_Bpp == 3) {
     pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan,
                                   width);
   } else {
     uint8_t* dp = src_cache_scan;
     for (int col = 0; col < width; col++) {
       pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
       src_scan += 4;
       dp += 3;
     }
   }
   _CompositeRow_Rgb2Rgb_NoBlend_NoClip(dest_scan, src_cache_scan, width,
                                        dest_Bpp, 3);
 }
 inline void _CompositeRow_Rgb2Rgb_NoBlend_Clip_Transform(
     uint8_t* dest_scan,
     const uint8_t* src_scan,
     int width,
     int dest_Bpp,
     int src_Bpp,
     const uint8_t* clip_scan,
     uint8_t* src_cache_scan,
     void* pIccTransform) {
-  ICodec_IccModule* pIccModule =
+  CCodec_IccModule* pIccModule =
       CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
   if (src_Bpp == 3) {
     pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan,
                                   width);
   } else {
     uint8_t* dp = src_cache_scan;
     for (int col = 0; col < width; col++) {
       pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
       src_scan += 4;
       dp += 3;
@@ skipping 2133 matching lines @@
   }
 }
 inline FX_BOOL _ScanlineCompositor_InitSourceMask(FXDIB_Format dest_format,
                                                   int alpha_flag,
                                                   uint32_t mask_color,
                                                   int& mask_alpha,
                                                   int& mask_red,
                                                   int& mask_green,
                                                   int& mask_blue,
                                                   int& mask_black,
-                                                  void* icc_module,
+                                                  CCodec_IccModule* pIccModule,
                                                   void* pIccTransform) {
-  ICodec_IccModule* pIccModule = (ICodec_IccModule*)icc_module;
   if (alpha_flag >> 8) {
     mask_alpha = alpha_flag & 0xff;
     mask_red = FXSYS_GetCValue(mask_color);
     mask_green = FXSYS_GetMValue(mask_color);
     mask_blue = FXSYS_GetYValue(mask_color);
     mask_black = FXSYS_GetKValue(mask_color);
   } else {
     mask_alpha = FXARGB_A(mask_color);
     mask_red = FXARGB_R(mask_color);
     mask_green = FXARGB_G(mask_color);
@@ skipping 40 matching lines @@
       mask_green = mask_color_p[1];
       mask_blue = mask_color_p[0];
     }
   }
   return TRUE;
 }
 inline void _ScanlineCompositor_InitSourcePalette(FXDIB_Format src_format,
                                                   FXDIB_Format dest_format,
                                                   uint32_t*& pDestPalette,
                                                   uint32_t* pSrcPalette,
-                                                  void* icc_module,
+                                                  CCodec_IccModule* pIccModule,
                                                   void* pIccTransform) {
-  ICodec_IccModule* pIccModule = (ICodec_IccModule*)icc_module;
   FX_BOOL isSrcCmyk = !!(src_format & 0x0400);
   FX_BOOL isDstCmyk = !!(dest_format & 0x0400);
   pDestPalette = NULL;
   if (pIccTransform) {
     if (pSrcPalette) {
       if ((dest_format & 0xff) == 8) {
         int pal_count = 1 << (src_format & 0xff);
         uint8_t* gray_pal = FX_Alloc(uint8_t, pal_count);
         pDestPalette = (uint32_t*)gray_pal;
         for (int i = 0; i < pal_count; i++) {
@@ skipping 135 matching lines @@
                                      uint32_t mask_color,
                                      int blend_type,
                                      FX_BOOL bClip,
                                      FX_BOOL bRgbByteOrder,
                                      int alpha_flag,
                                      void* pIccTransform) {
   m_SrcFormat = src_format;
   m_DestFormat = dest_format;
   m_BlendType = blend_type;
   m_bRgbByteOrder = bRgbByteOrder;
-  ICodec_IccModule* pIccModule = NULL;
+  CCodec_IccModule* pIccModule = nullptr;
   if (CFX_GEModule::Get()->GetCodecModule()) {
     pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
   }
   if (!pIccModule) {
     pIccTransform = NULL;
   }
   m_pIccTransform = pIccTransform;
   if ((dest_format & 0xff) == 1) {
     return FALSE;
   }
@@ skipping 596 matching lines @@
     dst_color = FXCMYK_TODIB(color);
   } else {
     dst_color = FXARGB_TODIB(color);
   }
   uint8_t* color_p = (uint8_t*)&dst_color;
   if (m_bpp == 8) {
     uint8_t gray = 255;
     if (!IsAlphaMask()) {
       if (pIccTransform && CFX_GEModule::Get()->GetCodecModule() &&
           CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
-        ICodec_IccModule* pIccModule =
+        CCodec_IccModule* pIccModule =
             CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
         pIccModule->TranslateScanline(pIccTransform, &gray, color_p, 1);
       } else {
         if (alpha_flag >> 8) {
           uint8_t r, g, b;
           AdobeCMYK_to_sRGB1(color_p[0], color_p[1], color_p[2], color_p[3], r,
                              g, b);
           gray = FXRGB2GRAY(r, g, b);
         } else {
           gray = (uint8_t)FXRGB2GRAY((int)color_p[2], color_p[1], color_p[0]);
@@ skipping 53 matching lines @@
         }
       }
     }
     return TRUE;
   }
   ASSERT(m_bpp >= 24);
   if (m_bpp < 24) {
     return FALSE;
   }
   if (pIccTransform && CFX_GEModule::Get()->GetCodecModule()) {
-    ICodec_IccModule* pIccModule =
+    CCodec_IccModule* pIccModule =
         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     pIccModule->TranslateScanline(pIccTransform, color_p, color_p, 1);
   } else {
     if (alpha_flag >> 8 && !IsCmykImage()) {
       AdobeCMYK_to_sRGB1(FXSYS_GetCValue(color), FXSYS_GetMValue(color),
                          FXSYS_GetYValue(color), FXSYS_GetKValue(color),
                          color_p[2], color_p[1], color_p[0]);
     } else if (!(alpha_flag >> 8) && IsCmykImage()) {
       return FALSE;
     }
@@ skipping 280 matching lines @@
   }
   src_alpha_scan = m_pScanlineAlphaV;
   dest_alpha_scan = dest_alpha_buf;
   if (dest_alpha_scan) {
     for (i = 0; i < m_DestHeight; i++) {
       *dest_alpha_scan = *src_alpha_scan++;
       dest_alpha_scan += y_alpha_step;
     }
   }
 }