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