Clean up CPDF_AnnotList.
[pdfium.git] / 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 const FX_DWORD g_dwMacPalette[256] = {
55     0xffFFFFFF, 0xffFFFFCC, 0xffFFFF99, 0xffFFFF66, 0xffFFFF33, 0xffFFFF00,
56     0xffFFCCFF, 0xffFFCCCC, 0xffFFCC99, 0xffFFCC66, 0xffFFCC33, 0xffFFCC00,
57     0xffFF99FF, 0xffFF99CC, 0xffFF9999, 0xffFF9966, 0xffFF9933, 0xffFF9900,
58     0xffFF66FF, 0xffFF66CC, 0xffFF6699, 0xffFF6666, 0xffFF6633, 0xffFF6600,
59     0xffFF33FF, 0xffFF33CC, 0xffFF3399, 0xffFF3366, 0xffFF3333, 0xffFF3300,
60     0xffFF00FF, 0xffFF00CC, 0xffFF0099, 0xffFF0066, 0xffFF0033, 0xffFF0000,
61     0xffCCFFFF, 0xffCCFFCC, 0xffCCFF99, 0xffCCFF66, 0xffCCFF33, 0xffCCFF00,
62     0xffCCCCFF, 0xffCCCCCC, 0xffCCCC99, 0xffCCCC66, 0xffCCCC33, 0xffCCCC00,
63     0xffCC99FF, 0xffCC99CC, 0xffCC9999, 0xffCC9966, 0xffCC9933, 0xffCC9900,
64     0xffCC66FF, 0xffCC66CC, 0xffCC6699, 0xffCC6666, 0xffCC6633, 0xffCC6600,
65     0xffCC33FF, 0xffCC33CC, 0xffCC3399, 0xffCC3366, 0xffCC3333, 0xffCC3300,
66     0xffCC00FF, 0xffCC00CC, 0xffCC0099, 0xffCC0066, 0xffCC0033, 0xffCC0000,
67     0xff99FFFF, 0xff99FFCC, 0xff99FF99, 0xff99FF66, 0xff99FF33, 0xff99FF00,
68     0xff99CCFF, 0xff99CCCC, 0xff99CC99, 0xff99CC66, 0xff99CC33, 0xff99CC00,
69     0xff9999FF, 0xff9999CC, 0xff999999, 0xff999966, 0xff999933, 0xff999900,
70     0xff9966FF, 0xff9966CC, 0xff996699, 0xff996666, 0xff996633, 0xff996600,
71     0xff9933FF, 0xff9933CC, 0xff993399, 0xff993366, 0xff993333, 0xff993300,
72     0xff9900FF, 0xff9900CC, 0xff990099, 0xff990066, 0xff990033, 0xff990000,
73     0xff66FFFF, 0xff66FFCC, 0xff66FF99, 0xff66FF66, 0xff66FF33, 0xff66FF00,
74     0xff66CCFF, 0xff66CCCC, 0xff66CC99, 0xff66CC66, 0xff66CC33, 0xff66CC00,
75     0xff6699FF, 0xff6699CC, 0xff669999, 0xff669966, 0xff669933, 0xff669900,
76     0xff6666FF, 0xff6666CC, 0xff666699, 0xff666666, 0xff666633, 0xff666600,
77     0xff6633FF, 0xff6633CC, 0xff663399, 0xff663366, 0xff663333, 0xff663300,
78     0xff6600FF, 0xff6600CC, 0xff660099, 0xff660066, 0xff660033, 0xff660000,
79     0xff33FFFF, 0xff33FFCC, 0xff33FF99, 0xff33FF66, 0xff33FF33, 0xff33FF00,
80     0xff33CCFF, 0xff33CCCC, 0xff33CC99, 0xff33CC66, 0xff33CC33, 0xff33CC00,
81     0xff3399FF, 0xff3399CC, 0xff339999, 0xff339966, 0xff339933, 0xff339900,
82     0xff3366FF, 0xff3366CC, 0xff336699, 0xff336666, 0xff336633, 0xff336600,
83     0xff3333FF, 0xff3333CC, 0xff333399, 0xff333366, 0xff333333, 0xff333300,
84     0xff3300FF, 0xff3300CC, 0xff330099, 0xff330066, 0xff330033, 0xff330000,
85     0xff00FFFF, 0xff00FFCC, 0xff00FF99, 0xff00FF66, 0xff00FF33, 0xff00FF00,
86     0xff00CCFF, 0xff00CCCC, 0xff00CC99, 0xff00CC66, 0xff00CC33, 0xff00CC00,
87     0xff0099FF, 0xff0099CC, 0xff009999, 0xff009966, 0xff009933, 0xff009900,
88     0xff0066FF, 0xff0066CC, 0xff006699, 0xff006666, 0xff006633, 0xff006600,
89     0xff0033FF, 0xff0033CC, 0xff003399, 0xff003366, 0xff003333, 0xff003300,
90     0xff0000FF, 0xff0000CC, 0xff000099, 0xff000066, 0xff000033, 0xffEE0000,
91     0xffDD0000, 0xffBB0000, 0xffAA0000, 0xff880000, 0xff770000, 0xff550000,
92     0xff440000, 0xff220000, 0xff110000, 0xff00EE00, 0xff00DD00, 0xff00BB00,
93     0xff00AA00, 0xff008800, 0xff007700, 0xff005500, 0xff004400, 0xff002200,
94     0xff001100, 0xff0000EE, 0xff0000DD, 0xff0000BB, 0xff0000AA, 0xff000088,
95     0xff000077, 0xff000055, 0xff000044, 0xff000022, 0xff000011, 0xffEEEEEE,
96     0xffDDDDDD, 0xffBBBBBB, 0xffAAAAAA, 0xff888888, 0xff777777, 0xff555555,
97     0xff444444, 0xff222222, 0xff111111, 0xff000000};
98 class CFX_Palette {
99  public:
100   CFX_Palette();
101   ~CFX_Palette();
102
103  public:
104   FX_BOOL BuildPalette(const CFX_DIBSource* pBitmap, int dwPaletteType);
105   FX_DWORD* GetPalette() const { return m_pPalette; }
106
107   FX_DWORD* GetColorLut() const { return m_cLut; }
108   FX_DWORD* GetAmountLut() const { return m_aLut; }
109   int32_t Getlut() const { return m_lut; }
110
111  protected:
112   FX_DWORD* m_pPalette;
113   FX_DWORD* m_cLut;
114   FX_DWORD* m_aLut;
115   int m_lut;
116 };
117 int _Partition(FX_DWORD* alut, FX_DWORD* clut, int l, int r) {
118   FX_DWORD p_a = alut[l];
119   FX_DWORD p_c = clut[l];
120   while (l < r) {
121     while (l < r && alut[r] >= p_a) {
122       r--;
123     }
124     if (l < r) {
125       alut[l] = alut[r];
126       clut[l++] = clut[r];
127     }
128     while (l < r && alut[l] <= p_a) {
129       l++;
130     }
131     if (l < r) {
132       alut[r] = alut[l];
133       clut[r--] = clut[l];
134     }
135   }
136   alut[l] = p_a;
137   clut[l] = p_c;
138   return l;
139 }
140 void _Qsort(FX_DWORD* alut, FX_DWORD* clut, int l, int r) {
141   if (l < r) {
142     int pI = _Partition(alut, clut, l, r);
143     _Qsort(alut, clut, l, pI - 1);
144     _Qsort(alut, clut, pI + 1, r);
145   }
146 }
147 void _ColorDecode(FX_DWORD pal_v, uint8_t& r, uint8_t& g, uint8_t& b) {
148   r = (uint8_t)((pal_v & 0xf00) >> 4);
149   g = (uint8_t)(pal_v & 0x0f0);
150   b = (uint8_t)((pal_v & 0x00f) << 4);
151 }
152 void _Obtain_Pal(FX_DWORD* aLut,
153                  FX_DWORD* cLut,
154                  FX_DWORD* dest_pal,
155                  int pal_type,
156                  FX_DWORD* win_mac_pal,
157                  FX_DWORD lut) {
158   int row, col;
159   FX_DWORD lut_1 = lut - 1;
160   if (pal_type == FXDIB_PALETTE_LOC) {
161     for (row = 0; row < 256; row++) {
162       int lut_offset = lut_1 - row;
163       if (lut_offset < 0) {
164         lut_offset += 256;
165       }
166       FX_DWORD color = cLut[lut_offset];
167       uint8_t r, g, b;
168       _ColorDecode(color, r, g, b);
169       dest_pal[row] = ((FX_DWORD)r << 16) | ((FX_DWORD)g << 8) | b | 0xff000000;
170       aLut[lut_offset] = row;
171     }
172   } else {
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       uint8_t r, g, b;
179       _ColorDecode(cLut[lut_offset], r, g, b);
180       int error, min_error = 1000000;
181       int c_index = 0;
182       for (col = 0; col < 256; col++) {
183         FX_DWORD p_color = win_mac_pal[col];
184         int d_r = r - (uint8_t)(p_color >> 16);
185         int d_g = g - (uint8_t)(p_color >> 8);
186         int d_b = b - (uint8_t)p_color;
187         error = d_r * d_r + d_g * d_g + d_b * d_b;
188         if (error < min_error) {
189           min_error = error;
190           c_index = col;
191         }
192       }
193       dest_pal[row] = win_mac_pal[c_index];
194       aLut[lut_offset] = row;
195     }
196   }
197 }
198 CFX_Palette::CFX_Palette() {
199   m_pPalette = NULL;
200   m_cLut = NULL;
201   m_aLut = NULL;
202   m_lut = 0;
203 }
204 CFX_Palette::~CFX_Palette() {
205   FX_Free(m_pPalette);
206   FX_Free(m_cLut);
207   FX_Free(m_aLut);
208   m_lut = 0;
209 }
210 FX_BOOL CFX_Palette::BuildPalette(const CFX_DIBSource* pBitmap, int pal_type) {
211   if (pBitmap == NULL) {
212     return FALSE;
213   }
214   FX_Free(m_pPalette);
215   m_pPalette = FX_Alloc(FX_DWORD, 256);
216   int bpp = pBitmap->GetBPP() / 8;
217   int width = pBitmap->GetWidth();
218   int height = pBitmap->GetHeight();
219   FX_Free(m_cLut);
220   m_cLut = NULL;
221   FX_Free(m_aLut);
222   m_aLut = NULL;
223   m_cLut = FX_Alloc(FX_DWORD, 4096);
224   m_aLut = FX_Alloc(FX_DWORD, 4096);
225   int row, col;
226   m_lut = 0;
227   for (row = 0; row < height; row++) {
228     uint8_t* scan_line = (uint8_t*)pBitmap->GetScanline(row);
229     for (col = 0; col < width; col++) {
230       uint8_t* src_port = scan_line + col * bpp;
231       FX_DWORD b = src_port[0] & 0xf0;
232       FX_DWORD g = src_port[1] & 0xf0;
233       FX_DWORD r = src_port[2] & 0xf0;
234       FX_DWORD index = (r << 4) + g + (b >> 4);
235       m_aLut[index]++;
236     }
237   }
238   for (row = 0; row < 4096; row++) {
239     if (m_aLut[row] != 0) {
240       m_aLut[m_lut] = m_aLut[row];
241       m_cLut[m_lut] = row;
242       m_lut++;
243     }
244   }
245   _Qsort(m_aLut, m_cLut, 0, m_lut - 1);
246   FX_DWORD* win_mac_pal = NULL;
247   if (pal_type == FXDIB_PALETTE_WIN) {
248     win_mac_pal = (FX_DWORD*)g_dwWinPalette;
249   } else if (pal_type == FXDIB_PALETTE_MAC) {
250     win_mac_pal = (FX_DWORD*)g_dwMacPalette;
251   }
252   _Obtain_Pal(m_aLut, m_cLut, m_pPalette, pal_type, win_mac_pal, m_lut);
253   return TRUE;
254 }
255 FX_BOOL _ConvertBuffer_1bppMask2Gray(uint8_t* dest_buf,
256                                      int dest_pitch,
257                                      int width,
258                                      int height,
259                                      const CFX_DIBSource* pSrcBitmap,
260                                      int src_left,
261                                      int src_top) {
262   uint8_t set_gray, reset_gray;
263   set_gray = 0xff;
264   reset_gray = 0x00;
265   for (int row = 0; row < height; row++) {
266     uint8_t* dest_scan = dest_buf + row * dest_pitch;
267     FXSYS_memset(dest_scan, reset_gray, width);
268     const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row);
269     for (int col = src_left; col < src_left + width; col++) {
270       if (src_scan[col / 8] & (1 << (7 - col % 8))) {
271         *dest_scan = set_gray;
272       }
273       dest_scan++;
274     }
275   }
276   return TRUE;
277 }
278 FX_BOOL _ConvertBuffer_8bppMask2Gray(uint8_t* dest_buf,
279                                      int dest_pitch,
280                                      int width,
281                                      int height,
282                                      const CFX_DIBSource* pSrcBitmap,
283                                      int src_left,
284                                      int src_top) {
285   for (int row = 0; row < height; row++) {
286     uint8_t* dest_scan = dest_buf + row * dest_pitch;
287     const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left;
288     FXSYS_memcpy(dest_scan, src_scan, width);
289   }
290   return TRUE;
291 }
292 FX_BOOL _ConvertBuffer_1bppPlt2Gray(uint8_t* dest_buf,
293                                     int dest_pitch,
294                                     int width,
295                                     int height,
296                                     const CFX_DIBSource* pSrcBitmap,
297                                     int src_left,
298                                     int src_top,
299                                     void* pIccTransform) {
300   FX_DWORD* src_plt = pSrcBitmap->GetPalette();
301   uint8_t gray[2];
302   if (pIccTransform) {
303     FX_DWORD plt[2];
304     if (pSrcBitmap->IsCmykImage()) {
305       plt[0] = FXCMYK_TODIB(src_plt[0]);
306       plt[1] = FXCMYK_TODIB(src_plt[1]);
307     } else {
308       uint8_t* bgr_ptr = (uint8_t*)plt;
309       bgr_ptr[0] = FXARGB_B(src_plt[0]);
310       bgr_ptr[1] = FXARGB_G(src_plt[0]);
311       bgr_ptr[2] = FXARGB_R(src_plt[0]);
312       bgr_ptr[3] = FXARGB_B(src_plt[1]);
313       bgr_ptr[4] = FXARGB_G(src_plt[1]);
314       bgr_ptr[5] = FXARGB_R(src_plt[1]);
315     }
316     ICodec_IccModule* pIccModule =
317         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
318     pIccModule->TranslateScanline(pIccTransform, gray, (const uint8_t*)plt, 2);
319   } else {
320     uint8_t reset_r, reset_g, reset_b, set_r, set_g, set_b;
321     if (pSrcBitmap->IsCmykImage()) {
322       AdobeCMYK_to_sRGB1(
323           FXSYS_GetCValue(src_plt[0]), FXSYS_GetMValue(src_plt[0]),
324           FXSYS_GetYValue(src_plt[0]), FXSYS_GetKValue(src_plt[0]), reset_r,
325           reset_g, reset_b);
326       AdobeCMYK_to_sRGB1(FXSYS_GetCValue(src_plt[1]),
327                          FXSYS_GetMValue(src_plt[1]),
328                          FXSYS_GetYValue(src_plt[1]),
329                          FXSYS_GetKValue(src_plt[1]), set_r, set_g, set_b);
330     } else {
331       reset_r = FXARGB_R(src_plt[0]);
332       reset_g = FXARGB_G(src_plt[0]);
333       reset_b = FXARGB_B(src_plt[0]);
334       set_r = FXARGB_R(src_plt[1]);
335       set_g = FXARGB_G(src_plt[1]);
336       set_b = FXARGB_B(src_plt[1]);
337     }
338     gray[0] = FXRGB2GRAY(reset_r, reset_g, reset_b);
339     gray[1] = FXRGB2GRAY(set_r, set_g, set_b);
340   }
341   for (int row = 0; row < height; row++) {
342     uint8_t* dest_scan = dest_buf + row * dest_pitch;
343     FXSYS_memset(dest_scan, gray[0], width);
344     const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row);
345     for (int col = src_left; col < src_left + width; col++) {
346       if (src_scan[col / 8] & (1 << (7 - col % 8))) {
347         *dest_scan = gray[1];
348       }
349       dest_scan++;
350     }
351   }
352   return TRUE;
353 }
354 FX_BOOL _ConvertBuffer_8bppPlt2Gray(uint8_t* dest_buf,
355                                     int dest_pitch,
356                                     int width,
357                                     int height,
358                                     const CFX_DIBSource* pSrcBitmap,
359                                     int src_left,
360                                     int src_top,
361                                     void* pIccTransform) {
362   FX_DWORD* src_plt = pSrcBitmap->GetPalette();
363   uint8_t gray[256];
364   if (pIccTransform) {
365     FX_DWORD plt[256];
366     if (pSrcBitmap->IsCmykImage()) {
367       for (int i = 0; i < 256; i++) {
368         plt[i] = FXCMYK_TODIB(src_plt[i]);
369       }
370     } else {
371       uint8_t* bgr_ptr = (uint8_t*)plt;
372       for (int i = 0; i < 256; i++) {
373         *bgr_ptr++ = FXARGB_B(src_plt[i]);
374         *bgr_ptr++ = FXARGB_G(src_plt[i]);
375         *bgr_ptr++ = FXARGB_R(src_plt[i]);
376       }
377     }
378     ICodec_IccModule* pIccModule =
379         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
380     pIccModule->TranslateScanline(pIccTransform, gray, (const uint8_t*)plt,
381                                   256);
382   } else {
383     if (pSrcBitmap->IsCmykImage()) {
384       uint8_t r, g, b;
385       for (int i = 0; i < 256; i++) {
386         AdobeCMYK_to_sRGB1(
387             FXSYS_GetCValue(src_plt[i]), FXSYS_GetMValue(src_plt[i]),
388             FXSYS_GetYValue(src_plt[i]), FXSYS_GetKValue(src_plt[i]), r, g, b);
389         gray[i] = FXRGB2GRAY(r, g, b);
390       }
391     } else
392       for (int i = 0; i < 256; i++) {
393         gray[i] = FXRGB2GRAY(FXARGB_R(src_plt[i]), FXARGB_G(src_plt[i]),
394                              FXARGB_B(src_plt[i]));
395       }
396   }
397   for (int row = 0; row < height; row++) {
398     uint8_t* dest_scan = dest_buf + row * dest_pitch;
399     const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left;
400     for (int col = 0; col < width; col++) {
401       *dest_scan++ = gray[*src_scan++];
402     }
403   }
404   return TRUE;
405 }
406 FX_BOOL _ConvertBuffer_RgbOrCmyk2Gray(uint8_t* dest_buf,
407                                       int dest_pitch,
408                                       int width,
409                                       int height,
410                                       const CFX_DIBSource* pSrcBitmap,
411                                       int src_left,
412                                       int src_top,
413                                       void* pIccTransform) {
414   int Bpp = pSrcBitmap->GetBPP() / 8;
415   if (pIccTransform) {
416     ICodec_IccModule* pIccModule =
417         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
418     if (Bpp == 3 || pSrcBitmap->IsCmykImage()) {
419       for (int row = 0; row < height; row++) {
420         uint8_t* dest_scan = dest_buf + row * dest_pitch;
421         const uint8_t* src_scan =
422             pSrcBitmap->GetScanline(src_top + row) + src_left * Bpp;
423         pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan,
424                                       width);
425       }
426     } else {
427       for (int row = 0; row < height; row++) {
428         uint8_t* dest_scan = dest_buf + row * dest_pitch;
429         const uint8_t* src_scan =
430             pSrcBitmap->GetScanline(src_top + row) + src_left * 4;
431         for (int col = 0; col < width; col++) {
432           pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan, 1);
433           dest_scan++;
434           src_scan += 4;
435         }
436       }
437     }
438   } else {
439     if (pSrcBitmap->IsCmykImage()) {
440       for (int row = 0; row < height; row++) {
441         uint8_t* dest_scan = dest_buf + row * dest_pitch;
442         const uint8_t* src_scan =
443             pSrcBitmap->GetScanline(src_top + row) + src_left * 4;
444         for (int col = 0; col < width; col++) {
445           uint8_t r, g, b;
446           AdobeCMYK_to_sRGB1(FXSYS_GetCValue((FX_DWORD)src_scan[0]),
447                              FXSYS_GetMValue((FX_DWORD)src_scan[1]),
448                              FXSYS_GetYValue((FX_DWORD)src_scan[2]),
449                              FXSYS_GetKValue((FX_DWORD)src_scan[3]), r, g, b);
450           *dest_scan++ = FXRGB2GRAY(r, g, b);
451           src_scan += 4;
452         }
453       }
454     } else {
455       for (int row = 0; row < height; row++) {
456         uint8_t* dest_scan = dest_buf + row * dest_pitch;
457         const uint8_t* src_scan =
458             pSrcBitmap->GetScanline(src_top + row) + src_left * Bpp;
459         for (int col = 0; col < width; col++) {
460           *dest_scan++ = FXRGB2GRAY(src_scan[2], src_scan[1], src_scan[0]);
461           src_scan += Bpp;
462         }
463       }
464     }
465   }
466   return TRUE;
467 }
468 inline void _ConvertBuffer_IndexCopy(uint8_t* dest_buf,
469                                      int dest_pitch,
470                                      int width,
471                                      int height,
472                                      const CFX_DIBSource* pSrcBitmap,
473                                      int src_left,
474                                      int src_top) {
475   if (pSrcBitmap->GetBPP() == 1) {
476     for (int row = 0; row < height; row++) {
477       uint8_t* dest_scan = dest_buf + row * dest_pitch;
478       FXSYS_memset(dest_scan, 0, width);
479       const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row);
480       for (int col = src_left; col < src_left + width; col++) {
481         if (src_scan[col / 8] & (1 << (7 - col % 8))) {
482           *dest_scan = 1;
483         }
484         dest_scan++;
485       }
486     }
487   } else {
488     for (int row = 0; row < height; row++) {
489       uint8_t* dest_scan = dest_buf + row * dest_pitch;
490       const uint8_t* src_scan =
491           pSrcBitmap->GetScanline(src_top + row) + src_left;
492       FXSYS_memcpy(dest_scan, src_scan, width);
493     }
494   }
495 }
496 FX_BOOL _ConvertBuffer_Plt2PltRgb8(uint8_t* dest_buf,
497                                    int dest_pitch,
498                                    int width,
499                                    int height,
500                                    const CFX_DIBSource* pSrcBitmap,
501                                    int src_left,
502                                    int src_top,
503                                    FX_DWORD* dst_plt,
504                                    void* pIccTransform) {
505   _ConvertBuffer_IndexCopy(dest_buf, dest_pitch, width, height, pSrcBitmap,
506                            src_left, src_top);
507   FX_DWORD* src_plt = pSrcBitmap->GetPalette();
508   int plt_size = pSrcBitmap->GetPaletteSize();
509   if (pIccTransform) {
510     FX_DWORD plt[256];
511     uint8_t* bgr_ptr = (uint8_t*)plt;
512     if (pSrcBitmap->IsCmykImage()) {
513       for (int i = 0; i < plt_size; i++) {
514         plt[i] = FXCMYK_TODIB(src_plt[i]);
515       }
516     } else {
517       for (int i = 0; i < plt_size; i++) {
518         *bgr_ptr++ = FXARGB_B(src_plt[i]);
519         *bgr_ptr++ = FXARGB_G(src_plt[i]);
520         *bgr_ptr++ = FXARGB_R(src_plt[i]);
521       }
522       bgr_ptr = (uint8_t*)plt;
523     }
524     ICodec_IccModule* pIccModule =
525         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
526     pIccModule->TranslateScanline(pIccTransform, (uint8_t*)plt,
527                                   (const uint8_t*)plt, plt_size);
528     for (int i = 0; i < plt_size; i++) {
529       dst_plt[i] = FXARGB_MAKE(0xff, bgr_ptr[2], bgr_ptr[1], bgr_ptr[0]);
530       bgr_ptr += 3;
531     }
532   } else {
533     if (pSrcBitmap->IsCmykImage()) {
534       for (int i = 0; i < plt_size; i++) {
535         uint8_t r, g, b;
536         AdobeCMYK_to_sRGB1(
537             FXSYS_GetCValue(src_plt[i]), FXSYS_GetMValue(src_plt[i]),
538             FXSYS_GetYValue(src_plt[i]), FXSYS_GetKValue(src_plt[i]), r, g, b);
539         dst_plt[i] = FXARGB_MAKE(0xff, r, g, b);
540       }
541     } else {
542       FXSYS_memcpy(dst_plt, src_plt, plt_size * 4);
543     }
544   }
545   return TRUE;
546 }
547 inline FX_BOOL _ConvertBuffer_Rgb2PltRgb8_NoTransform(
548     uint8_t* dest_buf,
549     int dest_pitch,
550     int width,
551     int height,
552     const CFX_DIBSource* pSrcBitmap,
553     int src_left,
554     int src_top,
555     FX_DWORD* dst_plt) {
556   int bpp = pSrcBitmap->GetBPP() / 8;
557   int row, col;
558   CFX_Palette palette;
559   palette.BuildPalette(pSrcBitmap, FXDIB_PALETTE_LOC);
560   FX_DWORD* cLut = palette.GetColorLut();
561   FX_DWORD* aLut = palette.GetAmountLut();
562   if (cLut == NULL || aLut == NULL) {
563     return FALSE;
564   }
565   int lut = palette.Getlut();
566   FX_DWORD* pPalette = palette.GetPalette();
567   if (lut > 256) {
568     int err, min_err;
569     int lut_256 = lut - 256;
570     for (row = 0; row < lut_256; row++) {
571       min_err = 1000000;
572       uint8_t r, g, b;
573       _ColorDecode(cLut[row], r, g, b);
574       int clrindex = 0;
575       for (int col = 0; col < 256; col++) {
576         FX_DWORD p_color = *(pPalette + col);
577         int d_r = r - (uint8_t)(p_color >> 16);
578         int d_g = g - (uint8_t)(p_color >> 8);
579         int d_b = b - (uint8_t)(p_color);
580         err = d_r * d_r + d_g * d_g + d_b * d_b;
581         if (err < min_err) {
582           min_err = err;
583           clrindex = col;
584         }
585       }
586       aLut[row] = clrindex;
587     }
588   }
589   int32_t lut_1 = lut - 1;
590   for (row = 0; row < height; row++) {
591     uint8_t* src_scan =
592         (uint8_t*)pSrcBitmap->GetScanline(src_top + row) + src_left;
593     uint8_t* dest_scan = dest_buf + row * dest_pitch;
594     for (col = 0; col < width; col++) {
595       uint8_t* src_port = src_scan + col * bpp;
596       int r = src_port[2] & 0xf0;
597       int g = src_port[1] & 0xf0;
598       int b = src_port[0] & 0xf0;
599       FX_DWORD clrindex = (r << 4) + g + (b >> 4);
600       for (int i = lut_1; i >= 0; i--)
601         if (clrindex == cLut[i]) {
602           *(dest_scan + col) = (uint8_t)(aLut[i]);
603           break;
604         }
605     }
606   }
607   FXSYS_memcpy(dst_plt, pPalette, sizeof(FX_DWORD) * 256);
608   return TRUE;
609 }
610 FX_BOOL _ConvertBuffer_Rgb2PltRgb8(uint8_t* dest_buf,
611                                    int dest_pitch,
612                                    int width,
613                                    int height,
614                                    const CFX_DIBSource* pSrcBitmap,
615                                    int src_left,
616                                    int src_top,
617                                    FX_DWORD* dst_plt,
618                                    void* pIccTransform) {
619   FX_BOOL ret = _ConvertBuffer_Rgb2PltRgb8_NoTransform(
620       dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top,
621       dst_plt);
622   if (ret && pIccTransform) {
623     ICodec_IccModule* pIccModule =
624         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
625     for (int i = 0; i < 256; i++) {
626       FX_ARGB* plt = dst_plt + i;
627       FX_ARGB plt_entry = FXARGB_TODIB(*plt);
628       pIccModule->TranslateScanline(pIccTransform, (uint8_t*)&plt_entry,
629                                     (const uint8_t*)&plt_entry, 1);
630       *plt = FXARGB_TODIB(plt_entry);
631     }
632   }
633   return ret;
634 }
635 FX_BOOL _ConvertBuffer_1bppMask2Rgb(FXDIB_Format dst_format,
636                                     uint8_t* dest_buf,
637                                     int dest_pitch,
638                                     int width,
639                                     int height,
640                                     const CFX_DIBSource* pSrcBitmap,
641                                     int src_left,
642                                     int src_top) {
643   int comps = (dst_format & 0xff) / 8;
644   uint8_t set_gray, reset_gray;
645   set_gray = 0xff;
646   reset_gray = 0x00;
647   for (int row = 0; row < height; row++) {
648     uint8_t* dest_scan = dest_buf + row * dest_pitch;
649     const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row);
650     for (int col = src_left; col < src_left + width; col++) {
651       if (src_scan[col / 8] & (1 << (7 - col % 8))) {
652         dest_scan[0] = set_gray;
653         dest_scan[1] = set_gray;
654         dest_scan[2] = set_gray;
655       } else {
656         dest_scan[0] = reset_gray;
657         dest_scan[1] = reset_gray;
658         dest_scan[2] = reset_gray;
659       }
660       dest_scan += comps;
661     }
662   }
663   return TRUE;
664 }
665 FX_BOOL _ConvertBuffer_8bppMask2Rgb(FXDIB_Format dst_format,
666                                     uint8_t* dest_buf,
667                                     int dest_pitch,
668                                     int width,
669                                     int height,
670                                     const CFX_DIBSource* pSrcBitmap,
671                                     int src_left,
672                                     int src_top) {
673   int comps = (dst_format & 0xff) / 8;
674   for (int row = 0; row < height; row++) {
675     uint8_t* dest_scan = dest_buf + row * dest_pitch;
676     const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left;
677     uint8_t src_pixel;
678     for (int col = 0; col < width; col++) {
679       src_pixel = *src_scan++;
680       *dest_scan++ = src_pixel;
681       *dest_scan++ = src_pixel;
682       *dest_scan = src_pixel;
683       dest_scan += comps - 2;
684     }
685   }
686   return TRUE;
687 }
688 FX_BOOL _ConvertBuffer_1bppPlt2Rgb(FXDIB_Format dst_format,
689                                    uint8_t* dest_buf,
690                                    int dest_pitch,
691                                    int width,
692                                    int height,
693                                    const CFX_DIBSource* pSrcBitmap,
694                                    int src_left,
695                                    int src_top,
696                                    void* pIccTransform) {
697   int comps = (dst_format & 0xff) / 8;
698   FX_DWORD* src_plt = pSrcBitmap->GetPalette();
699   FX_DWORD plt[2];
700   uint8_t* bgr_ptr = (uint8_t*)plt;
701   if (pSrcBitmap->IsCmykImage()) {
702     plt[0] = FXCMYK_TODIB(src_plt[0]);
703     plt[1] = FXCMYK_TODIB(src_plt[1]);
704   } else {
705     bgr_ptr[0] = FXARGB_B(src_plt[0]);
706     bgr_ptr[1] = FXARGB_G(src_plt[0]);
707     bgr_ptr[2] = FXARGB_R(src_plt[0]);
708     bgr_ptr[3] = FXARGB_B(src_plt[1]);
709     bgr_ptr[4] = FXARGB_G(src_plt[1]);
710     bgr_ptr[5] = FXARGB_R(src_plt[1]);
711   }
712   if (pIccTransform) {
713     ICodec_IccModule* pIccModule =
714         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
715     pIccModule->TranslateScanline(pIccTransform, (uint8_t*)plt,
716                                   (const uint8_t*)plt, 2);
717   } else {
718     if (pSrcBitmap->IsCmykImage()) {
719       AdobeCMYK_to_sRGB1(
720           FXSYS_GetCValue(src_plt[0]), FXSYS_GetMValue(src_plt[0]),
721           FXSYS_GetYValue(src_plt[0]), FXSYS_GetKValue(src_plt[0]), bgr_ptr[2],
722           bgr_ptr[1], bgr_ptr[0]);
723       AdobeCMYK_to_sRGB1(
724           FXSYS_GetCValue(src_plt[1]), FXSYS_GetMValue(src_plt[1]),
725           FXSYS_GetYValue(src_plt[1]), FXSYS_GetKValue(src_plt[1]), bgr_ptr[5],
726           bgr_ptr[4], bgr_ptr[3]);
727     }
728   }
729   for (int row = 0; row < height; row++) {
730     uint8_t* dest_scan = dest_buf + row * dest_pitch;
731     const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row);
732     for (int col = src_left; col < src_left + width; col++) {
733       if (src_scan[col / 8] & (1 << (7 - col % 8))) {
734         *dest_scan++ = bgr_ptr[3];
735         *dest_scan++ = bgr_ptr[4];
736         *dest_scan = bgr_ptr[5];
737       } else {
738         *dest_scan++ = bgr_ptr[0];
739         *dest_scan++ = bgr_ptr[1];
740         *dest_scan = bgr_ptr[2];
741       }
742       dest_scan += comps - 2;
743     }
744   }
745   return TRUE;
746 }
747 FX_BOOL _ConvertBuffer_8bppPlt2Rgb(FXDIB_Format dst_format,
748                                    uint8_t* dest_buf,
749                                    int dest_pitch,
750                                    int width,
751                                    int height,
752                                    const CFX_DIBSource* pSrcBitmap,
753                                    int src_left,
754                                    int src_top,
755                                    void* pIccTransform) {
756   int comps = (dst_format & 0xff) / 8;
757   FX_DWORD* src_plt = pSrcBitmap->GetPalette();
758   FX_DWORD plt[256];
759   uint8_t* bgr_ptr = (uint8_t*)plt;
760   if (!pSrcBitmap->IsCmykImage()) {
761     for (int i = 0; i < 256; i++) {
762       *bgr_ptr++ = FXARGB_B(src_plt[i]);
763       *bgr_ptr++ = FXARGB_G(src_plt[i]);
764       *bgr_ptr++ = FXARGB_R(src_plt[i]);
765     }
766     bgr_ptr = (uint8_t*)plt;
767   }
768   if (pIccTransform) {
769     if (pSrcBitmap->IsCmykImage()) {
770       for (int i = 0; i < 256; i++) {
771         plt[i] = FXCMYK_TODIB(src_plt[i]);
772       }
773     }
774     ICodec_IccModule* pIccModule =
775         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
776     pIccModule->TranslateScanline(pIccTransform, (uint8_t*)plt,
777                                   (const uint8_t*)plt, 256);
778   } else {
779     if (pSrcBitmap->IsCmykImage()) {
780       for (int i = 0; i < 256; i++) {
781         AdobeCMYK_to_sRGB1(
782             FXSYS_GetCValue(src_plt[i]), FXSYS_GetMValue(src_plt[i]),
783             FXSYS_GetYValue(src_plt[i]), FXSYS_GetKValue(src_plt[i]),
784             bgr_ptr[2], bgr_ptr[1], bgr_ptr[0]);
785         bgr_ptr += 3;
786       }
787       bgr_ptr = (uint8_t*)plt;
788     }
789   }
790   for (int row = 0; row < height; row++) {
791     uint8_t* dest_scan = dest_buf + row * dest_pitch;
792     const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left;
793     for (int col = 0; col < width; col++) {
794       uint8_t* src_pixel = bgr_ptr + 3 * (*src_scan++);
795       *dest_scan++ = *src_pixel++;
796       *dest_scan++ = *src_pixel++;
797       *dest_scan = *src_pixel++;
798       dest_scan += comps - 2;
799     }
800   }
801   return TRUE;
802 }
803 FX_BOOL _ConvertBuffer_24bppRgb2Rgb24(uint8_t* dest_buf,
804                                       int dest_pitch,
805                                       int width,
806                                       int height,
807                                       const CFX_DIBSource* pSrcBitmap,
808                                       int src_left,
809                                       int src_top,
810                                       void* pIccTransform) {
811   if (pIccTransform) {
812     ICodec_IccModule* pIccModule =
813         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
814     for (int row = 0; row < height; row++) {
815       uint8_t* dest_scan = dest_buf + row * dest_pitch;
816       const uint8_t* src_scan =
817           pSrcBitmap->GetScanline(src_top + row) + src_left * 3;
818       pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan, width);
819     }
820   } else {
821     for (int row = 0; row < height; row++) {
822       uint8_t* dest_scan = dest_buf + row * dest_pitch;
823       const uint8_t* src_scan =
824           pSrcBitmap->GetScanline(src_top + row) + src_left * 3;
825       FXSYS_memcpy(dest_scan, src_scan, width * 3);
826     }
827   }
828   return TRUE;
829 }
830 FX_BOOL _ConvertBuffer_32bppRgb2Rgb24(uint8_t* dest_buf,
831                                       int dest_pitch,
832                                       int width,
833                                       int height,
834                                       const CFX_DIBSource* pSrcBitmap,
835                                       int src_left,
836                                       int src_top,
837                                       void* pIccTransform) {
838   for (int row = 0; row < height; row++) {
839     uint8_t* dest_scan = dest_buf + row * dest_pitch;
840     const uint8_t* src_scan =
841         pSrcBitmap->GetScanline(src_top + row) + src_left * 4;
842     for (int col = 0; col < width; col++) {
843       *dest_scan++ = *src_scan++;
844       *dest_scan++ = *src_scan++;
845       *dest_scan++ = *src_scan++;
846       src_scan++;
847     }
848   }
849   if (pIccTransform) {
850     ICodec_IccModule* pIccModule =
851         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
852     for (int row = 0; row < height; row++) {
853       uint8_t* dest_scan = dest_buf + row * dest_pitch;
854       pIccModule->TranslateScanline(pIccTransform, dest_scan, dest_scan, width);
855     }
856   }
857   return TRUE;
858 }
859 FX_BOOL _ConvertBuffer_Rgb2Rgb32(uint8_t* dest_buf,
860                                  int dest_pitch,
861                                  int width,
862                                  int height,
863                                  const CFX_DIBSource* pSrcBitmap,
864                                  int src_left,
865                                  int src_top,
866                                  void* pIccTransform) {
867   int comps = pSrcBitmap->GetBPP() / 8;
868   if (pIccTransform) {
869     ICodec_IccModule* pIccModule =
870         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
871     for (int row = 0; row < height; row++) {
872       uint8_t* dest_scan = dest_buf + row * dest_pitch;
873       const uint8_t* src_scan =
874           pSrcBitmap->GetScanline(src_top + row) + src_left * comps;
875       for (int col = 0; col < width; col++) {
876         pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan, 1);
877         dest_scan += 4;
878         src_scan += comps;
879       }
880     }
881   } else {
882     for (int row = 0; row < height; row++) {
883       uint8_t* dest_scan = dest_buf + row * dest_pitch;
884       const uint8_t* src_scan =
885           pSrcBitmap->GetScanline(src_top + row) + src_left * comps;
886       for (int col = 0; col < width; col++) {
887         *dest_scan++ = *src_scan++;
888         *dest_scan++ = *src_scan++;
889         *dest_scan++ = *src_scan++;
890         dest_scan++;
891         src_scan += comps - 3;
892       }
893     }
894   }
895   return TRUE;
896 }
897 FX_BOOL _ConvertBuffer_32bppCmyk2Rgb32(uint8_t* dest_buf,
898                                        int dest_pitch,
899                                        int width,
900                                        int height,
901                                        const CFX_DIBSource* pSrcBitmap,
902                                        int src_left,
903                                        int src_top,
904                                        void* pIccTransform) {
905   if (pIccTransform) {
906     ICodec_IccModule* pIccModule =
907         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
908     for (int row = 0; row < height; row++) {
909       uint8_t* dest_scan = dest_buf + row * dest_pitch;
910       const uint8_t* src_scan =
911           pSrcBitmap->GetScanline(src_top + row) + src_left * 4;
912       for (int col = 0; col < width; col++) {
913         pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan, 1);
914         dest_scan += 4;
915         src_scan += 4;
916       }
917     }
918   } else {
919     for (int row = 0; row < height; row++) {
920       uint8_t* dest_scan = dest_buf + row * dest_pitch;
921       const uint8_t* src_scan =
922           pSrcBitmap->GetScanline(src_top + row) + src_left * 4;
923       for (int col = 0; col < width; col++) {
924         AdobeCMYK_to_sRGB1(src_scan[0], src_scan[1], src_scan[2], src_scan[3],
925                            dest_scan[2], dest_scan[1], dest_scan[0]);
926         dest_scan += 4;
927         src_scan += 4;
928       }
929     }
930   }
931   return TRUE;
932 }
933 FX_BOOL ConvertBuffer(FXDIB_Format dest_format,
934                       uint8_t* dest_buf,
935                       int dest_pitch,
936                       int width,
937                       int height,
938                       const CFX_DIBSource* pSrcBitmap,
939                       int src_left,
940                       int src_top,
941                       FX_DWORD*& d_pal,
942                       void* pIccTransform) {
943   FXDIB_Format src_format = pSrcBitmap->GetFormat();
944   if (!CFX_GEModule::Get()->GetCodecModule() ||
945       !CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
946     pIccTransform = NULL;
947   }
948   switch (dest_format) {
949     case FXDIB_Invalid:
950     case FXDIB_1bppCmyk:
951     case FXDIB_1bppMask:
952     case FXDIB_1bppRgb:
953       ASSERT(FALSE);
954       return FALSE;
955     case FXDIB_8bppMask: {
956       if ((src_format & 0xff) == 1) {
957         if (pSrcBitmap->GetPalette()) {
958           return _ConvertBuffer_1bppPlt2Gray(dest_buf, dest_pitch, width,
959                                              height, pSrcBitmap, src_left,
960                                              src_top, pIccTransform);
961         }
962         return _ConvertBuffer_1bppMask2Gray(dest_buf, dest_pitch, width, height,
963                                             pSrcBitmap, src_left, src_top);
964       }
965       if ((src_format & 0xff) == 8) {
966         if (pSrcBitmap->GetPalette()) {
967           return _ConvertBuffer_8bppPlt2Gray(dest_buf, dest_pitch, width,
968                                              height, pSrcBitmap, src_left,
969                                              src_top, pIccTransform);
970         }
971         return _ConvertBuffer_8bppMask2Gray(dest_buf, dest_pitch, width, height,
972                                             pSrcBitmap, src_left, src_top);
973       }
974       if ((src_format & 0xff) >= 24) {
975         return _ConvertBuffer_RgbOrCmyk2Gray(dest_buf, dest_pitch, width,
976                                              height, pSrcBitmap, src_left,
977                                              src_top, pIccTransform);
978       }
979       return FALSE;
980     }
981     case FXDIB_8bppRgb:
982     case FXDIB_8bppRgba: {
983       if ((src_format & 0xff) == 8 && pSrcBitmap->GetPalette() == NULL) {
984         return ConvertBuffer(FXDIB_8bppMask, dest_buf, dest_pitch, width,
985                              height, pSrcBitmap, src_left, src_top, d_pal,
986                              pIccTransform);
987       }
988       d_pal = FX_Alloc(FX_DWORD, 256);
989       if (((src_format & 0xff) == 1 || (src_format & 0xff) == 8) &&
990           pSrcBitmap->GetPalette()) {
991         return _ConvertBuffer_Plt2PltRgb8(dest_buf, dest_pitch, width, height,
992                                           pSrcBitmap, src_left, src_top, d_pal,
993                                           pIccTransform);
994       }
995       if ((src_format & 0xff) >= 24) {
996         return _ConvertBuffer_Rgb2PltRgb8(dest_buf, dest_pitch, width, height,
997                                           pSrcBitmap, src_left, src_top, d_pal,
998                                           pIccTransform);
999       }
1000       return FALSE;
1001     }
1002     case FXDIB_Rgb:
1003     case FXDIB_Rgba: {
1004       if ((src_format & 0xff) == 1) {
1005         if (pSrcBitmap->GetPalette()) {
1006           return _ConvertBuffer_1bppPlt2Rgb(dest_format, dest_buf, dest_pitch,
1007                                             width, height, pSrcBitmap, src_left,
1008                                             src_top, pIccTransform);
1009         }
1010         return _ConvertBuffer_1bppMask2Rgb(dest_format, dest_buf, dest_pitch,
1011                                            width, height, pSrcBitmap, src_left,
1012                                            src_top);
1013       }
1014       if ((src_format & 0xff) == 8) {
1015         if (pSrcBitmap->GetPalette()) {
1016           return _ConvertBuffer_8bppPlt2Rgb(dest_format, dest_buf, dest_pitch,
1017                                             width, height, pSrcBitmap, src_left,
1018                                             src_top, pIccTransform);
1019         }
1020         return _ConvertBuffer_8bppMask2Rgb(dest_format, dest_buf, dest_pitch,
1021                                            width, height, pSrcBitmap, src_left,
1022                                            src_top);
1023       }
1024       if ((src_format & 0xff) == 24) {
1025         return _ConvertBuffer_24bppRgb2Rgb24(dest_buf, dest_pitch, width,
1026                                              height, pSrcBitmap, src_left,
1027                                              src_top, pIccTransform);
1028       }
1029       if ((src_format & 0xff) == 32) {
1030         return _ConvertBuffer_32bppRgb2Rgb24(dest_buf, dest_pitch, width,
1031                                              height, pSrcBitmap, src_left,
1032                                              src_top, pIccTransform);
1033       }
1034       return FALSE;
1035     }
1036     case FXDIB_Argb:
1037     case FXDIB_Rgb32: {
1038       if ((src_format & 0xff) == 1) {
1039         if (pSrcBitmap->GetPalette()) {
1040           return _ConvertBuffer_1bppPlt2Rgb(dest_format, dest_buf, dest_pitch,
1041                                             width, height, pSrcBitmap, src_left,
1042                                             src_top, pIccTransform);
1043         }
1044         return _ConvertBuffer_1bppMask2Rgb(dest_format, dest_buf, dest_pitch,
1045                                            width, height, pSrcBitmap, src_left,
1046                                            src_top);
1047       }
1048       if ((src_format & 0xff) == 8) {
1049         if (pSrcBitmap->GetPalette()) {
1050           return _ConvertBuffer_8bppPlt2Rgb(dest_format, dest_buf, dest_pitch,
1051                                             width, height, pSrcBitmap, src_left,
1052                                             src_top, pIccTransform);
1053         }
1054         return _ConvertBuffer_8bppMask2Rgb(dest_format, dest_buf, dest_pitch,
1055                                            width, height, pSrcBitmap, src_left,
1056                                            src_top);
1057       }
1058       if ((src_format & 0xff) >= 24) {
1059         if (src_format & 0x0400) {
1060           return _ConvertBuffer_32bppCmyk2Rgb32(dest_buf, dest_pitch, width,
1061                                                 height, pSrcBitmap, src_left,
1062                                                 src_top, pIccTransform);
1063         }
1064         return _ConvertBuffer_Rgb2Rgb32(dest_buf, dest_pitch, width, height,
1065                                         pSrcBitmap, src_left, src_top,
1066                                         pIccTransform);
1067       }
1068       return FALSE;
1069     }
1070     default:
1071       return FALSE;
1072   }
1073   return FALSE;
1074 }
1075 CFX_DIBitmap* CFX_DIBSource::CloneConvert(FXDIB_Format dest_format,
1076                                           const FX_RECT* pClip,
1077                                           void* pIccTransform) const {
1078   if (dest_format == GetFormat() && pIccTransform == NULL) {
1079     return Clone(pClip);
1080   }
1081   if (pClip) {
1082     CFX_DIBitmap* pClone = Clone(pClip);
1083     if (pClone == NULL) {
1084       return NULL;
1085     }
1086     if (!pClone->ConvertFormat(dest_format, pIccTransform)) {
1087       delete pClone;
1088       return NULL;
1089     }
1090     return pClone;
1091   }
1092   CFX_DIBitmap* pClone = new CFX_DIBitmap;
1093   if (!pClone->Create(m_Width, m_Height, dest_format)) {
1094     delete pClone;
1095     return NULL;
1096   }
1097   FX_BOOL ret = TRUE;
1098   CFX_DIBitmap* pSrcAlpha = NULL;
1099   if (HasAlpha()) {
1100     pSrcAlpha = (GetFormat() == FXDIB_Argb) ? GetAlphaMask() : m_pAlphaMask;
1101     if (pSrcAlpha == NULL) {
1102       delete pClone;
1103       return NULL;
1104     }
1105   }
1106   if (dest_format & 0x0200) {
1107     if (dest_format == FXDIB_Argb)
1108       ret = pSrcAlpha ? pClone->LoadChannel(FXDIB_Alpha, pSrcAlpha, FXDIB_Alpha)
1109                       : pClone->LoadChannel(FXDIB_Alpha, 0xff);
1110     else {
1111       ret = pClone->CopyAlphaMask(pSrcAlpha);
1112     }
1113   }
1114   if (pSrcAlpha && pSrcAlpha != m_pAlphaMask) {
1115     delete pSrcAlpha;
1116     pSrcAlpha = NULL;
1117   }
1118   if (!ret) {
1119     delete pClone;
1120     return NULL;
1121   }
1122   FX_DWORD* pal_8bpp = NULL;
1123   ret = ConvertBuffer(dest_format, pClone->GetBuffer(), pClone->GetPitch(),
1124                       m_Width, m_Height, this, 0, 0, pal_8bpp, pIccTransform);
1125   if (!ret) {
1126     FX_Free(pal_8bpp);
1127     delete pClone;
1128     return NULL;
1129   }
1130   if (pal_8bpp) {
1131     pClone->CopyPalette(pal_8bpp);
1132     FX_Free(pal_8bpp);
1133     pal_8bpp = NULL;
1134   }
1135   return pClone;
1136 }
1137 FX_BOOL CFX_DIBitmap::ConvertFormat(FXDIB_Format dest_format,
1138                                     void* pIccTransform) {
1139   FXDIB_Format src_format = GetFormat();
1140   if (dest_format == src_format && pIccTransform == NULL) {
1141     return TRUE;
1142   }
1143   if (dest_format == FXDIB_8bppMask && src_format == FXDIB_8bppRgb &&
1144       m_pPalette == NULL) {
1145     m_AlphaFlag = 1;
1146     return TRUE;
1147   }
1148   if (dest_format == FXDIB_Argb && src_format == FXDIB_Rgb32 &&
1149       pIccTransform == NULL) {
1150     m_AlphaFlag = 2;
1151     for (int row = 0; row < m_Height; row++) {
1152       uint8_t* scanline = m_pBuffer + row * m_Pitch + 3;
1153       for (int col = 0; col < m_Width; col++) {
1154         *scanline = 0xff;
1155         scanline += 4;
1156       }
1157     }
1158     return TRUE;
1159   }
1160   int dest_bpp = dest_format & 0xff;
1161   int dest_pitch = (dest_bpp * m_Width + 31) / 32 * 4;
1162   uint8_t* dest_buf = FX_TryAlloc(uint8_t, dest_pitch * m_Height + 4);
1163   if (dest_buf == NULL) {
1164     return FALSE;
1165   }
1166   CFX_DIBitmap* pAlphaMask = NULL;
1167   if (dest_format == FXDIB_Argb) {
1168     FXSYS_memset(dest_buf, 0xff, dest_pitch * m_Height + 4);
1169     if (m_pAlphaMask) {
1170       for (int row = 0; row < m_Height; row++) {
1171         uint8_t* pDstScanline = dest_buf + row * dest_pitch + 3;
1172         const uint8_t* pSrcScanline = m_pAlphaMask->GetScanline(row);
1173         for (int col = 0; col < m_Width; col++) {
1174           *pDstScanline = *pSrcScanline++;
1175           pDstScanline += 4;
1176         }
1177       }
1178     }
1179   } else if (dest_format & 0x0200) {
1180     if (src_format == FXDIB_Argb) {
1181       pAlphaMask = GetAlphaMask();
1182       if (pAlphaMask == NULL) {
1183         FX_Free(dest_buf);
1184         return FALSE;
1185       }
1186     } else {
1187       if (m_pAlphaMask == NULL) {
1188         if (!BuildAlphaMask()) {
1189           FX_Free(dest_buf);
1190           return FALSE;
1191         }
1192         pAlphaMask = m_pAlphaMask;
1193         m_pAlphaMask = NULL;
1194       } else {
1195         pAlphaMask = m_pAlphaMask;
1196       }
1197     }
1198   }
1199   FX_BOOL ret = FALSE;
1200   FX_DWORD* pal_8bpp = NULL;
1201   ret = ConvertBuffer(dest_format, dest_buf, dest_pitch, m_Width, m_Height,
1202                       this, 0, 0, pal_8bpp, pIccTransform);
1203   if (!ret) {
1204     FX_Free(pal_8bpp);
1205     if (pAlphaMask != m_pAlphaMask) {
1206       delete pAlphaMask;
1207     }
1208     FX_Free(dest_buf);
1209     return FALSE;
1210   }
1211   if (m_pAlphaMask && pAlphaMask != m_pAlphaMask) {
1212     delete m_pAlphaMask;
1213   }
1214   m_pAlphaMask = pAlphaMask;
1215   FX_Free(m_pPalette);
1216   m_pPalette = pal_8bpp;
1217   if (!m_bExtBuf) {
1218     FX_Free(m_pBuffer);
1219   }
1220   m_bExtBuf = FALSE;
1221   m_pBuffer = dest_buf;
1222   m_bpp = (uint8_t)dest_format;
1223   m_AlphaFlag = (uint8_t)(dest_format >> 8);
1224   m_Pitch = dest_pitch;
1225   return TRUE;
1226 }