src/third_party/pdfium/core/src/fxge/dib/fx_dib_convert.cpp

   1 // Copyright 2014 PDFium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
   6
   7 #include "../../../include/fxge/fx_dib.h"
   8 #include "../../../include/fxge/fx_ge.h"
   9 #include "../../../include/fxcodec/fx_codec.h"
  10 const FX_DWORD g_dwWinPalette[256] = {
  11     0xff000000, 0xff800000, 0xff008000, 0xff808000, 0xff000080, 0xff800080,
  12     0xff008080, 0xff808080, 0xffC0DCC0, 0xffA6CAF0, 0xff2A3FAA, 0xff2A3FFF,
  13     0xff2A5F00, 0xff2A5F55, 0xff2A5FAA, 0xff2A5FFF, 0xff2A7F00, 0xff2A7F55,
  14     0xff2A7FAA, 0xff2A7FFF, 0xff2A9F00, 0xff2A9F55, 0xff2A9FAA, 0xff2A9FFF,
  15     0xff2ABF00, 0xff2ABF55, 0xff2ABFAA, 0xff2ABFFF, 0xff2ADF00, 0xff2ADF55,
  16     0xff2ADFAA, 0xff2ADFFF, 0xff2AFF00, 0xff2AFF55, 0xff2AFFAA, 0xff2AFFFF,
  17     0xff550000, 0xff550055, 0xff5500AA, 0xff5500FF, 0xff551F00, 0xff551F55,
  18     0xff551FAA, 0xff551FFF, 0xff553F00, 0xff553F55, 0xff553FAA, 0xff553FFF,
  19     0xff555F00, 0xff555F55, 0xff555FAA, 0xff555FFF, 0xff557F00, 0xff557F55,
  20     0xff557FAA, 0xff557FFF, 0xff559F00, 0xff559F55, 0xff559FAA, 0xff559FFF,
  21     0xff55BF00, 0xff55BF55, 0xff55BFAA, 0xff55BFFF, 0xff55DF00, 0xff55DF55,
  22     0xff55DFAA, 0xff55DFFF, 0xff55FF00, 0xff55FF55, 0xff55FFAA, 0xff55FFFF,
  23     0xff7F0000, 0xff7F0055, 0xff7F00AA, 0xff7F00FF, 0xff7F1F00, 0xff7F1F55,
  24     0xff7F1FAA, 0xff7F1FFF, 0xff7F3F00, 0xff7F3F55, 0xff7F3FAA, 0xff7F3FFF,
  25     0xff7F5F00, 0xff7F5F55, 0xff7F5FAA, 0xff7F5FFF, 0xff7F7F00, 0xff7F7F55,
  26     0xff7F7FAA, 0xff7F7FFF, 0xff7F9F00, 0xff7F9F55, 0xff7F9FAA, 0xff7F9FFF,
  27     0xff7FBF00, 0xff7FBF55, 0xff7FBFAA, 0xff7FBFFF, 0xff7FDF00, 0xff7FDF55,
  28     0xff7FDFAA, 0xff7FDFFF, 0xff00FF7F, 0xff7FFF55, 0xff7FFFAA, 0xff7FFFFF,
  29     0xffAA0000, 0xffAA0055, 0xffAA00AA, 0xffAA00FF, 0xffAA1F00, 0xffAA1F55,
  30     0xffAA1FAA, 0xffAA1FFF, 0xffAA3F00, 0xffAA3F55, 0xffAA3FAA, 0xffAA3FFF,
  31     0xffAA5F00, 0xffAA5F55, 0xffAA5FAA, 0xffAA5FFF, 0xffAA7F00, 0xffAA7F55,
  32     0xffAA7FAA, 0xffAA7FFF, 0xffAA9F00, 0xffAA9F55, 0xffAA9FAA, 0xffAA9FFF,
  33     0xffAABF00, 0xffAABF55, 0xffAABFAA, 0xffAABFFF, 0xffAADF00, 0xffAADF55,
  34     0xffAADFAA, 0xffAADFFF, 0xffAAFF00, 0xffAAFF55, 0xffAAFFAA, 0xffAAFFFF,
  35     0xffD40000, 0xffD40055, 0xffD400AA, 0xffD400FF, 0xffD41F00, 0xffD41F55,
  36     0xffD41FAA, 0xffD41FFF, 0xffD43F00, 0xffD43F55, 0xffD43FAA, 0xffD43FFF,
  37     0xffD45F00, 0xffD45F55, 0xffD45FAA, 0xffD45FFF, 0xffD47F00, 0xffD47F55,
  38     0xffD47FAA, 0xffD4F7FF, 0xffD49F00, 0xffD49F55, 0xffD49FAA, 0xffD49FFF,
  39     0xffD4BF00, 0xffD4BF55, 0xffD4BFAA, 0xffD4BFFF, 0xffD4DF00, 0xffD4DF55,
  40     0xffD4DFAA, 0xffD4DFFF, 0xffD4FF00, 0xffD4FF55, 0xffD4FFAA, 0xffD4FFFF,
  41     0xffFF0055, 0xffFF00AA, 0xffFF1F00, 0xffFF1F55, 0xffFF1FAA, 0xffFF1FFF,
  42     0xffFF3F00, 0xffFF3F55, 0xffFF3FAA, 0xffFF3FFF, 0xffFF5F00, 0xffFF5F55,
  43     0xffFF5FAA, 0xffFF5FFF, 0xffFF7F00, 0xffFF7F55, 0xffFF7FAA, 0xffFF7FFF,
  44     0xffFF9F00, 0xffFF9F55, 0xffFF9FAA, 0xffFF9FFF, 0xffFFBF00, 0xffFFBF55,
  45     0xffFFBFAA, 0xffFFBFFF, 0xffFFDF00, 0xffFFDF55, 0xffFFDFAA, 0xffFFDFFF,
  46     0xffFFFF55, 0xffFFFFAA, 0xffCCCCFF, 0xffFFCCFF, 0xff33FFFF, 0xff66FFFF,
  47     0xff99FFFF, 0xffCCFFFF, 0xff007F00, 0xff007F55, 0xff007FAA, 0xff007FFF,
  48     0xff009F00, 0xff009F55, 0xff009FAA, 0xff009FFF, 0xff00BF00, 0xff00BF55,
  49     0xff00BFAA, 0xff00BFFF, 0xff00DF00, 0xff00DF55, 0xff00DFAA, 0xff00DFFF,
  50     0xff00FF55, 0xff00FFAA, 0xff2A0000, 0xff2A0055, 0xff2A00AA, 0xff2A00FF,
  51     0xff2A1F00, 0xff2A1F55, 0xff2A1FAA, 0xff2A1FFF, 0xff2A3F00, 0xff2A3F55,
  52     0xffFFFBF0, 0xffA0A0A4, 0xff808080, 0xffFF0000, 0xff00FF00, 0xffFF0000,
  53     0xff0000FF, 0xffFF00FF, 0xff00FFFF, 0xffFFFFFF
  54 };
  55 const FX_DWORD g_dwMacPalette[256] = {
  56     0xffFFFFFF, 0xffFFFFCC, 0xffFFFF99, 0xffFFFF66, 0xffFFFF33, 0xffFFFF00,
  57     0xffFFCCFF, 0xffFFCCCC, 0xffFFCC99, 0xffFFCC66, 0xffFFCC33, 0xffFFCC00,
  58     0xffFF99FF, 0xffFF99CC, 0xffFF9999, 0xffFF9966, 0xffFF9933, 0xffFF9900,
  59     0xffFF66FF, 0xffFF66CC, 0xffFF6699, 0xffFF6666, 0xffFF6633, 0xffFF6600,
  60     0xffFF33FF, 0xffFF33CC, 0xffFF3399, 0xffFF3366, 0xffFF3333, 0xffFF3300,
  61     0xffFF00FF, 0xffFF00CC, 0xffFF0099, 0xffFF0066, 0xffFF0033, 0xffFF0000,
  62     0xffCCFFFF, 0xffCCFFCC, 0xffCCFF99, 0xffCCFF66, 0xffCCFF33, 0xffCCFF00,
  63     0xffCCCCFF, 0xffCCCCCC, 0xffCCCC99, 0xffCCCC66, 0xffCCCC33, 0xffCCCC00,
  64     0xffCC99FF, 0xffCC99CC, 0xffCC9999, 0xffCC9966, 0xffCC9933, 0xffCC9900,
  65     0xffCC66FF, 0xffCC66CC, 0xffCC6699, 0xffCC6666, 0xffCC6633, 0xffCC6600,
  66     0xffCC33FF, 0xffCC33CC, 0xffCC3399, 0xffCC3366, 0xffCC3333, 0xffCC3300,
  67     0xffCC00FF, 0xffCC00CC, 0xffCC0099, 0xffCC0066, 0xffCC0033, 0xffCC0000,
  68     0xff99FFFF, 0xff99FFCC, 0xff99FF99, 0xff99FF66, 0xff99FF33, 0xff99FF00,
  69     0xff99CCFF, 0xff99CCCC, 0xff99CC99, 0xff99CC66, 0xff99CC33, 0xff99CC00,
  70     0xff9999FF, 0xff9999CC, 0xff999999, 0xff999966, 0xff999933, 0xff999900,
  71     0xff9966FF, 0xff9966CC, 0xff996699, 0xff996666, 0xff996633, 0xff996600,
  72     0xff9933FF, 0xff9933CC, 0xff993399, 0xff993366, 0xff993333, 0xff993300,
  73     0xff9900FF, 0xff9900CC, 0xff990099, 0xff990066, 0xff990033, 0xff990000,
  74     0xff66FFFF, 0xff66FFCC, 0xff66FF99, 0xff66FF66, 0xff66FF33, 0xff66FF00,
  75     0xff66CCFF, 0xff66CCCC, 0xff66CC99, 0xff66CC66, 0xff66CC33, 0xff66CC00,
  76     0xff6699FF, 0xff6699CC, 0xff669999, 0xff669966, 0xff669933, 0xff669900,
  77     0xff6666FF, 0xff6666CC, 0xff666699, 0xff666666, 0xff666633, 0xff666600,
  78     0xff6633FF, 0xff6633CC, 0xff663399, 0xff663366, 0xff663333, 0xff663300,
  79     0xff6600FF, 0xff6600CC, 0xff660099, 0xff660066, 0xff660033, 0xff660000,
  80     0xff33FFFF, 0xff33FFCC, 0xff33FF99, 0xff33FF66, 0xff33FF33, 0xff33FF00,
  81     0xff33CCFF, 0xff33CCCC, 0xff33CC99, 0xff33CC66, 0xff33CC33, 0xff33CC00,
  82     0xff3399FF, 0xff3399CC, 0xff339999, 0xff339966, 0xff339933, 0xff339900,
  83     0xff3366FF, 0xff3366CC, 0xff336699, 0xff336666, 0xff336633, 0xff336600,
  84     0xff3333FF, 0xff3333CC, 0xff333399, 0xff333366, 0xff333333, 0xff333300,
  85     0xff3300FF, 0xff3300CC, 0xff330099, 0xff330066, 0xff330033, 0xff330000,
  86     0xff00FFFF, 0xff00FFCC, 0xff00FF99, 0xff00FF66, 0xff00FF33, 0xff00FF00,
  87     0xff00CCFF, 0xff00CCCC, 0xff00CC99, 0xff00CC66, 0xff00CC33, 0xff00CC00,
  88     0xff0099FF, 0xff0099CC, 0xff009999, 0xff009966, 0xff009933, 0xff009900,
  89     0xff0066FF, 0xff0066CC, 0xff006699, 0xff006666, 0xff006633, 0xff006600,
  90     0xff0033FF, 0xff0033CC, 0xff003399, 0xff003366, 0xff003333, 0xff003300,
  91     0xff0000FF, 0xff0000CC, 0xff000099, 0xff000066, 0xff000033,
  92     0xffEE0000, 0xffDD0000, 0xffBB0000, 0xffAA0000, 0xff880000, 0xff770000,
  93     0xff550000, 0xff440000, 0xff220000, 0xff110000, 0xff00EE00, 0xff00DD00,
  94     0xff00BB00, 0xff00AA00, 0xff008800, 0xff007700, 0xff005500, 0xff004400,
  95     0xff002200, 0xff001100, 0xff0000EE, 0xff0000DD, 0xff0000BB, 0xff0000AA,
  96     0xff000088, 0xff000077, 0xff000055, 0xff000044, 0xff000022, 0xff000011,
  97     0xffEEEEEE, 0xffDDDDDD, 0xffBBBBBB, 0xffAAAAAA, 0xff888888, 0xff777777,
  98     0xff555555, 0xff444444, 0xff222222, 0xff111111, 0xff000000
  99 };
 100 class CFX_Palette : public CFX_Object
 101 {
 102 public:
 103     CFX_Palette();
 104     ~CFX_Palette();
 105 public:
 106     FX_BOOL      BuildPalette(const CFX_DIBSource* pBitmap, int dwPaletteType);
 107     FX_DWORD*    GetPalette() const
 108     {
 109         return m_pPalette;
 110     }
 111
 112     FX_DWORD*    GetColorLut()const
 113     {
 114         return m_cLut;
 115     }
 116     FX_DWORD*    GetAmountLut()const
 117     {
 118         return m_aLut;
 119     }
 120     FX_INT32     Getlut()const
 121     {
 122         return m_lut;
 123     }
 124 protected:
 125     FX_DWORD*    m_pPalette;
 126     FX_DWORD*    m_cLut;
 127     FX_DWORD*    m_aLut;
 128     int          m_lut;
 129 };
 130 int _Partition(FX_DWORD* alut, FX_DWORD* clut, int l, int r)
 131 {
 132     FX_DWORD p_a = alut[l];
 133     FX_DWORD p_c = clut[l];
 134     while(l < r) {
 135         while(l < r && alut[r] >= p_a) {
 136             r--;
 137         }
 138         if (l < r) {
 139             alut[l] = alut[r];
 140             clut[l++] = clut[r];
 141         }
 142         while(l < r && alut[l] <= p_a) {
 143             l++;
 144         }
 145         if (l < r) {
 146             alut[r] = alut[l];
 147             clut[r--] = clut[l];
 148         }
 149     }
 150     alut[l] = p_a;
 151     clut[l] = p_c;
 152     return l;
 153 }
 154 void _Qsort(FX_DWORD* alut, FX_DWORD* clut, int l, int r)
 155 {
 156     if(l < r) {
 157         int pI = _Partition(alut, clut, l, r);
 158         _Qsort(alut, clut, l, pI - 1);
 159         _Qsort(alut, clut, pI + 1, r);
 160     }
 161 }
 162 void _ColorDecode(FX_DWORD pal_v, FX_BYTE& r, FX_BYTE& g, FX_BYTE& b)
 163 {
 164     r = (FX_BYTE)((pal_v & 0xf00) >> 4);
 165     g = (FX_BYTE)(pal_v & 0x0f0);
 166     b = (FX_BYTE)((pal_v & 0x00f) << 4);
 167 }
 168 void _Obtain_Pal(FX_DWORD* aLut, FX_DWORD*cLut, FX_DWORD* dest_pal, int pal_type, FX_DWORD* win_mac_pal, FX_DWORD lut)
 169 {
 170     int row, col;
 171     FX_DWORD lut_1 = lut - 1;
 172     if (pal_type == FXDIB_PALETTE_LOC) {
 173         for (row = 0; row < 256; row++) {
 174             int lut_offset = lut_1 - row;
 175             if (lut_offset < 0) {
 176                 lut_offset += 256;
 177             }
 178             FX_DWORD color = cLut[lut_offset];
 179             FX_BYTE r, g, b;
 180             _ColorDecode(color, r, g, b);
 181             dest_pal[row] = ((FX_DWORD)r << 16) | ((FX_DWORD)g << 8) | b | 0xff000000;
 182             aLut[lut_offset] = row;
 183         }
 184     } else {
 185         for (row = 0; row < 256; row++) {
 186             int lut_offset = lut_1 - row;
 187             if (lut_offset < 0) {
 188                 lut_offset += 256;
 189             }
 190             FX_BYTE r, g, b;
 191             _ColorDecode(cLut[lut_offset], r, g, b);
 192             int error, min_error = 1000000;
 193             int c_index = 0;
 194             for (col = 0; col < 256; col++) {
 195                 FX_DWORD p_color = win_mac_pal[col];
 196                 int d_r = r - (FX_BYTE)(p_color >> 16);
 197                 int d_g = g - (FX_BYTE)(p_color >> 8);
 198                 int d_b = b - (FX_BYTE)p_color;
 199                 error = d_r * d_r + d_g * d_g + d_b * d_b;
 200                 if (error < min_error) {
 201                     min_error = error;
 202                     c_index = col;
 203                 }
 204             }
 205             dest_pal[row] =  win_mac_pal[c_index];
 206             aLut[lut_offset] = row;
 207         }
 208     }
 209 }
 210 CFX_Palette::CFX_Palette()
 211 {
 212     m_pPalette = NULL;
 213     m_cLut = NULL;
 214     m_aLut = NULL;
 215     m_lut = 0;
 216 }
 217 CFX_Palette::~CFX_Palette()
 218 {
 219     if (m_pPalette) {
 220         FX_Free(m_pPalette);
 221     }
 222     if (m_cLut) {
 223         FX_Free(m_cLut);
 224     }
 225     if (m_aLut) {
 226         FX_Free(m_aLut);
 227     }
 228     m_lut = 0;
 229 }
 230 FX_BOOL CFX_Palette::BuildPalette(const CFX_DIBSource* pBitmap, int pal_type)
 231 {
 232     if (pBitmap == NULL) {
 233         return FALSE;
 234     }
 235     if (m_pPalette != NULL) {
 236         FX_Free(m_pPalette);
 237     }
 238     m_pPalette = FX_Alloc(FX_DWORD, 256);
 239     if (!m_pPalette) {
 240         return FALSE;
 241     }
 242     int bpp    = pBitmap->GetBPP() / 8;
 243     int width  = pBitmap->GetWidth();
 244     int height = pBitmap->GetHeight();
 245     if (m_cLut) {
 246         FX_Free(m_cLut);
 247         m_cLut = NULL;
 248     }
 249     if (m_aLut) {
 250         FX_Free(m_aLut);
 251         m_aLut = NULL;
 252     }
 253     m_cLut = FX_Alloc(FX_DWORD, 4096);
 254     if (!m_cLut) {
 255         return FALSE;
 256     }
 257     m_aLut = FX_Alloc(FX_DWORD, 4096);
 258     if (!m_aLut) {
 259         return FALSE;
 260     }
 261     int row, col;
 262     m_lut = 0;
 263     for (row = 0; row < height; row++) {
 264         FX_BYTE* scan_line = (FX_BYTE*)pBitmap->GetScanline(row);
 265         for (col = 0; col < width; col++) {
 266             FX_BYTE* src_port = scan_line + col * bpp;
 267             FX_DWORD b = src_port[0] & 0xf0;
 268             FX_DWORD g = src_port[1] & 0xf0;
 269             FX_DWORD r = src_port[2] & 0xf0;
 270             FX_DWORD index = (r << 4) + g + (b >> 4);
 271             m_aLut[index]++;
 272         }
 273     }
 274     for (row = 0; row < 4096; row++) {
 275         if (m_aLut[row] != 0) {
 276             m_aLut[m_lut] = m_aLut[row];
 277             m_cLut[m_lut] = row;
 278             m_lut++;
 279         }
 280     }
 281     _Qsort(m_aLut, m_cLut, 0, m_lut - 1);
 282     FX_DWORD* win_mac_pal = NULL;
 283     if (pal_type == FXDIB_PALETTE_WIN) {
 284         win_mac_pal = (FX_DWORD*)g_dwWinPalette;
 285     } else if (pal_type == FXDIB_PALETTE_MAC) {
 286         win_mac_pal = (FX_DWORD*)g_dwMacPalette;
 287     }
 288     _Obtain_Pal(m_aLut, m_cLut, m_pPalette, pal_type, win_mac_pal, m_lut);
 289     return TRUE;
 290 }
 291 FX_BOOL _ConvertBuffer_1bppMask2Gray(FX_LPBYTE dest_buf, int dest_pitch, int width, int height,
 292                                      const CFX_DIBSource* pSrcBitmap, int src_left, int src_top)
 293 {
 294     FX_BYTE set_gray, reset_gray;
 295     set_gray = 0xff;
 296     reset_gray = 0x00;
 297     for (int row = 0; row < height; row ++) {
 298         FX_LPBYTE dest_scan = dest_buf + row * dest_pitch;
 299         FXSYS_memset8(dest_scan, reset_gray, width);
 300         FX_LPCBYTE src_scan = pSrcBitmap->GetScanline(src_top + row);
 301         for (int col = src_left; col < src_left + width; col ++) {
 302             if (src_scan[col / 8] & (1 << (7 - col % 8))) {
 303                 *dest_scan = set_gray;
 304             }
 305             dest_scan ++;
 306         }
 307     }
 308     return TRUE;
 309 }
 310 FX_BOOL _ConvertBuffer_8bppMask2Gray(FX_LPBYTE dest_buf, int dest_pitch, int width, int height,
 311                                      const CFX_DIBSource* pSrcBitmap, int src_left, int src_top)
 312 {
 313     for (int row = 0; row < height; row ++) {
 314         FX_LPBYTE dest_scan = dest_buf + row * dest_pitch;
 315         FX_LPCBYTE src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left;
 316         FXSYS_memcpy32(dest_scan, src_scan, width);
 317     }
 318     return TRUE;
 319 }
 320 FX_BOOL _ConvertBuffer_1bppPlt2Gray(FX_LPBYTE dest_buf, int dest_pitch, int width, int height,
 321                                     const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, void* pIccTransform)
 322 {
 323     FX_DWORD* src_plt = pSrcBitmap->GetPalette();
 324     FX_BYTE gray[2];
 325     if (pIccTransform) {
 326         FX_DWORD plt[2];
 327         if (pSrcBitmap->IsCmykImage()) {
 328             plt[0] = FXCMYK_TODIB(src_plt[0]);
 329             plt[1] = FXCMYK_TODIB(src_plt[1]);
 330         } else {
 331             FX_LPBYTE bgr_ptr = (FX_LPBYTE)plt;
 332             bgr_ptr[0] = FXARGB_B(src_plt[0]);
 333             bgr_ptr[1] = FXARGB_G(src_plt[0]);
 334             bgr_ptr[2] = FXARGB_R(src_plt[0]);
 335             bgr_ptr[3] = FXARGB_B(src_plt[1]);
 336             bgr_ptr[4] = FXARGB_G(src_plt[1]);
 337             bgr_ptr[5] = FXARGB_R(src_plt[1]);
 338         }
 339         ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
 340         pIccModule->TranslateScanline(pIccTransform, gray, (FX_LPCBYTE)plt, 2);
 341     } else {
 342         FX_BYTE reset_r, reset_g, reset_b,
 343                 set_r, set_g, set_b;
 344         if (pSrcBitmap->IsCmykImage()) {
 345             AdobeCMYK_to_sRGB1(FXSYS_GetCValue(src_plt[0]), FXSYS_GetMValue(src_plt[0]), FXSYS_GetYValue(src_plt[0]), FXSYS_GetKValue(src_plt[0]),
 346                                reset_r, reset_g, reset_b);
 347             AdobeCMYK_to_sRGB1(FXSYS_GetCValue(src_plt[1]), FXSYS_GetMValue(src_plt[1]), FXSYS_GetYValue(src_plt[1]), FXSYS_GetKValue(src_plt[1]),
 348                                set_r, set_g, set_b);
 349         } else {
 350             reset_r = FXARGB_R(src_plt[0]);
 351             reset_g = FXARGB_G(src_plt[0]);
 352             reset_b = FXARGB_B(src_plt[0]);
 353             set_r = FXARGB_R(src_plt[1]);
 354             set_g = FXARGB_G(src_plt[1]);
 355             set_b = FXARGB_B(src_plt[1]);
 356         }
 357         gray[0] = FXRGB2GRAY(reset_r, reset_g, reset_b);
 358         gray[1] = FXRGB2GRAY(set_r, set_g, set_b);
 359     }
 360     for (int row = 0; row < height; row ++) {
 361         FX_LPBYTE dest_scan = dest_buf + row * dest_pitch;
 362         FXSYS_memset8(dest_scan, gray[0], width);
 363         FX_LPCBYTE src_scan = pSrcBitmap->GetScanline(src_top + row);
 364         for (int col = src_left; col < src_left + width; col ++) {
 365             if (src_scan[col / 8] & (1 << (7 - col % 8))) {
 366                 *dest_scan = gray[1];
 367             }
 368             dest_scan ++;
 369         }
 370     }
 371     return TRUE;
 372 }
 373 FX_BOOL _ConvertBuffer_8bppPlt2Gray(FX_LPBYTE dest_buf, int dest_pitch, int width, int height,
 374                                     const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, void* pIccTransform)
 375 {
 376     FX_DWORD* src_plt = pSrcBitmap->GetPalette();
 377     FX_BYTE gray[256];
 378     if (pIccTransform) {
 379         FX_DWORD plt[256];
 380         if (pSrcBitmap->IsCmykImage()) {
 381             for (int i = 0; i < 256; i ++) {
 382                 plt[i] = FXCMYK_TODIB(src_plt[i]);
 383             }
 384         } else {
 385             FX_LPBYTE bgr_ptr = (FX_LPBYTE)plt;
 386             for (int i = 0; i < 256; i ++) {
 387                 *bgr_ptr++ = FXARGB_B(src_plt[i]);
 388                 *bgr_ptr++ = FXARGB_G(src_plt[i]);
 389                 *bgr_ptr++ = FXARGB_R(src_plt[i]);
 390             }
 391         }
 392         ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
 393         pIccModule->TranslateScanline(pIccTransform, gray, (FX_LPCBYTE)plt, 256);
 394     } else {
 395         if (pSrcBitmap->IsCmykImage()) {
 396             FX_BYTE r, g, b;
 397             for (int i = 0; i < 256; i ++) {
 398                 AdobeCMYK_to_sRGB1(FXSYS_GetCValue(src_plt[i]), FXSYS_GetMValue(src_plt[i]), FXSYS_GetYValue(src_plt[i]), FXSYS_GetKValue(src_plt[i]),
 399                                    r, g, b);
 400                 gray[i] = FXRGB2GRAY(r, g, b);
 401             }
 402         } else
 403             for (int i = 0; i < 256; i ++) {
 404                 gray[i] = FXRGB2GRAY(FXARGB_R(src_plt[i]), FXARGB_G(src_plt[i]), FXARGB_B(src_plt[i]));
 405             }
 406     }
 407     for (int row = 0; row < height; row ++) {
 408         FX_LPBYTE dest_scan = dest_buf + row * dest_pitch;
 409         FX_LPCBYTE src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left;
 410         for (int col = 0; col < width; col ++) {
 411             *dest_scan++ = gray[*src_scan++];
 412         }
 413     }
 414     return TRUE;
 415 }
 416 FX_BOOL _ConvertBuffer_RgbOrCmyk2Gray(FX_LPBYTE dest_buf, int dest_pitch, int width, int height,
 417                                       const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, void* pIccTransform)
 418 {
 419     int Bpp = pSrcBitmap->GetBPP() / 8;
 420     if (pIccTransform) {
 421         ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
 422         if (Bpp == 3 || pSrcBitmap->IsCmykImage()) {
 423             for (int row = 0; row < height; row ++) {
 424                 FX_LPBYTE dest_scan = dest_buf + row * dest_pitch;
 425                 FX_LPCBYTE src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left * Bpp;
 426                 pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan, width);
 427             }
 428         } else {
 429             for (int row = 0; row < height; row ++) {
 430                 FX_LPBYTE dest_scan = dest_buf + row * dest_pitch;
 431                 FX_LPCBYTE src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left * 4;
 432                 for (int col = 0; col < width; col ++) {
 433                     pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan, 1);
 434                     dest_scan++;
 435                     src_scan += 4;
 436                 }
 437             }
 438         }
 439     } else {
 440         if (pSrcBitmap->IsCmykImage()) {
 441             for (int row = 0; row < height; row ++) {
 442                 FX_LPBYTE dest_scan = dest_buf + row * dest_pitch;
 443                 FX_LPCBYTE src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left * 4;
 444                 for (int col = 0; col < width; col ++) {
 445                     FX_BYTE r, g, b;
 446                     AdobeCMYK_to_sRGB1(FXSYS_GetCValue((FX_DWORD)src_scan[0]), FXSYS_GetMValue((FX_DWORD)src_scan[1]), FXSYS_GetYValue((FX_DWORD)src_scan[2]), FXSYS_GetKValue((FX_DWORD)src_scan[3]),
 447                                        r, g, b);
 448                     *dest_scan++ = FXRGB2GRAY(r, g, b);
 449                     src_scan += 4;
 450                 }
 451             }
 452         } else {
 453             for (int row = 0; row < height; row ++) {
 454                 FX_LPBYTE dest_scan = dest_buf + row * dest_pitch;
 455                 FX_LPCBYTE src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left * Bpp;
 456                 for (int col = 0; col < width; col ++) {
 457                     *dest_scan++ = FXRGB2GRAY(src_scan[2], src_scan[1], src_scan[0]);
 458                     src_scan += Bpp;
 459                 }
 460             }
 461         }
 462     }
 463     return TRUE;
 464 }
 465 inline void _ConvertBuffer_IndexCopy(FX_LPBYTE dest_buf, int dest_pitch, int width, int height,
 466                                      const CFX_DIBSource* pSrcBitmap, int src_left, int src_top)
 467 {
 468     if (pSrcBitmap->GetBPP() == 1) {
 469         for (int row = 0; row < height; row ++) {
 470             FX_LPBYTE dest_scan = dest_buf + row * dest_pitch;
 471             FXSYS_memset32(dest_scan, 0, width);
 472             FX_LPCBYTE src_scan = pSrcBitmap->GetScanline(src_top + row);
 473             for (int col = src_left; col < src_left + width; col ++) {
 474                 if (src_scan[col / 8] & (1 << (7 - col % 8))) {
 475                     *dest_scan = 1;
 476                 }
 477                 dest_scan ++;
 478             }
 479         }
 480     } else {
 481         for (int row = 0; row < height; row ++) {
 482             FX_LPBYTE dest_scan = dest_buf + row * dest_pitch;
 483             FX_LPCBYTE src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left;
 484             FXSYS_memcpy32(dest_scan, src_scan, width);
 485         }
 486     }
 487 }
 488 FX_BOOL _ConvertBuffer_Plt2PltRgb8(FX_LPBYTE dest_buf, int dest_pitch, int width, int height,
 489                                    const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, FX_DWORD* dst_plt, void* pIccTransform)
 490 {
 491     _ConvertBuffer_IndexCopy(dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top);
 492     FX_DWORD* src_plt = pSrcBitmap->GetPalette();
 493     int plt_size = pSrcBitmap->GetPaletteSize();
 494     if (pIccTransform) {
 495         FX_DWORD plt[256];
 496         FX_LPBYTE bgr_ptr = (FX_LPBYTE)plt;
 497         if (pSrcBitmap->IsCmykImage()) {
 498             for (int i = 0; i < plt_size; i ++) {
 499                 plt[i] = FXCMYK_TODIB(src_plt[i]);
 500             }
 501         } else {
 502             for (int i = 0; i < plt_size; i ++) {
 503                 *bgr_ptr++ = FXARGB_B(src_plt[i]);
 504                 *bgr_ptr++ = FXARGB_G(src_plt[i]);
 505                 *bgr_ptr++ = FXARGB_R(src_plt[i]);
 506             }
 507             bgr_ptr = (FX_LPBYTE)plt;
 508         }
 509         ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
 510         pIccModule->TranslateScanline(pIccTransform, (FX_LPBYTE)plt, (FX_LPCBYTE)plt, plt_size);
 511         for (int i = 0; i < plt_size; i ++) {
 512             dst_plt[i] = FXARGB_MAKE(0xff, bgr_ptr[2], bgr_ptr[1], bgr_ptr[0]);
 513             bgr_ptr += 3;
 514         }
 515     } else {
 516         if (pSrcBitmap->IsCmykImage()) {
 517             for (int i = 0; i < plt_size; i ++) {
 518                 FX_BYTE r, g, b;
 519                 AdobeCMYK_to_sRGB1(FXSYS_GetCValue(src_plt[i]), FXSYS_GetMValue(src_plt[i]), FXSYS_GetYValue(src_plt[i]), FXSYS_GetKValue(src_plt[i]),
 520                                    r, g, b);
 521                 dst_plt[i] = FXARGB_MAKE(0xff, r, g, b);
 522             }
 523         } else {
 524             FXSYS_memcpy32(dst_plt, src_plt, plt_size * 4);
 525         }
 526     }
 527     return TRUE;
 528 }
 529 inline FX_BOOL _ConvertBuffer_Rgb2PltRgb8_NoTransform(FX_LPBYTE dest_buf, int dest_pitch, int width, int height,
 530         const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, FX_DWORD* dst_plt)
 531 {
 532     int bpp = pSrcBitmap->GetBPP() / 8;
 533     int row, col;
 534     CFX_Palette palette;
 535     palette.BuildPalette(pSrcBitmap, FXDIB_PALETTE_LOC);
 536     FX_DWORD* cLut = palette.GetColorLut();
 537     FX_DWORD* aLut = palette.GetAmountLut();
 538     if (cLut == NULL || aLut == NULL) {
 539         return FALSE;
 540     }
 541     int lut = palette.Getlut();
 542     FX_DWORD* pPalette = palette.GetPalette();
 543     if (lut > 256) {
 544         int err, min_err;
 545         int lut_256 = lut - 256;
 546         for (row = 0; row < lut_256; row++) {
 547             min_err = 1000000;
 548             FX_BYTE r, g, b;
 549             _ColorDecode(cLut[row], r, g, b);
 550             int clrindex = 0;
 551             for (int col = 0; col < 256; col++) {
 552                 FX_DWORD p_color = *(pPalette + col);
 553                 int d_r = r - (FX_BYTE)(p_color >> 16);
 554                 int d_g = g - (FX_BYTE)(p_color >> 8);
 555                 int d_b = b - (FX_BYTE)(p_color);
 556                 err = d_r * d_r + d_g * d_g + d_b * d_b;
 557                 if (err < min_err) {
 558                     min_err = err;
 559                     clrindex = col;
 560                 }
 561             }
 562             aLut[row] = clrindex;
 563         }
 564     }
 565     FX_INT32 lut_1 = lut - 1;
 566     for (row = 0; row < height; row ++) {
 567         FX_BYTE* src_scan = (FX_BYTE*)pSrcBitmap->GetScanline(src_top + row) + src_left;
 568         FX_BYTE* dest_scan = dest_buf + row * dest_pitch;
 569         for (col = 0; col < width; col++) {
 570             FX_BYTE* src_port = src_scan + col * bpp;
 571             int r = src_port[2] & 0xf0;
 572             int g = src_port[1] & 0xf0;
 573             int b = src_port[0] & 0xf0;
 574             FX_DWORD clrindex = (r << 4) + g + (b >> 4);
 575             for (int i = lut_1; i >= 0; i--)
 576                 if (clrindex == cLut[i]) {
 577                     *(dest_scan + col) = (FX_BYTE)(aLut[i]);
 578                     break;
 579                 }
 580         }
 581     }
 582     FXSYS_memcpy32(dst_plt, pPalette, sizeof(FX_DWORD) * 256);
 583     return TRUE;
 584 }
 585 FX_BOOL _ConvertBuffer_Rgb2PltRgb8(FX_LPBYTE dest_buf, int dest_pitch, int width, int height,
 586                                    const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, FX_DWORD* dst_plt, void* pIccTransform)
 587 {
 588     ICodec_IccModule* pIccModule = NULL;
 589     if (pIccTransform) {
 590         pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
 591     }
 592     FX_BOOL ret = _ConvertBuffer_Rgb2PltRgb8_NoTransform(dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, dst_plt);
 593     if (ret && pIccTransform) {
 594         ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
 595         for (int i = 0; i < 256; i++) {
 596             FX_ARGB* plt = dst_plt + i;
 597             FX_ARGB plt_entry = FXARGB_TODIB(*plt);
 598             pIccModule->TranslateScanline(pIccTransform, (FX_LPBYTE)&plt_entry, (FX_LPCBYTE)&plt_entry, 1);
 599             *plt = FXARGB_TODIB(plt_entry);
 600         }
 601     }
 602     return ret;
 603 }
 604 FX_BOOL _ConvertBuffer_1bppMask2Rgb(FXDIB_Format dst_format, FX_LPBYTE dest_buf, int dest_pitch, int width, int height,
 605                                     const CFX_DIBSource* pSrcBitmap, int src_left, int src_top)
 606 {
 607     int comps = (dst_format & 0xff) / 8;
 608     FX_BYTE set_gray, reset_gray;
 609     set_gray = 0xff;
 610     reset_gray = 0x00;
 611     for (int row = 0; row < height; row ++) {
 612         FX_LPBYTE dest_scan = dest_buf + row * dest_pitch;
 613         FX_LPCBYTE src_scan = pSrcBitmap->GetScanline(src_top + row);
 614         for (int col = src_left; col < src_left + width; col ++) {
 615             if (src_scan[col / 8] & (1 << (7 - col % 8))) {
 616                 dest_scan[0] = set_gray;
 617                 dest_scan[1] = set_gray;
 618                 dest_scan[2] = set_gray;
 619             } else {
 620                 dest_scan[0] = reset_gray;
 621                 dest_scan[1] = reset_gray;
 622                 dest_scan[2] = reset_gray;
 623             }
 624             dest_scan += comps;
 625         }
 626     }
 627     return TRUE;
 628 }
 629 FX_BOOL _ConvertBuffer_8bppMask2Rgb(FXDIB_Format dst_format, FX_LPBYTE dest_buf, int dest_pitch, int width, int height,
 630                                     const CFX_DIBSource* pSrcBitmap, int src_left, int src_top)
 631 {
 632     int comps = (dst_format & 0xff) / 8;
 633     for (int row = 0; row < height; row ++) {
 634         FX_LPBYTE dest_scan = dest_buf + row * dest_pitch;
 635         FX_LPCBYTE src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left;
 636         FX_BYTE src_pixel;
 637         for (int col = 0; col < width; col ++) {
 638             src_pixel = *src_scan++;
 639             *dest_scan++ = src_pixel;
 640             *dest_scan++ = src_pixel;
 641             *dest_scan   = src_pixel;
 642             dest_scan += comps - 2;
 643         }
 644     }
 645     return TRUE;
 646 }
 647 FX_BOOL _ConvertBuffer_1bppPlt2Rgb(FXDIB_Format dst_format, FX_LPBYTE dest_buf, int dest_pitch, int width, int height,
 648                                    const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, void* pIccTransform)
 649 {
 650     int comps = (dst_format & 0xff) / 8;
 651     FX_DWORD* src_plt = pSrcBitmap->GetPalette();
 652     FX_DWORD plt[2];
 653     FX_LPBYTE bgr_ptr = (FX_LPBYTE)plt;
 654     if (pSrcBitmap->IsCmykImage()) {
 655         plt[0] = FXCMYK_TODIB(src_plt[0]);
 656         plt[1] = FXCMYK_TODIB(src_plt[1]);
 657     } else {
 658         bgr_ptr[0] = FXARGB_B(src_plt[0]);
 659         bgr_ptr[1] = FXARGB_G(src_plt[0]);
 660         bgr_ptr[2] = FXARGB_R(src_plt[0]);
 661         bgr_ptr[3] = FXARGB_B(src_plt[1]);
 662         bgr_ptr[4] = FXARGB_G(src_plt[1]);
 663         bgr_ptr[5] = FXARGB_R(src_plt[1]);
 664     }
 665     if (pIccTransform) {
 666         ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
 667         pIccModule->TranslateScanline(pIccTransform, (FX_LPBYTE)plt, (FX_LPCBYTE)plt, 2);
 668     } else {
 669         if (pSrcBitmap->IsCmykImage()) {
 670             AdobeCMYK_to_sRGB1(FXSYS_GetCValue(src_plt[0]), FXSYS_GetMValue(src_plt[0]), FXSYS_GetYValue(src_plt[0]), FXSYS_GetKValue(src_plt[0]),
 671                                bgr_ptr[2], bgr_ptr[1], bgr_ptr[0]);
 672             AdobeCMYK_to_sRGB1(FXSYS_GetCValue(src_plt[1]), FXSYS_GetMValue(src_plt[1]), FXSYS_GetYValue(src_plt[1]), FXSYS_GetKValue(src_plt[1]),
 673                                bgr_ptr[5], bgr_ptr[4], bgr_ptr[3]);
 674         }
 675     }
 676     for (int row = 0; row < height; row ++) {
 677         FX_LPBYTE dest_scan = dest_buf + row * dest_pitch;
 678         FX_LPCBYTE src_scan = pSrcBitmap->GetScanline(src_top + row);
 679         for (int col = src_left; col < src_left + width; col ++) {
 680             if (src_scan[col / 8] & (1 << (7 - col % 8))) {
 681                 *dest_scan++ = bgr_ptr[3];
 682                 *dest_scan++ = bgr_ptr[4];
 683                 *dest_scan   = bgr_ptr[5];
 684             } else {
 685                 *dest_scan++ = bgr_ptr[0];
 686                 *dest_scan++ = bgr_ptr[1];
 687                 *dest_scan   = bgr_ptr[2];
 688             }
 689             dest_scan += comps - 2;
 690         }
 691     }
 692     return TRUE;
 693 }
 694 FX_BOOL _ConvertBuffer_8bppPlt2Rgb(FXDIB_Format dst_format, FX_LPBYTE dest_buf, int dest_pitch, int width, int height,
 695                                    const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, void* pIccTransform)
 696 {
 697     int comps = (dst_format & 0xff) / 8;
 698     FX_DWORD* src_plt = pSrcBitmap->GetPalette();
 699     FX_DWORD plt[256];
 700     FX_LPBYTE bgr_ptr = (FX_LPBYTE)plt;
 701     if (!pSrcBitmap->IsCmykImage()) {
 702         for (int i = 0; i < 256; i++) {
 703             *bgr_ptr++ = FXARGB_B(src_plt[i]);
 704             *bgr_ptr++ = FXARGB_G(src_plt[i]);
 705             *bgr_ptr++ = FXARGB_R(src_plt[i]);
 706         }
 707         bgr_ptr = (FX_LPBYTE)plt;
 708     }
 709     if (pIccTransform) {
 710         if (pSrcBitmap->IsCmykImage()) {
 711             for (int i = 0; i < 256; i++) {
 712                 plt[i] = FXCMYK_TODIB(src_plt[i]);
 713             }
 714         }
 715         ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
 716         pIccModule->TranslateScanline(pIccTransform, (FX_LPBYTE)plt, (FX_LPCBYTE)plt, 256);
 717     } else {
 718         if (pSrcBitmap->IsCmykImage()) {
 719             for (int i = 0; i < 256; i++) {
 720                 AdobeCMYK_to_sRGB1(FXSYS_GetCValue(src_plt[i]), FXSYS_GetMValue(src_plt[i]), FXSYS_GetYValue(src_plt[i]), FXSYS_GetKValue(src_plt[i]),
 721                                    bgr_ptr[2], bgr_ptr[1], bgr_ptr[0]);
 722                 bgr_ptr += 3;
 723             }
 724             bgr_ptr = (FX_LPBYTE)plt;
 725         }
 726     }
 727     for (int row = 0; row < height; row ++) {
 728         FX_LPBYTE dest_scan = dest_buf + row * dest_pitch;
 729         FX_LPCBYTE src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left;
 730         for (int col = 0; col < width; col ++) {
 731             FX_LPBYTE src_pixel = bgr_ptr + 3 * (*src_scan++);
 732             *dest_scan++ = *src_pixel++;
 733             *dest_scan++ = *src_pixel++;
 734             *dest_scan   = *src_pixel++;
 735             dest_scan += comps - 2;
 736         }
 737     }
 738     return TRUE;
 739 }
 740 FX_BOOL _ConvertBuffer_24bppRgb2Rgb24(FX_LPBYTE dest_buf, int dest_pitch, int width, int height,
 741                                       const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, void* pIccTransform)
 742 {
 743     if (pIccTransform) {
 744         ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
 745         for (int row = 0; row < height; row ++) {
 746             FX_LPBYTE dest_scan = dest_buf + row * dest_pitch;
 747             FX_LPCBYTE src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left * 3;
 748             pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan, width);
 749         }
 750     } else {
 751         for (int row = 0; row < height; row ++) {
 752             FX_LPBYTE dest_scan = dest_buf + row * dest_pitch;
 753             FX_LPCBYTE src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left * 3;
 754             FXSYS_memcpy32(dest_scan, src_scan, width * 3);
 755         }
 756     }
 757     return TRUE;
 758 }
 759 FX_BOOL _ConvertBuffer_32bppRgb2Rgb24(FX_LPBYTE dest_buf, int dest_pitch, int width, int height,
 760                                       const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, void* pIccTransform)
 761 {
 762     for (int row = 0; row < height; row ++) {
 763         FX_LPBYTE dest_scan = dest_buf + row * dest_pitch;
 764         FX_LPCBYTE src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left * 4;
 765         for (int col = 0; col < width; col ++) {
 766             *dest_scan++ = *src_scan++;
 767             *dest_scan++ = *src_scan++;
 768             *dest_scan++ = *src_scan++;
 769             src_scan++;
 770         }
 771     }
 772     if (pIccTransform) {
 773         ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
 774         for (int row = 0; row < height; row ++) {
 775             FX_LPBYTE dest_scan = dest_buf + row * dest_pitch;
 776             pIccModule->TranslateScanline(pIccTransform, dest_scan, dest_scan, width);
 777         }
 778     }
 779     return TRUE;
 780 }
 781 FX_BOOL _ConvertBuffer_Rgb2Rgb32(FX_LPBYTE dest_buf, int dest_pitch, int width, int height,
 782                                  const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, void* pIccTransform)
 783 {
 784     int comps = pSrcBitmap->GetBPP() / 8;
 785     if (pIccTransform) {
 786         ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
 787         for (int row = 0; row < height; row ++) {
 788             FX_LPBYTE dest_scan = dest_buf + row * dest_pitch;
 789             FX_LPCBYTE src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left * comps;
 790             for (int col = 0; col < width; col ++) {
 791                 pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan, 1);
 792                 dest_scan += 4;
 793                 src_scan += comps;
 794             }
 795         }
 796     } else {
 797         for (int row = 0; row < height; row ++) {
 798             FX_LPBYTE dest_scan = dest_buf + row * dest_pitch;
 799             FX_LPCBYTE src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left * comps;
 800             for (int col = 0; col < width; col ++) {
 801                 *dest_scan++ = *src_scan++;
 802                 *dest_scan++ = *src_scan++;
 803                 *dest_scan++ = *src_scan++;
 804                 dest_scan++;
 805                 src_scan += comps - 3;
 806             }
 807         }
 808     }
 809     return TRUE;
 810 }
 811 FX_BOOL _ConvertBuffer_32bppCmyk2Rgb32(FX_LPBYTE dest_buf, int dest_pitch, int width, int height,
 812                                        const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, void* pIccTransform)
 813 {
 814     if (pIccTransform) {
 815         ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
 816         for (int row = 0; row < height; row ++) {
 817             FX_LPBYTE dest_scan = dest_buf + row * dest_pitch;
 818             FX_LPCBYTE src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left * 4;
 819             for (int col = 0; col < width; col ++) {
 820                 pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan, 1);
 821                 dest_scan += 4;
 822                 src_scan += 4;
 823             }
 824         }
 825     } else {
 826         for (int row = 0; row < height; row ++) {
 827             FX_LPBYTE dest_scan = dest_buf + row * dest_pitch;
 828             FX_LPCBYTE src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left * 4;
 829             for (int col = 0; col < width; col ++) {
 830                 AdobeCMYK_to_sRGB1(src_scan[0], src_scan[1], src_scan[2], src_scan[3],
 831                                    dest_scan[2], dest_scan[1], dest_scan[0]);
 832                 dest_scan += 4;
 833                 src_scan += 4;
 834             }
 835         }
 836     }
 837     return TRUE;
 838 }
 839 FX_BOOL ConvertBuffer(FXDIB_Format dest_format, FX_LPBYTE dest_buf, int dest_pitch, int width, int height,
 840                       const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, FX_DWORD*& d_pal, void* pIccTransform)
 841 {
 842     FXDIB_Format src_format = pSrcBitmap->GetFormat();
 843     if (!CFX_GEModule::Get()->GetCodecModule() || !CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
 844         pIccTransform = NULL;
 845     }
 846     switch (dest_format) {
 847         case FXDIB_Invalid:
 848         case FXDIB_1bppCmyk:
 849         case FXDIB_1bppMask:
 850         case FXDIB_1bppRgb:
 851             ASSERT(FALSE);
 852             return FALSE;
 853         case FXDIB_8bppMask: {
 854                 if ((src_format & 0xff) == 1) {
 855                     if (pSrcBitmap->GetPalette()) {
 856                         return _ConvertBuffer_1bppPlt2Gray(dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, pIccTransform);
 857                     }
 858                     return _ConvertBuffer_1bppMask2Gray(dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top);
 859                 } else if ((src_format & 0xff) == 8) {
 860                     if (pSrcBitmap->GetPalette()) {
 861                         return _ConvertBuffer_8bppPlt2Gray(dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, pIccTransform);
 862                     }
 863                     return _ConvertBuffer_8bppMask2Gray(dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top);
 864                 } else if ((src_format & 0xff) >= 24) {
 865                     return _ConvertBuffer_RgbOrCmyk2Gray(dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, pIccTransform);
 866                 }
 867                 return FALSE;
 868             }
 869         case FXDIB_8bppRgb:
 870         case FXDIB_8bppRgba: {
 871                 if ((src_format & 0xff) == 8 && pSrcBitmap->GetPalette() == NULL) {
 872                     return ConvertBuffer(FXDIB_8bppMask, dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, d_pal, pIccTransform);
 873                 }
 874                 d_pal = FX_Alloc(FX_DWORD, 256);
 875                 if (!d_pal) {
 876                     return FALSE;
 877                 }
 878                 if (((src_format & 0xff) == 1 || (src_format & 0xff) == 8) && pSrcBitmap->GetPalette()) {
 879                     return _ConvertBuffer_Plt2PltRgb8(dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, d_pal, pIccTransform);
 880                 } else if ((src_format & 0xff) >= 24) {
 881                     return _ConvertBuffer_Rgb2PltRgb8(dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, d_pal, pIccTransform);
 882                 }
 883                 return FALSE;
 884             }
 885         case FXDIB_Rgb:
 886         case FXDIB_Rgba: {
 887                 if ((src_format & 0xff) == 1) {
 888                     if (pSrcBitmap->GetPalette()) {
 889                         return _ConvertBuffer_1bppPlt2Rgb(dest_format, dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, pIccTransform);
 890                     }
 891                     return _ConvertBuffer_1bppMask2Rgb(dest_format, dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top);
 892                 } else if ((src_format & 0xff) == 8) {
 893                     if (pSrcBitmap->GetPalette()) {
 894                         return _ConvertBuffer_8bppPlt2Rgb(dest_format, dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, pIccTransform);
 895                     }
 896                     return _ConvertBuffer_8bppMask2Rgb(dest_format, dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top);
 897                 } else if ((src_format & 0xff) == 24) {
 898                     return _ConvertBuffer_24bppRgb2Rgb24(dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, pIccTransform);
 899                 } else if ((src_format & 0xff) == 32) {
 900                     return _ConvertBuffer_32bppRgb2Rgb24(dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, pIccTransform);
 901                 }
 902                 return FALSE;
 903             }
 904         case FXDIB_Argb:
 905         case FXDIB_Rgb32: {
 906                 if ((src_format & 0xff) == 1) {
 907                     if (pSrcBitmap->GetPalette()) {
 908                         return _ConvertBuffer_1bppPlt2Rgb(dest_format, dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, pIccTransform);
 909                     }
 910                     return _ConvertBuffer_1bppMask2Rgb(dest_format, dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top);
 911                 } else if ((src_format & 0xff) == 8) {
 912                     if (pSrcBitmap->GetPalette()) {
 913                         return _ConvertBuffer_8bppPlt2Rgb(dest_format, dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, pIccTransform);
 914                     }
 915                     return _ConvertBuffer_8bppMask2Rgb(dest_format, dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top);
 916                 } else if ((src_format & 0xff) >= 24) {
 917                     if (src_format & 0x0400) {
 918                         return _ConvertBuffer_32bppCmyk2Rgb32(dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, pIccTransform);
 919                     }
 920                     return _ConvertBuffer_Rgb2Rgb32(dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, pIccTransform);
 921                 }
 922                 return FALSE;
 923             }
 924         default:
 925             return FALSE;
 926     }
 927     return FALSE;
 928 }
 929 CFX_DIBitmap* CFX_DIBSource::CloneConvert(FXDIB_Format dest_format, const FX_RECT* pClip, void* pIccTransform) const
 930 {
 931     if(dest_format == GetFormat() && pIccTransform == NULL) {
 932         return Clone(pClip);
 933     }
 934     if (pClip) {
 935         CFX_DIBitmap* pClone = Clone(pClip);
 936         if (pClone == NULL) {
 937             return NULL;
 938         }
 939         if(!pClone->ConvertFormat(dest_format, pIccTransform)) {
 940             delete pClone;
 941             return NULL;
 942         }
 943         return pClone;
 944     }
 945     CFX_DIBitmap* pClone = FX_NEW CFX_DIBitmap;
 946     if (!pClone) {
 947         return NULL;
 948     }
 949     if(!pClone->Create(m_Width, m_Height, dest_format)) {
 950         delete pClone;
 951         return NULL;
 952     }
 953     FX_BOOL ret = TRUE;
 954     CFX_DIBitmap* pSrcAlpha = NULL;
 955     if (m_AlphaFlag & 2) {
 956         pSrcAlpha = (GetFormat() == FXDIB_Argb) ? GetAlphaMask() : m_pAlphaMask;
 957         if (pSrcAlpha == NULL) {
 958             delete pClone;
 959             return NULL;
 960         }
 961     }
 962     if (dest_format & 0x0200) {
 963         if (dest_format == FXDIB_Argb)
 964             ret = pSrcAlpha ?
 965                   pClone->LoadChannel(FXDIB_Alpha, pSrcAlpha, FXDIB_Alpha) :
 966                   pClone->LoadChannel(FXDIB_Alpha, 0xff);
 967         else {
 968             ret = pClone->CopyAlphaMask(pSrcAlpha);
 969         }
 970     }
 971     if (pSrcAlpha && pSrcAlpha != m_pAlphaMask) {
 972         delete pSrcAlpha;
 973         pSrcAlpha = NULL;
 974     }
 975     if (!ret) {
 976         delete pClone;
 977         return NULL;
 978     }
 979     FX_DWORD* pal_8bpp = NULL;
 980     ret = ConvertBuffer(dest_format, pClone->GetBuffer(), pClone->GetPitch(), m_Width, m_Height, this, 0, 0, pal_8bpp, pIccTransform);
 981     if (!ret) {
 982         if (pal_8bpp) {
 983             FX_Free(pal_8bpp);
 984         }
 985         delete pClone;
 986         return NULL;
 987     }
 988     if (pal_8bpp) {
 989         pClone->CopyPalette(pal_8bpp);
 990         FX_Free(pal_8bpp);
 991         pal_8bpp = NULL;
 992     }
 993     return pClone;
 994 }
 995 FX_BOOL CFX_DIBitmap::ConvertFormat(FXDIB_Format dest_format, void* pIccTransform)
 996 {
 997     FXDIB_Format src_format = GetFormat();
 998     if (dest_format == src_format && pIccTransform == NULL) {
 999         return TRUE;
1000     }
1001     if (dest_format == FXDIB_8bppMask && src_format == FXDIB_8bppRgb && m_pPalette == NULL) {
1002         m_AlphaFlag = 1;
1003         return TRUE;
1004     }
1005     if (dest_format == FXDIB_Argb && src_format == FXDIB_Rgb32 && pIccTransform == NULL) {
1006         m_AlphaFlag = 2;
1007         for (int row = 0; row < m_Height; row ++) {
1008             FX_LPBYTE scanline = m_pBuffer + row * m_Pitch + 3;
1009             for (int col = 0; col < m_Width; col ++) {
1010                 *scanline = 0xff;
1011                 scanline += 4;
1012             }
1013         }
1014         return TRUE;
1015     }
1016     int dest_bpp = dest_format & 0xff;
1017     int dest_pitch = (dest_bpp * m_Width + 31) / 32 * 4;
1018     FX_LPBYTE dest_buf = FX_AllocNL(FX_BYTE, dest_pitch * m_Height + 4);
1019     if (dest_buf == NULL) {
1020         return FALSE;
1021     }
1022     CFX_DIBitmap* pAlphaMask = NULL;
1023     if (dest_format == FXDIB_Argb) {
1024         FXSYS_memset8(dest_buf, 0xff, dest_pitch * m_Height + 4);
1025         if (m_pAlphaMask) {
1026             for (int row = 0; row < m_Height; row ++) {
1027                 FX_LPBYTE pDstScanline = dest_buf + row * dest_pitch + 3;
1028                 FX_LPCBYTE pSrcScanline = m_pAlphaMask->GetScanline(row);
1029                 for (int col = 0; col < m_Width; col ++) {
1030                     *pDstScanline = *pSrcScanline++;
1031                     pDstScanline += 4;
1032                 }
1033             }
1034         }
1035     } else if (dest_format & 0x0200) {
1036         if (src_format == FXDIB_Argb) {
1037             pAlphaMask = GetAlphaMask();
1038             if (pAlphaMask == NULL) {
1039                 FX_Free(dest_buf);
1040                 return FALSE;
1041             }
1042         } else {
1043             if (m_pAlphaMask == NULL) {
1044                 if (!BuildAlphaMask()) {
1045                     FX_Free(dest_buf);
1046                     return FALSE;
1047                 }
1048                 pAlphaMask = m_pAlphaMask;
1049                 m_pAlphaMask = NULL;
1050             } else {
1051                 pAlphaMask = m_pAlphaMask;
1052             }
1053         }
1054     }
1055     FX_BOOL ret = FALSE;
1056     FX_DWORD* pal_8bpp = NULL;
1057     ret = ConvertBuffer(dest_format, dest_buf, dest_pitch, m_Width, m_Height, this, 0, 0, pal_8bpp, pIccTransform);
1058     if (!ret) {
1059         if (pal_8bpp) {
1060             FX_Free(pal_8bpp);
1061         }
1062         if (pAlphaMask != m_pAlphaMask) {
1063             delete pAlphaMask;
1064         }
1065         if (dest_buf) {
1066             FX_Free(dest_buf);
1067         }
1068         return FALSE;
1069     }
1070     if (m_pAlphaMask && pAlphaMask != m_pAlphaMask) {
1071         delete m_pAlphaMask;
1072     }
1073     m_pAlphaMask = pAlphaMask;
1074     if (m_pPalette) {
1075         FX_Free(m_pPalette);
1076     }
1077     m_pPalette = pal_8bpp;
1078     if (!m_bExtBuf) {
1079         FX_Free(m_pBuffer);
1080     }
1081     m_bExtBuf = FALSE;
1082     m_pBuffer = dest_buf;
1083     m_bpp = (FX_BYTE)dest_format;
1084     m_AlphaFlag = (FX_BYTE)(dest_format >> 8);
1085     m_Pitch = dest_pitch;
1086     return TRUE;
1087 }