Fix clang warnings so we can treat warnings as errors.
[pdfium.git] / core / src / fxge / dib / fx_dib_transform.cpp
1 // Copyright 2014 PDFium Authors. All rights reserved.\r
2 // Use of this source code is governed by a BSD-style license that can be\r
3 // found in the LICENSE file.\r
4  \r
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com\r
6 \r
7 #include "../../../include/fxge/fx_dib.h"\r
8 #include "dib_int.h"\r
9 int SDP_Table[513] = {\r
10     256, 256, 256, 256, 256, 256, 256, 256, 256, 255, 255, 255, 255, 255, 255, 254, 254, 254, 254,\r
11     253, 253, 253, 252, 252, 252, 251, 251, 251, 250, 250, 249, 249, 249, 248, 248, 247, 247, 246,\r
12     246, 245, 244, 244, 243, 243, 242, 242, 241, 240, 240, 239, 238, 238, 237, 236, 236, 235, 234,\r
13     233, 233, 232, 231, 230, 230, 229, 228, 227, 226, 226, 225, 224, 223, 222, 221, 220, 219, 218,\r
14     218, 217, 216, 215, 214, 213, 212, 211, 210, 209, 208, 207, 206, 205, 204, 203, 202, 201, 200,\r
15     199, 198, 196, 195, 194, 193, 192, 191, 190, 189, 188, 186, 185, 184, 183, 182, 181, 179, 178,\r
16     177, 176, 175, 173, 172, 171, 170, 169, 167, 166, 165, 164, 162, 161, 160, 159, 157, 156, 155,\r
17     154, 152, 151, 150, 149, 147, 146, 145, 143, 142, 141, 140, 138, 137, 136, 134, 133, 132, 130,\r
18     129, 128, 126, 125, 124, 122, 121, 120, 119, 117, 116, 115, 113, 112, 111, 109, 108, 107, 105,\r
19     104, 103, 101, 100, 99, 97, 96, 95, 93, 92, 91, 89, 88, 87, 85, 84, 83, 81, 80, 79, 77, 76, 75,\r
20     73, 72, 71, 69, 68, 67, 66, 64, 63, 62, 60, 59, 58, 57, 55, 54, 53, 52, 50, 49, 48, 47, 45, 44,\r
21     43, 42, 40, 39, 38, 37, 36, 34, 33, 32, 31, 30, 28, 27, 26, 25, 24, 23, 21, 20, 19, 18, 17, 16,\r
22     15, 14, 13, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, -1, -2, -3, -4, -5, -6, -7, -7, -8, -9, -10,\r
23     -11, -12, -12, -13, -14, -15, -15, -16, -17, -17, -18, -19, -19, -20, -21, -21, -22, -22, -23, -24,\r
24     -24, -25, -25, -26, -26, -27, -27, -27, -28, -28, -29, -29, -30, -30, -30, -31, -31, -31, -32, -32,\r
25     -32, -33, -33, -33, -33, -34, -34, -34, -34, -35, -35, -35, -35, -35, -36, -36, -36, -36, -36, -36,\r
26     -36, -36, -36, -37, -37, -37, -37, -37, -37, -37, -37, -37, -37, -37, -37, -37, -37, -37, -37, -37,\r
27     -37, -37, -37, -37, -36, -36, -36, -36, -36, -36, -36, -36, -36, -35, -35, -35, -35, -35, -35, -34,\r
28     -34, -34, -34, -34, -33, -33, -33, -33, -33, -32, -32, -32, -32, -31, -31, -31, -31, -30, -30, -30,\r
29     -30, -29, -29, -29, -29, -28, -28, -28, -27, -27, -27, -27, -26, -26, -26, -25, -25, -25, -24, -24,\r
30     -24, -23, -23, -23, -22, -22, -22, -22, -21, -21, -21, -20, -20, -20, -19, -19, -19, -18, -18, -18,\r
31     -17, -17, -17, -16, -16, -16, -15, -15, -15, -14, -14, -14, -13, -13, -13, -12, -12, -12, -11, -11,\r
32     -11, -10, -10, -10, -9, -9, -9, -9, -8, -8, -8, -7, -7, -7, -7, -6, -6, -6, -6, -5, -5, -5, -5, -4,\r
33     -4, -4, -4, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0,\r
34     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\r
35 };\r
36 class CFX_BilinearMatrix : public CPDF_FixedMatrix\r
37 {\r
38 public:\r
39     CFX_BilinearMatrix(const CFX_AffineMatrix& src, int bits): CPDF_FixedMatrix(src, bits)\r
40     {}\r
41     inline void Transform(int x, int y, int& x1, int& y1, int&res_x, int&res_y)\r
42     {\r
43         x1 = a * x + c * y + e + base / 2;\r
44         y1 = b * x + d * y + f + base / 2;\r
45         res_x = x1 % base;\r
46         res_y = y1 % base;\r
47         if (res_x < 0 && res_x > -base) {\r
48             res_x = base + res_x;\r
49         }\r
50         if (res_y < 0 && res_x > -base) {\r
51             res_y = base + res_y;\r
52         }\r
53         x1 /= base;\r
54         y1 /= base;\r
55     }\r
56 };\r
57 CFX_DIBitmap* CFX_DIBSource::SwapXY(FX_BOOL bXFlip, FX_BOOL bYFlip, const FX_RECT* pDestClip) const\r
58 {\r
59     FX_RECT dest_clip(0, 0, m_Height, m_Width);\r
60     if (pDestClip) {\r
61         dest_clip.Intersect(*pDestClip);\r
62     }\r
63     if (dest_clip.IsEmpty()) {\r
64         return NULL;\r
65     }\r
66     CFX_DIBitmap* pTransBitmap = FX_NEW CFX_DIBitmap;\r
67     if (!pTransBitmap) {\r
68         return NULL;\r
69     }\r
70     int result_height = dest_clip.Height(), result_width = dest_clip.Width();\r
71     if (!pTransBitmap->Create(result_width, result_height, GetFormat())) {\r
72         delete pTransBitmap;\r
73         return NULL;\r
74     }\r
75     pTransBitmap->CopyPalette(m_pPalette);\r
76     int src_pitch = m_Pitch;\r
77     int dest_pitch = pTransBitmap->GetPitch();\r
78     FX_LPBYTE dest_buf = pTransBitmap->GetBuffer();\r
79     int row_start = bXFlip ? m_Height - dest_clip.right : dest_clip.left;\r
80     int row_end = bXFlip ? m_Height - dest_clip.left : dest_clip.right;\r
81     int col_start = bYFlip ? m_Width - dest_clip.bottom : dest_clip.top;\r
82     int col_end = bYFlip ? m_Width - dest_clip.top : dest_clip.bottom;\r
83     if (GetBPP() == 1) {\r
84         FXSYS_memset8(dest_buf, 0xff, dest_pitch * result_height);\r
85         for (int row = row_start; row < row_end; row ++) {\r
86             FX_LPCBYTE src_scan = GetScanline(row);\r
87             int dest_col = (bXFlip ? dest_clip.right - (row - row_start) - 1 : row) - dest_clip.left;\r
88             FX_LPBYTE dest_scan = dest_buf;\r
89             if (bYFlip) {\r
90                 dest_scan += (result_height - 1) * dest_pitch;\r
91             }\r
92             int dest_step = bYFlip ? -dest_pitch : dest_pitch;\r
93             for (int col = col_start; col < col_end; col ++) {\r
94                 if (!(src_scan[col / 8] & (1 << (7 - col % 8)))) {\r
95                     dest_scan[dest_col / 8] &= ~(1 << (7 - dest_col % 8));\r
96                 }\r
97                 dest_scan += dest_step;\r
98             }\r
99         }\r
100     } else {\r
101         int nBytes = GetBPP() / 8;\r
102         int dest_step = bYFlip ? -dest_pitch : dest_pitch;\r
103         if (nBytes == 3) {\r
104             dest_step -= 2;\r
105         }\r
106         for (int row = row_start; row < row_end; row ++) {\r
107             int dest_col = (bXFlip ? dest_clip.right - (row - row_start) - 1 : row) - dest_clip.left;\r
108             FX_LPBYTE dest_scan = dest_buf + dest_col * nBytes;\r
109             if (bYFlip) {\r
110                 dest_scan += (result_height - 1) * dest_pitch;\r
111             }\r
112             if (nBytes == 4) {\r
113                 FX_DWORD* src_scan = (FX_DWORD*)GetScanline(row) + col_start;\r
114                 for (int col = col_start; col < col_end; col ++) {\r
115                     *(FX_DWORD*)dest_scan = *src_scan++;\r
116                     dest_scan += dest_step;\r
117                 }\r
118             } else {\r
119                 FX_LPCBYTE src_scan = GetScanline(row) + col_start * nBytes;\r
120                 if (nBytes == 1)\r
121                     for (int col = col_start; col < col_end; col ++) {\r
122                         *dest_scan = *src_scan++;\r
123                         dest_scan += dest_step;\r
124                     }\r
125                 else\r
126                     for (int col = col_start; col < col_end; col ++) {\r
127                         *dest_scan++ = *src_scan++;\r
128                         *dest_scan++ = *src_scan++;\r
129                         *dest_scan = *src_scan++;\r
130                         dest_scan += dest_step;\r
131                     }\r
132             }\r
133         }\r
134     }\r
135     if (m_pAlphaMask) {\r
136         src_pitch = m_pAlphaMask->m_Pitch;\r
137         dest_pitch = pTransBitmap->m_pAlphaMask->GetPitch();\r
138         dest_buf = pTransBitmap->m_pAlphaMask->GetBuffer();\r
139         int dest_step = bYFlip ? -dest_pitch : dest_pitch;\r
140         for (int row = row_start; row < row_end; row ++) {\r
141             int dest_col = (bXFlip ? dest_clip.right - (row - row_start) - 1 : row) - dest_clip.left;\r
142             FX_LPBYTE dest_scan = dest_buf + dest_col;\r
143             if (bYFlip) {\r
144                 dest_scan += (result_height - 1) * dest_pitch;\r
145             }\r
146             FX_LPCBYTE src_scan = m_pAlphaMask->GetScanline(row) + col_start;\r
147             for (int col = col_start; col < col_end; col ++) {\r
148                 *dest_scan = *src_scan++;\r
149                 dest_scan += dest_step;\r
150             }\r
151         }\r
152     }\r
153     return pTransBitmap;\r
154 }\r
155 #define FIX16_005 0.05f\r
156 FX_RECT _FXDIB_SwapClipBox(FX_RECT& clip, int width, int height, FX_BOOL bFlipX, FX_BOOL bFlipY)\r
157 {\r
158     FX_RECT rect;\r
159     if (bFlipY) {\r
160         rect.left = height - clip.top;\r
161         rect.right = height - clip.bottom;\r
162     } else {\r
163         rect.left = clip.top;\r
164         rect.right = clip.bottom;\r
165     }\r
166     if (bFlipX) {\r
167         rect.top = width - clip.left;\r
168         rect.bottom = width - clip.right;\r
169     } else {\r
170         rect.top = clip.left;\r
171         rect.bottom = clip.right;\r
172     }\r
173     rect.Normalize();\r
174     return rect;\r
175 }\r
176 CFX_DIBitmap* CFX_DIBSource::TransformTo(const CFX_AffineMatrix* pDestMatrix, int& result_left, int& result_top,\r
177         FX_DWORD flags, const FX_RECT* pDestClip) const\r
178 {\r
179     CFX_ImageTransformer transformer;\r
180     transformer.Start(this, pDestMatrix, flags, pDestClip);\r
181     transformer.Continue(NULL);\r
182     result_left = transformer.m_ResultLeft;\r
183     result_top = transformer.m_ResultTop;\r
184     CFX_DIBitmap* pTransformed = transformer.m_Storer.Detach();\r
185     return pTransformed;\r
186 }\r
187 CFX_DIBitmap* CFX_DIBSource::StretchTo(int dest_width, int dest_height, FX_DWORD flags, const FX_RECT* pClip) const\r
188 {\r
189     FX_RECT clip_rect(0, 0, FXSYS_abs(dest_width), FXSYS_abs(dest_height));\r
190     if (pClip) {\r
191         clip_rect.Intersect(*pClip);\r
192     }\r
193     if (clip_rect.IsEmpty()) {\r
194         return NULL;\r
195     }\r
196     if (dest_width == m_Width && dest_height == m_Height) {\r
197         return Clone(&clip_rect);\r
198     }\r
199     CFX_ImageStretcher stretcher;\r
200     CFX_BitmapStorer storer;\r
201     if (stretcher.Start(&storer, this, dest_width, dest_height, clip_rect, flags)) {\r
202         stretcher.Continue(NULL);\r
203     }\r
204     return storer.Detach();\r
205 }\r
206 CFX_ImageTransformer::CFX_ImageTransformer()\r
207 {\r
208     m_Status = 0;\r
209     m_pMatrix = NULL;\r
210 }\r
211 CFX_ImageTransformer::~CFX_ImageTransformer()\r
212 {\r
213 }\r
214 FX_BOOL CFX_ImageTransformer::Start(const CFX_DIBSource* pSrc, const CFX_AffineMatrix* pDestMatrix, int flags, const FX_RECT* pDestClip)\r
215 {\r
216     m_pMatrix = (CFX_AffineMatrix*)pDestMatrix;\r
217     CFX_FloatRect unit_rect = pDestMatrix->GetUnitRect();\r
218     FX_RECT result_rect = unit_rect.GetClosestRect();\r
219     FX_RECT result_clip = result_rect;\r
220     if (pDestClip) {\r
221         result_clip.Intersect(*pDestClip);\r
222     }\r
223     if (result_clip.IsEmpty()) {\r
224         return FALSE;\r
225     }\r
226     m_ResultLeft = result_clip.left;\r
227     m_ResultTop = result_clip.top;\r
228     m_ResultWidth = result_clip.Width();\r
229     m_ResultHeight = result_clip.Height();\r
230     m_Flags = flags;\r
231     if (FXSYS_fabs(pDestMatrix->a) < FXSYS_fabs(pDestMatrix->b) / 20 &&\r
232             FXSYS_fabs(pDestMatrix->d) < FXSYS_fabs(pDestMatrix->c) / 20 &&\r
233             FXSYS_fabs(pDestMatrix->a) < 0.5f && FXSYS_fabs(pDestMatrix->d) < 0.5f) {\r
234         int dest_width = result_rect.Width();\r
235         int dest_height = result_rect.Height();\r
236         result_clip.Offset(-result_rect.left, -result_rect.top);\r
237         result_clip = _FXDIB_SwapClipBox(result_clip, dest_width, dest_height, pDestMatrix->c > 0, pDestMatrix->b < 0);\r
238         m_Stretcher.Start(&m_Storer, pSrc, dest_height, dest_width, result_clip, flags);\r
239         m_Status = 1;\r
240         return TRUE;\r
241     }\r
242     if (FXSYS_fabs(pDestMatrix->b) < FIX16_005 && FXSYS_fabs(pDestMatrix->c) < FIX16_005) {\r
243         int dest_width = pDestMatrix->a > 0 ? (int)FXSYS_ceil(pDestMatrix->a) : (int)FXSYS_floor(pDestMatrix->a);\r
244         int dest_height = pDestMatrix->d > 0 ? (int) - FXSYS_ceil(pDestMatrix->d) : (int) - FXSYS_floor(pDestMatrix->d);\r
245         result_clip.Offset(-result_rect.left, -result_rect.top);\r
246         m_Stretcher.Start(&m_Storer, pSrc, dest_width, dest_height, result_clip, flags);\r
247         m_Status = 2;\r
248         return TRUE;\r
249     }\r
250     int stretch_width = (int)FXSYS_ceil(FXSYS_sqrt2(pDestMatrix->a, pDestMatrix->b));\r
251     int stretch_height = (int)FXSYS_ceil(FXSYS_sqrt2(pDestMatrix->c, pDestMatrix->d));\r
252     CFX_AffineMatrix stretch2dest(1.0f, 0.0f, 0.0f, -1.0f, 0.0f, (FX_FLOAT)(stretch_height));\r
253     stretch2dest.Concat(pDestMatrix->a / stretch_width, pDestMatrix->b / stretch_width,\r
254                         pDestMatrix->c / stretch_height, pDestMatrix->d / stretch_height, pDestMatrix->e, pDestMatrix->f);\r
255     m_dest2stretch.SetReverse(stretch2dest);\r
256     CFX_FloatRect clip_rect_f(result_clip);\r
257     clip_rect_f.Transform(&m_dest2stretch);\r
258     m_StretchClip = clip_rect_f.GetOutterRect();\r
259     m_StretchClip.Intersect(0, 0, stretch_width, stretch_height);\r
260     m_Stretcher.Start(&m_Storer, pSrc, stretch_width, stretch_height, m_StretchClip, flags);\r
261     m_Status = 3;\r
262     return TRUE;\r
263 }\r
264 FX_BYTE _bilinear_interpol(FX_LPCBYTE buf, int row_offset_l, int row_offset_r,\r
265                            int src_col_l, int src_col_r, int res_x, int res_y,\r
266                            int bpp, int c_offset)\r
267 {\r
268     int i_resx = 255 - res_x;\r
269     int col_bpp_l = src_col_l * bpp;\r
270     int col_bpp_r = src_col_r * bpp;\r
271     FX_LPCBYTE buf_u = buf + row_offset_l + c_offset;\r
272     FX_LPCBYTE buf_d = buf + row_offset_r + c_offset;\r
273     FX_LPCBYTE src_pos0 = buf_u + col_bpp_l;\r
274     FX_LPCBYTE src_pos1 = buf_u + col_bpp_r;\r
275     FX_LPCBYTE src_pos2 = buf_d + col_bpp_l;\r
276     FX_LPCBYTE src_pos3 = buf_d + col_bpp_r;\r
277     FX_BYTE r_pos_0 = (*src_pos0 * i_resx + *src_pos1 * res_x) >> 8;\r
278     FX_BYTE r_pos_1 = (*src_pos2 * i_resx + *src_pos3 * res_x) >> 8;\r
279     return (r_pos_0 * (255 - res_y) + r_pos_1 * res_y) >> 8;\r
280 }\r
281 FX_BYTE _bicubic_interpol(FX_LPCBYTE buf, int pitch, int pos_pixel[], int u_w[], int v_w[], int res_x, int res_y,\r
282                           int bpp, int c_offset)\r
283 {\r
284     int s_result = 0;\r
285     for (int i = 0; i < 4; i ++) {\r
286         int a_result = 0;\r
287         for (int j = 0; j < 4; j ++) {\r
288             a_result += u_w[j] * (*(FX_BYTE*)(buf + pos_pixel[i + 4] * pitch + pos_pixel[j] * bpp + c_offset));\r
289         }\r
290         s_result += a_result * v_w[i];\r
291     }\r
292     s_result >>= 16;\r
293     return (FX_BYTE)(s_result < 0 ? 0 : s_result > 255 ? 255 : s_result);\r
294 }\r
295 void _bicubic_get_pos_weight(int pos_pixel[], int u_w[], int v_w[], int src_col_l, int src_row_l,\r
296                              int res_x, int res_y, int stretch_width, int stretch_height)\r
297 {\r
298     pos_pixel[0] = src_col_l - 1;\r
299     pos_pixel[1] = src_col_l;\r
300     pos_pixel[2] = src_col_l + 1;\r
301     pos_pixel[3] = src_col_l + 2;\r
302     pos_pixel[4] = src_row_l - 1;\r
303     pos_pixel[5] = src_row_l;\r
304     pos_pixel[6] = src_row_l + 1;\r
305     pos_pixel[7] = src_row_l + 2;\r
306     for (int i = 0 ; i < 4; i ++) {\r
307         if (pos_pixel[i] < 0) {\r
308             pos_pixel[i] = 0;\r
309         }\r
310         if (pos_pixel[i] >= stretch_width) {\r
311             pos_pixel[i] = stretch_width - 1;\r
312         }\r
313         if (pos_pixel[i + 4] < 0) {\r
314             pos_pixel[i + 4] = 0;\r
315         }\r
316         if (pos_pixel[i + 4] >= stretch_height) {\r
317             pos_pixel[i + 4] = stretch_height - 1;\r
318         }\r
319     }\r
320     u_w[0] = SDP_Table[256 + res_x];\r
321     u_w[1] = SDP_Table[res_x];\r
322     u_w[2] = SDP_Table[256 - res_x];\r
323     u_w[3] = SDP_Table[512 - res_x];\r
324     v_w[0] = SDP_Table[256 + res_y];\r
325     v_w[1] = SDP_Table[res_y];\r
326     v_w[2] = SDP_Table[256 - res_y];\r
327     v_w[3] = SDP_Table[512 - res_y];\r
328 }\r
329 FXDIB_Format _GetTransformedFormat(const CFX_DIBSource* pDrc)\r
330 {\r
331     FXDIB_Format format = pDrc->GetFormat();\r
332     if (pDrc->IsAlphaMask()) {\r
333         format = FXDIB_8bppMask;\r
334     } else if (format >= 1025) {\r
335         format = FXDIB_Cmyka;\r
336     } else if (format <= 32 || format == FXDIB_Argb) {\r
337         format = FXDIB_Argb;\r
338     } else {\r
339         format = FXDIB_Rgba;\r
340     }\r
341     return format;\r
342 }\r
343 FX_BOOL CFX_ImageTransformer::Continue(IFX_Pause* pPause)\r
344 {\r
345     if (m_Status == 1) {\r
346         if (m_Stretcher.Continue(pPause)) {\r
347             return TRUE;\r
348         }\r
349         if (m_Storer.GetBitmap()) {\r
350             m_Storer.Replace(m_Storer.GetBitmap()->SwapXY(m_pMatrix->c > 0, m_pMatrix->b < 0));\r
351         }\r
352         return FALSE;\r
353     } else if (m_Status == 2) {\r
354         return m_Stretcher.Continue(pPause);\r
355     } else if (m_Status != 3) {\r
356         return FALSE;\r
357     }\r
358     if (m_Stretcher.Continue(pPause)) {\r
359         return TRUE;\r
360     }\r
361     int stretch_width = m_StretchClip.Width();\r
362     int stretch_height = m_StretchClip.Height();\r
363     if (m_Storer.GetBitmap() == NULL) {\r
364         return FALSE;\r
365     }\r
366     FX_LPCBYTE stretch_buf = m_Storer.GetBitmap()->GetBuffer();\r
367     FX_LPCBYTE stretch_buf_mask = NULL;\r
368     if (m_Storer.GetBitmap()->m_pAlphaMask) {\r
369         stretch_buf_mask = m_Storer.GetBitmap()->m_pAlphaMask->GetBuffer();\r
370     }\r
371     int stretch_pitch = m_Storer.GetBitmap()->GetPitch();\r
372     CFX_DIBitmap* pTransformed = FX_NEW CFX_DIBitmap;\r
373     if (!pTransformed) {\r
374         return FALSE;\r
375     }\r
376     FXDIB_Format transformF = _GetTransformedFormat(m_Stretcher.m_pSource);\r
377     if (!pTransformed->Create(m_ResultWidth, m_ResultHeight, transformF)) {\r
378         delete pTransformed;\r
379         return FALSE;\r
380     }\r
381     pTransformed->Clear(0);\r
382     if (pTransformed->m_pAlphaMask) {\r
383         pTransformed->m_pAlphaMask->Clear(0);\r
384     }\r
385     CFX_AffineMatrix result2stretch(1.0f, 0.0f, 0.0f, 1.0f, (FX_FLOAT)(m_ResultLeft), (FX_FLOAT)(m_ResultTop));\r
386     result2stretch.Concat(m_dest2stretch);\r
387     result2stretch.TranslateI(-m_StretchClip.left, -m_StretchClip.top);\r
388     if (stretch_buf_mask == NULL && pTransformed->m_pAlphaMask) {\r
389         pTransformed->m_pAlphaMask->Clear(0xff000000);\r
390     } else if (pTransformed->m_pAlphaMask) {\r
391         int stretch_pitch_mask = m_Storer.GetBitmap()->m_pAlphaMask->GetPitch();\r
392         if (!(m_Flags & FXDIB_DOWNSAMPLE) && !(m_Flags & FXDIB_BICUBIC_INTERPOL)) {\r
393             CFX_BilinearMatrix result2stretch_fix(result2stretch, 8);\r
394             for (int row = 0; row < m_ResultHeight; row ++) {\r
395                 FX_BYTE* dest_pos_mask = (FX_BYTE*)pTransformed->m_pAlphaMask->GetScanline(row);\r
396                 for (int col = 0; col < m_ResultWidth; col ++) {\r
397                     int src_col_l, src_row_l, res_x, res_y;\r
398                     result2stretch_fix.Transform(col, row, src_col_l, src_row_l, res_x, res_y);\r
399                     if (src_col_l >= 0 && src_col_l <= stretch_width && src_row_l >= 0 && src_row_l <= stretch_height) {\r
400                         if (src_col_l == stretch_width) {\r
401                             src_col_l--;\r
402                         }\r
403                         if (src_row_l == stretch_height) {\r
404                             src_row_l--;\r
405                         }\r
406                         int src_col_r = src_col_l + 1;\r
407                         int src_row_r = src_row_l + 1;\r
408                         if (src_col_r == stretch_width) {\r
409                             src_col_r--;\r
410                         }\r
411                         if (src_row_r == stretch_height) {\r
412                             src_row_r--;\r
413                         }\r
414                         int row_offset_l = src_row_l * stretch_pitch_mask;\r
415                         int row_offset_r = src_row_r * stretch_pitch_mask;\r
416                         *dest_pos_mask = _bilinear_interpol(stretch_buf_mask, row_offset_l, row_offset_r, src_col_l, src_col_r, res_x, res_y, 1, 0);\r
417                     }\r
418                     dest_pos_mask++;\r
419                 }\r
420             }\r
421         } else if (m_Flags & FXDIB_BICUBIC_INTERPOL) {\r
422             CFX_BilinearMatrix result2stretch_fix(result2stretch, 8);\r
423             int pos_pixel[8];\r
424             for (int row = 0; row < m_ResultHeight; row ++) {\r
425                 FX_BYTE* dest_pos_mask = (FX_BYTE*)pTransformed->m_pAlphaMask->GetScanline(row);\r
426                 for (int col = 0; col < m_ResultWidth; col ++) {\r
427                     int src_col_l, src_row_l, res_x, res_y;\r
428                     result2stretch_fix.Transform(col, row, src_col_l, src_row_l, res_x, res_y);\r
429                     if (src_col_l >= 0 && src_col_l <= stretch_width && src_row_l >= 0 && src_row_l <= stretch_height) {\r
430                         int u_w[4], v_w[4];\r
431                         if (src_col_l == stretch_width) {\r
432                             src_col_l--;\r
433                         }\r
434                         if (src_row_l == stretch_height) {\r
435                             src_row_l--;\r
436                         }\r
437                         _bicubic_get_pos_weight(pos_pixel, u_w, v_w, src_col_l, src_row_l, res_x, res_y, stretch_width, stretch_height);\r
438                         *dest_pos_mask = _bicubic_interpol(stretch_buf_mask, stretch_pitch_mask, pos_pixel, u_w, v_w, res_x, res_y, 1, 0);\r
439                     }\r
440                     dest_pos_mask++;\r
441                 }\r
442             }\r
443         } else {\r
444             CPDF_FixedMatrix result2stretch_fix(result2stretch, 8);\r
445             for (int row = 0; row < m_ResultHeight; row ++) {\r
446                 FX_BYTE* dest_pos_mask = (FX_BYTE*)pTransformed->m_pAlphaMask->GetScanline(row);\r
447                 for (int col = 0; col < m_ResultWidth; col ++) {\r
448                     int src_col, src_row;\r
449                     result2stretch_fix.Transform(col, row, src_col, src_row);\r
450                     if (src_col >= 0 && src_col <= stretch_width && src_row >= 0 && src_row <= stretch_height) {\r
451                         if (src_col == stretch_width) {\r
452                             src_col --;\r
453                         }\r
454                         if (src_row == stretch_height) {\r
455                             src_row --;\r
456                         }\r
457                         *dest_pos_mask = stretch_buf_mask[src_row * stretch_pitch_mask + src_col];\r
458                     }\r
459                     dest_pos_mask++;\r
460                 }\r
461             }\r
462         }\r
463     }\r
464     if (m_Storer.GetBitmap()->IsAlphaMask()) {\r
465         if (!(m_Flags & FXDIB_DOWNSAMPLE) && !(m_Flags & FXDIB_BICUBIC_INTERPOL)) {\r
466             CFX_BilinearMatrix result2stretch_fix(result2stretch, 8);\r
467             for (int row = 0; row < m_ResultHeight; row ++) {\r
468                 FX_LPBYTE dest_scan = (FX_LPBYTE)pTransformed->GetScanline(row);\r
469                 for (int col = 0; col < m_ResultWidth; col ++) {\r
470                     int src_col_l, src_row_l, res_x, res_y;\r
471                     result2stretch_fix.Transform(col, row, src_col_l, src_row_l, res_x, res_y);\r
472                     if (src_col_l >= 0 && src_col_l <= stretch_width && src_row_l >= 0 && src_row_l <= stretch_height) {\r
473                         if (src_col_l == stretch_width) {\r
474                             src_col_l--;\r
475                         }\r
476                         if (src_row_l == stretch_height) {\r
477                             src_row_l--;\r
478                         }\r
479                         int src_col_r = src_col_l + 1;\r
480                         int src_row_r = src_row_l + 1;\r
481                         if (src_col_r == stretch_width) {\r
482                             src_col_r--;\r
483                         }\r
484                         if (src_row_r == stretch_height) {\r
485                             src_row_r--;\r
486                         }\r
487                         int row_offset_l = src_row_l * stretch_pitch;\r
488                         int row_offset_r = src_row_r * stretch_pitch;\r
489                         *dest_scan = _bilinear_interpol(stretch_buf, row_offset_l, row_offset_r, src_col_l, src_col_r, res_x, res_y, 1, 0);\r
490                     }\r
491                     dest_scan ++;\r
492                 }\r
493             }\r
494         } else if (m_Flags & FXDIB_BICUBIC_INTERPOL) {\r
495             CFX_BilinearMatrix result2stretch_fix(result2stretch, 8);\r
496             int pos_pixel[8];\r
497             for (int row = 0; row < m_ResultHeight; row ++) {\r
498                 FX_LPBYTE dest_scan = (FX_LPBYTE)pTransformed->GetScanline(row);\r
499                 for (int col = 0; col < m_ResultWidth; col ++) {\r
500                     int src_col_l, src_row_l, res_x, res_y;\r
501                     result2stretch_fix.Transform(col, row, src_col_l, src_row_l, res_x, res_y);\r
502                     if (src_col_l >= 0 && src_col_l <= stretch_width && src_row_l >= 0 && src_row_l <= stretch_height) {\r
503                         int u_w[4], v_w[4];\r
504                         if (src_col_l == stretch_width) {\r
505                             src_col_l--;\r
506                         }\r
507                         if (src_row_l == stretch_height) {\r
508                             src_row_l--;\r
509                         }\r
510                         _bicubic_get_pos_weight(pos_pixel, u_w, v_w, src_col_l, src_row_l, res_x, res_y, stretch_width, stretch_height);\r
511                         *dest_scan = _bicubic_interpol(stretch_buf, stretch_pitch, pos_pixel, u_w, v_w, res_x, res_y, 1, 0);\r
512                     }\r
513                     dest_scan ++;\r
514                 }\r
515             }\r
516         } else {\r
517             CPDF_FixedMatrix result2stretch_fix(result2stretch, 8);\r
518             for (int row = 0; row < m_ResultHeight; row ++) {\r
519                 FX_LPBYTE dest_scan = (FX_LPBYTE)pTransformed->GetScanline(row);\r
520                 for (int col = 0; col < m_ResultWidth; col ++) {\r
521                     int src_col, src_row;\r
522                     result2stretch_fix.Transform(col, row, src_col, src_row);\r
523                     if (src_col >= 0 && src_col <= stretch_width && src_row >= 0 && src_row <= stretch_height) {\r
524                         if (src_col == stretch_width) {\r
525                             src_col --;\r
526                         }\r
527                         if (src_row == stretch_height) {\r
528                             src_row --;\r
529                         }\r
530                         FX_LPCBYTE src_pixel = stretch_buf + stretch_pitch * src_row + src_col;\r
531                         *dest_scan = *src_pixel;\r
532                     }\r
533                     dest_scan ++;\r
534                 }\r
535             }\r
536         }\r
537     } else {\r
538         int Bpp = m_Storer.GetBitmap()->GetBPP() / 8;\r
539         int destBpp = pTransformed->GetBPP() / 8;\r
540         if (Bpp == 1) {\r
541             FX_BOOL bHasAlpha = m_Storer.GetBitmap()->HasAlpha();\r
542             FX_DWORD argb[256];\r
543             FX_ARGB* pPal = m_Storer.GetBitmap()->GetPalette();\r
544             if (pPal) {\r
545                 for (int i = 0; i < 256; i ++) {\r
546                     argb[i] = pPal[i];\r
547                 }\r
548             } else {\r
549                 if (m_Storer.GetBitmap()->IsCmykImage())\r
550                     for (int i = 0; i < 256; i ++) {\r
551                         argb[i] = 255 - i;\r
552                     }\r
553                 else\r
554                     for (int i = 0; i < 256; i ++) {\r
555                         argb[i] = 0xff000000 | (i * 0x010101);\r
556                     }\r
557             }\r
558             if (!(m_Flags & FXDIB_DOWNSAMPLE) && !(m_Flags & FXDIB_BICUBIC_INTERPOL)) {\r
559                 CFX_BilinearMatrix result2stretch_fix(result2stretch, 8);\r
560                 for (int row = 0; row < m_ResultHeight; row ++) {\r
561                     FX_BYTE* dest_pos = (FX_BYTE*)pTransformed->GetScanline(row);\r
562                     for (int col = 0; col < m_ResultWidth; col ++) {\r
563                         int src_col_l, src_row_l, res_x, res_y;\r
564                         result2stretch_fix.Transform(col, row, src_col_l, src_row_l, res_x, res_y);\r
565                         if (src_col_l >= 0 && src_col_l <= stretch_width && src_row_l >= 0 && src_row_l <= stretch_height) {\r
566                             if (src_col_l == stretch_width) {\r
567                                 src_col_l--;\r
568                             }\r
569                             if (src_row_l == stretch_height) {\r
570                                 src_row_l--;\r
571                             }\r
572                             int src_col_r = src_col_l + 1;\r
573                             int src_row_r = src_row_l + 1;\r
574                             if (src_col_r == stretch_width) {\r
575                                 src_col_r--;\r
576                             }\r
577                             if (src_row_r == stretch_height) {\r
578                                 src_row_r--;\r
579                             }\r
580                             int row_offset_l = src_row_l * stretch_pitch;\r
581                             int row_offset_r = src_row_r * stretch_pitch;\r
582                             FX_DWORD r_bgra_cmyk = argb[_bilinear_interpol(stretch_buf, row_offset_l, row_offset_r, src_col_l, src_col_r, res_x, res_y, 1, 0)];\r
583                             if (transformF == FXDIB_Rgba) {\r
584                                 dest_pos[0] = (FX_BYTE)(r_bgra_cmyk >> 24);\r
585                                 dest_pos[1] = (FX_BYTE)(r_bgra_cmyk >> 16);\r
586                                 dest_pos[2] = (FX_BYTE)(r_bgra_cmyk >> 8);\r
587                             } else {\r
588                                 *(FX_DWORD*)dest_pos = r_bgra_cmyk;\r
589                             }\r
590                         }\r
591                         dest_pos += destBpp;\r
592                     }\r
593                 }\r
594             } else if (m_Flags & FXDIB_BICUBIC_INTERPOL) {\r
595                 CFX_BilinearMatrix result2stretch_fix(result2stretch, 8);\r
596                 int pos_pixel[8];\r
597                 for (int row = 0; row < m_ResultHeight; row ++) {\r
598                     FX_BYTE* dest_pos = (FX_BYTE*)pTransformed->GetScanline(row);\r
599                     for (int col = 0; col < m_ResultWidth; col ++) {\r
600                         int src_col_l, src_row_l, res_x, res_y;\r
601                         result2stretch_fix.Transform(col, row, src_col_l, src_row_l, res_x, res_y);\r
602                         if (src_col_l >= 0 && src_col_l <= stretch_width && src_row_l >= 0 && src_row_l <= stretch_height) {\r
603                             int u_w[4], v_w[4];\r
604                             if (src_col_l == stretch_width) {\r
605                                 src_col_l--;\r
606                             }\r
607                             if (src_row_l == stretch_height) {\r
608                                 src_row_l--;\r
609                             }\r
610                             _bicubic_get_pos_weight(pos_pixel, u_w, v_w, src_col_l, src_row_l, res_x, res_y, stretch_width, stretch_height);\r
611                             FX_DWORD r_bgra_cmyk = argb[_bicubic_interpol(stretch_buf, stretch_pitch, pos_pixel, u_w, v_w, res_x, res_y, 1, 0)];\r
612                             if (transformF == FXDIB_Rgba) {\r
613                                 dest_pos[0] = (FX_BYTE)(r_bgra_cmyk >> 24);\r
614                                 dest_pos[1] = (FX_BYTE)(r_bgra_cmyk >> 16);\r
615                                 dest_pos[2] = (FX_BYTE)(r_bgra_cmyk >> 8);\r
616                             } else {\r
617                                 *(FX_DWORD*)dest_pos = r_bgra_cmyk;\r
618                             }\r
619                         }\r
620                         dest_pos += destBpp;\r
621                     }\r
622                 }\r
623             } else {\r
624                 CPDF_FixedMatrix result2stretch_fix(result2stretch, 8);\r
625                 for (int row = 0; row < m_ResultHeight; row ++) {\r
626                     FX_BYTE* dest_pos = (FX_BYTE*)pTransformed->GetScanline(row);\r
627                     for (int col = 0; col < m_ResultWidth; col ++) {\r
628                         int src_col, src_row;\r
629                         result2stretch_fix.Transform(col, row, src_col, src_row);\r
630                         if (src_col >= 0 && src_col <= stretch_width && src_row >= 0 && src_row <= stretch_height) {\r
631                             if (src_col == stretch_width) {\r
632                                 src_col --;\r
633                             }\r
634                             if (src_row == stretch_height) {\r
635                                 src_row --;\r
636                             }\r
637                             FX_DWORD r_bgra_cmyk = argb[stretch_buf[src_row * stretch_pitch + src_col]];\r
638                             if (transformF == FXDIB_Rgba) {\r
639                                 dest_pos[0] = (FX_BYTE)(r_bgra_cmyk >> 24);\r
640                                 dest_pos[1] = (FX_BYTE)(r_bgra_cmyk >> 16);\r
641                                 dest_pos[2] = (FX_BYTE)(r_bgra_cmyk >> 8);\r
642                             } else {\r
643                                 *(FX_DWORD*)dest_pos = r_bgra_cmyk;\r
644                             }\r
645                         }\r
646                         dest_pos += destBpp;\r
647                     }\r
648                 }\r
649             }\r
650         } else {\r
651             FX_BOOL bHasAlpha = m_Storer.GetBitmap()->HasAlpha();\r
652             int destBpp = pTransformed->GetBPP() / 8;\r
653             if (!(m_Flags & FXDIB_DOWNSAMPLE) && !(m_Flags & FXDIB_BICUBIC_INTERPOL)) {\r
654                 CFX_BilinearMatrix result2stretch_fix(result2stretch, 8);\r
655                 for (int row = 0; row < m_ResultHeight; row ++) {\r
656                     FX_BYTE* dest_pos = (FX_BYTE*)pTransformed->GetScanline(row);\r
657                     for (int col = 0; col < m_ResultWidth; col ++) {\r
658                         int src_col_l, src_row_l, res_x, res_y, r_pos_k_r = 0;\r
659                         result2stretch_fix.Transform(col, row, src_col_l, src_row_l, res_x, res_y);\r
660                         if (src_col_l >= 0 && src_col_l <= stretch_width && src_row_l >= 0 && src_row_l <= stretch_height) {\r
661                             if (src_col_l == stretch_width) {\r
662                                 src_col_l--;\r
663                             }\r
664                             if (src_row_l == stretch_height) {\r
665                                 src_row_l--;\r
666                             }\r
667                             int src_col_r = src_col_l + 1;\r
668                             int src_row_r = src_row_l + 1;\r
669                             if (src_col_r == stretch_width) {\r
670                                 src_col_r--;\r
671                             }\r
672                             if (src_row_r == stretch_height) {\r
673                                 src_row_r--;\r
674                             }\r
675                             int row_offset_l = src_row_l * stretch_pitch;\r
676                             int row_offset_r = src_row_r * stretch_pitch;\r
677                             FX_BYTE r_pos_red_y_r   = _bilinear_interpol(stretch_buf, row_offset_l, row_offset_r, src_col_l, src_col_r, res_x, res_y, Bpp, 2);\r
678                             FX_BYTE r_pos_green_m_r = _bilinear_interpol(stretch_buf, row_offset_l, row_offset_r, src_col_l, src_col_r, res_x, res_y, Bpp, 1);\r
679                             FX_BYTE r_pos_blue_c_r  = _bilinear_interpol(stretch_buf, row_offset_l, row_offset_r, src_col_l, src_col_r, res_x, res_y, Bpp, 0);\r
680                             if (bHasAlpha) {\r
681                                 if (transformF != FXDIB_Argb) {\r
682                                     if (transformF == FXDIB_Rgba) {\r
683                                         dest_pos[0] = r_pos_blue_c_r;\r
684                                         dest_pos[1] = r_pos_green_m_r;\r
685                                         dest_pos[2] = r_pos_red_y_r;\r
686                                     } else {\r
687                                         r_pos_k_r = _bilinear_interpol(stretch_buf, row_offset_l, row_offset_r, src_col_l, src_col_r, res_x, res_y, Bpp, 3);\r
688                                         *(FX_DWORD*)dest_pos = FXCMYK_TODIB(CmykEncode(r_pos_blue_c_r, r_pos_green_m_r, r_pos_red_y_r, r_pos_k_r));\r
689                                     }\r
690                                 } else {\r
691                                     FX_BYTE r_pos_a_r = _bilinear_interpol(stretch_buf, row_offset_l, row_offset_r, src_col_l, src_col_r, res_x, res_y, Bpp, 3);\r
692                                     *(FX_DWORD*)dest_pos = FXARGB_TODIB(FXARGB_MAKE(r_pos_a_r, r_pos_red_y_r, r_pos_green_m_r, r_pos_blue_c_r));\r
693                                 }\r
694                             } else {\r
695                                 r_pos_k_r = 0xff;\r
696                                 if (transformF == FXDIB_Cmyka) {\r
697                                     r_pos_k_r = _bilinear_interpol(stretch_buf, row_offset_l, row_offset_r, src_col_l, src_col_r, res_x, res_y, Bpp, 3);\r
698                                     *(FX_DWORD*)dest_pos = FXCMYK_TODIB(CmykEncode(r_pos_blue_c_r, r_pos_green_m_r, r_pos_red_y_r, r_pos_k_r));\r
699                                 } else {\r
700                                     *(FX_DWORD*)dest_pos = FXARGB_TODIB(FXARGB_MAKE(r_pos_k_r, r_pos_red_y_r, r_pos_green_m_r, r_pos_blue_c_r));\r
701                                 }\r
702                             }\r
703                         }\r
704                         dest_pos += destBpp;\r
705                     }\r
706                 }\r
707             } else if (m_Flags & FXDIB_BICUBIC_INTERPOL) {\r
708                 CFX_BilinearMatrix result2stretch_fix(result2stretch, 8);\r
709                 int pos_pixel[8];\r
710                 for (int row = 0; row < m_ResultHeight; row ++) {\r
711                     FX_BYTE* dest_pos = (FX_BYTE*)pTransformed->GetScanline(row);\r
712                     for (int col = 0; col < m_ResultWidth; col ++) {\r
713                         int src_col_l, src_row_l, res_x, res_y, r_pos_k_r = 0;\r
714                         result2stretch_fix.Transform(col, row, src_col_l, src_row_l, res_x, res_y);\r
715                         if (src_col_l >= 0 && src_col_l <= stretch_width && src_row_l >= 0 && src_row_l <= stretch_height) {\r
716                             int u_w[4], v_w[4];\r
717                             if (src_col_l == stretch_width) {\r
718                                 src_col_l--;\r
719                             }\r
720                             if (src_row_l == stretch_height) {\r
721                                 src_row_l--;\r
722                             }\r
723                             _bicubic_get_pos_weight(pos_pixel, u_w, v_w, src_col_l, src_row_l, res_x, res_y, stretch_width, stretch_height);\r
724                             FX_BYTE r_pos_red_y_r   = _bicubic_interpol(stretch_buf, stretch_pitch, pos_pixel, u_w, v_w, res_x, res_y, Bpp, 2);\r
725                             FX_BYTE r_pos_green_m_r = _bicubic_interpol(stretch_buf, stretch_pitch, pos_pixel, u_w, v_w, res_x, res_y, Bpp, 1);\r
726                             FX_BYTE r_pos_blue_c_r  = _bicubic_interpol(stretch_buf, stretch_pitch, pos_pixel, u_w, v_w, res_x, res_y, Bpp, 0);\r
727                             if (bHasAlpha) {\r
728                                 if (transformF != FXDIB_Argb) {\r
729                                     if (transformF == FXDIB_Rgba) {\r
730                                         dest_pos[0] = r_pos_blue_c_r;\r
731                                         dest_pos[1] = r_pos_green_m_r;\r
732                                         dest_pos[2] = r_pos_red_y_r;\r
733                                     } else {\r
734                                         r_pos_k_r = _bicubic_interpol(stretch_buf, stretch_pitch, pos_pixel, u_w, v_w, res_x, res_y, Bpp, 3);\r
735                                         *(FX_DWORD*)dest_pos = FXCMYK_TODIB(CmykEncode(r_pos_blue_c_r, r_pos_green_m_r, r_pos_red_y_r, r_pos_k_r));\r
736                                     }\r
737                                 } else {\r
738                                     FX_BYTE r_pos_a_r = _bicubic_interpol(stretch_buf, stretch_pitch, pos_pixel, u_w, v_w, res_x, res_y, Bpp, 3);\r
739                                     *(FX_DWORD*)dest_pos = FXARGB_TODIB(FXARGB_MAKE(r_pos_a_r, r_pos_red_y_r, r_pos_green_m_r, r_pos_blue_c_r));\r
740                                 }\r
741                             } else {\r
742                                 r_pos_k_r = 0xff;\r
743                                 if (transformF == FXDIB_Cmyka) {\r
744                                     r_pos_k_r = _bicubic_interpol(stretch_buf, stretch_pitch, pos_pixel, u_w, v_w, res_x, res_y, Bpp, 3);\r
745                                     *(FX_DWORD*)dest_pos = FXCMYK_TODIB(CmykEncode(r_pos_blue_c_r, r_pos_green_m_r, r_pos_red_y_r, r_pos_k_r));\r
746                                 } else {\r
747                                     *(FX_DWORD*)dest_pos = FXARGB_TODIB(FXARGB_MAKE(r_pos_k_r, r_pos_red_y_r, r_pos_green_m_r, r_pos_blue_c_r));\r
748                                 }\r
749                             }\r
750                         }\r
751                         dest_pos += destBpp;\r
752                     }\r
753                 }\r
754             } else {\r
755                 CPDF_FixedMatrix result2stretch_fix(result2stretch, 8);\r
756                 for (int row = 0; row < m_ResultHeight; row ++) {\r
757                     FX_BYTE* dest_pos = (FX_BYTE*)pTransformed->GetScanline(row);\r
758                     for (int col = 0; col < m_ResultWidth; col ++) {\r
759                         int src_col, src_row;\r
760                         result2stretch_fix.Transform(col, row, src_col, src_row);\r
761                         if (src_col >= 0 && src_col <= stretch_width && src_row >= 0 && src_row <= stretch_height) {\r
762                             if (src_col == stretch_width) {\r
763                                 src_col --;\r
764                             }\r
765                             if (src_row == stretch_height) {\r
766                                 src_row --;\r
767                             }\r
768                             FX_LPCBYTE src_pos = stretch_buf + src_row * stretch_pitch + src_col * Bpp;\r
769                             if (bHasAlpha) {\r
770                                 if (transformF != FXDIB_Argb) {\r
771                                     if (transformF == FXDIB_Rgba) {\r
772                                         dest_pos[0] = src_pos[0];\r
773                                         dest_pos[1] = src_pos[1];\r
774                                         dest_pos[2] = src_pos[2];\r
775                                     } else {\r
776                                         *(FX_DWORD*)dest_pos = FXCMYK_TODIB(CmykEncode(src_pos[0], src_pos[1], src_pos[2], src_pos[3]));\r
777                                     }\r
778                                 } else {\r
779                                     *(FX_DWORD*)dest_pos = FXARGB_TODIB(FXARGB_MAKE(src_pos[3], src_pos[2], src_pos[1], src_pos[0]));\r
780                                 }\r
781                             } else {\r
782                                 if (transformF == FXDIB_Cmyka) {\r
783                                     *(FX_DWORD*)dest_pos = FXCMYK_TODIB(CmykEncode(src_pos[0], src_pos[1], src_pos[2], src_pos[3]));\r
784                                 } else {\r
785                                     *(FX_DWORD*)dest_pos = FXARGB_TODIB(FXARGB_MAKE(0xff, src_pos[2], src_pos[1], src_pos[0]));\r
786                                 }\r
787                             }\r
788                         }\r
789                         dest_pos += destBpp;\r
790                     }\r
791                 }\r
792             }\r
793         }\r
794     }\r
795     m_Storer.Replace(pTransformed);\r
796     return FALSE;\r
797 }\r