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