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