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