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