a51038628e18022a35f81a6b9e761edc958e715a
[pdfium.git] / core / src / fxge / dib / fx_dib_engine.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 "dib_int.h"
10 #include <limits.h>
11 extern int SDP_Table[513];
12 void CWeightTable::Calc(int dest_len, int dest_min, int dest_max, int src_len, int src_min, int src_max, int flags)
13 {
14     if (m_pWeightTables) {
15         FX_Free(m_pWeightTables);
16         m_pWeightTables = NULL;
17     }
18     double scale, base;
19     scale = FXSYS_Div((FX_FLOAT)(src_len), (FX_FLOAT)(dest_len));
20     if (dest_len < 0) {
21         base = (FX_FLOAT)(src_len);
22     } else {
23         base = 0;
24     }
25     int ext_size = flags & FXDIB_BICUBIC_INTERPOL ? 3 : 1;
26     m_ItemSize = sizeof(int) * 2 + (int)(sizeof(int) * (FXSYS_ceil(FXSYS_fabs((FX_FLOAT)scale)) + ext_size));
27     m_DestMin = dest_min;
28     if ((dest_max - dest_min) > (int)((1U << 30) - 4) / m_ItemSize) {
29         return;
30     }
31     m_pWeightTables = FX_AllocNL(FX_BYTE, (dest_max - dest_min) * m_ItemSize + 4);
32     if (m_pWeightTables == NULL) {
33         return;
34     }
35     FXSYS_memset32(m_pWeightTables, 0, sizeof(FX_BYTE) * ((dest_max - dest_min)*m_ItemSize + 4));
36     if ((flags & FXDIB_NOSMOOTH) != 0 || FXSYS_fabs((FX_FLOAT)scale) < 1.0f) {
37         for (int dest_pixel = dest_min; dest_pixel < dest_max; dest_pixel ++) {
38             PixelWeight& pixel_weights = *GetPixelWeight(dest_pixel);
39             double src_pos = dest_pixel * scale + scale / 2 + base;
40             if (flags & FXDIB_INTERPOL) {
41                 pixel_weights.m_SrcStart = (int)FXSYS_floor((FX_FLOAT)src_pos - 1.0f / 2);
42                 pixel_weights.m_SrcEnd = (int)FXSYS_floor((FX_FLOAT)src_pos + 1.0f / 2);
43                 if (pixel_weights.m_SrcStart < src_min) {
44                     pixel_weights.m_SrcStart = src_min;
45                 }
46                 if (pixel_weights.m_SrcEnd >= src_max) {
47                     pixel_weights.m_SrcEnd = src_max - 1;
48                 }
49                 if (pixel_weights.m_SrcStart == pixel_weights.m_SrcEnd) {
50                     pixel_weights.m_Weights[0] = 65536;
51                 } else {
52                     pixel_weights.m_Weights[1] = FXSYS_round((FX_FLOAT)(src_pos - pixel_weights.m_SrcStart - 1.0f / 2) * 65536);
53                     pixel_weights.m_Weights[0] = 65536 - pixel_weights.m_Weights[1];
54                 }
55             } else if (flags & FXDIB_BICUBIC_INTERPOL) {
56                 pixel_weights.m_SrcStart = (int)FXSYS_floor((FX_FLOAT)src_pos - 1.0f / 2);
57                 pixel_weights.m_SrcEnd = (int)FXSYS_floor((FX_FLOAT)src_pos + 1.0f / 2);
58                 int start = pixel_weights.m_SrcStart - 1;
59                 int end = pixel_weights.m_SrcEnd + 1;
60                 if (start < src_min) {
61                     start = src_min;
62                 }
63                 if (end >= src_max) {
64                     end = src_max - 1;
65                 }
66                 if (pixel_weights.m_SrcStart < src_min) {
67                     src_pos += src_min - pixel_weights.m_SrcStart;
68                     pixel_weights.m_SrcStart = src_min;
69                 }
70                 if (pixel_weights.m_SrcEnd >= src_max) {
71                     pixel_weights.m_SrcEnd = src_max - 1;
72                 }
73                 int weight;
74                 weight = FXSYS_round((FX_FLOAT)(src_pos - pixel_weights.m_SrcStart - 1.0f / 2) * 256);
75                 if (start == end) {
76                     pixel_weights.m_Weights[0] = (SDP_Table[256 + weight] + SDP_Table[weight] + SDP_Table[256 - weight] + SDP_Table[512 - weight]) << 8;
77                 } else if ((start == pixel_weights.m_SrcStart && (pixel_weights.m_SrcStart == pixel_weights.m_SrcEnd ||
78                             end == pixel_weights.m_SrcEnd) && start < end) || (start < pixel_weights.m_SrcStart && pixel_weights.m_SrcStart == pixel_weights.m_SrcEnd && end == pixel_weights.m_SrcEnd)) {
79                     if (start < pixel_weights.m_SrcStart) {
80                         pixel_weights.m_Weights[0] = SDP_Table[256 + weight] << 8;
81                         pixel_weights.m_Weights[1] = (SDP_Table[weight] + SDP_Table[256 - weight] + SDP_Table[512 - weight]) << 8;
82                     } else {
83                         if (pixel_weights.m_SrcStart == pixel_weights.m_SrcEnd) {
84                             pixel_weights.m_Weights[0] = (SDP_Table[256 + weight] + SDP_Table[weight] + SDP_Table[256 - weight]) << 8;
85                             pixel_weights.m_Weights[1] = SDP_Table[512 - weight] << 8;
86                         } else {
87                             pixel_weights.m_Weights[0] = (SDP_Table[256 + weight] + SDP_Table[weight]) << 8;
88                             pixel_weights.m_Weights[1] = (SDP_Table[256 - weight] + SDP_Table[512 - weight]) << 8;
89                         }
90                     }
91                     if (pixel_weights.m_SrcStart == pixel_weights.m_SrcEnd) {
92                         pixel_weights.m_SrcEnd = end;
93                     }
94                     if (start < pixel_weights.m_SrcStart) {
95                         pixel_weights.m_SrcStart = start;
96                     }
97                 } else if (start == pixel_weights.m_SrcStart &&
98                            start < pixel_weights.m_SrcEnd &&
99                            pixel_weights.m_SrcEnd < end) {
100                     pixel_weights.m_Weights[0] = (SDP_Table[256 + weight] + SDP_Table[weight]) << 8;
101                     pixel_weights.m_Weights[1] = SDP_Table[256 - weight] << 8;
102                     pixel_weights.m_Weights[2] = SDP_Table[512 - weight] << 8;
103                     pixel_weights.m_SrcEnd = end;
104                 } else if (start < pixel_weights.m_SrcStart &&
105                            pixel_weights.m_SrcStart < pixel_weights.m_SrcEnd &&
106                            pixel_weights.m_SrcEnd == end) {
107                     pixel_weights.m_Weights[0] = SDP_Table[256 + weight] << 8;
108                     pixel_weights.m_Weights[1] = SDP_Table[weight] << 8;
109                     pixel_weights.m_Weights[2] = (SDP_Table[256 - weight] + SDP_Table[512 - weight]) << 8;
110                     pixel_weights.m_SrcStart = start;
111                 } else {
112                     pixel_weights.m_Weights[0] = SDP_Table[256 + weight] << 8;
113                     pixel_weights.m_Weights[1] = SDP_Table[weight] << 8;
114                     pixel_weights.m_Weights[2] = SDP_Table[256 - weight] << 8;
115                     pixel_weights.m_Weights[3] = SDP_Table[512 - weight] << 8;
116                     pixel_weights.m_SrcStart = start;
117                     pixel_weights.m_SrcEnd = end;
118                 }
119             } else {
120                 pixel_weights.m_SrcStart = pixel_weights.m_SrcEnd = (int)FXSYS_floor((FX_FLOAT)src_pos);
121                 if (pixel_weights.m_SrcStart < src_min) {
122                     pixel_weights.m_SrcStart = src_min;
123                 }
124                 if (pixel_weights.m_SrcEnd >= src_max) {
125                     pixel_weights.m_SrcEnd = src_max - 1;
126                 }
127                 pixel_weights.m_Weights[0] = 65536;
128             }
129         }
130         return;
131     }
132     for (int dest_pixel = dest_min; dest_pixel < dest_max; dest_pixel ++) {
133         PixelWeight& pixel_weights = *GetPixelWeight(dest_pixel);
134         double src_start = dest_pixel * scale + base;
135         double src_end = src_start + scale;
136         int start_i, end_i;
137         if (src_start < src_end) {
138             start_i = (int)FXSYS_floor((FX_FLOAT)src_start);
139             end_i = (int)FXSYS_ceil((FX_FLOAT)src_end);
140         } else {
141             start_i = (int)FXSYS_floor((FX_FLOAT)src_end);
142             end_i = (int)FXSYS_ceil((FX_FLOAT)src_start);
143         }
144         if (start_i < src_min) {
145             start_i = src_min;
146         }
147         if (end_i >= src_max) {
148             end_i = src_max - 1;
149         }
150         if (start_i > end_i) {
151             if (start_i >= src_max) {
152                 start_i = src_max - 1;
153             }
154             pixel_weights.m_SrcStart = start_i;
155             pixel_weights.m_SrcEnd = start_i;
156             continue;
157         }
158         pixel_weights.m_SrcStart = start_i;
159         pixel_weights.m_SrcEnd = end_i;
160         for (int j = start_i; j <= end_i; j ++) {
161             double dest_start = FXSYS_Div((FX_FLOAT)(j) - base, scale);
162             double dest_end = FXSYS_Div((FX_FLOAT)(j + 1) - base, scale);
163             if (dest_start > dest_end) {
164                 double temp = dest_start;
165                 dest_start = dest_end;
166                 dest_end = temp;
167             }
168             double area_start = dest_start > (FX_FLOAT)(dest_pixel) ? dest_start : (FX_FLOAT)(dest_pixel);
169             double area_end = dest_end > (FX_FLOAT)(dest_pixel + 1) ? (FX_FLOAT)(dest_pixel + 1) : dest_end;
170             double weight = area_start >= area_end ? 0.0f : area_end - area_start;
171             if (weight == 0 && j == end_i) {
172                 pixel_weights.m_SrcEnd --;
173                 break;
174             }
175             pixel_weights.m_Weights[j - start_i] = FXSYS_round((FX_FLOAT)(weight * 65536));
176         }
177     }
178 }
179 CStretchEngine::CStretchEngine(IFX_ScanlineComposer* pDestBitmap, FXDIB_Format dest_format,
180                                int dest_width, int dest_height, const FX_RECT& clip_rect,
181                                const CFX_DIBSource* pSrcBitmap, int flags)
182 {
183     m_State = 0;
184     m_DestFormat = dest_format;
185     m_DestBpp = dest_format & 0xff;
186     m_SrcBpp = pSrcBitmap->GetFormat() & 0xff;
187     m_bHasAlpha = pSrcBitmap->GetFormat() & 0x200;
188     m_pSrcPalette = pSrcBitmap->GetPalette();
189     m_pDestBitmap = pDestBitmap;
190     m_DestWidth = dest_width;
191     m_DestHeight = dest_height;
192     m_pInterBuf = NULL;
193     m_pExtraAlphaBuf = NULL;
194     m_pDestMaskScanline = NULL;
195     m_DestClip = clip_rect;
196     FX_DWORD size = clip_rect.Width();
197     if (size && m_DestBpp > (int)(INT_MAX / size)) {
198         return;
199     }
200     size *= m_DestBpp;
201     if (size > INT_MAX - 31) {
202         return;
203     }
204     size += 31;
205     size = size / 32 * 4;
206     m_pDestScanline = FX_AllocNL(FX_BYTE, size);
207     if (m_pDestScanline == NULL) {
208         return;
209     }
210     FXSYS_memset32(m_pDestScanline, 0, sizeof(FX_BYTE) * size);
211     if (dest_format == FXDIB_Rgb32) {
212         FXSYS_memset8(m_pDestScanline, 255, size);
213     }
214     m_InterPitch = (m_DestClip.Width() * m_DestBpp + 31) / 32 * 4;
215     m_ExtraMaskPitch = (m_DestClip.Width() * 8 + 31) / 32 * 4;
216     m_pInterBuf = NULL;
217     m_pSource = pSrcBitmap;
218     m_SrcWidth = pSrcBitmap->GetWidth();
219     m_SrcHeight = pSrcBitmap->GetHeight();
220     m_SrcPitch = (m_SrcWidth * m_SrcBpp + 31) / 32 * 4;
221     if ((flags & FXDIB_NOSMOOTH) == 0) {
222         FX_BOOL bInterpol = flags & FXDIB_INTERPOL || flags & FXDIB_BICUBIC_INTERPOL;
223         if (!bInterpol && FXSYS_abs(dest_width) != 0 && FXSYS_abs(dest_height) < m_SrcWidth * m_SrcHeight * 8 / FXSYS_abs(dest_width)) {
224             flags = FXDIB_INTERPOL;
225         }
226         m_Flags = flags;
227     } else {
228         m_Flags = FXDIB_NOSMOOTH;
229         if (flags & FXDIB_DOWNSAMPLE) {
230             m_Flags |= FXDIB_DOWNSAMPLE;
231         }
232     }
233     double scale_x = FXSYS_Div((FX_FLOAT)(m_SrcWidth), (FX_FLOAT)(m_DestWidth));
234     double scale_y = FXSYS_Div((FX_FLOAT)(m_SrcHeight), (FX_FLOAT)(m_DestHeight));
235     double base_x = m_DestWidth > 0 ? 0.0f : (FX_FLOAT)(m_DestWidth);
236     double base_y = m_DestHeight > 0 ? 0.0f : (FX_FLOAT)(m_DestHeight);
237     double src_left = FXSYS_Mul(scale_x, (FX_FLOAT)(clip_rect.left) + base_x);
238     double src_right = FXSYS_Mul(scale_x, (FX_FLOAT)(clip_rect.right) + base_x);
239     double src_top = FXSYS_Mul(scale_y, (FX_FLOAT)(clip_rect.top) + base_y);
240     double src_bottom = FXSYS_Mul(scale_y, (FX_FLOAT)(clip_rect.bottom) + base_y);
241     if (src_left > src_right) {
242         double temp = src_left;
243         src_left = src_right;
244         src_right = temp;
245     }
246     if (src_top > src_bottom) {
247         double temp = src_top;
248         src_top = src_bottom;
249         src_bottom = temp;
250     }
251     m_SrcClip.left = (int)FXSYS_floor((FX_FLOAT)src_left);
252     m_SrcClip.right = (int)FXSYS_ceil((FX_FLOAT)src_right);
253     m_SrcClip.top = (int)FXSYS_floor((FX_FLOAT)src_top);
254     m_SrcClip.bottom = (int)FXSYS_ceil((FX_FLOAT)src_bottom);
255     FX_RECT src_rect(0, 0, m_SrcWidth, m_SrcHeight);
256     m_SrcClip.Intersect(src_rect);
257     if (m_SrcBpp == 1) {
258         if (m_DestBpp == 8) {
259             m_TransMethod = 1;
260         } else {
261             m_TransMethod = 2;
262         }
263     } else if (m_SrcBpp == 8) {
264         if (m_DestBpp == 8) {
265             if (!m_bHasAlpha) {
266                 m_TransMethod = 3;
267             } else {
268                 m_TransMethod = 4;
269             }
270         } else {
271             if (!m_bHasAlpha) {
272                 m_TransMethod = 5;
273             } else {
274                 m_TransMethod = 6;
275             }
276         }
277     } else {
278         if (!m_bHasAlpha) {
279             m_TransMethod = 7;
280         } else {
281             m_TransMethod = 8;
282         }
283     }
284 }
285 FX_BOOL CStretchEngine::Continue(IFX_Pause* pPause)
286 {
287     while (m_State == 1) {
288         if (ContinueStretchHorz(pPause)) {
289             return TRUE;
290         }
291         m_State = 2;
292         StretchVert();
293     }
294     return FALSE;
295 }
296 CStretchEngine::~CStretchEngine()
297 {
298     if (m_pDestScanline) {
299         FX_Free(m_pDestScanline);
300     }
301     if (m_pInterBuf) {
302         FX_Free(m_pInterBuf);
303     }
304     if (m_pExtraAlphaBuf) {
305         FX_Free(m_pExtraAlphaBuf);
306     }
307     if (m_pDestMaskScanline) {
308         FX_Free(m_pDestMaskScanline);
309     }
310 }
311 FX_BOOL CStretchEngine::StartStretchHorz()
312 {
313     if (m_DestWidth == 0 || m_pDestScanline == NULL || m_SrcClip.Height() > (int)((1U << 29) / m_InterPitch) || m_SrcClip.Height() == 0) {
314         return FALSE;
315     }
316 #ifndef _FPDFAPI_MINI_
317     m_pInterBuf = FX_AllocNL(unsigned char, m_SrcClip.Height() * m_InterPitch);
318 #else
319     m_pInterBuf = FX_Alloc(unsigned char, m_SrcClip.Height() * m_InterPitch);
320 #endif
321     if (m_pInterBuf == NULL) {
322         return FALSE;
323     }
324     if (m_pSource && m_bHasAlpha && m_pSource->m_pAlphaMask) {
325         m_pExtraAlphaBuf = FX_Alloc(unsigned char, m_SrcClip.Height() * m_ExtraMaskPitch);
326         if (!m_pExtraAlphaBuf) {
327             return FALSE;
328         }
329         FX_DWORD size = (m_DestClip.Width() * 8 + 31) / 32 * 4;
330         m_pDestMaskScanline = FX_AllocNL(unsigned char, size);
331         if (!m_pDestMaskScanline) {
332             return FALSE;
333         }
334     }
335     m_WeightTable.Calc(m_DestWidth, m_DestClip.left, m_DestClip.right, m_SrcWidth, m_SrcClip.left, m_SrcClip.right, m_Flags);
336     if (m_WeightTable.m_pWeightTables == NULL) {
337         return FALSE;
338     }
339     m_CurRow = m_SrcClip.top;
340     m_State = 1;
341     return TRUE;
342 }
343 #define FX_STRECH_PAUSE_ROWS    10
344 FX_BOOL CStretchEngine::ContinueStretchHorz(IFX_Pause* pPause)
345 {
346     if (!m_DestWidth) {
347         return 0;
348     }
349     if (m_pSource->SkipToScanline(m_CurRow, pPause)) {
350         return TRUE;
351     }
352     int Bpp = m_DestBpp / 8;
353     int rows_to_go = FX_STRECH_PAUSE_ROWS;
354     for (; m_CurRow < m_SrcClip.bottom; m_CurRow ++) {
355         if (rows_to_go == 0) {
356             if (pPause && pPause->NeedToPauseNow()) {
357                 return TRUE;
358             } else {
359                 rows_to_go = FX_STRECH_PAUSE_ROWS;
360             }
361         }
362         FX_LPCBYTE src_scan = m_pSource->GetScanline(m_CurRow);
363         FX_LPBYTE dest_scan = m_pInterBuf + (m_CurRow - m_SrcClip.top) * m_InterPitch;
364         FX_LPCBYTE src_scan_mask = NULL;
365         FX_LPBYTE dest_scan_mask = NULL;
366         if (m_pExtraAlphaBuf) {
367             src_scan_mask = m_pSource->m_pAlphaMask->GetScanline(m_CurRow);
368             dest_scan_mask = m_pExtraAlphaBuf + (m_CurRow - m_SrcClip.top) * m_ExtraMaskPitch;
369         }
370         switch (m_TransMethod) {
371             case 1:
372             case 2: {
373                     for (int col = m_DestClip.left; col < m_DestClip.right; col ++) {
374                         PixelWeight* pPixelWeights = m_WeightTable.GetPixelWeight(col);
375                         int dest_a = 0;
376                         for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd; j ++) {
377                             int pixel_weight = pPixelWeights->m_Weights[j - pPixelWeights->m_SrcStart];
378                             if (src_scan[j / 8] & (1 << (7 - j % 8))) {
379                                 dest_a += pixel_weight * 255;
380                             }
381                         }
382                         if (m_Flags & FXDIB_BICUBIC_INTERPOL) {
383                             dest_a = dest_a < 0 ? 0 : dest_a > 16711680 ? 16711680 : dest_a;
384                         }
385                         *dest_scan++ = (FX_BYTE)(dest_a >> 16);
386                     }
387                     break;
388                 }
389             case 3: {
390                     for (int col = m_DestClip.left; col < m_DestClip.right; col ++) {
391                         PixelWeight* pPixelWeights = m_WeightTable.GetPixelWeight(col);
392                         int dest_a = 0;
393                         for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd; j ++) {
394                             int pixel_weight = pPixelWeights->m_Weights[j - pPixelWeights->m_SrcStart];
395                             dest_a += pixel_weight * src_scan[j];
396                         }
397                         if (m_Flags & FXDIB_BICUBIC_INTERPOL) {
398                             dest_a = dest_a < 0 ? 0 : dest_a > 16711680 ? 16711680 : dest_a;
399                         }
400                         *dest_scan++ = (FX_BYTE)(dest_a >> 16);
401                     }
402                     break;
403                 }
404             case 4: {
405                     for (int col = m_DestClip.left; col < m_DestClip.right; col ++) {
406                         PixelWeight* pPixelWeights = m_WeightTable.GetPixelWeight(col);
407                         int dest_a = 0, dest_r = 0;
408                         for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd; j ++) {
409                             int pixel_weight = pPixelWeights->m_Weights[j - pPixelWeights->m_SrcStart];
410                             pixel_weight = pixel_weight * src_scan_mask[j] / 255;
411                             dest_r += pixel_weight * src_scan[j];
412                             dest_a += pixel_weight;
413                         }
414                         if (m_Flags & FXDIB_BICUBIC_INTERPOL) {
415                             dest_r = dest_r < 0 ? 0 : dest_r > 16711680 ? 16711680 : dest_r;
416                             dest_a = dest_a < 0 ? 0 : dest_a > 65536 ? 65536 : dest_a;
417                         }
418                         *dest_scan++ = (FX_BYTE)(dest_r >> 16);
419                         *dest_scan_mask++ = (FX_BYTE)((dest_a * 255) >> 16);
420                     }
421                     break;
422                 }
423             case 5: {
424                     for (int col = m_DestClip.left; col < m_DestClip.right; col ++) {
425                         PixelWeight* pPixelWeights = m_WeightTable.GetPixelWeight(col);
426                         int dest_r_y = 0, dest_g_m = 0, dest_b_c = 0, dest_k = 0;
427                         for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd; j ++) {
428                             int pixel_weight = pPixelWeights->m_Weights[j - pPixelWeights->m_SrcStart];
429                             unsigned long argb_cmyk = m_pSrcPalette[src_scan[j]];
430                             if (m_DestFormat == FXDIB_Rgb) {
431                                 dest_r_y += pixel_weight * (FX_BYTE)(argb_cmyk >> 16);
432                                 dest_g_m += pixel_weight * (FX_BYTE)(argb_cmyk >> 8);
433                                 dest_b_c += pixel_weight * (FX_BYTE)argb_cmyk;
434                             } else {
435                                 dest_b_c += pixel_weight * (FX_BYTE)(argb_cmyk >> 24);
436                                 dest_g_m += pixel_weight * (FX_BYTE)(argb_cmyk >> 16);
437                                 dest_r_y += pixel_weight * (FX_BYTE)(argb_cmyk >> 8);
438                             }
439                         }
440                         if (m_Flags & FXDIB_BICUBIC_INTERPOL) {
441                             dest_r_y = dest_r_y < 0 ? 0 : dest_r_y > 16711680 ? 16711680 : dest_r_y;
442                             dest_g_m = dest_g_m < 0 ? 0 : dest_g_m > 16711680 ? 16711680 : dest_g_m;
443                             dest_b_c = dest_b_c < 0 ? 0 : dest_b_c > 16711680 ? 16711680 : dest_b_c;
444                         }
445                         *dest_scan++ = (FX_BYTE)(dest_b_c >> 16);
446                         *dest_scan++ = (FX_BYTE)(dest_g_m >> 16);
447                         *dest_scan++ = (FX_BYTE)(dest_r_y >> 16);
448                     }
449                     break;
450                 }
451             case 6: {
452                     for (int col = m_DestClip.left; col < m_DestClip.right; col ++) {
453                         PixelWeight* pPixelWeights = m_WeightTable.GetPixelWeight(col);
454                         int dest_a = 0, dest_r_y = 0, dest_g_m = 0, dest_b_c = 0, dest_k = 0;
455                         for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd; j ++) {
456                             int pixel_weight = pPixelWeights->m_Weights[j - pPixelWeights->m_SrcStart];
457                             pixel_weight = pixel_weight * src_scan_mask[j] / 255;
458                             unsigned long argb_cmyk = m_pSrcPalette[src_scan[j]];
459                             if (m_DestFormat == FXDIB_Rgba) {
460                                 dest_r_y += pixel_weight * (FX_BYTE)(argb_cmyk >> 16);
461                                 dest_g_m += pixel_weight * (FX_BYTE)(argb_cmyk >> 8);
462                                 dest_b_c += pixel_weight * (FX_BYTE)argb_cmyk;
463                             } else {
464                                 dest_b_c += pixel_weight * (FX_BYTE)(argb_cmyk >> 24);
465                                 dest_g_m += pixel_weight * (FX_BYTE)(argb_cmyk >> 16);
466                                 dest_r_y += pixel_weight * (FX_BYTE)(argb_cmyk >> 8);
467                             }
468                             dest_a += pixel_weight;
469                         }
470                         if (m_Flags & FXDIB_BICUBIC_INTERPOL) {
471                             dest_k = dest_k < 0 ? 0 : dest_k > 16711680 ? 16711680 : dest_k;
472                             dest_b_c = dest_b_c < 0 ? 0 : dest_b_c > 16711680 ? 16711680 : dest_b_c;
473                             dest_g_m = dest_g_m < 0 ? 0 : dest_g_m > 16711680 ? 16711680 : dest_g_m;
474                             dest_r_y = dest_r_y < 0 ? 0 : dest_r_y > 16711680 ? 16711680 : dest_r_y;
475                             dest_a = dest_a < 0 ? 0 : dest_a > 65536 ? 65536 : dest_a;
476                         }
477                         *dest_scan++ = (FX_BYTE)(dest_b_c >> 16);
478                         *dest_scan++ = (FX_BYTE)(dest_g_m >> 16);
479                         *dest_scan++ = (FX_BYTE)(dest_r_y >> 16);
480                         *dest_scan_mask++ = (FX_BYTE)((dest_a * 255) >> 16);
481                     }
482                     break;
483                 }
484             case 7: {
485                     for (int col = m_DestClip.left; col < m_DestClip.right; col ++) {
486                         PixelWeight* pPixelWeights = m_WeightTable.GetPixelWeight(col);
487                         int dest_r_y = 0, dest_g_m = 0, dest_b_c = 0, dest_k = 0;
488                         for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd; j ++) {
489                             int pixel_weight = pPixelWeights->m_Weights[j - pPixelWeights->m_SrcStart];
490                             FX_LPCBYTE src_pixel = src_scan + j * Bpp;
491                             dest_b_c += pixel_weight * (*src_pixel++);
492                             dest_g_m += pixel_weight * (*src_pixel++);
493                             dest_r_y += pixel_weight * (*src_pixel);
494                         }
495                         if (m_Flags & FXDIB_BICUBIC_INTERPOL) {
496                             dest_b_c = dest_b_c < 0 ? 0 : dest_b_c > 16711680 ? 16711680 : dest_b_c;
497                             dest_g_m = dest_g_m < 0 ? 0 : dest_g_m > 16711680 ? 16711680 : dest_g_m;
498                             dest_r_y = dest_r_y < 0 ? 0 : dest_r_y > 16711680 ? 16711680 : dest_r_y;
499                         }
500                         *dest_scan++ = (FX_BYTE)((dest_b_c) >> 16);
501                         *dest_scan++ = (FX_BYTE)((dest_g_m) >> 16);
502                         *dest_scan++ = (FX_BYTE)((dest_r_y) >> 16);
503                         dest_scan += Bpp - 3;
504                     }
505                     break;
506                 }
507             case 8: {
508                     for (int col = m_DestClip.left; col < m_DestClip.right; col ++) {
509                         PixelWeight* pPixelWeights = m_WeightTable.GetPixelWeight(col);
510                         int dest_a = 0, dest_r_y = 0, dest_g_m = 0, dest_b_c = 0, dest_k = 0;
511                         for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd; j ++) {
512                             int pixel_weight = pPixelWeights->m_Weights[j - pPixelWeights->m_SrcStart];
513                             FX_LPCBYTE src_pixel = src_scan + j * Bpp;
514                             if (m_DestFormat == FXDIB_Argb) {
515                                 pixel_weight = pixel_weight * src_pixel[3] / 255;
516                             } else {
517                                 pixel_weight = pixel_weight * src_scan_mask[j] / 255;
518                             }
519                             dest_b_c += pixel_weight * (*src_pixel++);
520                             dest_g_m += pixel_weight * (*src_pixel++);
521                             dest_r_y += pixel_weight * (*src_pixel);
522                             dest_a += pixel_weight;
523                         }
524                         if (m_Flags & FXDIB_BICUBIC_INTERPOL) {
525                             dest_r_y = dest_r_y < 0 ? 0 : dest_r_y > 16711680 ? 16711680 : dest_r_y;
526                             dest_g_m = dest_g_m < 0 ? 0 : dest_g_m > 16711680 ? 16711680 : dest_g_m;
527                             dest_b_c = dest_b_c < 0 ? 0 : dest_b_c > 16711680 ? 16711680 : dest_b_c;
528                             dest_a = dest_a < 0 ? 0 : dest_a > 65536 ? 65536 : dest_a;
529                         }
530                         *dest_scan++ = (FX_BYTE)((dest_b_c) >> 16);
531                         *dest_scan++ = (FX_BYTE)((dest_g_m) >> 16);
532                         *dest_scan++ = (FX_BYTE)((dest_r_y) >> 16);
533                         if (m_DestFormat == FXDIB_Argb) {
534                             *dest_scan = (FX_BYTE)((dest_a * 255) >> 16);
535                         }
536                         if (dest_scan_mask) {
537                             *dest_scan_mask++ = (FX_BYTE)((dest_a * 255) >> 16);
538                         }
539                         dest_scan += Bpp - 3;
540                     }
541                     break;
542                 }
543         }
544         rows_to_go --;
545     }
546     return FALSE;
547 }
548 void CStretchEngine::StretchVert()
549 {
550     if (m_DestHeight == 0) {
551         return;
552     }
553     CWeightTable table;
554     table.Calc(m_DestHeight, m_DestClip.top, m_DestClip.bottom, m_SrcHeight, m_SrcClip.top, m_SrcClip.bottom, m_Flags);
555     if (table.m_pWeightTables == NULL) {
556         return;
557     }
558     int DestBpp = m_DestBpp / 8;
559     for (int row = m_DestClip.top; row < m_DestClip.bottom; row ++) {
560         unsigned char* dest_scan = m_pDestScanline;
561         unsigned char* dest_sacn_mask = m_pDestMaskScanline;
562         PixelWeight* pPixelWeights = table.GetPixelWeight(row);
563         switch(m_TransMethod) {
564             case 1:
565             case 2:
566             case 3: {
567                     for (int col = m_DestClip.left; col < m_DestClip.right; col ++) {
568                         unsigned char* src_scan = m_pInterBuf + (col - m_DestClip.left) * DestBpp;
569                         int dest_a = 0;
570                         for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd; j ++) {
571                             int pixel_weight = pPixelWeights->m_Weights[j - pPixelWeights->m_SrcStart];
572                             dest_a += pixel_weight * src_scan[(j - m_SrcClip.top) * m_InterPitch];
573                         }
574                         if (m_Flags & FXDIB_BICUBIC_INTERPOL) {
575                             dest_a = dest_a < 0 ? 0 : dest_a > 16711680 ? 16711680 : dest_a;
576                         }
577                         *dest_scan = (FX_BYTE)(dest_a >> 16);
578                         dest_scan += DestBpp;
579                     }
580                     break;
581                 }
582             case 4: {
583                     for (int col = m_DestClip.left; col < m_DestClip.right; col ++) {
584                         unsigned char* src_scan = m_pInterBuf + (col - m_DestClip.left) * DestBpp;
585                         unsigned char* src_scan_mask = m_pExtraAlphaBuf + (col - m_DestClip.left);
586                         int dest_a = 0, dest_k = 0;
587                         for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd; j ++) {
588                             int pixel_weight = pPixelWeights->m_Weights[j - pPixelWeights->m_SrcStart];
589                             dest_k += pixel_weight * src_scan[(j - m_SrcClip.top) * m_InterPitch];
590                             dest_a += pixel_weight * src_scan_mask[(j - m_SrcClip.top) * m_ExtraMaskPitch];
591                         }
592                         if (m_Flags & FXDIB_BICUBIC_INTERPOL) {
593                             dest_k = dest_k < 0 ? 0 : dest_k > 16711680 ? 16711680 : dest_k;
594                             dest_a = dest_a < 0 ? 0 : dest_a > 16711680 ? 16711680 : dest_a;
595                         }
596                         *dest_scan = (FX_BYTE)(dest_k >> 16);
597                         dest_scan += DestBpp;
598                         *dest_sacn_mask++ = (FX_BYTE)(dest_a >> 16);
599                     }
600                     break;
601                 }
602             case 5:
603             case 7: {
604                     for (int col = m_DestClip.left; col < m_DestClip.right; col ++) {
605                         unsigned char* src_scan = m_pInterBuf + (col - m_DestClip.left) * DestBpp;
606                         int dest_r_y = 0, dest_g_m = 0, dest_b_c = 0, dest_k = 0;
607                         for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd; j ++) {
608                             int pixel_weight = pPixelWeights->m_Weights[j - pPixelWeights->m_SrcStart];
609                             FX_LPCBYTE src_pixel = src_scan + (j - m_SrcClip.top) * m_InterPitch;
610                             dest_b_c += pixel_weight * (*src_pixel++);
611                             dest_g_m += pixel_weight * (*src_pixel++);
612                             dest_r_y += pixel_weight * (*src_pixel);
613                         }
614                         if (m_Flags & FXDIB_BICUBIC_INTERPOL) {
615                             dest_r_y = dest_r_y < 0 ? 0 : dest_r_y > 16711680 ? 16711680 : dest_r_y;
616                             dest_g_m = dest_g_m < 0 ? 0 : dest_g_m > 16711680 ? 16711680 : dest_g_m;
617                             dest_b_c = dest_b_c < 0 ? 0 : dest_b_c > 16711680 ? 16711680 : dest_b_c;
618                         }
619                         dest_scan[0] = (FX_BYTE)((dest_b_c) >> 16);
620                         dest_scan[1] = (FX_BYTE)((dest_g_m) >> 16);
621                         dest_scan[2] = (FX_BYTE)((dest_r_y) >> 16);
622                         dest_scan += DestBpp;
623                     }
624                     break;
625                 }
626             case 6:
627             case 8: {
628                     for (int col = m_DestClip.left; col < m_DestClip.right; col ++) {
629                         unsigned char* src_scan = m_pInterBuf + (col - m_DestClip.left) * DestBpp;
630                         unsigned char* src_scan_mask = NULL;
631                         if (m_DestFormat != FXDIB_Argb) {
632                             src_scan_mask = m_pExtraAlphaBuf + (col - m_DestClip.left);
633                         }
634                         int dest_a = 0, dest_k = 0, dest_r_y = 0, dest_g_m = 0, dest_b_c = 0;
635                         for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd; j ++) {
636                             int pixel_weight = pPixelWeights->m_Weights[j - pPixelWeights->m_SrcStart];
637                             FX_LPCBYTE src_pixel = src_scan + (j - m_SrcClip.top) * m_InterPitch;
638                             int mask_v = 255;
639                             if (src_scan_mask) {
640                                 mask_v = src_scan_mask[(j - m_SrcClip.top) * m_ExtraMaskPitch];
641                             }
642                             dest_b_c += pixel_weight * (*src_pixel++);
643                             dest_g_m += pixel_weight * (*src_pixel++);
644                             dest_r_y += pixel_weight * (*src_pixel);
645                             if (m_DestFormat == FXDIB_Argb) {
646                                 dest_a += pixel_weight * (*(src_pixel + 1));
647                             } else {
648                                 dest_a += pixel_weight * mask_v;
649                             }
650                         }
651                         if (m_Flags & FXDIB_BICUBIC_INTERPOL) {
652                             dest_r_y = dest_r_y < 0 ? 0 : dest_r_y > 16711680 ? 16711680 : dest_r_y;
653                             dest_g_m = dest_g_m < 0 ? 0 : dest_g_m > 16711680 ? 16711680 : dest_g_m;
654                             dest_b_c = dest_b_c < 0 ? 0 : dest_b_c > 16711680 ? 16711680 : dest_b_c;
655                             dest_a = dest_a < 0 ? 0 : dest_a > 16711680 ? 16711680 : dest_a;
656                         }
657                         if (dest_a) {
658                             int r = ((FX_DWORD)dest_r_y) * 255 / dest_a;
659                             int g = ((FX_DWORD)dest_g_m) * 255 / dest_a;
660                             int b = ((FX_DWORD)dest_b_c) * 255 / dest_a;
661                             dest_scan[0] = b > 255 ? 255 : b < 0 ? 0 : b;
662                             dest_scan[1] = g > 255 ? 255 : g < 0 ? 0 : g;
663                             dest_scan[2] = r > 255 ? 255 : r < 0 ? 0 : r;
664                         }
665                         if (m_DestFormat == FXDIB_Argb) {
666                             dest_scan[3] = (FX_BYTE)((dest_a) >> 16);
667                         } else {
668                             *dest_sacn_mask = (FX_BYTE)((dest_a) >> 16);
669                         }
670                         dest_scan += DestBpp;
671                         if (dest_sacn_mask) {
672                             dest_sacn_mask++;
673                         }
674                     }
675                     break;
676                 }
677         }
678         m_pDestBitmap->ComposeScanline(row - m_DestClip.top, m_pDestScanline, m_pDestMaskScanline);
679     }
680 }
681 CFX_ImageStretcher::CFX_ImageStretcher()
682 {
683     m_pScanline = NULL;
684     m_pStretchEngine = NULL;
685     m_pMaskScanline = NULL;
686 }
687 CFX_ImageStretcher::~CFX_ImageStretcher()
688 {
689     if (m_pScanline) {
690         FX_Free(m_pScanline);
691     }
692     if (m_pStretchEngine) {
693         delete m_pStretchEngine;
694     }
695     if (m_pMaskScanline) {
696         FX_Free(m_pMaskScanline);
697     }
698 }
699 FXDIB_Format _GetStretchedFormat(const CFX_DIBSource* pSrc)
700 {
701     FXDIB_Format format = pSrc->GetFormat();
702     if (format == FXDIB_1bppMask) {
703         format = FXDIB_8bppMask;
704     } else if (format == FXDIB_1bppRgb) {
705         format = FXDIB_8bppRgb;
706     } else if (format == FXDIB_8bppRgb) {
707         if (pSrc->GetPalette()) {
708             format = FXDIB_Rgb;
709         }
710     }
711     return format;
712 }
713 FX_BOOL CFX_ImageStretcher::Start(IFX_ScanlineComposer* pDest,
714                                   const CFX_DIBSource* pSource, int dest_width, int dest_height,
715                                   const FX_RECT& rect, FX_DWORD flags)
716 {
717     m_DestFormat = _GetStretchedFormat(pSource);
718     m_DestBPP = m_DestFormat & 0xff;
719     m_pDest = pDest;
720     m_pSource = pSource;
721     m_DestWidth = dest_width;
722     m_DestHeight = dest_height;
723     m_ClipRect = rect;
724     m_Flags = flags;
725     if (pSource->GetFormat() == FXDIB_1bppRgb && pSource->GetPalette()) {
726         FX_ARGB pal[256];
727         int a0, r0, g0, b0, a1, r1, g1, b1;
728         ArgbDecode(pSource->GetPaletteEntry(0), a0, r0, g0, b0);
729         ArgbDecode(pSource->GetPaletteEntry(1), a1, r1, g1, b1);
730         for (int i = 0; i < 256; i ++) {
731             int a = a0 + (a1 - a0) * i / 255;
732             int r = r0 + (r1 - r0) * i / 255;
733             int g = g0 + (g1 - g0) * i / 255;
734             int b = b0 + (b1 - b0) * i / 255;
735             pal[i] = ArgbEncode(a, r, g, b);
736         }
737         if (!pDest->SetInfo(rect.Width(), rect.Height(), m_DestFormat, pal)) {
738             return FALSE;
739         }
740     } else if (pSource->GetFormat() == FXDIB_1bppCmyk && pSource->GetPalette()) {
741         FX_CMYK pal[256];
742         int c0, m0, y0, k0, c1, m1, y1, k1;
743         CmykDecode(pSource->GetPaletteEntry(0), c0, m0, y0, k0);
744         CmykDecode(pSource->GetPaletteEntry(1), c1, m1, y1, k1);
745         for (int i = 0; i < 256; i ++) {
746             int c = c0 + (c1 - c0) * i / 255;
747             int m = m0 + (m1 - m0) * i / 255;
748             int y = y0 + (y1 - y0) * i / 255;
749             int k = k0 + (k1 - k0) * i / 255;
750             pal[i] = CmykEncode(c, m, y, k);
751         }
752         if (!pDest->SetInfo(rect.Width(), rect.Height(), m_DestFormat, pal)) {
753             return FALSE;
754         }
755     } else if (!pDest->SetInfo(rect.Width(), rect.Height(), m_DestFormat, NULL)) {
756         return FALSE;
757     }
758     if (flags & FXDIB_DOWNSAMPLE) {
759         return StartQuickStretch();
760     } else {
761         return StartStretch();
762     }
763 }
764 FX_BOOL CFX_ImageStretcher::Continue(IFX_Pause* pPause)
765 {
766     if (m_Flags & FXDIB_DOWNSAMPLE) {
767         return ContinueQuickStretch(pPause);
768     } else {
769         return ContinueStretch(pPause);
770     }
771 }
772 #ifndef _FPDFAPI_MINI_
773 #define MAX_PROGRESSIVE_STRETCH_PIXELS  1000000
774 #else
775 #define MAX_PROGRESSIVE_STRETCH_PIXELS  100000
776 #endif
777 FX_BOOL CFX_ImageStretcher::StartStretch()
778 {
779     m_pStretchEngine = FX_NEW CStretchEngine(m_pDest, m_DestFormat, m_DestWidth, m_DestHeight, m_ClipRect, m_pSource, m_Flags);
780     if (!m_pStretchEngine) {
781         return FALSE;
782     }
783     m_pStretchEngine->StartStretchHorz();
784     if (m_pSource->GetWidth() * m_pSource->GetHeight() < MAX_PROGRESSIVE_STRETCH_PIXELS) {
785         m_pStretchEngine->Continue(NULL);
786         return FALSE;
787     }
788     return TRUE;
789 }
790 FX_BOOL CFX_ImageStretcher::ContinueStretch(IFX_Pause* pPause)
791 {
792     if (m_pStretchEngine == NULL) {
793         return FALSE;
794     }
795     return m_pStretchEngine->Continue(pPause);
796 }
797 FX_BOOL CFX_ImageStretcher::StartQuickStretch()
798 {
799 #ifdef _FPDFAPI_MINI_
800     m_pSource->SetDownSampleSize(m_DestWidth, m_DestHeight);
801 #endif
802     m_bFlipX = FALSE;
803     m_bFlipY = FALSE;
804     if (m_DestWidth < 0) {
805         m_bFlipX = TRUE;
806         m_DestWidth = -m_DestWidth;
807     }
808     if (m_DestHeight < 0) {
809         m_bFlipY = TRUE;
810         m_DestHeight = -m_DestHeight;
811     }
812     m_LineIndex = 0;
813     FX_DWORD size = m_ClipRect.Width();
814     if (size && m_DestBPP > (int)(INT_MAX / size)) {
815         return FALSE;
816     }
817     size *= m_DestBPP;
818     m_pScanline = FX_Alloc(FX_BYTE, (size / 8 + 3) / 4 * 4);
819     if (!m_pScanline) {
820         return FALSE;
821     }
822     if (m_pSource->m_pAlphaMask) {
823         m_pMaskScanline = FX_Alloc(FX_BYTE, (m_ClipRect.Width() + 3) / 4 * 4);
824         if (!m_pMaskScanline) {
825             return FALSE;
826         }
827     }
828     if (m_pSource->GetWidth() * m_pSource->GetHeight() < MAX_PROGRESSIVE_STRETCH_PIXELS) {
829         ContinueQuickStretch(NULL);
830         return FALSE;
831     }
832     return TRUE;
833 }
834 FX_BOOL CFX_ImageStretcher::ContinueQuickStretch(IFX_Pause* pPause)
835 {
836     if (m_pScanline == NULL) {
837         return FALSE;
838     }
839     int result_width = m_ClipRect.Width(), result_height = m_ClipRect.Height();
840     int src_width = m_pSource->GetWidth(), src_height = m_pSource->GetHeight();
841     for (; m_LineIndex < result_height; m_LineIndex ++) {
842         int dest_y, src_y;
843         if (m_bFlipY) {
844             dest_y = result_height - m_LineIndex - 1;
845             src_y = (m_DestHeight - (dest_y + m_ClipRect.top) - 1) * src_height / m_DestHeight;
846         } else {
847             dest_y = m_LineIndex;
848             src_y = (dest_y + m_ClipRect.top) * src_height / m_DestHeight;
849         }
850         if (src_y >= src_height) {
851             src_y = src_height - 1;
852         }
853         if (src_y < 0) {
854             src_y = 0;
855         }
856         if (m_pSource->SkipToScanline(src_y, pPause)) {
857             return TRUE;
858         }
859         m_pSource->DownSampleScanline(src_y, m_pScanline, m_DestBPP, m_DestWidth, m_bFlipX, m_ClipRect.left, result_width);
860         FX_LPBYTE scan_extra_alpha = NULL;
861         if (m_pMaskScanline) {
862             m_pSource->m_pAlphaMask->DownSampleScanline(src_y, m_pMaskScanline, 1, m_DestWidth, m_bFlipX, m_ClipRect.left, result_width);
863         }
864         m_pDest->ComposeScanline(dest_y, m_pScanline, m_pMaskScanline);
865     }
866     return FALSE;
867 }