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