1 // Copyright 2014 PDFium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
6
7 #include "../../../include/fxge/fx_dib.h"
8 #include "../../../include/fxge/fx_ge.h"
9 #include "../../../include/fxcodec/fx_codec.h"
10 #include "dib_int.h"
11 #include <limits.h>
12 FX_BOOL ConvertBuffer(FXDIB_Format dest_format, FX_LPBYTE dest_buf, int dest_pitch, int width, int height,
13 const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, FX_DWORD*& pal, void* pIccTransform);
CmykDecode(FX_DWORD cmyk,int & c,int & m,int & y,int & k)14 void CmykDecode(FX_DWORD cmyk, int& c, int& m, int& y, int& k)
15 {
16 c = FXSYS_GetCValue(cmyk);
17 m = FXSYS_GetMValue(cmyk);
18 y = FXSYS_GetYValue(cmyk);
19 k = FXSYS_GetKValue(cmyk);
20 }
ArgbDecode(FX_DWORD argb,int & a,int & r,int & g,int & b)21 void ArgbDecode(FX_DWORD argb, int& a, int& r, int& g, int& b)
22 {
23 a = FXARGB_A(argb);
24 r = FXARGB_R(argb);
25 g = FXARGB_G(argb);
26 b = FXARGB_B(argb);
27 }
ArgbDecode(FX_DWORD argb,int & a,FX_COLORREF & rgb)28 void ArgbDecode(FX_DWORD argb, int& a, FX_COLORREF& rgb)
29 {
30 a = FXARGB_A(argb);
31 rgb = FXSYS_RGB(FXARGB_R(argb), FXARGB_G(argb), FXARGB_B(argb));
32 }
ArgbEncode(int a,FX_COLORREF rgb)33 FX_DWORD ArgbEncode(int a, FX_COLORREF rgb)
34 {
35 return FXARGB_MAKE(a, FXSYS_GetRValue(rgb), FXSYS_GetGValue(rgb), FXSYS_GetBValue(rgb));
36 }
CFX_DIBSource()37 CFX_DIBSource::CFX_DIBSource()
38 {
39 m_bpp = 0;
40 m_AlphaFlag = 0;
41 m_Width = m_Height = 0;
42 m_Pitch = 0;
43 m_pPalette = NULL;
44 m_pAlphaMask = NULL;
45 }
~CFX_DIBSource()46 CFX_DIBSource::~CFX_DIBSource()
47 {
48 if (m_pPalette) {
49 FX_Free(m_pPalette);
50 }
51 if (m_pAlphaMask) {
52 delete m_pAlphaMask;
53 }
54 }
CFX_DIBitmap()55 CFX_DIBitmap::CFX_DIBitmap()
56 {
57 m_bExtBuf = FALSE;
58 m_pBuffer = NULL;
59 m_pPalette = NULL;
60 }
61 #define _MAX_OOM_LIMIT_ 12000000
Create(int width,int height,FXDIB_Format format,FX_LPBYTE pBuffer,int pitch)62 FX_BOOL CFX_DIBitmap::Create(int width, int height, FXDIB_Format format, FX_LPBYTE pBuffer, int pitch)
63 {
64 m_pBuffer = NULL;
65 m_bpp = (FX_BYTE)format;
66 m_AlphaFlag = (FX_BYTE)(format >> 8);
67 m_Width = m_Height = m_Pitch = 0;
68 if (width <= 0 || height <= 0 || pitch < 0) {
69 return FALSE;
70 }
71 if ((INT_MAX - 31) / width < (format & 0xff)) {
72 return FALSE;
73 }
74 if (!pitch) {
75 pitch = (width * (format & 0xff) + 31) / 32 * 4;
76 }
77 if ((1 << 30) / pitch < height) {
78 return FALSE;
79 }
80 if (pBuffer) {
81 m_pBuffer = pBuffer;
82 m_bExtBuf = TRUE;
83 } else {
84 int size = pitch * height + 4;
85 int oomlimit = _MAX_OOM_LIMIT_;
86 if (oomlimit >= 0 && size >= oomlimit) {
87 m_pBuffer = FX_TryAlloc(FX_BYTE, size);
88 if (m_pBuffer == NULL) {
89 return FALSE;
90 }
91 } else {
92 m_pBuffer = FX_Alloc(FX_BYTE, size);
93 }
94 }
95 m_Width = width;
96 m_Height = height;
97 m_Pitch = pitch;
98 if (HasAlpha() && format != FXDIB_Argb) {
99 FX_BOOL ret = TRUE;
100 ret = BuildAlphaMask();
101 if (!ret) {
102 if (!m_bExtBuf && m_pBuffer) {
103 FX_Free(m_pBuffer);
104 m_pBuffer = NULL;
105 m_Width = m_Height = m_Pitch = 0;
106 return FALSE;
107 }
108 }
109 }
110 return TRUE;
111 }
Copy(const CFX_DIBSource * pSrc)112 FX_BOOL CFX_DIBitmap::Copy(const CFX_DIBSource* pSrc)
113 {
114 if (m_pBuffer) {
115 return FALSE;
116 }
117 if (!Create(pSrc->GetWidth(), pSrc->GetHeight(), pSrc->GetFormat())) {
118 return FALSE;
119 }
120 CopyPalette(pSrc->GetPalette());
121 CopyAlphaMask(pSrc->m_pAlphaMask);
122 for (int row = 0; row < pSrc->GetHeight(); row ++) {
123 FXSYS_memcpy32(m_pBuffer + row * m_Pitch, pSrc->GetScanline(row), m_Pitch);
124 }
125 return TRUE;
126 }
~CFX_DIBitmap()127 CFX_DIBitmap::~CFX_DIBitmap()
128 {
129 if (m_pBuffer && !m_bExtBuf) {
130 FX_Free(m_pBuffer);
131 }
132 m_pBuffer = NULL;
133 }
TakeOver(CFX_DIBitmap * pSrcBitmap)134 void CFX_DIBitmap::TakeOver(CFX_DIBitmap* pSrcBitmap)
135 {
136 if (m_pBuffer && !m_bExtBuf) {
137 FX_Free(m_pBuffer);
138 }
139 if (m_pPalette) {
140 FX_Free(m_pPalette);
141 }
142 if (m_pAlphaMask) {
143 delete m_pAlphaMask;
144 }
145 m_pBuffer = pSrcBitmap->m_pBuffer;
146 m_pPalette = pSrcBitmap->m_pPalette;
147 m_pAlphaMask = pSrcBitmap->m_pAlphaMask;
148 pSrcBitmap->m_pBuffer = NULL;
149 pSrcBitmap->m_pPalette = NULL;
150 pSrcBitmap->m_pAlphaMask = NULL;
151 m_bpp = pSrcBitmap->m_bpp;
152 m_bExtBuf = pSrcBitmap->m_bExtBuf;
153 m_AlphaFlag = pSrcBitmap->m_AlphaFlag;
154 m_Width = pSrcBitmap->m_Width;
155 m_Height = pSrcBitmap->m_Height;
156 m_Pitch = pSrcBitmap->m_Pitch;
157 }
Clone(const FX_RECT * pClip) const158 CFX_DIBitmap* CFX_DIBSource::Clone(const FX_RECT* pClip) const
159 {
160 FX_RECT rect(0, 0, m_Width, m_Height);
161 if (pClip) {
162 rect.Intersect(*pClip);
163 if (rect.IsEmpty()) {
164 return NULL;
165 }
166 }
167 CFX_DIBitmap* pNewBitmap = new CFX_DIBitmap;
168 if (!pNewBitmap->Create(rect.Width(), rect.Height(), GetFormat())) {
169 delete pNewBitmap;
170 return NULL;
171 }
172 pNewBitmap->CopyPalette(m_pPalette);
173 pNewBitmap->CopyAlphaMask(m_pAlphaMask, pClip);
174 if (GetBPP() == 1 && rect.left % 8 != 0) {
175 int left_shift = rect.left % 32;
176 int right_shift = 32 - left_shift;
177 int dword_count = pNewBitmap->m_Pitch / 4;
178 for (int row = rect.top; row < rect.bottom; row ++) {
179 FX_DWORD* src_scan = (FX_DWORD*)GetScanline(row) + rect.left / 32;
180 FX_DWORD* dest_scan = (FX_DWORD*)pNewBitmap->GetScanline(row - rect.top);
181 for (int i = 0; i < dword_count; i ++) {
182 dest_scan[i] = (src_scan[i] << left_shift) | (src_scan[i + 1] >> right_shift);
183 }
184 }
185 } else {
186 int copy_len = (pNewBitmap->GetWidth() * pNewBitmap->GetBPP() + 7) / 8;
187 if (m_Pitch < (FX_DWORD)copy_len) {
188 copy_len = m_Pitch;
189 }
190 for (int row = rect.top; row < rect.bottom; row ++) {
191 FX_LPCBYTE src_scan = GetScanline(row) + rect.left * m_bpp / 8;
192 FX_LPBYTE dest_scan = (FX_LPBYTE)pNewBitmap->GetScanline(row - rect.top);
193 FXSYS_memcpy32(dest_scan, src_scan, copy_len);
194 }
195 }
196 return pNewBitmap;
197 }
BuildPalette()198 void CFX_DIBSource::BuildPalette()
199 {
200 if (m_pPalette) {
201 return;
202 }
203 if (GetBPP() == 1) {
204 m_pPalette = FX_Alloc(FX_DWORD, 2);
205 if(IsCmykImage()) {
206 m_pPalette[0] = 0xff;
207 m_pPalette[1] = 0;
208 } else {
209 m_pPalette[0] = 0xff000000;
210 m_pPalette[1] = 0xffffffff;
211 }
212 } else if (GetBPP() == 8) {
213 m_pPalette = FX_Alloc(FX_DWORD, 256);
214 if(IsCmykImage()) {
215 for (int i = 0; i < 256; i ++) {
216 m_pPalette[i] = 0xff - i;
217 }
218 } else {
219 for (int i = 0; i < 256; i ++) {
220 m_pPalette[i] = 0xff000000 | (i * 0x10101);
221 }
222 }
223 }
224 }
BuildAlphaMask()225 FX_BOOL CFX_DIBSource::BuildAlphaMask()
226 {
227 if (m_pAlphaMask) {
228 return TRUE;
229 }
230 m_pAlphaMask = new CFX_DIBitmap;
231 if (!m_pAlphaMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
232 delete m_pAlphaMask;
233 m_pAlphaMask = NULL;
234 return FALSE;
235 }
236 FXSYS_memset8(m_pAlphaMask->GetBuffer(), 0xff, m_pAlphaMask->GetHeight()*m_pAlphaMask->GetPitch());
237 return TRUE;
238 }
GetPaletteEntry(int index) const239 FX_DWORD CFX_DIBSource::GetPaletteEntry(int index) const
240 {
241 ASSERT((GetBPP() == 1 || GetBPP() == 8) && !IsAlphaMask());
242 if (m_pPalette) {
243 return m_pPalette[index];
244 }
245 if (IsCmykImage()) {
246 if (GetBPP() == 1) {
247 return index ? 0 : 0xff;
248 }
249 return 0xff - index;
250 }
251 if (GetBPP() == 1) {
252 return index ? 0xffffffff : 0xff000000;
253 }
254 return index * 0x10101 | 0xff000000;
255 }
SetPaletteEntry(int index,FX_DWORD color)256 void CFX_DIBSource::SetPaletteEntry(int index, FX_DWORD color)
257 {
258 ASSERT((GetBPP() == 1 || GetBPP() == 8) && !IsAlphaMask());
259 if (m_pPalette == NULL) {
260 BuildPalette();
261 }
262 m_pPalette[index] = color;
263 }
FindPalette(FX_DWORD color) const264 int CFX_DIBSource::FindPalette(FX_DWORD color) const
265 {
266 ASSERT((GetBPP() == 1 || GetBPP() == 8) && !IsAlphaMask());
267 if (m_pPalette == NULL) {
268 if (IsCmykImage()) {
269 if (GetBPP() == 1) {
270 return ((FX_BYTE)color == 0xff) ? 0 : 1;
271 }
272 return 0xff - (FX_BYTE)color;
273 }
274 if (GetBPP() == 1) {
275 return ((FX_BYTE)color == 0xff) ? 1 : 0;
276 }
277 return (FX_BYTE)color;
278 }
279 int palsize = (1 << GetBPP());
280 for (int i = 0; i < palsize; i ++)
281 if (m_pPalette[i] == color) {
282 return i;
283 }
284 return -1;
285 }
Clear(FX_DWORD color)286 void CFX_DIBitmap::Clear(FX_DWORD color)
287 {
288 if (m_pBuffer == NULL) {
289 return;
290 }
291 switch (GetFormat()) {
292 case FXDIB_1bppMask:
293 FXSYS_memset8(m_pBuffer, (color & 0xff000000) ? 0xff : 0, m_Pitch * m_Height);
294 break;
295 case FXDIB_1bppRgb: {
296 int index = FindPalette(color);
297 FXSYS_memset8(m_pBuffer, index ? 0xff : 0, m_Pitch * m_Height);
298 break;
299 }
300 case FXDIB_8bppMask:
301 FXSYS_memset8(m_pBuffer, color >> 24, m_Pitch * m_Height);
302 break;
303 case FXDIB_8bppRgb: {
304 int index = FindPalette(color);
305 FXSYS_memset8(m_pBuffer, index, m_Pitch * m_Height);
306 break;
307 }
308 case FXDIB_Rgb:
309 case FXDIB_Rgba: {
310 int a, r, g, b;
311 ArgbDecode(color, a, r, g, b);
312 if (r == g && g == b) {
313 FXSYS_memset8(m_pBuffer, r, m_Pitch * m_Height);
314 } else {
315 int byte_pos = 0;
316 for (int col = 0; col < m_Width; col ++) {
317 m_pBuffer[byte_pos++] = b;
318 m_pBuffer[byte_pos++] = g;
319 m_pBuffer[byte_pos++] = r;
320 }
321 for (int row = 1; row < m_Height; row ++) {
322 FXSYS_memcpy32(m_pBuffer + row * m_Pitch, m_pBuffer, m_Pitch);
323 }
324 }
325 break;
326 }
327 case FXDIB_Rgb32:
328 case FXDIB_Argb: {
329 color = IsCmykImage() ? FXCMYK_TODIB(color) : FXARGB_TODIB(color);
330 for (int i = 0; i < m_Width; i ++) {
331 ((FX_DWORD*)m_pBuffer)[i] = color;
332 }
333 for (int row = 1; row < m_Height; row ++) {
334 FXSYS_memcpy32(m_pBuffer + row * m_Pitch, m_pBuffer, m_Pitch);
335 }
336 break;
337 }
338 default:
339 break;
340 }
341 }
GetOverlapRect(int & dest_left,int & dest_top,int & width,int & height,int src_width,int src_height,int & src_left,int & src_top,const CFX_ClipRgn * pClipRgn)342 void CFX_DIBSource::GetOverlapRect(int& dest_left, int& dest_top, int& width, int& height,
343 int src_width, int src_height, int& src_left, int& src_top,
344 const CFX_ClipRgn* pClipRgn)
345 {
346 if (width == 0 || height == 0) {
347 return;
348 }
349 ASSERT(width > 0 && height > 0);
350 if (dest_left > m_Width || dest_top > m_Height) {
351 width = 0;
352 height = 0;
353 return;
354 }
355 int x_offset = dest_left - src_left;
356 int y_offset = dest_top - src_top;
357 FX_RECT src_rect(src_left, src_top, src_left + width, src_top + height);
358 FX_RECT src_bound(0, 0, src_width, src_height);
359 src_rect.Intersect(src_bound);
360 FX_RECT dest_rect(src_rect.left + x_offset, src_rect.top + y_offset,
361 src_rect.right + x_offset, src_rect.bottom + y_offset);
362 FX_RECT dest_bound(0, 0, m_Width, m_Height);
363 dest_rect.Intersect(dest_bound);
364 if (pClipRgn) {
365 dest_rect.Intersect(pClipRgn->GetBox());
366 }
367 dest_left = dest_rect.left;
368 dest_top = dest_rect.top;
369 src_left = dest_left - x_offset;
370 src_top = dest_top - y_offset;
371 width = dest_rect.right - dest_rect.left;
372 height = dest_rect.bottom - dest_rect.top;
373 }
TransferBitmap(int dest_left,int dest_top,int width,int height,const CFX_DIBSource * pSrcBitmap,int src_left,int src_top,void * pIccTransform)374 FX_BOOL CFX_DIBitmap::TransferBitmap(int dest_left, int dest_top, int width, int height,
375 const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, void* pIccTransform)
376 {
377 if (m_pBuffer == NULL) {
378 return FALSE;
379 }
380 GetOverlapRect(dest_left, dest_top, width, height, pSrcBitmap->GetWidth(), pSrcBitmap->GetHeight(), src_left, src_top, NULL);
381 if (width == 0 || height == 0) {
382 return TRUE;
383 }
384 FXDIB_Format dest_format = GetFormat();
385 FXDIB_Format src_format = pSrcBitmap->GetFormat();
386 if (dest_format == src_format && pIccTransform == NULL) {
387 if (GetBPP() == 1) {
388 for (int row = 0; row < height; row ++) {
389 FX_LPBYTE dest_scan = m_pBuffer + (dest_top + row) * m_Pitch;
390 FX_LPCBYTE src_scan = pSrcBitmap->GetScanline(src_top + row);
391 for (int col = 0; col < width; col ++) {
392 if (src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8))) {
393 dest_scan[(dest_left + col) / 8] |= 1 << (7 - (dest_left + col) % 8);
394 } else {
395 dest_scan[(dest_left + col) / 8] &= ~(1 << (7 - (dest_left + col) % 8));
396 }
397 }
398 }
399 } else {
400 int Bpp = GetBPP() / 8;
401 for (int row = 0; row < height; row ++) {
402 FX_LPBYTE dest_scan = m_pBuffer + (dest_top + row) * m_Pitch + dest_left * Bpp;
403 FX_LPCBYTE src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left * Bpp;
404 FXSYS_memcpy32(dest_scan, src_scan, width * Bpp);
405 }
406 }
407 } else {
408 if (m_pPalette) {
409 return FALSE;
410 }
411 if (m_bpp == 8) {
412 dest_format = FXDIB_8bppMask;
413 }
414 FX_LPBYTE dest_buf = m_pBuffer + dest_top * m_Pitch + dest_left * GetBPP() / 8;
415 FX_DWORD* d_plt = NULL;
416 if(!ConvertBuffer(dest_format, dest_buf, m_Pitch, width, height, pSrcBitmap, src_left, src_top, d_plt, pIccTransform)) {
417 return FALSE;
418 }
419 }
420 return TRUE;
421 }
TransferMask(int dest_left,int dest_top,int width,int height,const CFX_DIBSource * pMask,FX_DWORD color,int src_left,int src_top,int alpha_flag,void * pIccTransform)422 FX_BOOL CFX_DIBitmap::TransferMask(int dest_left, int dest_top, int width, int height,
423 const CFX_DIBSource* pMask, FX_DWORD color, int src_left, int src_top, int alpha_flag, void* pIccTransform)
424 {
425 if (m_pBuffer == NULL) {
426 return FALSE;
427 }
428 ASSERT(HasAlpha() && (m_bpp >= 24));
429 ASSERT(pMask->IsAlphaMask());
430 if (!HasAlpha() || !pMask->IsAlphaMask() || m_bpp < 24) {
431 return FALSE;
432 }
433 GetOverlapRect(dest_left, dest_top, width, height, pMask->GetWidth(), pMask->GetHeight(), src_left, src_top, NULL);
434 if (width == 0 || height == 0) {
435 return TRUE;
436 }
437 int src_bpp = pMask->GetBPP();
438 int alpha;
439 FX_DWORD dst_color;
440 if (alpha_flag >> 8) {
441 alpha = alpha_flag & 0xff;
442 dst_color = FXCMYK_TODIB(color);
443 } else {
444 alpha = FXARGB_A(color);
445 dst_color = FXARGB_TODIB(color);
446 }
447 FX_LPBYTE color_p = (FX_LPBYTE)&dst_color;
448 if (pIccTransform && CFX_GEModule::Get()->GetCodecModule() && CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
449 ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
450 pIccModule->TranslateScanline(pIccTransform, color_p, color_p, 1);
451 } else {
452 if (alpha_flag >> 8 && !IsCmykImage())
453 AdobeCMYK_to_sRGB1(FXSYS_GetCValue(color), FXSYS_GetMValue(color), FXSYS_GetYValue(color), FXSYS_GetKValue(color),
454 color_p[2], color_p[1], color_p[0]);
455 else if (!(alpha_flag >> 8) && IsCmykImage()) {
456 return FALSE;
457 }
458 }
459 if(!IsCmykImage()) {
460 color_p[3] = (FX_BYTE)alpha;
461 }
462 if (GetFormat() == FXDIB_Argb) {
463 for (int row = 0; row < height; row ++) {
464 FX_DWORD* dest_pos = (FX_DWORD*)(m_pBuffer + (dest_top + row) * m_Pitch + dest_left * 4);
465 FX_LPCBYTE src_scan = pMask->GetScanline(src_top + row);
466 if (src_bpp == 1) {
467 for (int col = 0; col < width; col ++) {
468 int src_bitpos = src_left + col;
469 if (src_scan[src_bitpos / 8] & (1 << (7 - src_bitpos % 8))) {
470 *dest_pos = dst_color;
471 } else {
472 *dest_pos = 0;
473 }
474 dest_pos ++;
475 }
476 } else {
477 src_scan += src_left;
478 dst_color = FXARGB_TODIB(dst_color);
479 dst_color &= 0xffffff;
480 for (int col = 0; col < width; col ++) {
481 FXARGB_SETDIB(dest_pos++, dst_color | ((alpha * (*src_scan++) / 255) << 24));
482 }
483 }
484 }
485 } else {
486 int comps = m_bpp / 8;
487 for (int row = 0; row < height; row ++) {
488 FX_LPBYTE dest_color_pos = m_pBuffer + (dest_top + row) * m_Pitch + dest_left * comps;
489 FX_LPBYTE dest_alpha_pos = (FX_LPBYTE)m_pAlphaMask->GetScanline(dest_top + row) + dest_left;
490 FX_LPCBYTE src_scan = pMask->GetScanline(src_top + row);
491 if (src_bpp == 1) {
492 for (int col = 0; col < width; col ++) {
493 int src_bitpos = src_left + col;
494 if (src_scan[src_bitpos / 8] & (1 << (7 - src_bitpos % 8))) {
495 FXSYS_memcpy32(dest_color_pos, color_p, comps);
496 *dest_alpha_pos = 0xff;
497 } else {
498 FXSYS_memset32(dest_color_pos, 0, comps);
499 *dest_alpha_pos = 0;
500 }
501 dest_color_pos += comps;
502 dest_alpha_pos ++;
503 }
504 } else {
505 src_scan += src_left;
506 for (int col = 0; col < width; col ++) {
507 FXSYS_memcpy32(dest_color_pos, color_p, comps);
508 dest_color_pos += comps;
509 *dest_alpha_pos++ = (alpha * (*src_scan++) / 255);
510 }
511 }
512 }
513 }
514 return TRUE;
515 }
CopyPalette(const FX_DWORD * pSrc,FX_DWORD size)516 void CFX_DIBSource::CopyPalette(const FX_DWORD* pSrc, FX_DWORD size)
517 {
518 if (pSrc == NULL || GetBPP() > 8) {
519 if (m_pPalette) {
520 FX_Free(m_pPalette);
521 }
522 m_pPalette = NULL;
523 } else {
524 FX_DWORD pal_size = 1 << GetBPP();
525 if (m_pPalette == NULL) {
526 m_pPalette = FX_Alloc(FX_DWORD, pal_size);
527 }
528 if (pal_size > size) {
529 pal_size = size;
530 }
531 FXSYS_memcpy32(m_pPalette, pSrc, pal_size * sizeof(FX_DWORD));
532 }
533 }
GetPalette(FX_DWORD * pal,int alpha) const534 void CFX_DIBSource::GetPalette(FX_DWORD* pal, int alpha) const
535 {
536 ASSERT(GetBPP() <= 8 && !IsCmykImage());
537 if (GetBPP() == 1) {
538 pal[0] = ((m_pPalette ? m_pPalette[0] : 0xff000000) & 0xffffff) | (alpha << 24);
539 pal[1] = ((m_pPalette ? m_pPalette[1] : 0xffffffff) & 0xffffff) | (alpha << 24);
540 return;
541 }
542 if (m_pPalette) {
543 for (int i = 0; i < 256; i ++) {
544 pal[i] = (m_pPalette[i] & 0x00ffffff) | (alpha << 24);
545 }
546 } else {
547 for (int i = 0; i < 256; i ++) {
548 pal[i] = (i * 0x10101) | (alpha << 24);
549 }
550 }
551 }
GetAlphaMask(const FX_RECT * pClip) const552 CFX_DIBitmap* CFX_DIBSource::GetAlphaMask(const FX_RECT* pClip) const
553 {
554 ASSERT(GetFormat() == FXDIB_Argb);
555 FX_RECT rect(0, 0, m_Width, m_Height);
556 if (pClip) {
557 rect.Intersect(*pClip);
558 if (rect.IsEmpty()) {
559 return NULL;
560 }
561 }
562 CFX_DIBitmap* pMask = new CFX_DIBitmap;
563 if (!pMask->Create(rect.Width(), rect.Height(), FXDIB_8bppMask)) {
564 delete pMask;
565 return NULL;
566 }
567 for (int row = rect.top; row < rect.bottom; row ++) {
568 FX_LPCBYTE src_scan = GetScanline(row) + rect.left * 4 + 3;
569 FX_LPBYTE dest_scan = (FX_LPBYTE)pMask->GetScanline(row - rect.top);
570 for (int col = rect.left; col < rect.right; col ++) {
571 *dest_scan ++ = *src_scan;
572 src_scan += 4;
573 }
574 }
575 return pMask;
576 }
CopyAlphaMask(const CFX_DIBSource * pAlphaMask,const FX_RECT * pClip)577 FX_BOOL CFX_DIBSource::CopyAlphaMask(const CFX_DIBSource* pAlphaMask, const FX_RECT* pClip)
578 {
579 if (!HasAlpha() || GetFormat() == FXDIB_Argb) {
580 return FALSE;
581 }
582 if (pAlphaMask) {
583 FX_RECT rect(0, 0, pAlphaMask->m_Width, pAlphaMask->m_Height);
584 if (pClip) {
585 rect.Intersect(*pClip);
586 if (rect.IsEmpty() || rect.Width() != m_Width || rect.Height() != m_Height) {
587 return FALSE;
588 }
589 } else {
590 if (pAlphaMask->m_Width != m_Width || pAlphaMask->m_Height != m_Height) {
591 return FALSE;
592 }
593 }
594 for (int row = 0; row < m_Height; row ++)
595 FXSYS_memcpy32((void*)m_pAlphaMask->GetScanline(row),
596 pAlphaMask->GetScanline(row + rect.top) + rect.left, m_pAlphaMask->m_Pitch);
597 } else {
598 m_pAlphaMask->Clear(0xff000000);
599 }
600 return TRUE;
601 }
602 const int g_ChannelOffset[] = {0, 2, 1, 0, 0, 1, 2, 3, 3};
LoadChannel(FXDIB_Channel destChannel,const CFX_DIBSource * pSrcBitmap,FXDIB_Channel srcChannel)603 FX_BOOL CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel, const CFX_DIBSource* pSrcBitmap, FXDIB_Channel srcChannel)
604 {
605 if (m_pBuffer == NULL) {
606 return FALSE;
607 }
608 CFX_DIBSource* pSrcClone = (CFX_DIBSource*)pSrcBitmap;
609 CFX_DIBitmap* pDst = this;
610 int destOffset, srcOffset;
611 if (srcChannel == FXDIB_Alpha) {
612 if (!pSrcBitmap->HasAlpha() && !pSrcBitmap->IsAlphaMask()) {
613 return FALSE;
614 }
615 if (pSrcBitmap->GetBPP() == 1) {
616 pSrcClone = pSrcBitmap->CloneConvert(FXDIB_8bppMask);
617 if (pSrcClone == NULL) {
618 return FALSE;
619 }
620 }
621 if(pSrcBitmap->GetFormat() == FXDIB_Argb) {
622 srcOffset = 3;
623 } else {
624 srcOffset = 0;
625 }
626 } else {
627 if (pSrcBitmap->IsAlphaMask()) {
628 return FALSE;
629 }
630 if (pSrcBitmap->GetBPP() < 24) {
631 if (pSrcBitmap->IsCmykImage()) {
632 pSrcClone = pSrcBitmap->CloneConvert((FXDIB_Format)((pSrcBitmap->GetFormat() & 0xff00) | 0x20));
633 } else {
634 pSrcClone = pSrcBitmap->CloneConvert((FXDIB_Format)((pSrcBitmap->GetFormat() & 0xff00) | 0x18));
635 }
636 if (pSrcClone == NULL) {
637 return FALSE;
638 }
639 }
640 srcOffset = g_ChannelOffset[srcChannel];
641 }
642 if (destChannel == FXDIB_Alpha) {
643 if (IsAlphaMask()) {
644 if(!ConvertFormat(FXDIB_8bppMask)) {
645 if (pSrcClone != pSrcBitmap) {
646 delete pSrcClone;
647 }
648 return FALSE;
649 }
650 destOffset = 0;
651 } else {
652 destOffset = 0;
653 if(!ConvertFormat(IsCmykImage() ? FXDIB_Cmyka : FXDIB_Argb)) {
654 if (pSrcClone != pSrcBitmap) {
655 delete pSrcClone;
656 }
657 return FALSE;
658 }
659 if (GetFormat() == FXDIB_Argb) {
660 destOffset = 3;
661 }
662 }
663 } else {
664 if (IsAlphaMask()) {
665 if (pSrcClone != pSrcBitmap) {
666 delete pSrcClone;
667 }
668 return FALSE;
669 }
670 if (GetBPP() < 24) {
671 if (HasAlpha()) {
672 if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyka : FXDIB_Argb)) {
673 if (pSrcClone != pSrcBitmap) {
674 delete pSrcClone;
675 }
676 return FALSE;
677 }
678 } else
679 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
680 if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyk : FXDIB_Rgb32)) {
681 #else
682 if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyk : FXDIB_Rgb)) {
683 #endif
684 if (pSrcClone != pSrcBitmap) {
685 delete pSrcClone;
686 }
687 return FALSE;
688 }
689 }
690 destOffset = g_ChannelOffset[destChannel];
691 }
692 if (srcChannel == FXDIB_Alpha && pSrcClone->m_pAlphaMask) {
693 CFX_DIBitmap* pAlphaMask = pSrcClone->m_pAlphaMask;
694 if (pSrcClone->GetWidth() != m_Width || pSrcClone->GetHeight() != m_Height) {
695 if (pAlphaMask) {
696 pAlphaMask = pAlphaMask->StretchTo(m_Width, m_Height);
697 if (pAlphaMask == NULL) {
698 if (pSrcClone != pSrcBitmap) {
699 delete pSrcClone;
700 }
701 return FALSE;
702 }
703 }
704 }
705 if (pSrcClone != pSrcBitmap) {
706 pSrcClone->m_pAlphaMask = NULL;
707 delete pSrcClone;
708 }
709 pSrcClone = pAlphaMask;
710 srcOffset = 0;
711 } else if (pSrcClone->GetWidth() != m_Width || pSrcClone->GetHeight() != m_Height) {
712 CFX_DIBitmap* pSrcMatched = pSrcClone->StretchTo(m_Width, m_Height);
713 if (pSrcClone != pSrcBitmap) {
714 delete pSrcClone;
715 }
716 if (pSrcMatched == NULL) {
717 return FALSE;
718 }
719 pSrcClone = pSrcMatched;
720 }
721 if (destChannel == FXDIB_Alpha && m_pAlphaMask) {
722 pDst = m_pAlphaMask;
723 destOffset = 0;
724 }
725 int srcBytes = pSrcClone->GetBPP() / 8;
726 int destBytes = pDst->GetBPP() / 8;
727 for (int row = 0; row < m_Height; row ++) {
728 FX_LPBYTE dest_pos = (FX_LPBYTE)pDst->GetScanline(row) + destOffset;
729 FX_LPCBYTE src_pos = pSrcClone->GetScanline(row) + srcOffset;
730 for (int col = 0; col < m_Width; col ++) {
731 *dest_pos = *src_pos;
732 dest_pos += destBytes;
733 src_pos += srcBytes;
734 }
735 }
736 if (pSrcClone != pSrcBitmap && pSrcClone != pSrcBitmap->m_pAlphaMask) {
737 delete pSrcClone;
738 }
739 return TRUE;
740 }
741 FX_BOOL CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel, int value)
742 {
743 if (m_pBuffer == NULL) {
744 return FALSE;
745 }
746 int destOffset;
747 if (destChannel == FXDIB_Alpha) {
748 if (IsAlphaMask()) {
749 if(!ConvertFormat(FXDIB_8bppMask)) {
750 return FALSE;
751 }
752 destOffset = 0;
753 } else {
754 destOffset = 0;
755 if(!ConvertFormat(IsCmykImage() ? FXDIB_Cmyka : FXDIB_Argb)) {
756 return FALSE;
757 }
758 if (GetFormat() == FXDIB_Argb) {
759 destOffset = 3;
760 }
761 }
762 } else {
763 if (IsAlphaMask()) {
764 return FALSE;
765 }
766 if (GetBPP() < 24) {
767 if (HasAlpha()) {
768 if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyka : FXDIB_Argb)) {
769 return FALSE;
770 }
771 } else
772 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
773 if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyk : FXDIB_Rgb)) {
774 return FALSE;
775 }
776 #else
777 if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyk : FXDIB_Rgb32)) {
778 return FALSE;
779 }
780 #endif
781 }
782 destOffset = g_ChannelOffset[destChannel];
783 }
784 int Bpp = GetBPP() / 8;
785 if (Bpp == 1) {
786 FXSYS_memset8(m_pBuffer, value, m_Height * m_Pitch);
787 return TRUE;
788 }
789 if (destChannel == FXDIB_Alpha && m_pAlphaMask) {
790 FXSYS_memset8(m_pAlphaMask->GetBuffer(), value, m_pAlphaMask->GetHeight()*m_pAlphaMask->GetPitch());
791 return TRUE;
792 }
793 for (int row = 0; row < m_Height; row ++) {
794 FX_LPBYTE scan_line = m_pBuffer + row * m_Pitch + destOffset;
795 for (int col = 0; col < m_Width; col ++) {
796 *scan_line = value;
797 scan_line += Bpp;
798 }
799 }
800 return TRUE;
801 }
802 FX_BOOL CFX_DIBitmap::MultiplyAlpha(const CFX_DIBSource* pSrcBitmap)
803 {
804 if (m_pBuffer == NULL) {
805 return FALSE;
806 }
807 ASSERT(pSrcBitmap->IsAlphaMask());
808 if (!pSrcBitmap->IsAlphaMask()) {
809 return FALSE;
810 }
811 if (!IsAlphaMask() && !HasAlpha()) {
812 return LoadChannel(FXDIB_Alpha, pSrcBitmap, FXDIB_Alpha);
813 }
814 CFX_DIBitmap* pSrcClone = (CFX_DIBitmap*)pSrcBitmap;
815 if (pSrcBitmap->GetWidth() != m_Width || pSrcBitmap->GetHeight() != m_Height) {
816 pSrcClone = pSrcBitmap->StretchTo(m_Width, m_Height);
817 ASSERT(pSrcClone != NULL);
818 if (pSrcClone == NULL) {
819 return FALSE;
820 }
821 }
822 if (IsAlphaMask()) {
823 if(!ConvertFormat(FXDIB_8bppMask)) {
824 if (pSrcClone != pSrcBitmap) {
825 delete pSrcClone;
826 }
827 return FALSE;
828 }
829 for (int row = 0; row < m_Height; row ++) {
830 FX_LPBYTE dest_scan = m_pBuffer + m_Pitch * row;
831 FX_LPBYTE src_scan = pSrcClone->m_pBuffer + pSrcClone->m_Pitch * row;
832 if (pSrcClone->GetBPP() == 1) {
833 for (int col = 0; col < m_Width; col ++) {
834 if (!((1 << (7 - col % 8)) & src_scan[col / 8])) {
835 dest_scan[col] = 0;
836 }
837 }
838 } else {
839 for (int col = 0; col < m_Width; col ++) {
840 *dest_scan = (*dest_scan) * src_scan[col] / 255;
841 dest_scan ++;
842 }
843 }
844 }
845 } else {
846 if(GetFormat() == FXDIB_Argb) {
847 if (pSrcClone->GetBPP() == 1) {
848 if (pSrcClone != pSrcBitmap) {
849 delete pSrcClone;
850 }
851 return FALSE;
852 }
853 for (int row = 0; row < m_Height; row ++) {
854 FX_LPBYTE dest_scan = m_pBuffer + m_Pitch * row + 3;
855 FX_LPBYTE src_scan = pSrcClone->m_pBuffer + pSrcClone->m_Pitch * row;
856 for (int col = 0; col < m_Width; col ++) {
857 *dest_scan = (*dest_scan) * src_scan[col] / 255;
858 dest_scan += 4;
859 }
860 }
861 } else {
862 m_pAlphaMask->MultiplyAlpha(pSrcClone);
863 }
864 }
865 if (pSrcClone != pSrcBitmap) {
866 delete pSrcClone;
867 }
868 return TRUE;
869 }
870 FX_BOOL CFX_DIBitmap::GetGrayData(void* pIccTransform)
871 {
872 if (m_pBuffer == NULL) {
873 return FALSE;
874 }
875 switch (GetFormat()) {
876 case FXDIB_1bppRgb: {
877 if (m_pPalette == NULL) {
878 return FALSE;
879 }
880 FX_BYTE gray[2];
881 for (int i = 0; i < 2; i ++) {
882 int r = (FX_BYTE)(m_pPalette[i] >> 16);
883 int g = (FX_BYTE)(m_pPalette[i] >> 8);
884 int b = (FX_BYTE)m_pPalette[i];
885 gray[i] = (FX_BYTE)FXRGB2GRAY(r, g, b);
886 }
887 CFX_DIBitmap* pMask = new CFX_DIBitmap;
888 if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
889 delete pMask;
890 return FALSE;
891 }
892 FXSYS_memset8(pMask->GetBuffer(), gray[0], pMask->GetPitch() * m_Height);
893 for (int row = 0; row < m_Height; row ++) {
894 FX_LPBYTE src_pos = m_pBuffer + row * m_Pitch;
895 FX_LPBYTE dest_pos = (FX_LPBYTE)pMask->GetScanline(row);
896 for (int col = 0; col < m_Width; col ++) {
897 if (src_pos[col / 8] & (1 << (7 - col % 8))) {
898 *dest_pos = gray[1];
899 }
900 dest_pos ++;
901 }
902 }
903 TakeOver(pMask);
904 delete pMask;
905 break;
906 }
907 case FXDIB_8bppRgb: {
908 if (m_pPalette == NULL) {
909 return FALSE;
910 }
911 FX_BYTE gray[256];
912 for (int i = 0; i < 256; i ++) {
913 int r = (FX_BYTE)(m_pPalette[i] >> 16);
914 int g = (FX_BYTE)(m_pPalette[i] >> 8);
915 int b = (FX_BYTE)m_pPalette[i];
916 gray[i] = (FX_BYTE)FXRGB2GRAY(r, g, b);
917 }
918 CFX_DIBitmap* pMask = new CFX_DIBitmap;
919 if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
920 delete pMask;
921 return FALSE;
922 }
923 for (int row = 0; row < m_Height; row ++) {
924 FX_LPBYTE dest_pos = pMask->GetBuffer() + row * pMask->GetPitch();
925 FX_LPBYTE src_pos = m_pBuffer + row * m_Pitch;
926 for (int col = 0; col < m_Width; col ++) {
927 *dest_pos ++ = gray[*src_pos ++];
928 }
929 }
930 TakeOver(pMask);
931 delete pMask;
932 break;
933 }
934 case FXDIB_Rgb: {
935 CFX_DIBitmap* pMask = new CFX_DIBitmap;
936 if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
937 delete pMask;
938 return FALSE;
939 }
940 for (int row = 0; row < m_Height; row ++) {
941 FX_LPBYTE src_pos = m_pBuffer + row * m_Pitch;
942 FX_LPBYTE dest_pos = pMask->GetBuffer() + row * pMask->GetPitch();
943 for (int col = 0; col < m_Width; col ++) {
944 *dest_pos ++ = FXRGB2GRAY(src_pos[2], src_pos[1], *src_pos);
945 src_pos += 3;
946 }
947 }
948 TakeOver(pMask);
949 delete pMask;
950 break;
951 }
952 case FXDIB_Rgb32: {
953 CFX_DIBitmap* pMask = new CFX_DIBitmap;
954 if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
955 delete pMask;
956 return FALSE;
957 }
958 for (int row = 0; row < m_Height; row ++) {
959 FX_LPBYTE src_pos = m_pBuffer + row * m_Pitch;
960 FX_LPBYTE dest_pos = pMask->GetBuffer() + row * pMask->GetPitch();
961 for (int col = 0; col < m_Width; col ++) {
962 *dest_pos ++ = FXRGB2GRAY(src_pos[2], src_pos[1], *src_pos);
963 src_pos += 4;
964 }
965 }
966 TakeOver(pMask);
967 delete pMask;
968 break;
969 }
970 default:
971 return FALSE;
972 }
973 return TRUE;
974 }
975 FX_BOOL CFX_DIBitmap::MultiplyAlpha(int alpha)
976 {
977 if (m_pBuffer == NULL) {
978 return FALSE;
979 }
980 switch (GetFormat()) {
981 case FXDIB_1bppMask:
982 if (!ConvertFormat(FXDIB_8bppMask)) {
983 return FALSE;
984 }
985 MultiplyAlpha(alpha);
986 break;
987 case FXDIB_8bppMask: {
988 for (int row = 0; row < m_Height; row ++) {
989 FX_LPBYTE scan_line = m_pBuffer + row * m_Pitch;
990 for (int col = 0; col < m_Width; col ++) {
991 scan_line[col] = scan_line[col] * alpha / 255;
992 }
993 }
994 break;
995 }
996 case FXDIB_Argb: {
997 for (int row = 0; row < m_Height; row ++) {
998 FX_LPBYTE scan_line = m_pBuffer + row * m_Pitch + 3;
999 for (int col = 0; col < m_Width; col ++) {
1000 *scan_line = (*scan_line) * alpha / 255;
1001 scan_line += 4;
1002 }
1003 }
1004 break;
1005 }
1006 default:
1007 if (HasAlpha()) {
1008 m_pAlphaMask->MultiplyAlpha(alpha);
1009 } else if (IsCmykImage()) {
1010 if (!ConvertFormat((FXDIB_Format)(GetFormat() | 0x0200))) {
1011 return FALSE;
1012 }
1013 m_pAlphaMask->MultiplyAlpha(alpha);
1014 } else {
1015 if (!ConvertFormat(FXDIB_Argb)) {
1016 return FALSE;
1017 }
1018 MultiplyAlpha(alpha);
1019 }
1020 break;
1021 }
1022 return TRUE;
1023 }
1024 FX_DWORD CFX_DIBitmap::GetPixel(int x, int y) const
1025 {
1026 if (m_pBuffer == NULL) {
1027 return 0;
1028 }
1029 FX_LPBYTE pos = m_pBuffer + y * m_Pitch + x * GetBPP() / 8;
1030 switch (GetFormat()) {
1031 case FXDIB_1bppMask: {
1032 if ((*pos) & (1 << (7 - x % 8))) {
1033 return 0xff000000;
1034 }
1035 return 0;
1036 }
1037 case FXDIB_1bppRgb: {
1038 if ((*pos) & (1 << (7 - x % 8))) {
1039 return m_pPalette ? m_pPalette[1] : 0xffffffff;
1040 } else {
1041 return m_pPalette ? m_pPalette[0] : 0xff000000;
1042 }
1043 break;
1044 }
1045 case FXDIB_8bppMask:
1046 return (*pos) << 24;
1047 case FXDIB_8bppRgb:
1048 return m_pPalette ? m_pPalette[*pos] : (0xff000000 | ((*pos) * 0x10101));
1049 case FXDIB_Rgb:
1050 case FXDIB_Rgba:
1051 case FXDIB_Rgb32:
1052 return FXARGB_GETDIB(pos) | 0xff000000;
1053 case FXDIB_Argb:
1054 return FXARGB_GETDIB(pos);
1055 default:
1056 break;
1057 }
1058 return 0;
1059 }
1060 void CFX_DIBitmap::SetPixel(int x, int y, FX_DWORD color)
1061 {
1062 if (m_pBuffer == NULL) {
1063 return;
1064 }
1065 if (x < 0 || x >= m_Width || y < 0 || y >= m_Height) {
1066 return;
1067 }
1068 FX_LPBYTE pos = m_pBuffer + y * m_Pitch + x * GetBPP() / 8;
1069 switch (GetFormat()) {
1070 case FXDIB_1bppMask:
1071 if (color >> 24) {
1072 *pos |= 1 << (7 - x % 8);
1073 } else {
1074 *pos &= ~(1 << (7 - x % 8));
1075 }
1076 break;
1077 case FXDIB_1bppRgb:
1078 if (m_pPalette) {
1079 if (color == m_pPalette[1]) {
1080 *pos |= 1 << (7 - x % 8);
1081 } else {
1082 *pos &= ~(1 << (7 - x % 8));
1083 }
1084 } else {
1085 if (color == 0xffffffff) {
1086 *pos |= 1 << (7 - x % 8);
1087 } else {
1088 *pos &= ~(1 << (7 - x % 8));
1089 }
1090 }
1091 break;
1092 case FXDIB_8bppMask:
1093 *pos = (FX_BYTE)(color >> 24);
1094 break;
1095 case FXDIB_8bppRgb: {
1096 if (m_pPalette) {
1097 for (int i = 0; i < 256; i ++) {
1098 if (m_pPalette[i] == color) {
1099 *pos = (FX_BYTE)i;
1100 return;
1101 }
1102 }
1103 *pos = 0;
1104 } else {
1105 *pos = FXRGB2GRAY(FXARGB_R(color), FXARGB_G(color), FXARGB_B(color));
1106 }
1107 break;
1108 }
1109 case FXDIB_Rgb:
1110 case FXDIB_Rgb32: {
1111 int alpha = FXARGB_A(color);
1112 pos[0] = (FXARGB_B(color) * alpha + pos[0] * (255 - alpha)) / 255;
1113 pos[1] = (FXARGB_G(color) * alpha + pos[1] * (255 - alpha)) / 255;
1114 pos[2] = (FXARGB_R(color) * alpha + pos[2] * (255 - alpha)) / 255;
1115 break;
1116 }
1117 case FXDIB_Rgba: {
1118 pos[0] = FXARGB_B(color);
1119 pos[1] = FXARGB_G(color);
1120 pos[2] = FXARGB_R(color);
1121 break;
1122 }
1123 case FXDIB_Argb:
1124 FXARGB_SETDIB(pos, color);
1125 break;
1126 default:
1127 break;
1128 }
1129 }
1130 void CFX_DIBitmap::DownSampleScanline(int line, FX_LPBYTE dest_scan, int dest_bpp,
1131 int dest_width, FX_BOOL bFlipX, int clip_left, int clip_width) const
1132 {
1133 if (m_pBuffer == NULL) {
1134 return;
1135 }
1136 int src_Bpp = m_bpp / 8;
1137 FX_LPBYTE scanline = m_pBuffer + line * m_Pitch;
1138 if (src_Bpp == 0) {
1139 for (int i = 0; i < clip_width; i ++) {
1140 FX_DWORD dest_x = clip_left + i;
1141 FX_DWORD src_x = dest_x * m_Width / dest_width;
1142 if (bFlipX) {
1143 src_x = m_Width - src_x - 1;
1144 }
1145 src_x %= m_Width;
1146 dest_scan[i] = (scanline[src_x / 8] & (1 << (7 - src_x % 8))) ? 255 : 0;
1147 }
1148 } else if (src_Bpp == 1) {
1149 for (int i = 0; i < clip_width; i ++) {
1150 FX_DWORD dest_x = clip_left + i;
1151 FX_DWORD src_x = dest_x * m_Width / dest_width;
1152 if (bFlipX) {
1153 src_x = m_Width - src_x - 1;
1154 }
1155 src_x %= m_Width;
1156 int dest_pos = i;
1157 if (m_pPalette) {
1158 if (!IsCmykImage()) {
1159 dest_pos *= 3;
1160 FX_ARGB argb = m_pPalette[scanline[src_x]];
1161 dest_scan[dest_pos] = FXARGB_B(argb);
1162 dest_scan[dest_pos + 1] = FXARGB_G(argb);
1163 dest_scan[dest_pos + 2] = FXARGB_R(argb);
1164 } else {
1165 dest_pos *= 4;
1166 FX_CMYK cmyk = m_pPalette[scanline[src_x]];
1167 dest_scan[dest_pos] = FXSYS_GetCValue(cmyk);
1168 dest_scan[dest_pos + 1] = FXSYS_GetMValue(cmyk);
1169 dest_scan[dest_pos + 2] = FXSYS_GetYValue(cmyk);
1170 dest_scan[dest_pos + 3] = FXSYS_GetKValue(cmyk);
1171 }
1172 } else {
1173 dest_scan[dest_pos] = scanline[src_x];
1174 }
1175 }
1176 } else {
1177 for (int i = 0; i < clip_width; i ++) {
1178 FX_DWORD dest_x = clip_left + i;
1179 FX_DWORD src_x = bFlipX ? (m_Width - dest_x * m_Width / dest_width - 1) * src_Bpp : (dest_x * m_Width / dest_width) * src_Bpp;
1180 src_x %= m_Width * src_Bpp;
1181 int dest_pos = i * src_Bpp;
1182 for (int b = 0; b < src_Bpp; b ++) {
1183 dest_scan[dest_pos + b] = scanline[src_x + b];
1184 }
1185 }
1186 }
1187 }
1188 FX_BOOL CFX_DIBitmap::ConvertColorScale(FX_DWORD forecolor, FX_DWORD backcolor)
1189 {
1190 ASSERT(!IsAlphaMask());
1191 if (m_pBuffer == NULL || IsAlphaMask()) {
1192 return FALSE;
1193 }
1194 int fc, fm, fy, fk, bc, bm, by, bk;
1195 int fr, fg, fb, br, bg, bb;
1196 FX_BOOL isCmykImage = IsCmykImage();
1197 if (isCmykImage) {
1198 fc = FXSYS_GetCValue(forecolor);
1199 fm = FXSYS_GetMValue(forecolor);
1200 fy = FXSYS_GetYValue(forecolor);
1201 fk = FXSYS_GetKValue(forecolor);
1202 bc = FXSYS_GetCValue(backcolor);
1203 bm = FXSYS_GetMValue(backcolor);
1204 by = FXSYS_GetYValue(backcolor);
1205 bk = FXSYS_GetKValue(backcolor);
1206 } else {
1207 fr = FXSYS_GetRValue(forecolor);
1208 fg = FXSYS_GetGValue(forecolor);
1209 fb = FXSYS_GetBValue(forecolor);
1210 br = FXSYS_GetRValue(backcolor);
1211 bg = FXSYS_GetGValue(backcolor);
1212 bb = FXSYS_GetBValue(backcolor);
1213 }
1214 if (m_bpp <= 8) {
1215 if (isCmykImage) {
1216 if (forecolor == 0xff && backcolor == 0 && m_pPalette == NULL) {
1217 return TRUE;
1218 }
1219 } else if (forecolor == 0 && backcolor == 0xffffff && m_pPalette == NULL) {
1220 return TRUE;
1221 }
1222 if (m_pPalette == NULL) {
1223 BuildPalette();
1224 }
1225 int size = 1 << m_bpp;
1226 if (isCmykImage) {
1227 for (int i = 0; i < size; i ++) {
1228 FX_BYTE b, g, r;
1229 AdobeCMYK_to_sRGB1(FXSYS_GetCValue(m_pPalette[i]), FXSYS_GetMValue(m_pPalette[i]), FXSYS_GetYValue(m_pPalette[i]), FXSYS_GetKValue(m_pPalette[i]),
1230 r, g, b);
1231 int gray = 255 - FXRGB2GRAY(r, g, b);
1232 m_pPalette[i] = CmykEncode(bc + (fc - bc) * gray / 255, bm + (fm - bm) * gray / 255,
1233 by + (fy - by) * gray / 255, bk + (fk - bk) * gray / 255);
1234 }
1235 } else
1236 for (int i = 0; i < size; i ++) {
1237 int gray = FXRGB2GRAY(FXARGB_R(m_pPalette[i]), FXARGB_G(m_pPalette[i]), FXARGB_B(m_pPalette[i]));
1238 m_pPalette[i] = FXARGB_MAKE(0xff, br + (fr - br) * gray / 255, bg + (fg - bg) * gray / 255,
1239 bb + (fb - bb) * gray / 255);
1240 }
1241 return TRUE;
1242 }
1243 if (isCmykImage) {
1244 if (forecolor == 0xff && backcolor == 0x00) {
1245 for (int row = 0; row < m_Height; row ++) {
1246 FX_LPBYTE scanline = m_pBuffer + row * m_Pitch;
1247 for (int col = 0; col < m_Width; col ++) {
1248 FX_BYTE b, g, r;
1249 AdobeCMYK_to_sRGB1(scanline[0], scanline[1], scanline[2], scanline[3],
1250 r, g, b);
1251 *scanline ++ = 0;
1252 *scanline ++ = 0;
1253 *scanline ++ = 0;
1254 *scanline ++ = 255 - FXRGB2GRAY(r, g, b);
1255 }
1256 }
1257 return TRUE;
1258 }
1259 } else if (forecolor == 0 && backcolor == 0xffffff) {
1260 for (int row = 0; row < m_Height; row ++) {
1261 FX_LPBYTE scanline = m_pBuffer + row * m_Pitch;
1262 int gap = m_bpp / 8 - 2;
1263 for (int col = 0; col < m_Width; col ++) {
1264 int gray = FXRGB2GRAY(scanline[2], scanline[1], scanline[0]);
1265 *scanline ++ = gray;
1266 *scanline ++ = gray;
1267 *scanline = gray;
1268 scanline += gap;
1269 }
1270 }
1271 return TRUE;
1272 }
1273 if (isCmykImage) {
1274 for (int row = 0; row < m_Height; row ++) {
1275 FX_LPBYTE scanline = m_pBuffer + row * m_Pitch;
1276 for (int col = 0; col < m_Width; col ++) {
1277 FX_BYTE b, g, r;
1278 AdobeCMYK_to_sRGB1(scanline[0], scanline[1], scanline[2], scanline[3],
1279 r, g, b);
1280 int gray = 255 - FXRGB2GRAY(r, g, b);
1281 *scanline ++ = bc + (fc - bc) * gray / 255;
1282 *scanline ++ = bm + (fm - bm) * gray / 255;
1283 *scanline ++ = by + (fy - by) * gray / 255;
1284 *scanline ++ = bk + (fk - bk) * gray / 255;
1285 }
1286 }
1287 } else {
1288 for (int row = 0; row < m_Height; row ++) {
1289 FX_LPBYTE scanline = m_pBuffer + row * m_Pitch;
1290 int gap = m_bpp / 8 - 2;
1291 for (int col = 0; col < m_Width; col ++) {
1292 int gray = FXRGB2GRAY(scanline[2], scanline[1], scanline[0]);
1293 *scanline ++ = bb + (fb - bb) * gray / 255;
1294 *scanline ++ = bg + (fg - bg) * gray / 255;
1295 *scanline = br + (fr - br) * gray / 255;
1296 scanline += gap;
1297 }
1298 }
1299 }
1300 return TRUE;
1301 }
1302 FX_BOOL CFX_DIBitmap::DitherFS(const FX_DWORD* pPalette, int pal_size, const FX_RECT* pRect)
1303 {
1304 if (m_pBuffer == NULL) {
1305 return FALSE;
1306 }
1307 if (m_bpp != 8 && m_pPalette != NULL && m_AlphaFlag != 0) {
1308 return FALSE;
1309 }
1310 if (m_Width < 4 && m_Height < 4) {
1311 return FALSE;
1312 }
1313 FX_RECT rect(0, 0, m_Width, m_Height);
1314 if (pRect) {
1315 rect.Intersect(*pRect);
1316 }
1317 FX_BYTE translate[256];
1318 for (int i = 0; i < 256; i ++) {
1319 int err2 = 65536;
1320 for (int j = 0; j < pal_size; j ++) {
1321 FX_BYTE entry = (FX_BYTE)pPalette[j];
1322 int err = (int)entry - i;
1323 if (err * err < err2) {
1324 err2 = err * err;
1325 translate[i] = entry;
1326 }
1327 }
1328 }
1329 for (int row = rect.top; row < rect.bottom; row ++) {
1330 FX_LPBYTE scan = m_pBuffer + row * m_Pitch;
1331 FX_LPBYTE next_scan = m_pBuffer + (row + 1) * m_Pitch;
1332 for (int col = rect.left; col < rect.right; col ++) {
1333 int src_pixel = scan[col];
1334 int dest_pixel = translate[src_pixel];
1335 scan[col] = (FX_BYTE)dest_pixel;
1336 int error = -dest_pixel + src_pixel;
1337 if (col < rect.right - 1) {
1338 int src = scan[col + 1];
1339 src += error * 7 / 16;
1340 if (src > 255) {
1341 scan[col + 1] = 255;
1342 } else if (src < 0) {
1343 scan[col + 1] = 0;
1344 } else {
1345 scan[col + 1] = src;
1346 }
1347 }
1348 if (col < rect.right - 1 && row < rect.bottom - 1) {
1349 int src = next_scan[col + 1];
1350 src += error * 1 / 16;
1351 if (src > 255) {
1352 next_scan[col + 1] = 255;
1353 } else if (src < 0) {
1354 next_scan[col + 1] = 0;
1355 } else {
1356 next_scan[col + 1] = src;
1357 }
1358 }
1359 if (row < rect.bottom - 1) {
1360 int src = next_scan[col];
1361 src += error * 5 / 16;
1362 if (src > 255) {
1363 next_scan[col] = 255;
1364 } else if (src < 0) {
1365 next_scan[col] = 0;
1366 } else {
1367 next_scan[col] = src;
1368 }
1369 }
1370 if (col > rect.left && row < rect.bottom - 1) {
1371 int src = next_scan[col - 1];
1372 src += error * 3 / 16;
1373 if (src > 255) {
1374 next_scan[col - 1] = 255;
1375 } else if (src < 0) {
1376 next_scan[col - 1] = 0;
1377 } else {
1378 next_scan[col - 1] = src;
1379 }
1380 }
1381 }
1382 }
1383 return TRUE;
1384 }
1385 CFX_DIBitmap* CFX_DIBSource::FlipImage(FX_BOOL bXFlip, FX_BOOL bYFlip) const
1386 {
1387 CFX_DIBitmap* pFlipped = new CFX_DIBitmap;
1388 if (!pFlipped->Create(m_Width, m_Height, GetFormat())) {
1389 delete pFlipped;
1390 return NULL;
1391 }
1392 pFlipped->CopyPalette(m_pPalette);
1393 FX_LPBYTE pDestBuffer = pFlipped->GetBuffer();
1394 int Bpp = m_bpp / 8;
1395 for (int row = 0; row < m_Height; row ++) {
1396 FX_LPCBYTE src_scan = GetScanline(row);
1397 FX_LPBYTE dest_scan = pDestBuffer + m_Pitch * (bYFlip ? (m_Height - row - 1) : row);
1398 if (!bXFlip) {
1399 FXSYS_memcpy32(dest_scan, src_scan, m_Pitch);
1400 continue;
1401 }
1402 if (m_bpp == 1) {
1403 FXSYS_memset32(dest_scan, 0, m_Pitch);
1404 for (int col = 0; col < m_Width; col ++)
1405 if (src_scan[col / 8] & (1 << (7 - col % 8))) {
1406 int dest_col = m_Width - col - 1;
1407 dest_scan[dest_col / 8] |= (1 << (7 - dest_col % 8));
1408 }
1409 } else {
1410 dest_scan += (m_Width - 1) * Bpp;
1411 if (Bpp == 1) {
1412 for (int col = 0; col < m_Width; col ++) {
1413 *dest_scan = *src_scan;
1414 dest_scan --;
1415 src_scan ++;
1416 }
1417 } else if (Bpp == 3) {
1418 for (int col = 0; col < m_Width; col ++) {
1419 dest_scan[0] = src_scan[0];
1420 dest_scan[1] = src_scan[1];
1421 dest_scan[2] = src_scan[2];
1422 dest_scan -= 3;
1423 src_scan += 3;
1424 }
1425 } else {
1426 ASSERT(Bpp == 4);
1427 for (int col = 0; col < m_Width; col ++) {
1428 *(FX_DWORD*)dest_scan = *(FX_DWORD*)src_scan;
1429 dest_scan -= 4;
1430 src_scan += 4;
1431 }
1432 }
1433 }
1434 }
1435 if (m_pAlphaMask) {
1436 pDestBuffer = pFlipped->m_pAlphaMask->GetBuffer();
1437 FX_DWORD dest_pitch = pFlipped->m_pAlphaMask->GetPitch();
1438 for (int row = 0; row < m_Height; row ++) {
1439 FX_LPCBYTE src_scan = m_pAlphaMask->GetScanline(row);
1440 FX_LPBYTE dest_scan = pDestBuffer + dest_pitch * (bYFlip ? (m_Height - row - 1) : row);
1441 if (!bXFlip) {
1442 FXSYS_memcpy32(dest_scan, src_scan, dest_pitch);
1443 continue;
1444 }
1445 dest_scan += (m_Width - 1);
1446 for (int col = 0; col < m_Width; col ++) {
1447 *dest_scan = *src_scan;
1448 dest_scan --;
1449 src_scan ++;
1450 }
1451 }
1452 }
1453 return pFlipped;
1454 }
1455 CFX_DIBExtractor::CFX_DIBExtractor(const CFX_DIBSource* pSrc)
1456 {
1457 m_pBitmap = NULL;
1458 if (pSrc->GetBuffer() == NULL) {
1459 m_pBitmap = pSrc->Clone();
1460 } else {
1461 m_pBitmap = new CFX_DIBitmap;
1462 if (!m_pBitmap->Create(pSrc->GetWidth(), pSrc->GetHeight(), pSrc->GetFormat(), pSrc->GetBuffer())) {
1463 delete m_pBitmap;
1464 m_pBitmap = NULL;
1465 return;
1466 }
1467 m_pBitmap->CopyPalette(pSrc->GetPalette());
1468 m_pBitmap->CopyAlphaMask(pSrc->m_pAlphaMask);
1469 }
1470 }
1471 CFX_DIBExtractor::~CFX_DIBExtractor()
1472 {
1473 if (m_pBitmap) {
1474 delete m_pBitmap;
1475 }
1476 }
1477 CFX_FilteredDIB::CFX_FilteredDIB()
1478 {
1479 m_pScanline = NULL;
1480 m_pSrc = NULL;
1481 }
1482 CFX_FilteredDIB::~CFX_FilteredDIB()
1483 {
1484 if (m_pSrc && m_bAutoDropSrc) {
1485 delete m_pSrc;
1486 }
1487 if (m_pScanline) {
1488 FX_Free(m_pScanline);
1489 }
1490 }
1491 void CFX_FilteredDIB::LoadSrc(const CFX_DIBSource* pSrc, FX_BOOL bAutoDropSrc)
1492 {
1493 m_pSrc = pSrc;
1494 m_bAutoDropSrc = bAutoDropSrc;
1495 m_Width = pSrc->GetWidth();
1496 m_Height = pSrc->GetHeight();
1497 FXDIB_Format format = GetDestFormat();
1498 m_bpp = (FX_BYTE)format;
1499 m_AlphaFlag = (FX_BYTE)(format >> 8);
1500 m_Pitch = (m_Width * (format & 0xff) + 31) / 32 * 4;
1501 m_pPalette = GetDestPalette();
1502 m_pScanline = FX_Alloc(FX_BYTE, m_Pitch);
1503 }
1504 FX_LPCBYTE CFX_FilteredDIB::GetScanline(int line) const
1505 {
1506 TranslateScanline(m_pScanline, m_pSrc->GetScanline(line));
1507 return m_pScanline;
1508 }
1509 void CFX_FilteredDIB::DownSampleScanline(int line, FX_LPBYTE dest_scan, int dest_bpp,
1510 int dest_width, FX_BOOL bFlipX, int clip_left, int clip_width) const
1511 {
1512 m_pSrc->DownSampleScanline(line, dest_scan, dest_bpp, dest_width, bFlipX, clip_left, clip_width);
1513 TranslateDownSamples(dest_scan, dest_scan, clip_width, dest_bpp);
1514 }
1515 CFX_ImageRenderer::CFX_ImageRenderer()
1516 {
1517 m_Status = 0;
1518 m_pTransformer = NULL;
1519 m_bRgbByteOrder = FALSE;
1520 m_BlendType = FXDIB_BLEND_NORMAL;
1521 }
1522 CFX_ImageRenderer::~CFX_ImageRenderer()
1523 {
1524 if (m_pTransformer) {
1525 delete m_pTransformer;
1526 }
1527 }
1528 extern FX_RECT _FXDIB_SwapClipBox(FX_RECT& clip, int width, int height, FX_BOOL bFlipX, FX_BOOL bFlipY);
1529 FX_BOOL CFX_ImageRenderer::Start(CFX_DIBitmap* pDevice, const CFX_ClipRgn* pClipRgn,
1530 const CFX_DIBSource* pSource, int bitmap_alpha,
1531 FX_DWORD mask_color, const CFX_AffineMatrix* pMatrix,
1532 FX_DWORD dib_flags, FX_BOOL bRgbByteOrder,
1533 int alpha_flag, void* pIccTransform, int blend_type)
1534 {
1535 m_Matrix = *pMatrix;
1536 CFX_FloatRect image_rect_f = m_Matrix.GetUnitRect();
1537 FX_RECT image_rect = image_rect_f.GetOutterRect();
1538 m_ClipBox = pClipRgn ? pClipRgn->GetBox() : FX_RECT(0, 0, pDevice->GetWidth(), pDevice->GetHeight());
1539 m_ClipBox.Intersect(image_rect);
1540 if (m_ClipBox.IsEmpty()) {
1541 return FALSE;
1542 }
1543 m_pDevice = pDevice;
1544 m_pClipRgn = pClipRgn;
1545 m_MaskColor = mask_color;
1546 m_BitmapAlpha = bitmap_alpha;
1547 m_Matrix = *pMatrix;
1548 m_Flags = dib_flags;
1549 m_AlphaFlag = alpha_flag;
1550 m_pIccTransform = pIccTransform;
1551 m_bRgbByteOrder = bRgbByteOrder;
1552 m_BlendType = blend_type;
1553 FX_BOOL ret = TRUE;
1554 if ((FXSYS_fabs(m_Matrix.b) >= 0.5f || m_Matrix.a == 0) ||
1555 (FXSYS_fabs(m_Matrix.c) >= 0.5f || m_Matrix.d == 0) ) {
1556 if (FXSYS_fabs(m_Matrix.a) < FXSYS_fabs(m_Matrix.b) / 20 && FXSYS_fabs(m_Matrix.d) < FXSYS_fabs(m_Matrix.c) / 20 &&
1557 FXSYS_fabs(m_Matrix.a) < 0.5f && FXSYS_fabs(m_Matrix.d) < 0.5f) {
1558 int dest_width = image_rect.Width();
1559 int dest_height = image_rect.Height();
1560 FX_RECT bitmap_clip = m_ClipBox;
1561 bitmap_clip.Offset(-image_rect.left, -image_rect.top);
1562 bitmap_clip = _FXDIB_SwapClipBox(bitmap_clip, dest_width, dest_height, m_Matrix.c > 0, m_Matrix.b < 0);
1563 m_Composer.Compose(pDevice, pClipRgn, bitmap_alpha, mask_color, m_ClipBox, TRUE,
1564 m_Matrix.c > 0, m_Matrix.b < 0, m_bRgbByteOrder, alpha_flag, pIccTransform, m_BlendType);
1565 if (!m_Stretcher.Start(&m_Composer, pSource, dest_height, dest_width, bitmap_clip, dib_flags)) {
1566 return FALSE;
1567 }
1568 m_Status = 1;
1569 return TRUE;
1570 }
1571 m_Status = 2;
1572 m_pTransformer = new CFX_ImageTransformer;
1573 m_pTransformer->Start(pSource, &m_Matrix, dib_flags, &m_ClipBox);
1574 return TRUE;
1575 }
1576 int dest_width = image_rect.Width();
1577 if (m_Matrix.a < 0) {
1578 dest_width = -dest_width;
1579 }
1580 int dest_height = image_rect.Height();
1581 if (m_Matrix.d > 0) {
1582 dest_height = -dest_height;
1583 }
1584 if (dest_width == 0 || dest_height == 0) {
1585 return FALSE;
1586 }
1587 FX_RECT bitmap_clip = m_ClipBox;
1588 bitmap_clip.Offset(-image_rect.left, -image_rect.top);
1589 m_Composer.Compose(pDevice, pClipRgn, bitmap_alpha, mask_color,
1590 m_ClipBox, FALSE, FALSE, FALSE, m_bRgbByteOrder, alpha_flag, pIccTransform, m_BlendType);
1591 m_Status = 1;
1592 ret = m_Stretcher.Start(&m_Composer, pSource, dest_width, dest_height, bitmap_clip, dib_flags);
1593 return ret;
1594 }
1595 FX_BOOL CFX_ImageRenderer::Continue(IFX_Pause* pPause)
1596 {
1597 if (m_Status == 1) {
1598 return m_Stretcher.Continue(pPause);
1599 } else if (m_Status == 2) {
1600 if (m_pTransformer->Continue(pPause)) {
1601 return TRUE;
1602 }
1603 CFX_DIBitmap* pBitmap = m_pTransformer->m_Storer.Detach();
1604 if (pBitmap == NULL) {
1605 return FALSE;
1606 }
1607 if (pBitmap->GetBuffer() == NULL) {
1608 delete pBitmap;
1609 return FALSE;
1610 }
1611 if (pBitmap->IsAlphaMask()) {
1612 if (m_BitmapAlpha != 255) {
1613 if (m_AlphaFlag >> 8) {
1614 m_AlphaFlag = (((FX_BYTE)((m_AlphaFlag & 0xff) * m_BitmapAlpha / 255)) | ((m_AlphaFlag >> 8) << 8));
1615 } else {
1616 m_MaskColor = FXARGB_MUL_ALPHA(m_MaskColor, m_BitmapAlpha);
1617 }
1618 }
1619 m_pDevice->CompositeMask(m_pTransformer->m_ResultLeft, m_pTransformer->m_ResultTop,
1620 pBitmap->GetWidth(), pBitmap->GetHeight(), pBitmap, m_MaskColor,
1621 0, 0, m_BlendType, m_pClipRgn, m_bRgbByteOrder, m_AlphaFlag, m_pIccTransform);
1622 } else {
1623 if (m_BitmapAlpha != 255) {
1624 pBitmap->MultiplyAlpha(m_BitmapAlpha);
1625 }
1626 m_pDevice->CompositeBitmap(m_pTransformer->m_ResultLeft, m_pTransformer->m_ResultTop,
1627 pBitmap->GetWidth(), pBitmap->GetHeight(), pBitmap, 0, 0, m_BlendType, m_pClipRgn, m_bRgbByteOrder, m_pIccTransform);
1628 }
1629 delete pBitmap;
1630 return FALSE;
1631 }
1632 return FALSE;
1633 }
1634 CFX_BitmapStorer::CFX_BitmapStorer()
1635 {
1636 m_pBitmap = NULL;
1637 }
1638 CFX_BitmapStorer::~CFX_BitmapStorer()
1639 {
1640 if (m_pBitmap) {
1641 delete m_pBitmap;
1642 }
1643 }
1644 CFX_DIBitmap* CFX_BitmapStorer::Detach()
1645 {
1646 CFX_DIBitmap* pBitmap = m_pBitmap;
1647 m_pBitmap = NULL;
1648 return pBitmap;
1649 }
1650 void CFX_BitmapStorer::Replace(CFX_DIBitmap* pBitmap)
1651 {
1652 if (m_pBitmap) {
1653 delete m_pBitmap;
1654 }
1655 m_pBitmap = pBitmap;
1656 }
1657 void CFX_BitmapStorer::ComposeScanline(int line, FX_LPCBYTE scanline, FX_LPCBYTE scan_extra_alpha)
1658 {
1659 FX_LPBYTE dest_buf = (FX_LPBYTE)m_pBitmap->GetScanline(line);
1660 FX_LPBYTE dest_alpha_buf = m_pBitmap->m_pAlphaMask ?
1661 (FX_LPBYTE)m_pBitmap->m_pAlphaMask->GetScanline(line) : NULL;
1662 if (dest_buf) {
1663 FXSYS_memcpy32(dest_buf, scanline, m_pBitmap->GetPitch());
1664 }
1665 if (dest_alpha_buf) {
1666 FXSYS_memcpy32(dest_alpha_buf, scan_extra_alpha, m_pBitmap->m_pAlphaMask->GetPitch());
1667 }
1668 }
1669 FX_BOOL CFX_BitmapStorer::SetInfo(int width, int height, FXDIB_Format src_format, FX_DWORD* pSrcPalette)
1670 {
1671 m_pBitmap = new CFX_DIBitmap;
1672 if (!m_pBitmap->Create(width, height, src_format)) {
1673 delete m_pBitmap;
1674 m_pBitmap = NULL;
1675 return FALSE;
1676 }
1677 if (pSrcPalette) {
1678 m_pBitmap->CopyPalette(pSrcPalette);
1679 }
1680 return TRUE;
1681 }
1682