clang-format all pdfium code.
[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   if (m_pPalette) {
206     FX_Free(m_pPalette);
207   }
208   if (m_cLut) {
209     FX_Free(m_cLut);
210   }
211   if (m_aLut) {
212     FX_Free(m_aLut);
213   }
214   m_lut = 0;
215 }
216 FX_BOOL CFX_Palette::BuildPalette(const CFX_DIBSource* pBitmap, int pal_type) {
217   if (pBitmap == NULL) {
218     return FALSE;
219   }
220   if (m_pPalette != NULL) {
221     FX_Free(m_pPalette);
222   }
223   m_pPalette = FX_Alloc(FX_DWORD, 256);
224   int bpp = pBitmap->GetBPP() / 8;
225   int width = pBitmap->GetWidth();
226   int height = pBitmap->GetHeight();
227   if (m_cLut) {
228     FX_Free(m_cLut);
229     m_cLut = NULL;
230   }
231   if (m_aLut) {
232     FX_Free(m_aLut);
233     m_aLut = NULL;
234   }
235   m_cLut = FX_Alloc(FX_DWORD, 4096);
236   m_aLut = FX_Alloc(FX_DWORD, 4096);
237   int row, col;
238   m_lut = 0;
239   for (row = 0; row < height; row++) {
240     uint8_t* scan_line = (uint8_t*)pBitmap->GetScanline(row);
241     for (col = 0; col < width; col++) {
242       uint8_t* src_port = scan_line + col * bpp;
243       FX_DWORD b = src_port[0] & 0xf0;
244       FX_DWORD g = src_port[1] & 0xf0;
245       FX_DWORD r = src_port[2] & 0xf0;
246       FX_DWORD index = (r << 4) + g + (b >> 4);
247       m_aLut[index]++;
248     }
249   }
250   for (row = 0; row < 4096; row++) {
251     if (m_aLut[row] != 0) {
252       m_aLut[m_lut] = m_aLut[row];
253       m_cLut[m_lut] = row;
254       m_lut++;
255     }
256   }
257   _Qsort(m_aLut, m_cLut, 0, m_lut - 1);
258   FX_DWORD* win_mac_pal = NULL;
259   if (pal_type == FXDIB_PALETTE_WIN) {
260     win_mac_pal = (FX_DWORD*)g_dwWinPalette;
261   } else if (pal_type == FXDIB_PALETTE_MAC) {
262     win_mac_pal = (FX_DWORD*)g_dwMacPalette;
263   }
264   _Obtain_Pal(m_aLut, m_cLut, m_pPalette, pal_type, win_mac_pal, m_lut);
265   return TRUE;
266 }
267 FX_BOOL _ConvertBuffer_1bppMask2Gray(uint8_t* dest_buf,
268                                      int dest_pitch,
269                                      int width,
270                                      int height,
271                                      const CFX_DIBSource* pSrcBitmap,
272                                      int src_left,
273                                      int src_top) {
274   uint8_t set_gray, reset_gray;
275   set_gray = 0xff;
276   reset_gray = 0x00;
277   for (int row = 0; row < height; row++) {
278     uint8_t* dest_scan = dest_buf + row * dest_pitch;
279     FXSYS_memset(dest_scan, reset_gray, width);
280     const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row);
281     for (int col = src_left; col < src_left + width; col++) {
282       if (src_scan[col / 8] & (1 << (7 - col % 8))) {
283         *dest_scan = set_gray;
284       }
285       dest_scan++;
286     }
287   }
288   return TRUE;
289 }
290 FX_BOOL _ConvertBuffer_8bppMask2Gray(uint8_t* dest_buf,
291                                      int dest_pitch,
292                                      int width,
293                                      int height,
294                                      const CFX_DIBSource* pSrcBitmap,
295                                      int src_left,
296                                      int src_top) {
297   for (int row = 0; row < height; row++) {
298     uint8_t* dest_scan = dest_buf + row * dest_pitch;
299     const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left;
300     FXSYS_memcpy(dest_scan, src_scan, width);
301   }
302   return TRUE;
303 }
304 FX_BOOL _ConvertBuffer_1bppPlt2Gray(uint8_t* dest_buf,
305                                     int dest_pitch,
306                                     int width,
307                                     int height,
308                                     const CFX_DIBSource* pSrcBitmap,
309                                     int src_left,
310                                     int src_top,
311                                     void* pIccTransform) {
312   FX_DWORD* src_plt = pSrcBitmap->GetPalette();
313   uint8_t gray[2];
314   if (pIccTransform) {
315     FX_DWORD plt[2];
316     if (pSrcBitmap->IsCmykImage()) {
317       plt[0] = FXCMYK_TODIB(src_plt[0]);
318       plt[1] = FXCMYK_TODIB(src_plt[1]);
319     } else {
320       uint8_t* bgr_ptr = (uint8_t*)plt;
321       bgr_ptr[0] = FXARGB_B(src_plt[0]);
322       bgr_ptr[1] = FXARGB_G(src_plt[0]);
323       bgr_ptr[2] = FXARGB_R(src_plt[0]);
324       bgr_ptr[3] = FXARGB_B(src_plt[1]);
325       bgr_ptr[4] = FXARGB_G(src_plt[1]);
326       bgr_ptr[5] = FXARGB_R(src_plt[1]);
327     }
328     ICodec_IccModule* pIccModule =
329         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
330     pIccModule->TranslateScanline(pIccTransform, gray, (const uint8_t*)plt, 2);
331   } else {
332     uint8_t reset_r, reset_g, reset_b, set_r, set_g, set_b;
333     if (pSrcBitmap->IsCmykImage()) {
334       AdobeCMYK_to_sRGB1(
335           FXSYS_GetCValue(src_plt[0]), FXSYS_GetMValue(src_plt[0]),
336           FXSYS_GetYValue(src_plt[0]), FXSYS_GetKValue(src_plt[0]), reset_r,
337           reset_g, reset_b);
338       AdobeCMYK_to_sRGB1(FXSYS_GetCValue(src_plt[1]),
339                          FXSYS_GetMValue(src_plt[1]),
340                          FXSYS_GetYValue(src_plt[1]),
341                          FXSYS_GetKValue(src_plt[1]), set_r, set_g, set_b);
342     } else {
343       reset_r = FXARGB_R(src_plt[0]);
344       reset_g = FXARGB_G(src_plt[0]);
345       reset_b = FXARGB_B(src_plt[0]);
346       set_r = FXARGB_R(src_plt[1]);
347       set_g = FXARGB_G(src_plt[1]);
348       set_b = FXARGB_B(src_plt[1]);
349     }
350     gray[0] = FXRGB2GRAY(reset_r, reset_g, reset_b);
351     gray[1] = FXRGB2GRAY(set_r, set_g, set_b);
352   }
353   for (int row = 0; row < height; row++) {
354     uint8_t* dest_scan = dest_buf + row * dest_pitch;
355     FXSYS_memset(dest_scan, gray[0], width);
356     const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row);
357     for (int col = src_left; col < src_left + width; col++) {
358       if (src_scan[col / 8] & (1 << (7 - col % 8))) {
359         *dest_scan = gray[1];
360       }
361       dest_scan++;
362     }
363   }
364   return TRUE;
365 }
366 FX_BOOL _ConvertBuffer_8bppPlt2Gray(uint8_t* dest_buf,
367                                     int dest_pitch,
368                                     int width,
369                                     int height,
370                                     const CFX_DIBSource* pSrcBitmap,
371                                     int src_left,
372                                     int src_top,
373                                     void* pIccTransform) {
374   FX_DWORD* src_plt = pSrcBitmap->GetPalette();
375   uint8_t gray[256];
376   if (pIccTransform) {
377     FX_DWORD plt[256];
378     if (pSrcBitmap->IsCmykImage()) {
379       for (int i = 0; i < 256; i++) {
380         plt[i] = FXCMYK_TODIB(src_plt[i]);
381       }
382     } else {
383       uint8_t* bgr_ptr = (uint8_t*)plt;
384       for (int i = 0; i < 256; i++) {
385         *bgr_ptr++ = FXARGB_B(src_plt[i]);
386         *bgr_ptr++ = FXARGB_G(src_plt[i]);
387         *bgr_ptr++ = FXARGB_R(src_plt[i]);
388       }
389     }
390     ICodec_IccModule* pIccModule =
391         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
392     pIccModule->TranslateScanline(pIccTransform, gray, (const uint8_t*)plt,
393                                   256);
394   } else {
395     if (pSrcBitmap->IsCmykImage()) {
396       uint8_t r, g, b;
397       for (int i = 0; i < 256; i++) {
398         AdobeCMYK_to_sRGB1(
399             FXSYS_GetCValue(src_plt[i]), FXSYS_GetMValue(src_plt[i]),
400             FXSYS_GetYValue(src_plt[i]), FXSYS_GetKValue(src_plt[i]), r, g, b);
401         gray[i] = FXRGB2GRAY(r, g, b);
402       }
403     } else
404       for (int i = 0; i < 256; i++) {
405         gray[i] = FXRGB2GRAY(FXARGB_R(src_plt[i]), FXARGB_G(src_plt[i]),
406                              FXARGB_B(src_plt[i]));
407       }
408   }
409   for (int row = 0; row < height; row++) {
410     uint8_t* dest_scan = dest_buf + row * dest_pitch;
411     const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left;
412     for (int col = 0; col < width; col++) {
413       *dest_scan++ = gray[*src_scan++];
414     }
415   }
416   return TRUE;
417 }
418 FX_BOOL _ConvertBuffer_RgbOrCmyk2Gray(uint8_t* dest_buf,
419                                       int dest_pitch,
420                                       int width,
421                                       int height,
422                                       const CFX_DIBSource* pSrcBitmap,
423                                       int src_left,
424                                       int src_top,
425                                       void* pIccTransform) {
426   int Bpp = pSrcBitmap->GetBPP() / 8;
427   if (pIccTransform) {
428     ICodec_IccModule* pIccModule =
429         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
430     if (Bpp == 3 || pSrcBitmap->IsCmykImage()) {
431       for (int row = 0; row < height; row++) {
432         uint8_t* dest_scan = dest_buf + row * dest_pitch;
433         const uint8_t* src_scan =
434             pSrcBitmap->GetScanline(src_top + row) + src_left * Bpp;
435         pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan,
436                                       width);
437       }
438     } else {
439       for (int row = 0; row < height; row++) {
440         uint8_t* dest_scan = dest_buf + row * dest_pitch;
441         const uint8_t* src_scan =
442             pSrcBitmap->GetScanline(src_top + row) + src_left * 4;
443         for (int col = 0; col < width; col++) {
444           pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan, 1);
445           dest_scan++;
446           src_scan += 4;
447         }
448       }
449     }
450   } else {
451     if (pSrcBitmap->IsCmykImage()) {
452       for (int row = 0; row < height; row++) {
453         uint8_t* dest_scan = dest_buf + row * dest_pitch;
454         const uint8_t* src_scan =
455             pSrcBitmap->GetScanline(src_top + row) + src_left * 4;
456         for (int col = 0; col < width; col++) {
457           uint8_t r, g, b;
458           AdobeCMYK_to_sRGB1(FXSYS_GetCValue((FX_DWORD)src_scan[0]),
459                              FXSYS_GetMValue((FX_DWORD)src_scan[1]),
460                              FXSYS_GetYValue((FX_DWORD)src_scan[2]),
461                              FXSYS_GetKValue((FX_DWORD)src_scan[3]), r, g, b);
462           *dest_scan++ = FXRGB2GRAY(r, g, b);
463           src_scan += 4;
464         }
465       }
466     } else {
467       for (int row = 0; row < height; row++) {
468         uint8_t* dest_scan = dest_buf + row * dest_pitch;
469         const uint8_t* src_scan =
470             pSrcBitmap->GetScanline(src_top + row) + src_left * Bpp;
471         for (int col = 0; col < width; col++) {
472           *dest_scan++ = FXRGB2GRAY(src_scan[2], src_scan[1], src_scan[0]);
473           src_scan += Bpp;
474         }
475       }
476     }
477   }
478   return TRUE;
479 }
480 inline void _ConvertBuffer_IndexCopy(uint8_t* dest_buf,
481                                      int dest_pitch,
482                                      int width,
483                                      int height,
484                                      const CFX_DIBSource* pSrcBitmap,
485                                      int src_left,
486                                      int src_top) {
487   if (pSrcBitmap->GetBPP() == 1) {
488     for (int row = 0; row < height; row++) {
489       uint8_t* dest_scan = dest_buf + row * dest_pitch;
490       FXSYS_memset(dest_scan, 0, width);
491       const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row);
492       for (int col = src_left; col < src_left + width; col++) {
493         if (src_scan[col / 8] & (1 << (7 - col % 8))) {
494           *dest_scan = 1;
495         }
496         dest_scan++;
497       }
498     }
499   } else {
500     for (int row = 0; row < height; row++) {
501       uint8_t* dest_scan = dest_buf + row * dest_pitch;
502       const uint8_t* src_scan =
503           pSrcBitmap->GetScanline(src_top + row) + src_left;
504       FXSYS_memcpy(dest_scan, src_scan, width);
505     }
506   }
507 }
508 FX_BOOL _ConvertBuffer_Plt2PltRgb8(uint8_t* dest_buf,
509                                    int dest_pitch,
510                                    int width,
511                                    int height,
512                                    const CFX_DIBSource* pSrcBitmap,
513                                    int src_left,
514                                    int src_top,
515                                    FX_DWORD* dst_plt,
516                                    void* pIccTransform) {
517   _ConvertBuffer_IndexCopy(dest_buf, dest_pitch, width, height, pSrcBitmap,
518                            src_left, src_top);
519   FX_DWORD* src_plt = pSrcBitmap->GetPalette();
520   int plt_size = pSrcBitmap->GetPaletteSize();
521   if (pIccTransform) {
522     FX_DWORD plt[256];
523     uint8_t* bgr_ptr = (uint8_t*)plt;
524     if (pSrcBitmap->IsCmykImage()) {
525       for (int i = 0; i < plt_size; i++) {
526         plt[i] = FXCMYK_TODIB(src_plt[i]);
527       }
528     } else {
529       for (int i = 0; i < plt_size; i++) {
530         *bgr_ptr++ = FXARGB_B(src_plt[i]);
531         *bgr_ptr++ = FXARGB_G(src_plt[i]);
532         *bgr_ptr++ = FXARGB_R(src_plt[i]);
533       }
534       bgr_ptr = (uint8_t*)plt;
535     }
536     ICodec_IccModule* pIccModule =
537         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
538     pIccModule->TranslateScanline(pIccTransform, (uint8_t*)plt,
539                                   (const uint8_t*)plt, plt_size);
540     for (int i = 0; i < plt_size; i++) {
541       dst_plt[i] = FXARGB_MAKE(0xff, bgr_ptr[2], bgr_ptr[1], bgr_ptr[0]);
542       bgr_ptr += 3;
543     }
544   } else {
545     if (pSrcBitmap->IsCmykImage()) {
546       for (int i = 0; i < plt_size; i++) {
547         uint8_t r, g, b;
548         AdobeCMYK_to_sRGB1(
549             FXSYS_GetCValue(src_plt[i]), FXSYS_GetMValue(src_plt[i]),
550             FXSYS_GetYValue(src_plt[i]), FXSYS_GetKValue(src_plt[i]), r, g, b);
551         dst_plt[i] = FXARGB_MAKE(0xff, r, g, b);
552       }
553     } else {
554       FXSYS_memcpy(dst_plt, src_plt, plt_size * 4);
555     }
556   }
557   return TRUE;
558 }
559 inline FX_BOOL _ConvertBuffer_Rgb2PltRgb8_NoTransform(
560     uint8_t* dest_buf,
561     int dest_pitch,
562     int width,
563     int height,
564     const CFX_DIBSource* pSrcBitmap,
565     int src_left,
566     int src_top,
567     FX_DWORD* dst_plt) {
568   int bpp = pSrcBitmap->GetBPP() / 8;
569   int row, col;
570   CFX_Palette palette;
571   palette.BuildPalette(pSrcBitmap, FXDIB_PALETTE_LOC);
572   FX_DWORD* cLut = palette.GetColorLut();
573   FX_DWORD* aLut = palette.GetAmountLut();
574   if (cLut == NULL || aLut == NULL) {
575     return FALSE;
576   }
577   int lut = palette.Getlut();
578   FX_DWORD* pPalette = palette.GetPalette();
579   if (lut > 256) {
580     int err, min_err;
581     int lut_256 = lut - 256;
582     for (row = 0; row < lut_256; row++) {
583       min_err = 1000000;
584       uint8_t r, g, b;
585       _ColorDecode(cLut[row], r, g, b);
586       int clrindex = 0;
587       for (int col = 0; col < 256; col++) {
588         FX_DWORD p_color = *(pPalette + col);
589         int d_r = r - (uint8_t)(p_color >> 16);
590         int d_g = g - (uint8_t)(p_color >> 8);
591         int d_b = b - (uint8_t)(p_color);
592         err = d_r * d_r + d_g * d_g + d_b * d_b;
593         if (err < min_err) {
594           min_err = err;
595           clrindex = col;
596         }
597       }
598       aLut[row] = clrindex;
599     }
600   }
601   int32_t lut_1 = lut - 1;
602   for (row = 0; row < height; row++) {
603     uint8_t* src_scan =
604         (uint8_t*)pSrcBitmap->GetScanline(src_top + row) + src_left;
605     uint8_t* dest_scan = dest_buf + row * dest_pitch;
606     for (col = 0; col < width; col++) {
607       uint8_t* src_port = src_scan + col * bpp;
608       int r = src_port[2] & 0xf0;
609       int g = src_port[1] & 0xf0;
610       int b = src_port[0] & 0xf0;
611       FX_DWORD clrindex = (r << 4) + g + (b >> 4);
612       for (int i = lut_1; i >= 0; i--)
613         if (clrindex == cLut[i]) {
614           *(dest_scan + col) = (uint8_t)(aLut[i]);
615           break;
616         }
617     }
618   }
619   FXSYS_memcpy(dst_plt, pPalette, sizeof(FX_DWORD) * 256);
620   return TRUE;
621 }
622 FX_BOOL _ConvertBuffer_Rgb2PltRgb8(uint8_t* dest_buf,
623                                    int dest_pitch,
624                                    int width,
625                                    int height,
626                                    const CFX_DIBSource* pSrcBitmap,
627                                    int src_left,
628                                    int src_top,
629                                    FX_DWORD* dst_plt,
630                                    void* pIccTransform) {
631   FX_BOOL ret = _ConvertBuffer_Rgb2PltRgb8_NoTransform(
632       dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top,
633       dst_plt);
634   if (ret && pIccTransform) {
635     ICodec_IccModule* pIccModule =
636         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
637     for (int i = 0; i < 256; i++) {
638       FX_ARGB* plt = dst_plt + i;
639       FX_ARGB plt_entry = FXARGB_TODIB(*plt);
640       pIccModule->TranslateScanline(pIccTransform, (uint8_t*)&plt_entry,
641                                     (const uint8_t*)&plt_entry, 1);
642       *plt = FXARGB_TODIB(plt_entry);
643     }
644   }
645   return ret;
646 }
647 FX_BOOL _ConvertBuffer_1bppMask2Rgb(FXDIB_Format dst_format,
648                                     uint8_t* dest_buf,
649                                     int dest_pitch,
650                                     int width,
651                                     int height,
652                                     const CFX_DIBSource* pSrcBitmap,
653                                     int src_left,
654                                     int src_top) {
655   int comps = (dst_format & 0xff) / 8;
656   uint8_t set_gray, reset_gray;
657   set_gray = 0xff;
658   reset_gray = 0x00;
659   for (int row = 0; row < height; row++) {
660     uint8_t* dest_scan = dest_buf + row * dest_pitch;
661     const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row);
662     for (int col = src_left; col < src_left + width; col++) {
663       if (src_scan[col / 8] & (1 << (7 - col % 8))) {
664         dest_scan[0] = set_gray;
665         dest_scan[1] = set_gray;
666         dest_scan[2] = set_gray;
667       } else {
668         dest_scan[0] = reset_gray;
669         dest_scan[1] = reset_gray;
670         dest_scan[2] = reset_gray;
671       }
672       dest_scan += comps;
673     }
674   }
675   return TRUE;
676 }
677 FX_BOOL _ConvertBuffer_8bppMask2Rgb(FXDIB_Format dst_format,
678                                     uint8_t* dest_buf,
679                                     int dest_pitch,
680                                     int width,
681                                     int height,
682                                     const CFX_DIBSource* pSrcBitmap,
683                                     int src_left,
684                                     int src_top) {
685   int comps = (dst_format & 0xff) / 8;
686   for (int row = 0; row < height; row++) {
687     uint8_t* dest_scan = dest_buf + row * dest_pitch;
688     const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left;
689     uint8_t src_pixel;
690     for (int col = 0; col < width; col++) {
691       src_pixel = *src_scan++;
692       *dest_scan++ = src_pixel;
693       *dest_scan++ = src_pixel;
694       *dest_scan = src_pixel;
695       dest_scan += comps - 2;
696     }
697   }
698   return TRUE;
699 }
700 FX_BOOL _ConvertBuffer_1bppPlt2Rgb(FXDIB_Format dst_format,
701                                    uint8_t* dest_buf,
702                                    int dest_pitch,
703                                    int width,
704                                    int height,
705                                    const CFX_DIBSource* pSrcBitmap,
706                                    int src_left,
707                                    int src_top,
708                                    void* pIccTransform) {
709   int comps = (dst_format & 0xff) / 8;
710   FX_DWORD* src_plt = pSrcBitmap->GetPalette();
711   FX_DWORD plt[2];
712   uint8_t* bgr_ptr = (uint8_t*)plt;
713   if (pSrcBitmap->IsCmykImage()) {
714     plt[0] = FXCMYK_TODIB(src_plt[0]);
715     plt[1] = FXCMYK_TODIB(src_plt[1]);
716   } else {
717     bgr_ptr[0] = FXARGB_B(src_plt[0]);
718     bgr_ptr[1] = FXARGB_G(src_plt[0]);
719     bgr_ptr[2] = FXARGB_R(src_plt[0]);
720     bgr_ptr[3] = FXARGB_B(src_plt[1]);
721     bgr_ptr[4] = FXARGB_G(src_plt[1]);
722     bgr_ptr[5] = FXARGB_R(src_plt[1]);
723   }
724   if (pIccTransform) {
725     ICodec_IccModule* pIccModule =
726         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
727     pIccModule->TranslateScanline(pIccTransform, (uint8_t*)plt,
728                                   (const uint8_t*)plt, 2);
729   } else {
730     if (pSrcBitmap->IsCmykImage()) {
731       AdobeCMYK_to_sRGB1(
732           FXSYS_GetCValue(src_plt[0]), FXSYS_GetMValue(src_plt[0]),
733           FXSYS_GetYValue(src_plt[0]), FXSYS_GetKValue(src_plt[0]), bgr_ptr[2],
734           bgr_ptr[1], bgr_ptr[0]);
735       AdobeCMYK_to_sRGB1(
736           FXSYS_GetCValue(src_plt[1]), FXSYS_GetMValue(src_plt[1]),
737           FXSYS_GetYValue(src_plt[1]), FXSYS_GetKValue(src_plt[1]), bgr_ptr[5],
738           bgr_ptr[4], bgr_ptr[3]);
739     }
740   }
741   for (int row = 0; row < height; row++) {
742     uint8_t* dest_scan = dest_buf + row * dest_pitch;
743     const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row);
744     for (int col = src_left; col < src_left + width; col++) {
745       if (src_scan[col / 8] & (1 << (7 - col % 8))) {
746         *dest_scan++ = bgr_ptr[3];
747         *dest_scan++ = bgr_ptr[4];
748         *dest_scan = bgr_ptr[5];
749       } else {
750         *dest_scan++ = bgr_ptr[0];
751         *dest_scan++ = bgr_ptr[1];
752         *dest_scan = bgr_ptr[2];
753       }
754       dest_scan += comps - 2;
755     }
756   }
757   return TRUE;
758 }
759 FX_BOOL _ConvertBuffer_8bppPlt2Rgb(FXDIB_Format dst_format,
760                                    uint8_t* dest_buf,
761                                    int dest_pitch,
762                                    int width,
763                                    int height,
764                                    const CFX_DIBSource* pSrcBitmap,
765                                    int src_left,
766                                    int src_top,
767                                    void* pIccTransform) {
768   int comps = (dst_format & 0xff) / 8;
769   FX_DWORD* src_plt = pSrcBitmap->GetPalette();
770   FX_DWORD plt[256];
771   uint8_t* bgr_ptr = (uint8_t*)plt;
772   if (!pSrcBitmap->IsCmykImage()) {
773     for (int i = 0; i < 256; i++) {
774       *bgr_ptr++ = FXARGB_B(src_plt[i]);
775       *bgr_ptr++ = FXARGB_G(src_plt[i]);
776       *bgr_ptr++ = FXARGB_R(src_plt[i]);
777     }
778     bgr_ptr = (uint8_t*)plt;
779   }
780   if (pIccTransform) {
781     if (pSrcBitmap->IsCmykImage()) {
782       for (int i = 0; i < 256; i++) {
783         plt[i] = FXCMYK_TODIB(src_plt[i]);
784       }
785     }
786     ICodec_IccModule* pIccModule =
787         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
788     pIccModule->TranslateScanline(pIccTransform, (uint8_t*)plt,
789                                   (const uint8_t*)plt, 256);
790   } else {
791     if (pSrcBitmap->IsCmykImage()) {
792       for (int i = 0; i < 256; i++) {
793         AdobeCMYK_to_sRGB1(
794             FXSYS_GetCValue(src_plt[i]), FXSYS_GetMValue(src_plt[i]),
795             FXSYS_GetYValue(src_plt[i]), FXSYS_GetKValue(src_plt[i]),
796             bgr_ptr[2], bgr_ptr[1], bgr_ptr[0]);
797         bgr_ptr += 3;
798       }
799       bgr_ptr = (uint8_t*)plt;
800     }
801   }
802   for (int row = 0; row < height; row++) {
803     uint8_t* dest_scan = dest_buf + row * dest_pitch;
804     const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left;
805     for (int col = 0; col < width; col++) {
806       uint8_t* src_pixel = bgr_ptr + 3 * (*src_scan++);
807       *dest_scan++ = *src_pixel++;
808       *dest_scan++ = *src_pixel++;
809       *dest_scan = *src_pixel++;
810       dest_scan += comps - 2;
811     }
812   }
813   return TRUE;
814 }
815 FX_BOOL _ConvertBuffer_24bppRgb2Rgb24(uint8_t* dest_buf,
816                                       int dest_pitch,
817                                       int width,
818                                       int height,
819                                       const CFX_DIBSource* pSrcBitmap,
820                                       int src_left,
821                                       int src_top,
822                                       void* pIccTransform) {
823   if (pIccTransform) {
824     ICodec_IccModule* pIccModule =
825         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
826     for (int row = 0; row < height; row++) {
827       uint8_t* dest_scan = dest_buf + row * dest_pitch;
828       const uint8_t* src_scan =
829           pSrcBitmap->GetScanline(src_top + row) + src_left * 3;
830       pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan, width);
831     }
832   } else {
833     for (int row = 0; row < height; row++) {
834       uint8_t* dest_scan = dest_buf + row * dest_pitch;
835       const uint8_t* src_scan =
836           pSrcBitmap->GetScanline(src_top + row) + src_left * 3;
837       FXSYS_memcpy(dest_scan, src_scan, width * 3);
838     }
839   }
840   return TRUE;
841 }
842 FX_BOOL _ConvertBuffer_32bppRgb2Rgb24(uint8_t* dest_buf,
843                                       int dest_pitch,
844                                       int width,
845                                       int height,
846                                       const CFX_DIBSource* pSrcBitmap,
847                                       int src_left,
848                                       int src_top,
849                                       void* pIccTransform) {
850   for (int row = 0; row < height; row++) {
851     uint8_t* dest_scan = dest_buf + row * dest_pitch;
852     const uint8_t* src_scan =
853         pSrcBitmap->GetScanline(src_top + row) + src_left * 4;
854     for (int col = 0; col < width; col++) {
855       *dest_scan++ = *src_scan++;
856       *dest_scan++ = *src_scan++;
857       *dest_scan++ = *src_scan++;
858       src_scan++;
859     }
860   }
861   if (pIccTransform) {
862     ICodec_IccModule* pIccModule =
863         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
864     for (int row = 0; row < height; row++) {
865       uint8_t* dest_scan = dest_buf + row * dest_pitch;
866       pIccModule->TranslateScanline(pIccTransform, dest_scan, dest_scan, width);
867     }
868   }
869   return TRUE;
870 }
871 FX_BOOL _ConvertBuffer_Rgb2Rgb32(uint8_t* dest_buf,
872                                  int dest_pitch,
873                                  int width,
874                                  int height,
875                                  const CFX_DIBSource* pSrcBitmap,
876                                  int src_left,
877                                  int src_top,
878                                  void* pIccTransform) {
879   int comps = pSrcBitmap->GetBPP() / 8;
880   if (pIccTransform) {
881     ICodec_IccModule* pIccModule =
882         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
883     for (int row = 0; row < height; row++) {
884       uint8_t* dest_scan = dest_buf + row * dest_pitch;
885       const uint8_t* src_scan =
886           pSrcBitmap->GetScanline(src_top + row) + src_left * comps;
887       for (int col = 0; col < width; col++) {
888         pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan, 1);
889         dest_scan += 4;
890         src_scan += comps;
891       }
892     }
893   } else {
894     for (int row = 0; row < height; row++) {
895       uint8_t* dest_scan = dest_buf + row * dest_pitch;
896       const uint8_t* src_scan =
897           pSrcBitmap->GetScanline(src_top + row) + src_left * comps;
898       for (int col = 0; col < width; col++) {
899         *dest_scan++ = *src_scan++;
900         *dest_scan++ = *src_scan++;
901         *dest_scan++ = *src_scan++;
902         dest_scan++;
903         src_scan += comps - 3;
904       }
905     }
906   }
907   return TRUE;
908 }
909 FX_BOOL _ConvertBuffer_32bppCmyk2Rgb32(uint8_t* dest_buf,
910                                        int dest_pitch,
911                                        int width,
912                                        int height,
913                                        const CFX_DIBSource* pSrcBitmap,
914                                        int src_left,
915                                        int src_top,
916                                        void* pIccTransform) {
917   if (pIccTransform) {
918     ICodec_IccModule* pIccModule =
919         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
920     for (int row = 0; row < height; row++) {
921       uint8_t* dest_scan = dest_buf + row * dest_pitch;
922       const uint8_t* src_scan =
923           pSrcBitmap->GetScanline(src_top + row) + src_left * 4;
924       for (int col = 0; col < width; col++) {
925         pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan, 1);
926         dest_scan += 4;
927         src_scan += 4;
928       }
929     }
930   } else {
931     for (int row = 0; row < height; row++) {
932       uint8_t* dest_scan = dest_buf + row * dest_pitch;
933       const uint8_t* src_scan =
934           pSrcBitmap->GetScanline(src_top + row) + src_left * 4;
935       for (int col = 0; col < width; col++) {
936         AdobeCMYK_to_sRGB1(src_scan[0], src_scan[1], src_scan[2], src_scan[3],
937                            dest_scan[2], dest_scan[1], dest_scan[0]);
938         dest_scan += 4;
939         src_scan += 4;
940       }
941     }
942   }
943   return TRUE;
944 }
945 FX_BOOL ConvertBuffer(FXDIB_Format dest_format,
946                       uint8_t* dest_buf,
947                       int dest_pitch,
948                       int width,
949                       int height,
950                       const CFX_DIBSource* pSrcBitmap,
951                       int src_left,
952                       int src_top,
953                       FX_DWORD*& d_pal,
954                       void* pIccTransform) {
955   FXDIB_Format src_format = pSrcBitmap->GetFormat();
956   if (!CFX_GEModule::Get()->GetCodecModule() ||
957       !CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
958     pIccTransform = NULL;
959   }
960   switch (dest_format) {
961     case FXDIB_Invalid:
962     case FXDIB_1bppCmyk:
963     case FXDIB_1bppMask:
964     case FXDIB_1bppRgb:
965       ASSERT(FALSE);
966       return FALSE;
967     case FXDIB_8bppMask: {
968       if ((src_format & 0xff) == 1) {
969         if (pSrcBitmap->GetPalette()) {
970           return _ConvertBuffer_1bppPlt2Gray(dest_buf, dest_pitch, width,
971                                              height, pSrcBitmap, src_left,
972                                              src_top, pIccTransform);
973         }
974         return _ConvertBuffer_1bppMask2Gray(dest_buf, dest_pitch, width, height,
975                                             pSrcBitmap, src_left, src_top);
976       }
977       if ((src_format & 0xff) == 8) {
978         if (pSrcBitmap->GetPalette()) {
979           return _ConvertBuffer_8bppPlt2Gray(dest_buf, dest_pitch, width,
980                                              height, pSrcBitmap, src_left,
981                                              src_top, pIccTransform);
982         }
983         return _ConvertBuffer_8bppMask2Gray(dest_buf, dest_pitch, width, height,
984                                             pSrcBitmap, src_left, src_top);
985       }
986       if ((src_format & 0xff) >= 24) {
987         return _ConvertBuffer_RgbOrCmyk2Gray(dest_buf, dest_pitch, width,
988                                              height, pSrcBitmap, src_left,
989                                              src_top, pIccTransform);
990       }
991       return FALSE;
992     }
993     case FXDIB_8bppRgb:
994     case FXDIB_8bppRgba: {
995       if ((src_format & 0xff) == 8 && pSrcBitmap->GetPalette() == NULL) {
996         return ConvertBuffer(FXDIB_8bppMask, dest_buf, dest_pitch, width,
997                              height, pSrcBitmap, src_left, src_top, d_pal,
998                              pIccTransform);
999       }
1000       d_pal = FX_Alloc(FX_DWORD, 256);
1001       if (((src_format & 0xff) == 1 || (src_format & 0xff) == 8) &&
1002           pSrcBitmap->GetPalette()) {
1003         return _ConvertBuffer_Plt2PltRgb8(dest_buf, dest_pitch, width, height,
1004                                           pSrcBitmap, src_left, src_top, d_pal,
1005                                           pIccTransform);
1006       }
1007       if ((src_format & 0xff) >= 24) {
1008         return _ConvertBuffer_Rgb2PltRgb8(dest_buf, dest_pitch, width, height,
1009                                           pSrcBitmap, src_left, src_top, d_pal,
1010                                           pIccTransform);
1011       }
1012       return FALSE;
1013     }
1014     case FXDIB_Rgb:
1015     case FXDIB_Rgba: {
1016       if ((src_format & 0xff) == 1) {
1017         if (pSrcBitmap->GetPalette()) {
1018           return _ConvertBuffer_1bppPlt2Rgb(dest_format, dest_buf, dest_pitch,
1019                                             width, height, pSrcBitmap, src_left,
1020                                             src_top, pIccTransform);
1021         }
1022         return _ConvertBuffer_1bppMask2Rgb(dest_format, dest_buf, dest_pitch,
1023                                            width, height, pSrcBitmap, src_left,
1024                                            src_top);
1025       }
1026       if ((src_format & 0xff) == 8) {
1027         if (pSrcBitmap->GetPalette()) {
1028           return _ConvertBuffer_8bppPlt2Rgb(dest_format, dest_buf, dest_pitch,
1029                                             width, height, pSrcBitmap, src_left,
1030                                             src_top, pIccTransform);
1031         }
1032         return _ConvertBuffer_8bppMask2Rgb(dest_format, dest_buf, dest_pitch,
1033                                            width, height, pSrcBitmap, src_left,
1034                                            src_top);
1035       }
1036       if ((src_format & 0xff) == 24) {
1037         return _ConvertBuffer_24bppRgb2Rgb24(dest_buf, dest_pitch, width,
1038                                              height, pSrcBitmap, src_left,
1039                                              src_top, pIccTransform);
1040       }
1041       if ((src_format & 0xff) == 32) {
1042         return _ConvertBuffer_32bppRgb2Rgb24(dest_buf, dest_pitch, width,
1043                                              height, pSrcBitmap, src_left,
1044                                              src_top, pIccTransform);
1045       }
1046       return FALSE;
1047     }
1048     case FXDIB_Argb:
1049     case FXDIB_Rgb32: {
1050       if ((src_format & 0xff) == 1) {
1051         if (pSrcBitmap->GetPalette()) {
1052           return _ConvertBuffer_1bppPlt2Rgb(dest_format, dest_buf, dest_pitch,
1053                                             width, height, pSrcBitmap, src_left,
1054                                             src_top, pIccTransform);
1055         }
1056         return _ConvertBuffer_1bppMask2Rgb(dest_format, dest_buf, dest_pitch,
1057                                            width, height, pSrcBitmap, src_left,
1058                                            src_top);
1059       }
1060       if ((src_format & 0xff) == 8) {
1061         if (pSrcBitmap->GetPalette()) {
1062           return _ConvertBuffer_8bppPlt2Rgb(dest_format, dest_buf, dest_pitch,
1063                                             width, height, pSrcBitmap, src_left,
1064                                             src_top, pIccTransform);
1065         }
1066         return _ConvertBuffer_8bppMask2Rgb(dest_format, dest_buf, dest_pitch,
1067                                            width, height, pSrcBitmap, src_left,
1068                                            src_top);
1069       }
1070       if ((src_format & 0xff) >= 24) {
1071         if (src_format & 0x0400) {
1072           return _ConvertBuffer_32bppCmyk2Rgb32(dest_buf, dest_pitch, width,
1073                                                 height, pSrcBitmap, src_left,
1074                                                 src_top, pIccTransform);
1075         }
1076         return _ConvertBuffer_Rgb2Rgb32(dest_buf, dest_pitch, width, height,
1077                                         pSrcBitmap, src_left, src_top,
1078                                         pIccTransform);
1079       }
1080       return FALSE;
1081     }
1082     default:
1083       return FALSE;
1084   }
1085   return FALSE;
1086 }
1087 CFX_DIBitmap* CFX_DIBSource::CloneConvert(FXDIB_Format dest_format,
1088                                           const FX_RECT* pClip,
1089                                           void* pIccTransform) const {
1090   if (dest_format == GetFormat() && pIccTransform == NULL) {
1091     return Clone(pClip);
1092   }
1093   if (pClip) {
1094     CFX_DIBitmap* pClone = Clone(pClip);
1095     if (pClone == NULL) {
1096       return NULL;
1097     }
1098     if (!pClone->ConvertFormat(dest_format, pIccTransform)) {
1099       delete pClone;
1100       return NULL;
1101     }
1102     return pClone;
1103   }
1104   CFX_DIBitmap* pClone = new CFX_DIBitmap;
1105   if (!pClone->Create(m_Width, m_Height, dest_format)) {
1106     delete pClone;
1107     return NULL;
1108   }
1109   FX_BOOL ret = TRUE;
1110   CFX_DIBitmap* pSrcAlpha = NULL;
1111   if (m_AlphaFlag & 2) {
1112     pSrcAlpha = (GetFormat() == FXDIB_Argb) ? GetAlphaMask() : m_pAlphaMask;
1113     if (pSrcAlpha == NULL) {
1114       delete pClone;
1115       return NULL;
1116     }
1117   }
1118   if (dest_format & 0x0200) {
1119     if (dest_format == FXDIB_Argb)
1120       ret = pSrcAlpha ? pClone->LoadChannel(FXDIB_Alpha, pSrcAlpha, FXDIB_Alpha)
1121                       : pClone->LoadChannel(FXDIB_Alpha, 0xff);
1122     else {
1123       ret = pClone->CopyAlphaMask(pSrcAlpha);
1124     }
1125   }
1126   if (pSrcAlpha && pSrcAlpha != m_pAlphaMask) {
1127     delete pSrcAlpha;
1128     pSrcAlpha = NULL;
1129   }
1130   if (!ret) {
1131     delete pClone;
1132     return NULL;
1133   }
1134   FX_DWORD* pal_8bpp = NULL;
1135   ret = ConvertBuffer(dest_format, pClone->GetBuffer(), pClone->GetPitch(),
1136                       m_Width, m_Height, this, 0, 0, pal_8bpp, pIccTransform);
1137   if (!ret) {
1138     if (pal_8bpp) {
1139       FX_Free(pal_8bpp);
1140     }
1141     delete pClone;
1142     return NULL;
1143   }
1144   if (pal_8bpp) {
1145     pClone->CopyPalette(pal_8bpp);
1146     FX_Free(pal_8bpp);
1147     pal_8bpp = NULL;
1148   }
1149   return pClone;
1150 }
1151 FX_BOOL CFX_DIBitmap::ConvertFormat(FXDIB_Format dest_format,
1152                                     void* pIccTransform) {
1153   FXDIB_Format src_format = GetFormat();
1154   if (dest_format == src_format && pIccTransform == NULL) {
1155     return TRUE;
1156   }
1157   if (dest_format == FXDIB_8bppMask && src_format == FXDIB_8bppRgb &&
1158       m_pPalette == NULL) {
1159     m_AlphaFlag = 1;
1160     return TRUE;
1161   }
1162   if (dest_format == FXDIB_Argb && src_format == FXDIB_Rgb32 &&
1163       pIccTransform == NULL) {
1164     m_AlphaFlag = 2;
1165     for (int row = 0; row < m_Height; row++) {
1166       uint8_t* scanline = m_pBuffer + row * m_Pitch + 3;
1167       for (int col = 0; col < m_Width; col++) {
1168         *scanline = 0xff;
1169         scanline += 4;
1170       }
1171     }
1172     return TRUE;
1173   }
1174   int dest_bpp = dest_format & 0xff;
1175   int dest_pitch = (dest_bpp * m_Width + 31) / 32 * 4;
1176   uint8_t* dest_buf = FX_TryAlloc(uint8_t, dest_pitch * m_Height + 4);
1177   if (dest_buf == NULL) {
1178     return FALSE;
1179   }
1180   CFX_DIBitmap* pAlphaMask = NULL;
1181   if (dest_format == FXDIB_Argb) {
1182     FXSYS_memset(dest_buf, 0xff, dest_pitch * m_Height + 4);
1183     if (m_pAlphaMask) {
1184       for (int row = 0; row < m_Height; row++) {
1185         uint8_t* pDstScanline = dest_buf + row * dest_pitch + 3;
1186         const uint8_t* pSrcScanline = m_pAlphaMask->GetScanline(row);
1187         for (int col = 0; col < m_Width; col++) {
1188           *pDstScanline = *pSrcScanline++;
1189           pDstScanline += 4;
1190         }
1191       }
1192     }
1193   } else if (dest_format & 0x0200) {
1194     if (src_format == FXDIB_Argb) {
1195       pAlphaMask = GetAlphaMask();
1196       if (pAlphaMask == NULL) {
1197         FX_Free(dest_buf);
1198         return FALSE;
1199       }
1200     } else {
1201       if (m_pAlphaMask == NULL) {
1202         if (!BuildAlphaMask()) {
1203           FX_Free(dest_buf);
1204           return FALSE;
1205         }
1206         pAlphaMask = m_pAlphaMask;
1207         m_pAlphaMask = NULL;
1208       } else {
1209         pAlphaMask = m_pAlphaMask;
1210       }
1211     }
1212   }
1213   FX_BOOL ret = FALSE;
1214   FX_DWORD* pal_8bpp = NULL;
1215   ret = ConvertBuffer(dest_format, dest_buf, dest_pitch, m_Width, m_Height,
1216                       this, 0, 0, pal_8bpp, pIccTransform);
1217   if (!ret) {
1218     if (pal_8bpp) {
1219       FX_Free(pal_8bpp);
1220     }
1221     if (pAlphaMask != m_pAlphaMask) {
1222       delete pAlphaMask;
1223     }
1224     if (dest_buf) {
1225       FX_Free(dest_buf);
1226     }
1227     return FALSE;
1228   }
1229   if (m_pAlphaMask && pAlphaMask != m_pAlphaMask) {
1230     delete m_pAlphaMask;
1231   }
1232   m_pAlphaMask = pAlphaMask;
1233   if (m_pPalette) {
1234     FX_Free(m_pPalette);
1235   }
1236   m_pPalette = pal_8bpp;
1237   if (!m_bExtBuf) {
1238     FX_Free(m_pBuffer);
1239   }
1240   m_bExtBuf = FALSE;
1241   m_pBuffer = dest_buf;
1242   m_bpp = (uint8_t)dest_format;
1243   m_AlphaFlag = (uint8_t)(dest_format >> 8);
1244   m_Pitch = dest_pitch;
1245   return TRUE;
1246 }