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