Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(157)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: core/src/fxcodec/jbig2/JBig2_Image.cpp

Issue 1265503005: clang-format all pdfium code. (Closed) Base URL: https://pdfium.googlesource.com/pdfium.git@master
Patch Set: Created 5 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« core/src/fpdfapi/fpdf_cmaps/Japan1/UniJIS-UCS2-H_4.cpp ('K') | « core/src/fxcodec/jbig2/JBig2_Image.h ('k') | core/src/fxcodec/jbig2/JBig2_List.h » ('j') | public/fpdf_doc.h » ('J')
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright 2014 PDFium Authors. All rights reserved. 1 // Copyright 2014 PDFium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com 5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
6 6
7 #include <limits.h> 7 #include <limits.h>
8 8
9 #include "../../../include/fxcrt/fx_coordinates.h" 9 #include "../../../include/fxcrt/fx_coordinates.h"
10 #include "../../../include/fxcrt/fx_safe_types.h" 10 #include "../../../include/fxcrt/fx_safe_types.h"
11 #include "JBig2_Image.h" 11 #include "JBig2_Image.h"
12 12
13 CJBig2_Image::CJBig2_Image(int32_t w, int32_t h) 13 CJBig2_Image::CJBig2_Image(int32_t w, int32_t h) {
14 { 14 m_nWidth = w;
15 m_nWidth» = w; 15 m_nHeight = h;
16 m_nHeight» = h; 16 if (m_nWidth <= 0 || m_nHeight <= 0 || m_nWidth > INT_MAX - 31) {
17 if (m_nWidth <= 0 || m_nHeight <= 0 || m_nWidth > INT_MAX - 31) { 17 m_pData = NULL;
18 m_pData = NULL; 18 m_bNeedFree = FALSE;
19 m_bNeedFree = FALSE; 19 return;
20 return; 20 }
21 m_nStride = ((w + 31) >> 5) << 2;
22 if (m_nStride * m_nHeight > 0 && 104857600 / (int)m_nStride > m_nHeight) {
23 m_pData = (uint8_t*)m_pModule->JBig2_Malloc2(m_nStride, m_nHeight);
24 } else {
25 m_pData = NULL;
26 }
27 m_bNeedFree = TRUE;
28 }
29 CJBig2_Image::CJBig2_Image(int32_t w,
30 int32_t h,
31 int32_t stride,
32 uint8_t* pBuf) {
33 m_nWidth = w;
34 m_nHeight = h;
35 m_nStride = stride;
36 m_pData = pBuf;
37 m_bNeedFree = FALSE;
38 }
39 CJBig2_Image::CJBig2_Image(CJBig2_Image& im) {
40 m_pModule = im.m_pModule;
41 m_nWidth = im.m_nWidth;
42 m_nHeight = im.m_nHeight;
43 m_nStride = im.m_nStride;
44 if (im.m_pData) {
45 m_pData = (uint8_t*)m_pModule->JBig2_Malloc2(m_nStride, m_nHeight);
46 JBIG2_memcpy(m_pData, im.m_pData, m_nStride * m_nHeight);
47 } else {
48 m_pData = NULL;
49 }
50 m_bNeedFree = TRUE;
51 }
52 CJBig2_Image::~CJBig2_Image() {
53 if (m_bNeedFree && m_pData) {
54 m_pModule->JBig2_Free(m_pData);
55 }
56 }
57 FX_BOOL CJBig2_Image::getPixel(int32_t x, int32_t y) {
58 if (!m_pData) {
59 return 0;
60 }
61 int32_t m, n;
62 if (x < 0 || x >= m_nWidth) {
63 return 0;
64 }
65 if (y < 0 || y >= m_nHeight) {
66 return 0;
67 }
68 m = y * m_nStride + (x >> 3);
69 n = x & 7;
70 return ((m_pData[m] >> (7 - n)) & 1);
71 }
72
73 int32_t CJBig2_Image::setPixel(int32_t x, int32_t y, FX_BOOL v) {
74 if (!m_pData) {
75 return 0;
76 }
77 int32_t m, n;
78 if (x < 0 || x >= m_nWidth) {
79 return 0;
80 }
81 if (y < 0 || y >= m_nHeight) {
82 return 0;
83 }
84 m = y * m_nStride + (x >> 3);
85 n = x & 7;
86 if (v) {
87 m_pData[m] |= 1 << (7 - n);
88 } else {
89 m_pData[m] &= ~(1 << (7 - n));
90 }
91 return 1;
92 }
93 void CJBig2_Image::copyLine(int32_t hTo, int32_t hFrom) {
94 if (!m_pData) {
95 return;
96 }
97 if (hFrom < 0 || hFrom >= m_nHeight) {
98 JBIG2_memset(m_pData + hTo * m_nStride, 0, m_nStride);
99 } else {
100 JBIG2_memcpy(m_pData + hTo * m_nStride, m_pData + hFrom * m_nStride,
101 m_nStride);
102 }
103 }
104 void CJBig2_Image::fill(FX_BOOL v) {
105 if (!m_pData) {
106 return;
107 }
108 JBIG2_memset(m_pData, v ? 0xff : 0, m_nStride * m_nHeight);
109 }
110 FX_BOOL CJBig2_Image::composeTo(CJBig2_Image* pDst,
111 int32_t x,
112 int32_t y,
113 JBig2ComposeOp op) {
114 if (!m_pData) {
115 return FALSE;
116 }
117 return composeTo_opt2(pDst, x, y, op);
118 }
119 FX_BOOL CJBig2_Image::composeTo(CJBig2_Image* pDst,
120 int32_t x,
121 int32_t y,
122 JBig2ComposeOp op,
123 const FX_RECT* pSrcRect) {
124 if (!m_pData) {
125 return FALSE;
126 }
127 if (NULL == pSrcRect || *pSrcRect == FX_RECT(0, 0, m_nWidth, m_nHeight)) {
128 return composeTo_opt2(pDst, x, y, op);
129 }
130 return composeTo_opt2(pDst, x, y, op, pSrcRect);
131 }
132 FX_BOOL CJBig2_Image::composeTo_unopt(CJBig2_Image* pDst,
133 int32_t x,
134 int32_t y,
135 JBig2ComposeOp op) {
136 int32_t w, h, dx, dy;
137 int32_t i, j;
138 w = m_nWidth;
139 h = m_nHeight;
140 dx = dy = 0;
141 if (x < 0) {
142 dx += -x;
143 w -= -x;
144 x = 0;
145 }
146 if (y < 0) {
147 dy += -y;
148 h -= -y;
149 y = 0;
150 }
151 if (x + w > pDst->m_nWidth) {
152 w = pDst->m_nWidth - x;
153 }
154 if (y + h > pDst->m_nHeight) {
155 h = pDst->m_nHeight - y;
156 }
157 switch (op) {
158 case JBIG2_COMPOSE_OR:
159 for (j = 0; j < h; j++) {
160 for (i = 0; i < w; i++) {
161 pDst->setPixel(
162 x + i, y + j,
163 (getPixel(i + dx, j + dy) | pDst->getPixel(x + i, y + j)) & 1);
164 }
165 }
166 break;
167 case JBIG2_COMPOSE_AND:
168 for (j = 0; j < h; j++) {
169 for (i = 0; i < w; i++) {
170 pDst->setPixel(
171 x + i, y + j,
172 (getPixel(i + dx, j + dy) & pDst->getPixel(x + i, y + j)) & 1);
173 }
174 }
175 break;
176 case JBIG2_COMPOSE_XOR:
177 for (j = 0; j < h; j++) {
178 for (i = 0; i < w; i++) {
179 pDst->setPixel(
180 x + i, y + j,
181 (getPixel(i + dx, j + dy) ^ pDst->getPixel(x + i, y + j)) & 1);
182 }
183 }
184 break;
185 case JBIG2_COMPOSE_XNOR:
186 for (j = 0; j < h; j++) {
187 for (i = 0; i < w; i++) {
188 pDst->setPixel(
189 x + i, y + j,
190 (~(getPixel(i + dx, j + dy) ^ pDst->getPixel(x + i, y + j))) & 1);
191 }
192 }
193 break;
194 case JBIG2_COMPOSE_REPLACE:
195 for (j = 0; j < h; j++) {
196 for (i = 0; i < w; i++) {
197 pDst->setPixel(x + i, y + j, getPixel(i + dx, j + dy));
198 }
199 }
200 break;
201 }
202 return TRUE;
203 }
204
205 FX_BOOL CJBig2_Image::composeTo_opt(CJBig2_Image* pDst,
206 int32_t x,
207 int32_t y,
208 JBig2ComposeOp op) {
209 int32_t x0, x1, y0, y1, xx, yy;
210 uint8_t *pLineSrc, *pLineDst, *srcPtr, *destPtr;
211 FX_DWORD src0, src1, src, dest, s1, s2, m1, m2, m3;
212 FX_BOOL oneByte;
213 if (!m_pData) {
214 return FALSE;
215 }
216 if (y < 0) {
217 y0 = -y;
218 } else {
219 y0 = 0;
220 }
221 if (y + m_nHeight > pDst->m_nHeight) {
222 y1 = pDst->m_nHeight - y;
223 } else {
224 y1 = m_nHeight;
225 }
226 if (y0 >= y1) {
227 return FALSE;
228 }
229 if (x >= 0) {
230 x0 = x & ~7;
231 } else {
232 x0 = 0;
233 }
234 x1 = x + m_nWidth;
235 if (x1 > pDst->m_nWidth) {
236 x1 = pDst->m_nWidth;
237 }
238 if (x0 >= x1) {
239 return FALSE;
240 }
241 s1 = x & 7;
242 s2 = 8 - s1;
243 m1 = 0xff >> (x1 & 7);
244 m2 = 0xff << (((x1 & 7) == 0) ? 0 : 8 - (x1 & 7));
245 m3 = (0xff >> s1) & m2;
246 oneByte = x0 == ((x1 - 1) & ~7);
247 pLineDst = pDst->m_pData + y * pDst->m_nStride;
248 pLineSrc = m_pData + y0 * m_nStride;
249 if (oneByte) {
250 if (x >= 0) {
251 switch (op) {
252 case JBIG2_COMPOSE_OR: {
253 for (yy = y0; yy < y1; ++yy) {
254 destPtr = pLineDst + (x >> 3);
255 srcPtr = pLineSrc;
256 dest = *destPtr;
257 dest |= (*srcPtr >> s1) & m2;
258 *destPtr = (uint8_t)dest;
259 pLineDst += pDst->m_nStride;
260 pLineSrc += m_nStride;
261 }
262 } break;
263 case JBIG2_COMPOSE_AND: {
264 for (yy = y0; yy < y1; ++yy) {
265 destPtr = pLineDst + (x >> 3);
266 srcPtr = pLineSrc;
267 dest = *destPtr;
268 dest &= ((0xff00 | *srcPtr) >> s1) | m1;
269 *destPtr = (uint8_t)dest;
270 pLineDst += pDst->m_nStride;
271 pLineSrc += m_nStride;
272 }
273 } break;
274 case JBIG2_COMPOSE_XOR: {
275 for (yy = y0; yy < y1; ++yy) {
276 destPtr = pLineDst + (x >> 3);
277 srcPtr = pLineSrc;
278 dest = *destPtr;
279 dest ^= (*srcPtr >> s1) & m2;
280 *destPtr = (uint8_t)dest;
281 pLineDst += pDst->m_nStride;
282 pLineSrc += m_nStride;
283 }
284 } break;
285 case JBIG2_COMPOSE_XNOR: {
286 for (yy = y0; yy < y1; ++yy) {
287 destPtr = pLineDst + (x >> 3);
288 srcPtr = pLineSrc;
289 dest = *destPtr;
290 dest ^= ((*srcPtr ^ 0xff) >> s1) & m2;
291 *destPtr = (uint8_t)dest;
292 pLineDst += pDst->m_nStride;
293 pLineSrc += m_nStride;
294 }
295 } break;
296 case JBIG2_COMPOSE_REPLACE: {
297 for (yy = y0; yy < y1; ++yy) {
298 destPtr = pLineDst + (x >> 3);
299 srcPtr = pLineSrc;
300 dest = *destPtr;
301 dest = (dest & ~m3) | ((*srcPtr >> s1) & m3);
302 *destPtr = (uint8_t)dest;
303 pLineDst += pDst->m_nStride;
304 pLineSrc += m_nStride;
305 }
306 } break;
307 }
308 } else {
309 switch (op) {
310 case JBIG2_COMPOSE_OR: {
311 for (yy = y0; yy < y1; ++yy) {
312 destPtr = pLineDst;
313 srcPtr = pLineSrc + (-x >> 3);
314 dest = *destPtr;
315 dest |= *srcPtr & m2;
316 *destPtr = (uint8_t)dest;
317 pLineDst += pDst->m_nStride;
318 pLineSrc += m_nStride;
319 }
320 } break;
321 case JBIG2_COMPOSE_AND: {
322 for (yy = y0; yy < y1; ++yy) {
323 destPtr = pLineDst;
324 srcPtr = pLineSrc + (-x >> 3);
325 dest = *destPtr;
326 dest &= *srcPtr | m1;
327 *destPtr = (uint8_t)dest;
328 pLineDst += pDst->m_nStride;
329 pLineSrc += m_nStride;
330 }
331 } break;
332 case JBIG2_COMPOSE_XOR: {
333 for (yy = y0; yy < y1; ++yy) {
334 destPtr = pLineDst;
335 srcPtr = pLineSrc + (-x >> 3);
336 dest = *destPtr;
337 dest ^= *srcPtr & m2;
338 *destPtr = (uint8_t)dest;
339 pLineDst += pDst->m_nStride;
340 pLineSrc += m_nStride;
341 }
342 } break;
343 case JBIG2_COMPOSE_XNOR: {
344 for (yy = y0; yy < y1; ++yy) {
345 destPtr = pLineDst;
346 srcPtr = pLineSrc + (-x >> 3);
347 dest = *destPtr;
348 dest ^= (*srcPtr ^ 0xff) & m2;
349 *destPtr = (uint8_t)dest;
350 pLineDst += pDst->m_nStride;
351 pLineSrc += m_nStride;
352 }
353 } break;
354 case JBIG2_COMPOSE_REPLACE: {
355 for (yy = y0; yy < y1; ++yy) {
356 destPtr = pLineDst;
357 srcPtr = pLineSrc + (-x >> 3);
358 dest = *destPtr;
359 dest = (*srcPtr & m2) | (dest & m1);
360 *destPtr = (uint8_t)dest;
361 pLineDst += pDst->m_nStride;
362 pLineSrc += m_nStride;
363 }
364 } break;
365 }
21 } 366 }
22 m_nStride = ((w + 31) >> 5) << 2; 367 } else {
23 if (m_nStride * m_nHeight > 0 && 104857600 / (int)m_nStride > m_nHeight) { 368 if (x >= 0) {
24 m_pData = (uint8_t *)m_pModule->JBig2_Malloc2(m_nStride, m_nHeight); 369 switch (op) {
370 case JBIG2_COMPOSE_OR: {
371 for (yy = y0; yy < y1; ++yy) {
372 destPtr = pLineDst + (x >> 3);
373 srcPtr = pLineSrc;
374 src1 = *srcPtr++;
375 dest = *destPtr;
376 dest |= src1 >> s1;
377 *destPtr++ = (uint8_t)dest;
378 xx = x0 + 8;
379 for (; xx < x1 - 8; xx += 8) {
380 dest = *destPtr;
381 src0 = src1;
382 src1 = *srcPtr++;
383 src = (((src0 << 8) | src1) >> s1) & 0xff;
384 dest |= src;
385 *destPtr++ = (uint8_t)dest;
386 }
387 dest = *destPtr;
388 src0 = src1;
389 if (srcPtr - pLineSrc < m_nStride) {
390 src1 = *srcPtr++;
391 } else {
392 src1 = 0;
393 }
394 src = (((src0 << 8) | src1) >> s1) & 0xff;
395 dest |= src & m2;
396 *destPtr = (uint8_t)dest;
397 pLineDst += pDst->m_nStride;
398 pLineSrc += m_nStride;
399 }
400 } break;
401 case JBIG2_COMPOSE_AND: {
402 for (yy = y0; yy < y1; ++yy) {
403 destPtr = pLineDst + (x >> 3);
404 srcPtr = pLineSrc;
405 src1 = *srcPtr++;
406 dest = *destPtr;
407 dest &= (0xff00 | src1) >> s1;
408 *destPtr++ = (uint8_t)dest;
409 xx = x0 + 8;
410 for (; xx < x1 - 8; xx += 8) {
411 dest = *destPtr;
412 src0 = src1;
413 src1 = *srcPtr++;
414 src = (((src0 << 8) | src1) >> s1) & 0xff;
415 dest &= src;
416 *destPtr++ = (uint8_t)dest;
417 }
418 dest = *destPtr;
419 src0 = src1;
420 if (srcPtr - pLineSrc < m_nStride) {
421 src1 = *srcPtr++;
422 } else {
423 src1 = 0;
424 }
425 src = (((src0 << 8) | src1) >> s1) & 0xff;
426 dest &= src | m1;
427 *destPtr = (uint8_t)dest;
428 pLineDst += pDst->m_nStride;
429 pLineSrc += m_nStride;
430 }
431 } break;
432 case JBIG2_COMPOSE_XOR: {
433 for (yy = y0; yy < y1; ++yy) {
434 destPtr = pLineDst + (x >> 3);
435 srcPtr = pLineSrc;
436 src1 = *srcPtr++;
437 dest = *destPtr;
438 dest ^= src1 >> s1;
439 *destPtr++ = (uint8_t)dest;
440 xx = x0 + 8;
441 for (; xx < x1 - 8; xx += 8) {
442 dest = *destPtr;
443 src0 = src1;
444 src1 = *srcPtr++;
445 src = (((src0 << 8) | src1) >> s1) & 0xff;
446 dest ^= src;
447 *destPtr++ = (uint8_t)dest;
448 }
449 dest = *destPtr;
450 src0 = src1;
451 if (srcPtr - pLineSrc < m_nStride) {
452 src1 = *srcPtr++;
453 } else {
454 src1 = 0;
455 }
456 src = (((src0 << 8) | src1) >> s1) & 0xff;
457 dest ^= src & m2;
458 *destPtr = (uint8_t)dest;
459 pLineDst += pDst->m_nStride;
460 pLineSrc += m_nStride;
461 }
462 } break;
463 case JBIG2_COMPOSE_XNOR: {
464 for (yy = y0; yy < y1; ++yy) {
465 destPtr = pLineDst + (x >> 3);
466 srcPtr = pLineSrc;
467 src1 = *srcPtr++;
468 dest = *destPtr;
469 dest ^= (src1 ^ 0xff) >> s1;
470 *destPtr++ = (uint8_t)dest;
471 xx = x0 + 8;
472 for (; xx < x1 - 8; xx += 8) {
473 dest = *destPtr;
474 src0 = src1;
475 src1 = *srcPtr++;
476 src = (((src0 << 8) | src1) >> s1) & 0xff;
477 dest ^= src ^ 0xff;
478 *destPtr++ = (uint8_t)dest;
479 }
480 dest = *destPtr;
481 src0 = src1;
482 if (srcPtr - pLineSrc < m_nStride) {
483 src1 = *srcPtr++;
484 } else {
485 src1 = 0;
486 }
487 src = (((src0 << 8) | src1) >> s1) & 0xff;
488 dest ^= (src ^ 0xff) & m2;
489 *destPtr = (uint8_t)dest;
490 pLineDst += pDst->m_nStride;
491 pLineSrc += m_nStride;
492 }
493 } break;
494 case JBIG2_COMPOSE_REPLACE: {
495 for (yy = y0; yy < y1; ++yy) {
496 destPtr = pLineDst + (x >> 3);
497 srcPtr = pLineSrc;
498 src1 = *srcPtr++;
499 dest = *destPtr;
500 dest = (dest & (0xff << s2)) | (src1 >> s1);
501 *destPtr++ = (uint8_t)dest;
502 xx = x0 + 8;
503 for (; xx < x1 - 8; xx += 8) {
504 dest = *destPtr;
505 src0 = src1;
506 src1 = *srcPtr++;
507 src = (((src0 << 8) | src1) >> s1) & 0xff;
508 dest = src;
509 *destPtr++ = (uint8_t)dest;
510 }
511 dest = *destPtr;
512 src0 = src1;
513 if (srcPtr - pLineSrc < m_nStride) {
514 src1 = *srcPtr++;
515 } else {
516 src1 = 0;
517 }
518 src = (((src0 << 8) | src1) >> s1) & 0xff;
519 dest = (src & m2) | (dest & m1);
520 *destPtr = (uint8_t)dest;
521 pLineDst += pDst->m_nStride;
522 pLineSrc += m_nStride;
523 }
524 } break;
525 }
25 } else { 526 } else {
26 m_pData = NULL; 527 switch (op) {
528 case JBIG2_COMPOSE_OR: {
529 for (yy = y0; yy < y1; ++yy) {
530 destPtr = pLineDst;
531 srcPtr = pLineSrc + (-x >> 3);
532 src1 = *srcPtr++;
533 xx = x0;
534 for (; xx < x1 - 8; xx += 8) {
535 dest = *destPtr;
536 src0 = src1;
537 src1 = *srcPtr++;
538 src = (((src0 << 8) | src1) >> s1) & 0xff;
539 dest |= src;
540 *destPtr++ = (uint8_t)dest;
541 }
542 dest = *destPtr;
543 src0 = src1;
544 if (srcPtr - pLineSrc < m_nStride) {
545 src1 = *srcPtr++;
546 } else {
547 src1 = 0;
548 }
549 src = (((src0 << 8) | src1) >> s1) & 0xff;
550 dest |= src & m2;
551 *destPtr = (uint8_t)dest;
552 pLineDst += pDst->m_nStride;
553 pLineSrc += m_nStride;
554 }
555 } break;
556 case JBIG2_COMPOSE_AND: {
557 for (yy = y0; yy < y1; ++yy) {
558 destPtr = pLineDst;
559 srcPtr = pLineSrc + (-x >> 3);
560 src1 = *srcPtr++;
561 xx = x0;
562 for (; xx < x1 - 8; xx += 8) {
563 dest = *destPtr;
564 src0 = src1;
565 src1 = *srcPtr++;
566 src = (((src0 << 8) | src1) >> s1) & 0xff;
567 dest &= src;
568 *destPtr++ = (uint8_t)dest;
569 }
570 dest = *destPtr;
571 src0 = src1;
572 if (srcPtr - pLineSrc < m_nStride) {
573 src1 = *srcPtr++;
574 } else {
575 src1 = 0;
576 }
577 src = (((src0 << 8) | src1) >> s1) & 0xff;
578 dest &= src | m1;
579 *destPtr = (uint8_t)dest;
580 pLineDst += pDst->m_nStride;
581 pLineSrc += m_nStride;
582 }
583 } break;
584 case JBIG2_COMPOSE_XOR: {
585 for (yy = y0; yy < y1; ++yy) {
586 destPtr = pLineDst;
587 srcPtr = pLineSrc + (-x >> 3);
588 src1 = *srcPtr++;
589 xx = x0;
590 for (; xx < x1 - 8; xx += 8) {
591 dest = *destPtr;
592 src0 = src1;
593 src1 = *srcPtr++;
594 src = (((src0 << 8) | src1) >> s1) & 0xff;
595 dest ^= src;
596 *destPtr++ = (uint8_t)dest;
597 }
598 dest = *destPtr;
599 src0 = src1;
600 if (srcPtr - pLineSrc < m_nStride) {
601 src1 = *srcPtr++;
602 } else {
603 src1 = 0;
604 }
605 src = (((src0 << 8) | src1) >> s1) & 0xff;
606 dest ^= src & m2;
607 *destPtr = (uint8_t)dest;
608 pLineDst += pDst->m_nStride;
609 pLineSrc += m_nStride;
610 }
611 } break;
612 case JBIG2_COMPOSE_XNOR: {
613 for (yy = y0; yy < y1; ++yy) {
614 destPtr = pLineDst;
615 srcPtr = pLineSrc + (-x >> 3);
616 src1 = *srcPtr++;
617 xx = x0;
618 for (; xx < x1 - 8; xx += 8) {
619 dest = *destPtr;
620 src0 = src1;
621 src1 = *srcPtr++;
622 src = (((src0 << 8) | src1) >> s1) & 0xff;
623 dest ^= src ^ 0xff;
624 *destPtr++ = (uint8_t)dest;
625 }
626 dest = *destPtr;
627 src0 = src1;
628 if (srcPtr - pLineSrc < m_nStride) {
629 src1 = *srcPtr++;
630 } else {
631 src1 = 0;
632 }
633 src = (((src0 << 8) | src1) >> s1) & 0xff;
634 dest ^= (src ^ 0xff) & m2;
635 *destPtr = (uint8_t)dest;
636 pLineDst += pDst->m_nStride;
637 pLineSrc += m_nStride;
638 }
639 } break;
640 case JBIG2_COMPOSE_REPLACE: {
641 for (yy = y0; yy < y1; ++yy) {
642 destPtr = pLineDst;
643 srcPtr = pLineSrc + (-x >> 3);
644 src1 = *srcPtr++;
645 xx = x0;
646 for (; xx < x1 - 8; xx += 8) {
647 dest = *destPtr;
648 src0 = src1;
649 src1 = *srcPtr++;
650 src = (((src0 << 8) | src1) >> s1) & 0xff;
651 dest = src;
652 *destPtr++ = (uint8_t)dest;
653 }
654 dest = *destPtr;
655 src0 = src1;
656 if (srcPtr - pLineSrc < m_nStride) {
657 src1 = *srcPtr++;
658 } else {
659 src1 = 0;
660 }
661 src = (((src0 << 8) | src1) >> s1) & 0xff;
662 dest = (src & m2) | (dest & m1);
663 *destPtr = (uint8_t)dest;
664 pLineDst += pDst->m_nStride;
665 pLineSrc += m_nStride;
666 }
667 } break;
668 }
27 } 669 }
28 m_bNeedFree = TRUE; 670 }
29 } 671 return TRUE;
30 CJBig2_Image::CJBig2_Image(int32_t w, int32_t h, int32_t stride, uint8_t*pBuf) 672 }
31 { 673 FX_BOOL CJBig2_Image::composeFrom(int32_t x,
32 m_nWidth = w; 674 int32_t y,
33 m_nHeight = h; 675 CJBig2_Image* pSrc,
34 m_nStride = stride; 676 JBig2ComposeOp op) {
35 m_pData = pBuf; 677 if (!m_pData) {
36 m_bNeedFree = FALSE; 678 return FALSE;
37 } 679 }
38 CJBig2_Image::CJBig2_Image(CJBig2_Image &im) 680 return pSrc->composeTo(this, x, y, op);
39 { 681 }
40 m_pModule = im.m_pModule; 682 FX_BOOL CJBig2_Image::composeFrom(int32_t x,
41 m_nWidth» = im.m_nWidth; 683 int32_t y,
42 m_nHeight» = im.m_nHeight; 684 CJBig2_Image* pSrc,
43 m_nStride» = im.m_nStride; 685 JBig2ComposeOp op,
44 if (im.m_pData) { 686 const FX_RECT* pSrcRect) {
45 m_pData = (uint8_t*)m_pModule->JBig2_Malloc2(m_nStride, m_nHeight); 687 if (!m_pData) {
46 JBIG2_memcpy(m_pData, im.m_pData, m_nStride * m_nHeight); 688 return FALSE;
689 }
690 return pSrc->composeTo(this, x, y, op, pSrcRect);
691 }
692 CJBig2_Image* CJBig2_Image::subImage_unopt(int32_t x,
693 int32_t y,
694 int32_t w,
695 int32_t h) {
696 CJBig2_Image* pImage;
697 int32_t i, j;
698 JBIG2_ALLOC(pImage, CJBig2_Image(w, h));
699 for (j = 0; j < h; j++) {
700 for (i = 0; i < w; i++) {
701 pImage->setPixel(i, j, getPixel(x + i, y + j));
702 }
703 }
704 return pImage;
705 }
706 #define JBIG2_GETDWORD(buf) \
707 ((FX_DWORD)(((buf)[0] << 24) | ((buf)[1] << 16) | ((buf)[2] << 8) | (buf)[3]))
708 CJBig2_Image* CJBig2_Image::subImage(int32_t x,
709 int32_t y,
710 int32_t w,
711 int32_t h) {
712 CJBig2_Image* pImage;
713 int32_t m, n, j;
714 uint8_t *pLineSrc, *pLineDst;
715 FX_DWORD wTmp;
716 uint8_t *pSrc, *pSrcEnd, *pDst, *pDstEnd;
717 if (w == 0 || h == 0) {
718 return NULL;
719 }
720 JBIG2_ALLOC(pImage, CJBig2_Image(w, h));
721 if (!m_pData) {
722 pImage->fill(0);
723 return pImage;
724 }
725 if (!pImage->m_pData) {
726 return pImage;
727 }
728 pLineSrc = m_pData + m_nStride * y;
729 pLineDst = pImage->m_pData;
730 m = (x >> 5) << 2;
731 n = x & 31;
732 if (n == 0) {
733 for (j = 0; j < h; j++) {
734 pSrc = pLineSrc + m;
735 pSrcEnd = pLineSrc + m_nStride;
736 pDst = pLineDst;
737 pDstEnd = pLineDst + pImage->m_nStride;
738 for (; pDst < pDstEnd; pSrc += 4, pDst += 4) {
739 *((FX_DWORD*)pDst) = *((FX_DWORD*)pSrc);
740 }
741 pLineSrc += m_nStride;
742 pLineDst += pImage->m_nStride;
743 }
744 } else {
745 for (j = 0; j < h; j++) {
746 pSrc = pLineSrc + m;
747 pSrcEnd = pLineSrc + m_nStride;
748 pDst = pLineDst;
749 pDstEnd = pLineDst + pImage->m_nStride;
750 for (; pDst < pDstEnd; pSrc += 4, pDst += 4) {
751 if (pSrc + 4 < pSrcEnd) {
752 wTmp = (JBIG2_GETDWORD(pSrc) << n) |
753 (JBIG2_GETDWORD(pSrc + 4) >> (32 - n));
754 } else {
755 wTmp = JBIG2_GETDWORD(pSrc) << n;
756 }
757 pDst[0] = (uint8_t)(wTmp >> 24);
758 pDst[1] = (uint8_t)(wTmp >> 16);
759 pDst[2] = (uint8_t)(wTmp >> 8);
760 pDst[3] = (uint8_t)wTmp;
761 }
762 pLineSrc += m_nStride;
763 pLineDst += pImage->m_nStride;
764 }
765 }
766 return pImage;
767 }
768 void CJBig2_Image::expand(int32_t h, FX_BOOL v) {
769 if (!m_pData || h <= m_nHeight) {
770 return;
771 }
772 FX_DWORD dwH = pdfium::base::checked_cast<FX_DWORD>(h);
773 FX_DWORD dwStride = pdfium::base::checked_cast<FX_DWORD>(m_nStride);
774 FX_DWORD dwHeight = pdfium::base::checked_cast<FX_DWORD>(m_nHeight);
775 FX_SAFE_DWORD safeMemSize = dwH;
776 safeMemSize *= dwStride;
777 if (!safeMemSize.IsValid()) {
778 return;
779 }
780 // The guaranteed reallocated memory is to be < 4GB (unsigned int).
781 m_pData =
782 (uint8_t*)m_pModule->JBig2_Realloc(m_pData, safeMemSize.ValueOrDie());
783 // The result of dwHeight * dwStride doesn't overflow after the
784 // checking of safeMemSize.
785 // The same as the result of (dwH - dwHeight) * dwStride) because
786 // dwH - dwHeight is always less than dwH(h) which is checked in
787 // the calculation of dwH * dwStride.
788 JBIG2_memset(m_pData + dwHeight * dwStride, v ? 0xff : 0,
789 (dwH - dwHeight) * dwStride);
790 m_nHeight = h;
791 }
792 FX_BOOL CJBig2_Image::composeTo_opt2(CJBig2_Image* pDst,
793 int32_t x,
794 int32_t y,
795 JBig2ComposeOp op) {
796 int32_t xs0 = 0, ys0 = 0, xs1 = 0, ys1 = 0, xd0 = 0, yd0 = 0, xd1 = 0,
797 yd1 = 0, xx = 0, yy = 0, w = 0, h = 0, middleDwords = 0, lineLeft = 0;
798
799 FX_DWORD s1 = 0, d1 = 0, d2 = 0, shift = 0, shift1 = 0, shift2 = 0, tmp = 0,
800 tmp1 = 0, tmp2 = 0, maskL = 0, maskR = 0, maskM = 0;
801
802 uint8_t *lineSrc = NULL, *lineDst = NULL, *sp = NULL, *dp = NULL;
803
804 if (!m_pData) {
805 return FALSE;
806 }
807 if (x < -1048576 || x > 1048576 || y < -1048576 || y > 1048576) {
808 return FALSE;
809 }
810 if (y < 0) {
811 ys0 = -y;
812 }
813 if (y + m_nHeight > pDst->m_nHeight) {
814 ys1 = pDst->m_nHeight - y;
815 } else {
816 ys1 = m_nHeight;
817 }
818 if (x < 0) {
819 xs0 = -x;
820 }
821 if (x + m_nWidth > pDst->m_nWidth) {
822 xs1 = pDst->m_nWidth - x;
823 } else {
824 xs1 = m_nWidth;
825 }
826 if ((ys0 >= ys1) || (xs0 >= xs1)) {
827 return 0;
828 }
829 w = xs1 - xs0;
830 h = ys1 - ys0;
831 if (y >= 0) {
832 yd0 = y;
833 }
834 if (x >= 0) {
835 xd0 = x;
836 }
837 xd1 = xd0 + w;
838 yd1 = yd0 + h;
839 d1 = xd0 & 31;
840 d2 = xd1 & 31;
841 s1 = xs0 & 31;
842 maskL = 0xffffffff >> d1;
843 maskR = 0xffffffff << ((32 - (xd1 & 31)) % 32);
844 maskM = maskL & maskR;
845 lineSrc = m_pData + ys0 * m_nStride + ((xs0 >> 5) << 2);
846 lineLeft = m_nStride - ((xs0 >> 5) << 2);
847 lineDst = pDst->m_pData + yd0 * pDst->m_nStride + ((xd0 >> 5) << 2);
848 if ((xd0 & ~31) == ((xd1 - 1) & ~31)) {
849 if ((xs0 & ~31) == ((xs1 - 1) & ~31)) {
850 if (s1 > d1) {
851 shift = s1 - d1;
852 for (yy = yd0; yy < yd1; yy++) {
853 tmp1 = JBIG2_GETDWORD(lineSrc) << shift;
854 tmp2 = JBIG2_GETDWORD(lineDst);
855 switch (op) {
856 case JBIG2_COMPOSE_OR:
857 tmp = (tmp2 & ~maskM) | ((tmp1 | tmp2) & maskM);
858 break;
859 case JBIG2_COMPOSE_AND:
860 tmp = (tmp2 & ~maskM) | ((tmp1 & tmp2) & maskM);
861 break;
862 case JBIG2_COMPOSE_XOR:
863 tmp = (tmp2 & ~maskM) | ((tmp1 ^ tmp2) & maskM);
864 break;
865 case JBIG2_COMPOSE_XNOR:
866 tmp = (tmp2 & ~maskM) | ((~(tmp1 ^ tmp2)) & maskM);
867 break;
868 case JBIG2_COMPOSE_REPLACE:
869 tmp = (tmp2 & ~maskM) | (tmp1 & maskM);
870 break;
871 }
872 lineDst[0] = (uint8_t)(tmp >> 24);
873 lineDst[1] = (uint8_t)(tmp >> 16);
874 lineDst[2] = (uint8_t)(tmp >> 8);
875 lineDst[3] = (uint8_t)tmp;
876 lineSrc += m_nStride;
877 lineDst += pDst->m_nStride;
878 }
879 } else {
880 shift = d1 - s1;
881 for (yy = yd0; yy < yd1; yy++) {
882 tmp1 = JBIG2_GETDWORD(lineSrc) >> shift;
883 tmp2 = JBIG2_GETDWORD(lineDst);
884 switch (op) {
885 case JBIG2_COMPOSE_OR:
886 tmp = (tmp2 & ~maskM) | ((tmp1 | tmp2) & maskM);
887 break;
888 case JBIG2_COMPOSE_AND:
889 tmp = (tmp2 & ~maskM) | ((tmp1 & tmp2) & maskM);
890 break;
891 case JBIG2_COMPOSE_XOR:
892 tmp = (tmp2 & ~maskM) | ((tmp1 ^ tmp2) & maskM);
893 break;
894 case JBIG2_COMPOSE_XNOR:
895 tmp = (tmp2 & ~maskM) | ((~(tmp1 ^ tmp2)) & maskM);
896 break;
897 case JBIG2_COMPOSE_REPLACE:
898 tmp = (tmp2 & ~maskM) | (tmp1 & maskM);
899 break;
900 }
901 lineDst[0] = (uint8_t)(tmp >> 24);
902 lineDst[1] = (uint8_t)(tmp >> 16);
903 lineDst[2] = (uint8_t)(tmp >> 8);
904 lineDst[3] = (uint8_t)tmp;
905 lineSrc += m_nStride;
906 lineDst += pDst->m_nStride;
907 }
908 }
47 } else { 909 } else {
48 m_pData = NULL; 910 shift1 = s1 - d1;
911 shift2 = 32 - shift1;
912 for (yy = yd0; yy < yd1; yy++) {
913 tmp1 = (JBIG2_GETDWORD(lineSrc) << shift1) |
914 (JBIG2_GETDWORD(lineSrc + 4) >> shift2);
915 tmp2 = JBIG2_GETDWORD(lineDst);
916 switch (op) {
917 case JBIG2_COMPOSE_OR:
918 tmp = (tmp2 & ~maskM) | ((tmp1 | tmp2) & maskM);
919 break;
920 case JBIG2_COMPOSE_AND:
921 tmp = (tmp2 & ~maskM) | ((tmp1 & tmp2) & maskM);
922 break;
923 case JBIG2_COMPOSE_XOR:
924 tmp = (tmp2 & ~maskM) | ((tmp1 ^ tmp2) & maskM);
925 break;
926 case JBIG2_COMPOSE_XNOR:
927 tmp = (tmp2 & ~maskM) | ((~(tmp1 ^ tmp2)) & maskM);
928 break;
929 case JBIG2_COMPOSE_REPLACE:
930 tmp = (tmp2 & ~maskM) | (tmp1 & maskM);
931 break;
932 }
933 lineDst[0] = (uint8_t)(tmp >> 24);
934 lineDst[1] = (uint8_t)(tmp >> 16);
935 lineDst[2] = (uint8_t)(tmp >> 8);
936 lineDst[3] = (uint8_t)tmp;
937 lineSrc += m_nStride;
938 lineDst += pDst->m_nStride;
939 }
49 } 940 }
50 m_bNeedFree = TRUE; 941 } else {
51 } 942 if (s1 > d1) {
52 CJBig2_Image::~CJBig2_Image() 943 shift1 = s1 - d1;
53 { 944 shift2 = 32 - shift1;
54 if(m_bNeedFree && m_pData) { 945 middleDwords = (xd1 >> 5) - ((xd0 + 31) >> 5);
55 m_pModule->JBig2_Free(m_pData); 946 for (yy = yd0; yy < yd1; yy++) {
947 sp = lineSrc;
948 dp = lineDst;
949 if (d1 != 0) {
950 tmp1 = (JBIG2_GETDWORD(sp) << shift1) |
951 (JBIG2_GETDWORD(sp + 4) >> shift2);
952 tmp2 = JBIG2_GETDWORD(dp);
953 switch (op) {
954 case JBIG2_COMPOSE_OR:
955 tmp = (tmp2 & ~maskL) | ((tmp1 | tmp2) & maskL);
956 break;
957 case JBIG2_COMPOSE_AND:
958 tmp = (tmp2 & ~maskL) | ((tmp1 & tmp2) & maskL);
959 break;
960 case JBIG2_COMPOSE_XOR:
961 tmp = (tmp2 & ~maskL) | ((tmp1 ^ tmp2) & maskL);
962 break;
963 case JBIG2_COMPOSE_XNOR:
964 tmp = (tmp2 & ~maskL) | ((~(tmp1 ^ tmp2)) & maskL);
965 break;
966 case JBIG2_COMPOSE_REPLACE:
967 tmp = (tmp2 & ~maskL) | (tmp1 & maskL);
968 break;
969 }
970 dp[0] = (uint8_t)(tmp >> 24);
971 dp[1] = (uint8_t)(tmp >> 16);
972 dp[2] = (uint8_t)(tmp >> 8);
973 dp[3] = (uint8_t)tmp;
974 sp += 4;
975 dp += 4;
976 }
977 for (xx = 0; xx < middleDwords; xx++) {
978 tmp1 = (JBIG2_GETDWORD(sp) << shift1) |
979 (JBIG2_GETDWORD(sp + 4) >> shift2);
980 tmp2 = JBIG2_GETDWORD(dp);
981 switch (op) {
982 case JBIG2_COMPOSE_OR:
983 tmp = tmp1 | tmp2;
984 break;
985 case JBIG2_COMPOSE_AND:
986 tmp = tmp1 & tmp2;
987 break;
988 case JBIG2_COMPOSE_XOR:
989 tmp = tmp1 ^ tmp2;
990 break;
991 case JBIG2_COMPOSE_XNOR:
992 tmp = ~(tmp1 ^ tmp2);
993 break;
994 case JBIG2_COMPOSE_REPLACE:
995 tmp = tmp1;
996 break;
997 }
998 dp[0] = (uint8_t)(tmp >> 24);
999 dp[1] = (uint8_t)(tmp >> 16);
1000 dp[2] = (uint8_t)(tmp >> 8);
1001 dp[3] = (uint8_t)tmp;
1002 sp += 4;
1003 dp += 4;
1004 }
1005 if (d2 != 0) {
1006 tmp1 =
1007 (JBIG2_GETDWORD(sp) << shift1) |
1008 (((sp + 4) < lineSrc + lineLeft ? JBIG2_GETDWORD(sp + 4) : 0) >>
1009 shift2);
1010 tmp2 = JBIG2_GETDWORD(dp);
1011 switch (op) {
1012 case JBIG2_COMPOSE_OR:
1013 tmp = (tmp2 & ~maskR) | ((tmp1 | tmp2) & maskR);
1014 break;
1015 case JBIG2_COMPOSE_AND:
1016 tmp = (tmp2 & ~maskR) | ((tmp1 & tmp2) & maskR);
1017 break;
1018 case JBIG2_COMPOSE_XOR:
1019 tmp = (tmp2 & ~maskR) | ((tmp1 ^ tmp2) & maskR);
1020 break;
1021 case JBIG2_COMPOSE_XNOR:
1022 tmp = (tmp2 & ~maskR) | ((~(tmp1 ^ tmp2)) & maskR);
1023 break;
1024 case JBIG2_COMPOSE_REPLACE:
1025 tmp = (tmp2 & ~maskR) | (tmp1 & maskR);
1026 break;
1027 }
1028 dp[0] = (uint8_t)(tmp >> 24);
1029 dp[1] = (uint8_t)(tmp >> 16);
1030 dp[2] = (uint8_t)(tmp >> 8);
1031 dp[3] = (uint8_t)tmp;
1032 }
1033 lineSrc += m_nStride;
1034 lineDst += pDst->m_nStride;
1035 }
1036 } else if (s1 == d1) {
1037 middleDwords = (xd1 >> 5) - ((xd0 + 31) >> 5);
1038 for (yy = yd0; yy < yd1; yy++) {
1039 sp = lineSrc;
1040 dp = lineDst;
1041 if (d1 != 0) {
1042 tmp1 = JBIG2_GETDWORD(sp);
1043 tmp2 = JBIG2_GETDWORD(dp);
1044 switch (op) {
1045 case JBIG2_COMPOSE_OR:
1046 tmp = (tmp2 & ~maskL) | ((tmp1 | tmp2) & maskL);
1047 break;
1048 case JBIG2_COMPOSE_AND:
1049 tmp = (tmp2 & ~maskL) | ((tmp1 & tmp2) & maskL);
1050 break;
1051 case JBIG2_COMPOSE_XOR:
1052 tmp = (tmp2 & ~maskL) | ((tmp1 ^ tmp2) & maskL);
1053 break;
1054 case JBIG2_COMPOSE_XNOR:
1055 tmp = (tmp2 & ~maskL) | ((~(tmp1 ^ tmp2)) & maskL);
1056 break;
1057 case JBIG2_COMPOSE_REPLACE:
1058 tmp = (tmp2 & ~maskL) | (tmp1 & maskL);
1059 break;
1060 }
1061 dp[0] = (uint8_t)(tmp >> 24);
1062 dp[1] = (uint8_t)(tmp >> 16);
1063 dp[2] = (uint8_t)(tmp >> 8);
1064 dp[3] = (uint8_t)tmp;
1065 sp += 4;
1066 dp += 4;
1067 }
1068 for (xx = 0; xx < middleDwords; xx++) {
1069 tmp1 = JBIG2_GETDWORD(sp);
1070 tmp2 = JBIG2_GETDWORD(dp);
1071 switch (op) {
1072 case JBIG2_COMPOSE_OR:
1073 tmp = tmp1 | tmp2;
1074 break;
1075 case JBIG2_COMPOSE_AND:
1076 tmp = tmp1 & tmp2;
1077 break;
1078 case JBIG2_COMPOSE_XOR:
1079 tmp = tmp1 ^ tmp2;
1080 break;
1081 case JBIG2_COMPOSE_XNOR:
1082 tmp = ~(tmp1 ^ tmp2);
1083 break;
1084 case JBIG2_COMPOSE_REPLACE:
1085 tmp = tmp1;
1086 break;
1087 }
1088 dp[0] = (uint8_t)(tmp >> 24);
1089 dp[1] = (uint8_t)(tmp >> 16);
1090 dp[2] = (uint8_t)(tmp >> 8);
1091 dp[3] = (uint8_t)tmp;
1092 sp += 4;
1093 dp += 4;
1094 }
1095 if (d2 != 0) {
1096 tmp1 = JBIG2_GETDWORD(sp);
1097 tmp2 = JBIG2_GETDWORD(dp);
1098 switch (op) {
1099 case JBIG2_COMPOSE_OR:
1100 tmp = (tmp2 & ~maskR) | ((tmp1 | tmp2) & maskR);
1101 break;
1102 case JBIG2_COMPOSE_AND:
1103 tmp = (tmp2 & ~maskR) | ((tmp1 & tmp2) & maskR);
1104 break;
1105 case JBIG2_COMPOSE_XOR:
1106 tmp = (tmp2 & ~maskR) | ((tmp1 ^ tmp2) & maskR);
1107 break;
1108 case JBIG2_COMPOSE_XNOR:
1109 tmp = (tmp2 & ~maskR) | ((~(tmp1 ^ tmp2)) & maskR);
1110 break;
1111 case JBIG2_COMPOSE_REPLACE:
1112 tmp = (tmp2 & ~maskR) | (tmp1 & maskR);
1113 break;
1114 }
1115 dp[0] = (uint8_t)(tmp >> 24);
1116 dp[1] = (uint8_t)(tmp >> 16);
1117 dp[2] = (uint8_t)(tmp >> 8);
1118 dp[3] = (uint8_t)tmp;
1119 }
1120 lineSrc += m_nStride;
1121 lineDst += pDst->m_nStride;
1122 }
1123 } else {
1124 shift1 = d1 - s1;
1125 shift2 = 32 - shift1;
1126 middleDwords = (xd1 >> 5) - ((xd0 + 31) >> 5);
1127 for (yy = yd0; yy < yd1; yy++) {
1128 sp = lineSrc;
1129 dp = lineDst;
1130 if (d1 != 0) {
1131 tmp1 = JBIG2_GETDWORD(sp) >> shift1;
1132 tmp2 = JBIG2_GETDWORD(dp);
1133 switch (op) {
1134 case JBIG2_COMPOSE_OR:
1135 tmp = (tmp2 & ~maskL) | ((tmp1 | tmp2) & maskL);
1136 break;
1137 case JBIG2_COMPOSE_AND:
1138 tmp = (tmp2 & ~maskL) | ((tmp1 & tmp2) & maskL);
1139 break;
1140 case JBIG2_COMPOSE_XOR:
1141 tmp = (tmp2 & ~maskL) | ((tmp1 ^ tmp2) & maskL);
1142 break;
1143 case JBIG2_COMPOSE_XNOR:
1144 tmp = (tmp2 & ~maskL) | ((~(tmp1 ^ tmp2)) & maskL);
1145 break;
1146 case JBIG2_COMPOSE_REPLACE:
1147 tmp = (tmp2 & ~maskL) | (tmp1 & maskL);
1148 break;
1149 }
1150 dp[0] = (uint8_t)(tmp >> 24);
1151 dp[1] = (uint8_t)(tmp >> 16);
1152 dp[2] = (uint8_t)(tmp >> 8);
1153 dp[3] = (uint8_t)tmp;
1154 dp += 4;
1155 }
1156 for (xx = 0; xx < middleDwords; xx++) {
1157 tmp1 = (JBIG2_GETDWORD(sp) << shift2) |
1158 ((JBIG2_GETDWORD(sp + 4)) >> shift1);
1159 tmp2 = JBIG2_GETDWORD(dp);
1160 switch (op) {
1161 case JBIG2_COMPOSE_OR:
1162 tmp = tmp1 | tmp2;
1163 break;
1164 case JBIG2_COMPOSE_AND:
1165 tmp = tmp1 & tmp2;
1166 break;
1167 case JBIG2_COMPOSE_XOR:
1168 tmp = tmp1 ^ tmp2;
1169 break;
1170 case JBIG2_COMPOSE_XNOR:
1171 tmp = ~(tmp1 ^ tmp2);
1172 break;
1173 case JBIG2_COMPOSE_REPLACE:
1174 tmp = tmp1;
1175 break;
1176 }
1177 dp[0] = (uint8_t)(tmp >> 24);
1178 dp[1] = (uint8_t)(tmp >> 16);
1179 dp[2] = (uint8_t)(tmp >> 8);
1180 dp[3] = (uint8_t)tmp;
1181 sp += 4;
1182 dp += 4;
1183 }
1184 if (d2 != 0) {
1185 tmp1 =
1186 (JBIG2_GETDWORD(sp) << shift2) |
1187 (((sp + 4) < lineSrc + lineLeft ? JBIG2_GETDWORD(sp + 4) : 0) >>
1188 shift1);
1189 tmp2 = JBIG2_GETDWORD(dp);
1190 switch (op) {
1191 case JBIG2_COMPOSE_OR:
1192 tmp = (tmp2 & ~maskR) | ((tmp1 | tmp2) & maskR);
1193 break;
1194 case JBIG2_COMPOSE_AND:
1195 tmp = (tmp2 & ~maskR) | ((tmp1 & tmp2) & maskR);
1196 break;
1197 case JBIG2_COMPOSE_XOR:
1198 tmp = (tmp2 & ~maskR) | ((tmp1 ^ tmp2) & maskR);
1199 break;
1200 case JBIG2_COMPOSE_XNOR:
1201 tmp = (tmp2 & ~maskR) | ((~(tmp1 ^ tmp2)) & maskR);
1202 break;
1203 case JBIG2_COMPOSE_REPLACE:
1204 tmp = (tmp2 & ~maskR) | (tmp1 & maskR);
1205 break;
1206 }
1207 dp[0] = (uint8_t)(tmp >> 24);
1208 dp[1] = (uint8_t)(tmp >> 16);
1209 dp[2] = (uint8_t)(tmp >> 8);
1210 dp[3] = (uint8_t)tmp;
1211 }
1212 lineSrc += m_nStride;
1213 lineDst += pDst->m_nStride;
1214 }
56 } 1215 }
57 } 1216 }
58 FX_BOOL CJBig2_Image::getPixel(int32_t x, int32_t y) 1217 return 1;
59 { 1218 }
60 if (!m_pData) { 1219 FX_BOOL CJBig2_Image::composeTo_opt2(CJBig2_Image* pDst,
61 return 0; 1220 int32_t x,
1221 int32_t y,
1222 JBig2ComposeOp op,
1223 const FX_RECT* pSrcRect) {
1224 int32_t xs0, ys0, xs1, ys1, xd0, yd0, xd1, yd1, xx, yy, w, h, middleDwords,
1225 lineLeft;
1226 FX_DWORD s1, d1, d2, shift, shift1, shift2, tmp, tmp1, tmp2, maskL, maskR,
1227 maskM;
1228 uint8_t *lineSrc, *lineDst, *sp, *dp;
1229 int32_t sw, sh;
1230 if (!m_pData) {
1231 return FALSE;
1232 }
1233 if (x < -1048576 || x > 1048576 || y < -1048576 || y > 1048576) {
1234 return FALSE;
1235 }
1236 sw = pSrcRect->Width();
1237 sh = pSrcRect->Height();
1238 if (y < 0) {
1239 ys0 = -y;
1240 } else {
1241 ys0 = 0;
1242 }
1243 if (y + sh > pDst->m_nHeight) {
1244 ys1 = pDst->m_nHeight - y;
1245 } else {
1246 ys1 = sh;
1247 }
1248 if (x < 0) {
1249 xs0 = -x;
1250 } else {
1251 xs0 = 0;
1252 }
1253 if (x + sw > pDst->m_nWidth) {
1254 xs1 = pDst->m_nWidth - x;
1255 } else {
1256 xs1 = sw;
1257 }
1258 if ((ys0 >= ys1) || (xs0 >= xs1)) {
1259 return 0;
1260 }
1261 w = xs1 - xs0;
1262 h = ys1 - ys0;
1263 if (y < 0) {
1264 yd0 = 0;
1265 } else {
1266 yd0 = y;
1267 }
1268 if (x < 0) {
1269 xd0 = 0;
1270 } else {
1271 xd0 = x;
1272 }
1273 xd1 = xd0 + w;
1274 yd1 = yd0 + h;
1275 d1 = xd0 & 31;
1276 d2 = xd1 & 31;
1277 s1 = xs0 & 31;
1278 maskL = 0xffffffff >> d1;
1279 maskR = 0xffffffff << ((32 - (xd1 & 31)) % 32);
1280 maskM = maskL & maskR;
1281 lineSrc = m_pData + (pSrcRect->top + ys0) * m_nStride +
1282 (((xs0 + pSrcRect->left) >> 5) << 2);
1283 lineLeft = m_nStride - ((xs0 >> 5) << 2);
1284 lineDst = pDst->m_pData + yd0 * pDst->m_nStride + ((xd0 >> 5) << 2);
1285 if ((xd0 & ~31) == ((xd1 - 1) & ~31)) {
1286 if ((xs0 & ~31) == ((xs1 - 1) & ~31)) {
1287 if (s1 > d1) {
1288 shift = s1 - d1;
1289 for (yy = yd0; yy < yd1; yy++) {
1290 tmp1 = JBIG2_GETDWORD(lineSrc) << shift;
1291 tmp2 = JBIG2_GETDWORD(lineDst);
1292 switch (op) {
1293 case JBIG2_COMPOSE_OR:
1294 tmp = (tmp2 & ~maskM) | ((tmp1 | tmp2) & maskM);
1295 break;
1296 case JBIG2_COMPOSE_AND:
1297 tmp = (tmp2 & ~maskM) | ((tmp1 & tmp2) & maskM);
1298 break;
1299 case JBIG2_COMPOSE_XOR:
1300 tmp = (tmp2 & ~maskM) | ((tmp1 ^ tmp2) & maskM);
1301 break;
1302 case JBIG2_COMPOSE_XNOR:
1303 tmp = (tmp2 & ~maskM) | ((~(tmp1 ^ tmp2)) & maskM);
1304 break;
1305 case JBIG2_COMPOSE_REPLACE:
1306 tmp = (tmp2 & ~maskM) | (tmp1 & maskM);
1307 break;
1308 }
1309 lineDst[0] = (uint8_t)(tmp >> 24);
1310 lineDst[1] = (uint8_t)(tmp >> 16);
1311 lineDst[2] = (uint8_t)(tmp >> 8);
1312 lineDst[3] = (uint8_t)tmp;
1313 lineSrc += m_nStride;
1314 lineDst += pDst->m_nStride;
1315 }
1316 } else {
1317 shift = d1 - s1;
1318 for (yy = yd0; yy < yd1; yy++) {
1319 tmp1 = JBIG2_GETDWORD(lineSrc) >> shift;
1320 tmp2 = JBIG2_GETDWORD(lineDst);
1321 switch (op) {
1322 case JBIG2_COMPOSE_OR:
1323 tmp = (tmp2 & ~maskM) | ((tmp1 | tmp2) & maskM);
1324 break;
1325 case JBIG2_COMPOSE_AND:
1326 tmp = (tmp2 & ~maskM) | ((tmp1 & tmp2) & maskM);
1327 break;
1328 case JBIG2_COMPOSE_XOR:
1329 tmp = (tmp2 & ~maskM) | ((tmp1 ^ tmp2) & maskM);
1330 break;
1331 case JBIG2_COMPOSE_XNOR:
1332 tmp = (tmp2 & ~maskM) | ((~(tmp1 ^ tmp2)) & maskM);
1333 break;
1334 case JBIG2_COMPOSE_REPLACE:
1335 tmp = (tmp2 & ~maskM) | (tmp1 & maskM);
1336 break;
1337 }
1338 lineDst[0] = (uint8_t)(tmp >> 24);
1339 lineDst[1] = (uint8_t)(tmp >> 16);
1340 lineDst[2] = (uint8_t)(tmp >> 8);
1341 lineDst[3] = (uint8_t)tmp;
1342 lineSrc += m_nStride;
1343 lineDst += pDst->m_nStride;
1344 }
1345 }
1346 } else {
1347 shift1 = s1 - d1;
1348 shift2 = 32 - shift1;
1349 for (yy = yd0; yy < yd1; yy++) {
1350 tmp1 = (JBIG2_GETDWORD(lineSrc) << shift1) |
1351 (JBIG2_GETDWORD(lineSrc + 4) >> shift2);
1352 tmp2 = JBIG2_GETDWORD(lineDst);
1353 switch (op) {
1354 case JBIG2_COMPOSE_OR:
1355 tmp = (tmp2 & ~maskM) | ((tmp1 | tmp2) & maskM);
1356 break;
1357 case JBIG2_COMPOSE_AND:
1358 tmp = (tmp2 & ~maskM) | ((tmp1 & tmp2) & maskM);
1359 break;
1360 case JBIG2_COMPOSE_XOR:
1361 tmp = (tmp2 & ~maskM) | ((tmp1 ^ tmp2) & maskM);
1362 break;
1363 case JBIG2_COMPOSE_XNOR:
1364 tmp = (tmp2 & ~maskM) | ((~(tmp1 ^ tmp2)) & maskM);
1365 break;
1366 case JBIG2_COMPOSE_REPLACE:
1367 tmp = (tmp2 & ~maskM) | (tmp1 & maskM);
1368 break;
1369 }
1370 lineDst[0] = (uint8_t)(tmp >> 24);
1371 lineDst[1] = (uint8_t)(tmp >> 16);
1372 lineDst[2] = (uint8_t)(tmp >> 8);
1373 lineDst[3] = (uint8_t)tmp;
1374 lineSrc += m_nStride;
1375 lineDst += pDst->m_nStride;
1376 }
62 } 1377 }
63 int32_t m, n; 1378 } else {
64 if(x < 0 || x >= m_nWidth) { 1379 if (s1 > d1) {
65 return 0; 1380 shift1 = s1 - d1;
1381 shift2 = 32 - shift1;
1382 middleDwords = (xd1 >> 5) - ((xd0 + 31) >> 5);
1383 for (yy = yd0; yy < yd1; yy++) {
1384 sp = lineSrc;
1385 dp = lineDst;
1386 if (d1 != 0) {
1387 tmp1 = (JBIG2_GETDWORD(sp) << shift1) |
1388 (JBIG2_GETDWORD(sp + 4) >> shift2);
1389 tmp2 = JBIG2_GETDWORD(dp);
1390 switch (op) {
1391 case JBIG2_COMPOSE_OR:
1392 tmp = (tmp2 & ~maskL) | ((tmp1 | tmp2) & maskL);
1393 break;
1394 case JBIG2_COMPOSE_AND:
1395 tmp = (tmp2 & ~maskL) | ((tmp1 & tmp2) & maskL);
1396 break;
1397 case JBIG2_COMPOSE_XOR:
1398 tmp = (tmp2 & ~maskL) | ((tmp1 ^ tmp2) & maskL);
1399 break;
1400 case JBIG2_COMPOSE_XNOR:
1401 tmp = (tmp2 & ~maskL) | ((~(tmp1 ^ tmp2)) & maskL);
1402 break;
1403 case JBIG2_COMPOSE_REPLACE:
1404 tmp = (tmp2 & ~maskL) | (tmp1 & maskL);
1405 break;
1406 }
1407 dp[0] = (uint8_t)(tmp >> 24);
1408 dp[1] = (uint8_t)(tmp >> 16);
1409 dp[2] = (uint8_t)(tmp >> 8);
1410 dp[3] = (uint8_t)tmp;
1411 sp += 4;
1412 dp += 4;
1413 }
1414 for (xx = 0; xx < middleDwords; xx++) {
1415 tmp1 = (JBIG2_GETDWORD(sp) << shift1) |
1416 (JBIG2_GETDWORD(sp + 4) >> shift2);
1417 tmp2 = JBIG2_GETDWORD(dp);
1418 switch (op) {
1419 case JBIG2_COMPOSE_OR:
1420 tmp = tmp1 | tmp2;
1421 break;
1422 case JBIG2_COMPOSE_AND:
1423 tmp = tmp1 & tmp2;
1424 break;
1425 case JBIG2_COMPOSE_XOR:
1426 tmp = tmp1 ^ tmp2;
1427 break;
1428 case JBIG2_COMPOSE_XNOR:
1429 tmp = ~(tmp1 ^ tmp2);
1430 break;
1431 case JBIG2_COMPOSE_REPLACE:
1432 tmp = tmp1;
1433 break;
1434 }
1435 dp[0] = (uint8_t)(tmp >> 24);
1436 dp[1] = (uint8_t)(tmp >> 16);
1437 dp[2] = (uint8_t)(tmp >> 8);
1438 dp[3] = (uint8_t)tmp;
1439 sp += 4;
1440 dp += 4;
1441 }
1442 if (d2 != 0) {
1443 tmp1 =
1444 (JBIG2_GETDWORD(sp) << shift1) |
1445 (((sp + 4) < lineSrc + lineLeft ? JBIG2_GETDWORD(sp + 4) : 0) >>
1446 shift2);
1447 tmp2 = JBIG2_GETDWORD(dp);
1448 switch (op) {
1449 case JBIG2_COMPOSE_OR:
1450 tmp = (tmp2 & ~maskR) | ((tmp1 | tmp2) & maskR);
1451 break;
1452 case JBIG2_COMPOSE_AND:
1453 tmp = (tmp2 & ~maskR) | ((tmp1 & tmp2) & maskR);
1454 break;
1455 case JBIG2_COMPOSE_XOR:
1456 tmp = (tmp2 & ~maskR) | ((tmp1 ^ tmp2) & maskR);
1457 break;
1458 case JBIG2_COMPOSE_XNOR:
1459 tmp = (tmp2 & ~maskR) | ((~(tmp1 ^ tmp2)) & maskR);
1460 break;
1461 case JBIG2_COMPOSE_REPLACE:
1462 tmp = (tmp2 & ~maskR) | (tmp1 & maskR);
1463 break;
1464 }
1465 dp[0] = (uint8_t)(tmp >> 24);
1466 dp[1] = (uint8_t)(tmp >> 16);
1467 dp[2] = (uint8_t)(tmp >> 8);
1468 dp[3] = (uint8_t)tmp;
1469 }
1470 lineSrc += m_nStride;
1471 lineDst += pDst->m_nStride;
1472 }
1473 } else if (s1 == d1) {
1474 middleDwords = (xd1 >> 5) - ((xd0 + 31) >> 5);
1475 for (yy = yd0; yy < yd1; yy++) {
1476 sp = lineSrc;
1477 dp = lineDst;
1478 if (d1 != 0) {
1479 tmp1 = JBIG2_GETDWORD(sp);
1480 tmp2 = JBIG2_GETDWORD(dp);
1481 switch (op) {
1482 case JBIG2_COMPOSE_OR:
1483 tmp = (tmp2 & ~maskL) | ((tmp1 | tmp2) & maskL);
1484 break;
1485 case JBIG2_COMPOSE_AND:
1486 tmp = (tmp2 & ~maskL) | ((tmp1 & tmp2) & maskL);
1487 break;
1488 case JBIG2_COMPOSE_XOR:
1489 tmp = (tmp2 & ~maskL) | ((tmp1 ^ tmp2) & maskL);
1490 break;
1491 case JBIG2_COMPOSE_XNOR:
1492 tmp = (tmp2 & ~maskL) | ((~(tmp1 ^ tmp2)) & maskL);
1493 break;
1494 case JBIG2_COMPOSE_REPLACE:
1495 tmp = (tmp2 & ~maskL) | (tmp1 & maskL);
1496 break;
1497 }
1498 dp[0] = (uint8_t)(tmp >> 24);
1499 dp[1] = (uint8_t)(tmp >> 16);
1500 dp[2] = (uint8_t)(tmp >> 8);
1501 dp[3] = (uint8_t)tmp;
1502 sp += 4;
1503 dp += 4;
1504 }
1505 for (xx = 0; xx < middleDwords; xx++) {
1506 tmp1 = JBIG2_GETDWORD(sp);
1507 tmp2 = JBIG2_GETDWORD(dp);
1508 switch (op) {
1509 case JBIG2_COMPOSE_OR:
1510 tmp = tmp1 | tmp2;
1511 break;
1512 case JBIG2_COMPOSE_AND:
1513 tmp = tmp1 & tmp2;
1514 break;
1515 case JBIG2_COMPOSE_XOR:
1516 tmp = tmp1 ^ tmp2;
1517 break;
1518 case JBIG2_COMPOSE_XNOR:
1519 tmp = ~(tmp1 ^ tmp2);
1520 break;
1521 case JBIG2_COMPOSE_REPLACE:
1522 tmp = tmp1;
1523 break;
1524 }
1525 dp[0] = (uint8_t)(tmp >> 24);
1526 dp[1] = (uint8_t)(tmp >> 16);
1527 dp[2] = (uint8_t)(tmp >> 8);
1528 dp[3] = (uint8_t)tmp;
1529 sp += 4;
1530 dp += 4;
1531 }
1532 if (d2 != 0) {
1533 tmp1 = JBIG2_GETDWORD(sp);
1534 tmp2 = JBIG2_GETDWORD(dp);
1535 switch (op) {
1536 case JBIG2_COMPOSE_OR:
1537 tmp = (tmp2 & ~maskR) | ((tmp1 | tmp2) & maskR);
1538 break;
1539 case JBIG2_COMPOSE_AND:
1540 tmp = (tmp2 & ~maskR) | ((tmp1 & tmp2) & maskR);
1541 break;
1542 case JBIG2_COMPOSE_XOR:
1543 tmp = (tmp2 & ~maskR) | ((tmp1 ^ tmp2) & maskR);
1544 break;
1545 case JBIG2_COMPOSE_XNOR:
1546 tmp = (tmp2 & ~maskR) | ((~(tmp1 ^ tmp2)) & maskR);
1547 break;
1548 case JBIG2_COMPOSE_REPLACE:
1549 tmp = (tmp2 & ~maskR) | (tmp1 & maskR);
1550 break;
1551 }
1552 dp[0] = (uint8_t)(tmp >> 24);
1553 dp[1] = (uint8_t)(tmp >> 16);
1554 dp[2] = (uint8_t)(tmp >> 8);
1555 dp[3] = (uint8_t)tmp;
1556 }
1557 lineSrc += m_nStride;
1558 lineDst += pDst->m_nStride;
1559 }
1560 } else {
1561 shift1 = d1 - s1;
1562 shift2 = 32 - shift1;
1563 middleDwords = (xd1 >> 5) - ((xd0 + 31) >> 5);
1564 for (yy = yd0; yy < yd1; yy++) {
1565 sp = lineSrc;
1566 dp = lineDst;
1567 if (d1 != 0) {
1568 tmp1 = JBIG2_GETDWORD(sp) >> shift1;
1569 tmp2 = JBIG2_GETDWORD(dp);
1570 switch (op) {
1571 case JBIG2_COMPOSE_OR:
1572 tmp = (tmp2 & ~maskL) | ((tmp1 | tmp2) & maskL);
1573 break;
1574 case JBIG2_COMPOSE_AND:
1575 tmp = (tmp2 & ~maskL) | ((tmp1 & tmp2) & maskL);
1576 break;
1577 case JBIG2_COMPOSE_XOR:
1578 tmp = (tmp2 & ~maskL) | ((tmp1 ^ tmp2) & maskL);
1579 break;
1580 case JBIG2_COMPOSE_XNOR:
1581 tmp = (tmp2 & ~maskL) | ((~(tmp1 ^ tmp2)) & maskL);
1582 break;
1583 case JBIG2_COMPOSE_REPLACE:
1584 tmp = (tmp2 & ~maskL) | (tmp1 & maskL);
1585 break;
1586 }
1587 dp[0] = (uint8_t)(tmp >> 24);
1588 dp[1] = (uint8_t)(tmp >> 16);
1589 dp[2] = (uint8_t)(tmp >> 8);
1590 dp[3] = (uint8_t)tmp;
1591 dp += 4;
1592 }
1593 for (xx = 0; xx < middleDwords; xx++) {
1594 tmp1 = (JBIG2_GETDWORD(sp) << shift2) |
1595 ((JBIG2_GETDWORD(sp + 4)) >> shift1);
1596 tmp2 = JBIG2_GETDWORD(dp);
1597 switch (op) {
1598 case JBIG2_COMPOSE_OR:
1599 tmp = tmp1 | tmp2;
1600 break;
1601 case JBIG2_COMPOSE_AND:
1602 tmp = tmp1 & tmp2;
1603 break;
1604 case JBIG2_COMPOSE_XOR:
1605 tmp = tmp1 ^ tmp2;
1606 break;
1607 case JBIG2_COMPOSE_XNOR:
1608 tmp = ~(tmp1 ^ tmp2);
1609 break;
1610 case JBIG2_COMPOSE_REPLACE:
1611 tmp = tmp1;
1612 break;
1613 }
1614 dp[0] = (uint8_t)(tmp >> 24);
1615 dp[1] = (uint8_t)(tmp >> 16);
1616 dp[2] = (uint8_t)(tmp >> 8);
1617 dp[3] = (uint8_t)tmp;
1618 sp += 4;
1619 dp += 4;
1620 }
1621 if (d2 != 0) {
1622 tmp1 =
1623 (JBIG2_GETDWORD(sp) << shift2) |
1624 (((sp + 4) < lineSrc + lineLeft ? JBIG2_GETDWORD(sp + 4) : 0) >>
1625 shift1);
1626 tmp2 = JBIG2_GETDWORD(dp);
1627 switch (op) {
1628 case JBIG2_COMPOSE_OR:
1629 tmp = (tmp2 & ~maskR) | ((tmp1 | tmp2) & maskR);
1630 break;
1631 case JBIG2_COMPOSE_AND:
1632 tmp = (tmp2 & ~maskR) | ((tmp1 & tmp2) & maskR);
1633 break;
1634 case JBIG2_COMPOSE_XOR:
1635 tmp = (tmp2 & ~maskR) | ((tmp1 ^ tmp2) & maskR);
1636 break;
1637 case JBIG2_COMPOSE_XNOR:
1638 tmp = (tmp2 & ~maskR) | ((~(tmp1 ^ tmp2)) & maskR);
1639 break;
1640 case JBIG2_COMPOSE_REPLACE:
1641 tmp = (tmp2 & ~maskR) | (tmp1 & maskR);
1642 break;
1643 }
1644 dp[0] = (uint8_t)(tmp >> 24);
1645 dp[1] = (uint8_t)(tmp >> 16);
1646 dp[2] = (uint8_t)(tmp >> 8);
1647 dp[3] = (uint8_t)tmp;
1648 }
1649 lineSrc += m_nStride;
1650 lineDst += pDst->m_nStride;
1651 }
66 } 1652 }
67 if(y < 0 || y >= m_nHeight) { 1653 }
68 return 0; 1654 return 1;
69 } 1655 }
70 m = y * m_nStride + (x >> 3);
71 n = x & 7;
72 return ((m_pData[m] >> (7 - n)) & 1);
73 }
74
75 int32_t CJBig2_Image::setPixel(int32_t x, int32_t y, FX_BOOL v)
76 {
77 if (!m_pData) {
78 return 0;
79 }
80 int32_t m, n;
81 if(x < 0 || x >= m_nWidth) {
82 return 0;
83 }
84 if(y < 0 || y >= m_nHeight) {
85 return 0;
86 }
87 m = y * m_nStride + (x >> 3);
88 n = x & 7;
89 if(v) {
90 m_pData[m] |= 1 << (7 - n);
91 } else {
92 m_pData[m] &= ~(1 << (7 - n));
93 }
94 return 1;
95 }
96 void CJBig2_Image::copyLine(int32_t hTo, int32_t hFrom)
97 {
98 if (!m_pData) {
99 return;
100 }
101 if(hFrom < 0 || hFrom >= m_nHeight) {
102 JBIG2_memset(m_pData + hTo * m_nStride, 0, m_nStride);
103 } else {
104 JBIG2_memcpy(m_pData + hTo * m_nStride, m_pData + hFrom * m_nStride, m_n Stride);
105 }
106 }
107 void CJBig2_Image::fill(FX_BOOL v)
108 {
109 if (!m_pData) {
110 return;
111 }
112 JBIG2_memset(m_pData, v ? 0xff : 0, m_nStride * m_nHeight);
113 }
114 FX_BOOL CJBig2_Image::composeTo(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2C omposeOp op)
115 {
116 if (!m_pData) {
117 return FALSE;
118 }
119 return composeTo_opt2(pDst, x, y, op);
120 }
121 FX_BOOL CJBig2_Image::composeTo(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2C omposeOp op, const FX_RECT* pSrcRect)
122 {
123 if (!m_pData) {
124 return FALSE;
125 }
126 if (NULL == pSrcRect || *pSrcRect == FX_RECT(0, 0, m_nWidth, m_nHeight)) {
127 return composeTo_opt2(pDst, x, y, op);
128 }
129 return composeTo_opt2(pDst, x, y, op, pSrcRect);
130 }
131 FX_BOOL CJBig2_Image::composeTo_unopt(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op)
132 {
133 int32_t w, h, dx, dy;
134 int32_t i, j;
135 w = m_nWidth;
136 h = m_nHeight;
137 dx = dy = 0;
138 if(x < 0) {
139 dx += -x;
140 w -= -x;
141 x = 0;
142 }
143 if(y < 0) {
144 dy += -y;
145 h -= -y;
146 y = 0;
147 }
148 if(x + w > pDst->m_nWidth) {
149 w = pDst->m_nWidth - x;
150 }
151 if(y + h > pDst->m_nHeight) {
152 h = pDst->m_nHeight - y;
153 }
154 switch(op) {
155 case JBIG2_COMPOSE_OR:
156 for(j = 0; j < h; j++) {
157 for(i = 0; i < w; i++) {
158 pDst->setPixel(x + i, y + j,
159 (getPixel(i + dx, j + dy) | pDst->getPixel(x + i, y + j)) & 1);
160 }
161 }
162 break;
163 case JBIG2_COMPOSE_AND:
164 for(j = 0; j < h; j++) {
165 for(i = 0; i < w; i++) {
166 pDst->setPixel(x + i, y + j,
167 (getPixel(i + dx, j + dy) & pDst->getPixel(x + i, y + j)) & 1);
168 }
169 }
170 break;
171 case JBIG2_COMPOSE_XOR:
172 for(j = 0; j < h; j++) {
173 for(i = 0; i < w; i++) {
174 pDst->setPixel(x + i, y + j,
175 (getPixel(i + dx, j + dy) ^ pDst->getPixel(x + i, y + j)) & 1);
176 }
177 }
178 break;
179 case JBIG2_COMPOSE_XNOR:
180 for(j = 0; j < h; j++) {
181 for(i = 0; i < w; i++) {
182 pDst->setPixel(x + i, y + j,
183 (~(getPixel(i + dx, j + dy) ^ pDst->getPixel( x + i, y + j))) & 1);
184 }
185 }
186 break;
187 case JBIG2_COMPOSE_REPLACE:
188 for(j = 0; j < h; j++) {
189 for(i = 0; i < w; i++) {
190 pDst->setPixel(x + i, y + j, getPixel(i + dx, j + dy));
191 }
192 }
193 break;
194 }
195 return TRUE;
196 }
197
198 FX_BOOL CJBig2_Image::composeTo_opt(CJBig2_Image *pDst, int32_t x, int32_t y, JB ig2ComposeOp op)
199 {
200 int32_t x0, x1, y0, y1, xx, yy;
201 uint8_t *pLineSrc, *pLineDst, *srcPtr, *destPtr;
202 FX_DWORD src0, src1, src, dest, s1, s2, m1, m2, m3;
203 FX_BOOL oneByte;
204 if (!m_pData) {
205 return FALSE;
206 }
207 if (y < 0) {
208 y0 = -y;
209 } else {
210 y0 = 0;
211 }
212 if (y + m_nHeight > pDst->m_nHeight) {
213 y1 = pDst->m_nHeight - y;
214 } else {
215 y1 = m_nHeight;
216 }
217 if (y0 >= y1) {
218 return FALSE;
219 }
220 if (x >= 0) {
221 x0 = x & ~7;
222 } else {
223 x0 = 0;
224 }
225 x1 = x + m_nWidth;
226 if (x1 > pDst->m_nWidth) {
227 x1 = pDst->m_nWidth;
228 }
229 if (x0 >= x1) {
230 return FALSE;
231 }
232 s1 = x & 7;
233 s2 = 8 - s1;
234 m1 = 0xff >> (x1 & 7);
235 m2 = 0xff << (((x1 & 7) == 0) ? 0 : 8 - (x1 & 7));
236 m3 = (0xff >> s1) & m2;
237 oneByte = x0 == ((x1 - 1) & ~7);
238 pLineDst = pDst->m_pData + y * pDst->m_nStride;
239 pLineSrc = m_pData + y0 * m_nStride;
240 if(oneByte) {
241 if(x >= 0) {
242 switch(op) {
243 case JBIG2_COMPOSE_OR: {
244 for (yy = y0; yy < y1; ++yy) {
245 destPtr = pLineDst + (x >> 3);
246 srcPtr = pLineSrc;
247 dest = *destPtr;
248 dest |= (*srcPtr >> s1) & m2;
249 *destPtr = (uint8_t)dest;
250 pLineDst += pDst->m_nStride;
251 pLineSrc += m_nStride;
252 }
253 }
254 break;
255 case JBIG2_COMPOSE_AND: {
256 for (yy = y0; yy < y1; ++yy) {
257 destPtr = pLineDst + (x >> 3);
258 srcPtr = pLineSrc;
259 dest = *destPtr;
260 dest &= ((0xff00 | *srcPtr) >> s1) | m1;
261 *destPtr = (uint8_t)dest;
262 pLineDst += pDst->m_nStride;
263 pLineSrc += m_nStride;
264 }
265 }
266 break;
267 case JBIG2_COMPOSE_XOR: {
268 for (yy = y0; yy < y1; ++yy) {
269 destPtr = pLineDst + (x >> 3);
270 srcPtr = pLineSrc;
271 dest = *destPtr;
272 dest ^= (*srcPtr >> s1) & m2;
273 *destPtr = (uint8_t)dest;
274 pLineDst += pDst->m_nStride;
275 pLineSrc += m_nStride;
276 }
277 }
278 break;
279 case JBIG2_COMPOSE_XNOR: {
280 for (yy = y0; yy < y1; ++yy) {
281 destPtr = pLineDst + (x >> 3);
282 srcPtr = pLineSrc;
283 dest = *destPtr;
284 dest ^= ((*srcPtr ^ 0xff) >> s1) & m2;
285 *destPtr = (uint8_t)dest;
286 pLineDst += pDst->m_nStride;
287 pLineSrc += m_nStride;
288 }
289 }
290 break;
291 case JBIG2_COMPOSE_REPLACE: {
292 for (yy = y0; yy < y1; ++yy) {
293 destPtr = pLineDst + (x >> 3);
294 srcPtr = pLineSrc;
295 dest = *destPtr;
296 dest = (dest & ~m3) | ((*srcPtr >> s1) & m3);
297 *destPtr = (uint8_t)dest;
298 pLineDst += pDst->m_nStride;
299 pLineSrc += m_nStride;
300 }
301 }
302 break;
303 }
304 } else {
305 switch(op) {
306 case JBIG2_COMPOSE_OR: {
307 for(yy = y0; yy < y1; ++yy) {
308 destPtr = pLineDst;
309 srcPtr = pLineSrc + (-x >> 3);
310 dest = *destPtr;
311 dest |= *srcPtr & m2;
312 *destPtr = (uint8_t)dest;
313 pLineDst += pDst->m_nStride;
314 pLineSrc += m_nStride;
315 }
316 }
317 break;
318 case JBIG2_COMPOSE_AND: {
319 for(yy = y0; yy < y1; ++yy) {
320 destPtr = pLineDst;
321 srcPtr = pLineSrc + (-x >> 3);
322 dest = *destPtr;
323 dest &= *srcPtr | m1;
324 *destPtr = (uint8_t)dest;
325 pLineDst += pDst->m_nStride;
326 pLineSrc += m_nStride;
327 }
328 }
329 break;
330 case JBIG2_COMPOSE_XOR: {
331 for(yy = y0; yy < y1; ++yy) {
332 destPtr = pLineDst;
333 srcPtr = pLineSrc + (-x >> 3);
334 dest = *destPtr;
335 dest ^= *srcPtr & m2;
336 *destPtr = (uint8_t)dest;
337 pLineDst += pDst->m_nStride;
338 pLineSrc += m_nStride;
339 }
340 }
341 break;
342 case JBIG2_COMPOSE_XNOR: {
343 for(yy = y0; yy < y1; ++yy) {
344 destPtr = pLineDst;
345 srcPtr = pLineSrc + (-x >> 3);
346 dest = *destPtr;
347 dest ^= (*srcPtr ^ 0xff) & m2;
348 *destPtr = (uint8_t)dest;
349 pLineDst += pDst->m_nStride;
350 pLineSrc += m_nStride;
351 }
352 }
353 break;
354 case JBIG2_COMPOSE_REPLACE: {
355 for(yy = y0; yy < y1; ++yy) {
356 destPtr = pLineDst;
357 srcPtr = pLineSrc + (-x >> 3);
358 dest = *destPtr;
359 dest = (*srcPtr & m2) | (dest & m1);
360 *destPtr = (uint8_t)dest;
361 pLineDst += pDst->m_nStride;
362 pLineSrc += m_nStride;
363 }
364 }
365 break;
366 }
367 }
368 } else {
369 if(x >= 0) {
370 switch(op) {
371 case JBIG2_COMPOSE_OR: {
372 for(yy = y0; yy < y1; ++yy) {
373 destPtr = pLineDst + (x >> 3);
374 srcPtr = pLineSrc;
375 src1 = *srcPtr++;
376 dest = *destPtr;
377 dest |= src1 >> s1;
378 *destPtr++ = (uint8_t)dest;
379 xx = x0 + 8;
380 for (; xx < x1 - 8; xx += 8) {
381 dest = *destPtr;
382 src0 = src1;
383 src1 = *srcPtr++;
384 src = (((src0 << 8) | src1) >> s1) & 0xff;
385 dest |= src;
386 *destPtr++ = (uint8_t)dest;
387 }
388 dest = *destPtr;
389 src0 = src1;
390 if(srcPtr - pLineSrc < m_nStride) {
391 src1 = *srcPtr++;
392 } else {
393 src1 = 0;
394 }
395 src = (((src0 << 8) | src1) >> s1) & 0xff;
396 dest |= src & m2;
397 *destPtr = (uint8_t)dest;
398 pLineDst += pDst->m_nStride;
399 pLineSrc += m_nStride;
400 }
401 }
402 break;
403 case JBIG2_COMPOSE_AND: {
404 for(yy = y0; yy < y1; ++yy) {
405 destPtr = pLineDst + (x >> 3);
406 srcPtr = pLineSrc;
407 src1 = *srcPtr++;
408 dest = *destPtr;
409 dest &= (0xff00 | src1) >> s1;
410 *destPtr++ = (uint8_t)dest;
411 xx = x0 + 8;
412 for (; xx < x1 - 8; xx += 8) {
413 dest = *destPtr;
414 src0 = src1;
415 src1 = *srcPtr++;
416 src = (((src0 << 8) | src1) >> s1) & 0xff;
417 dest &= src;
418 *destPtr++ = (uint8_t)dest;
419 }
420 dest = *destPtr;
421 src0 = src1;
422 if(srcPtr - pLineSrc < m_nStride) {
423 src1 = *srcPtr++;
424 } else {
425 src1 = 0;
426 }
427 src = (((src0 << 8) | src1) >> s1) & 0xff;
428 dest &= src | m1;
429 *destPtr = (uint8_t)dest;
430 pLineDst += pDst->m_nStride;
431 pLineSrc += m_nStride;
432 }
433 }
434 break;
435 case JBIG2_COMPOSE_XOR: {
436 for(yy = y0; yy < y1; ++yy) {
437 destPtr = pLineDst + (x >> 3);
438 srcPtr = pLineSrc;
439 src1 = *srcPtr++;
440 dest = *destPtr;
441 dest ^= src1 >> s1;
442 *destPtr++ = (uint8_t)dest;
443 xx = x0 + 8;
444 for (; xx < x1 - 8; xx += 8) {
445 dest = *destPtr;
446 src0 = src1;
447 src1 = *srcPtr++;
448 src = (((src0 << 8) | src1) >> s1) & 0xff;
449 dest ^= src;
450 *destPtr++ = (uint8_t)dest;
451 }
452 dest = *destPtr;
453 src0 = src1;
454 if(srcPtr - pLineSrc < m_nStride) {
455 src1 = *srcPtr++;
456 } else {
457 src1 = 0;
458 }
459 src = (((src0 << 8) | src1) >> s1) & 0xff;
460 dest ^= src & m2;
461 *destPtr = (uint8_t)dest;
462 pLineDst += pDst->m_nStride;
463 pLineSrc += m_nStride;
464 }
465 }
466 break;
467 case JBIG2_COMPOSE_XNOR: {
468 for(yy = y0; yy < y1; ++yy) {
469 destPtr = pLineDst + (x >> 3);
470 srcPtr = pLineSrc;
471 src1 = *srcPtr++;
472 dest = *destPtr;
473 dest ^= (src1 ^ 0xff) >> s1;
474 *destPtr++ = (uint8_t)dest;
475 xx = x0 + 8;
476 for (; xx < x1 - 8; xx += 8) {
477 dest = *destPtr;
478 src0 = src1;
479 src1 = *srcPtr++;
480 src = (((src0 << 8) | src1) >> s1) & 0xff;
481 dest ^= src ^ 0xff;
482 *destPtr++ = (uint8_t)dest;
483 }
484 dest = *destPtr;
485 src0 = src1;
486 if(srcPtr - pLineSrc < m_nStride) {
487 src1 = *srcPtr++;
488 } else {
489 src1 = 0;
490 }
491 src = (((src0 << 8) | src1) >> s1) & 0xff;
492 dest ^= (src ^ 0xff) & m2;
493 *destPtr = (uint8_t)dest;
494 pLineDst += pDst->m_nStride;
495 pLineSrc += m_nStride;
496 }
497 }
498 break;
499 case JBIG2_COMPOSE_REPLACE: {
500 for(yy = y0; yy < y1; ++yy) {
501 destPtr = pLineDst + (x >> 3);
502 srcPtr = pLineSrc;
503 src1 = *srcPtr++;
504 dest = *destPtr;
505 dest = (dest & (0xff << s2)) | (src1 >> s1);
506 *destPtr++ = (uint8_t)dest;
507 xx = x0 + 8;
508 for (; xx < x1 - 8; xx += 8) {
509 dest = *destPtr;
510 src0 = src1;
511 src1 = *srcPtr++;
512 src = (((src0 << 8) | src1) >> s1) & 0xff;
513 dest = src;
514 *destPtr++ = (uint8_t)dest;
515 }
516 dest = *destPtr;
517 src0 = src1;
518 if(srcPtr - pLineSrc < m_nStride) {
519 src1 = *srcPtr++;
520 } else {
521 src1 = 0;
522 }
523 src = (((src0 << 8) | src1) >> s1) & 0xff;
524 dest = (src & m2) | (dest & m1);
525 *destPtr = (uint8_t)dest;
526 pLineDst += pDst->m_nStride;
527 pLineSrc += m_nStride;
528 }
529 }
530 break;
531 }
532 } else {
533 switch(op) {
534 case JBIG2_COMPOSE_OR: {
535 for(yy = y0; yy < y1; ++yy) {
536 destPtr = pLineDst;
537 srcPtr = pLineSrc + (-x >> 3);
538 src1 = *srcPtr++;
539 xx = x0;
540 for (; xx < x1 - 8; xx += 8) {
541 dest = *destPtr;
542 src0 = src1;
543 src1 = *srcPtr++;
544 src = (((src0 << 8) | src1) >> s1) & 0xff;
545 dest |= src;
546 *destPtr++ = (uint8_t)dest;
547 }
548 dest = *destPtr;
549 src0 = src1;
550 if(srcPtr - pLineSrc < m_nStride) {
551 src1 = *srcPtr++;
552 } else {
553 src1 = 0;
554 }
555 src = (((src0 << 8) | src1) >> s1) & 0xff;
556 dest |= src & m2;
557 *destPtr = (uint8_t)dest;
558 pLineDst += pDst->m_nStride;
559 pLineSrc += m_nStride;
560 }
561 }
562 break;
563 case JBIG2_COMPOSE_AND: {
564 for(yy = y0; yy < y1; ++yy) {
565 destPtr = pLineDst;
566 srcPtr = pLineSrc + (-x >> 3);
567 src1 = *srcPtr++;
568 xx = x0;
569 for (; xx < x1 - 8; xx += 8) {
570 dest = *destPtr;
571 src0 = src1;
572 src1 = *srcPtr++;
573 src = (((src0 << 8) | src1) >> s1) & 0xff;
574 dest &= src;
575 *destPtr++ = (uint8_t)dest;
576 }
577 dest = *destPtr;
578 src0 = src1;
579 if(srcPtr - pLineSrc < m_nStride) {
580 src1 = *srcPtr++;
581 } else {
582 src1 = 0;
583 }
584 src = (((src0 << 8) | src1) >> s1) & 0xff;
585 dest &= src | m1;
586 *destPtr = (uint8_t)dest;
587 pLineDst += pDst->m_nStride;
588 pLineSrc += m_nStride;
589 }
590 }
591 break;
592 case JBIG2_COMPOSE_XOR: {
593 for(yy = y0; yy < y1; ++yy) {
594 destPtr = pLineDst;
595 srcPtr = pLineSrc + (-x >> 3);
596 src1 = *srcPtr++;
597 xx = x0;
598 for (; xx < x1 - 8; xx += 8) {
599 dest = *destPtr;
600 src0 = src1;
601 src1 = *srcPtr++;
602 src = (((src0 << 8) | src1) >> s1) & 0xff;
603 dest ^= src;
604 *destPtr++ = (uint8_t)dest;
605 }
606 dest = *destPtr;
607 src0 = src1;
608 if(srcPtr - pLineSrc < m_nStride) {
609 src1 = *srcPtr++;
610 } else {
611 src1 = 0;
612 }
613 src = (((src0 << 8) | src1) >> s1) & 0xff;
614 dest ^= src & m2;
615 *destPtr = (uint8_t)dest;
616 pLineDst += pDst->m_nStride;
617 pLineSrc += m_nStride;
618 }
619 }
620 break;
621 case JBIG2_COMPOSE_XNOR: {
622 for(yy = y0; yy < y1; ++yy) {
623 destPtr = pLineDst;
624 srcPtr = pLineSrc + (-x >> 3);
625 src1 = *srcPtr++;
626 xx = x0;
627 for (; xx < x1 - 8; xx += 8) {
628 dest = *destPtr;
629 src0 = src1;
630 src1 = *srcPtr++;
631 src = (((src0 << 8) | src1) >> s1) & 0xff;
632 dest ^= src ^ 0xff;
633 *destPtr++ = (uint8_t)dest;
634 }
635 dest = *destPtr;
636 src0 = src1;
637 if(srcPtr - pLineSrc < m_nStride) {
638 src1 = *srcPtr++;
639 } else {
640 src1 = 0;
641 }
642 src = (((src0 << 8) | src1) >> s1) & 0xff;
643 dest ^= (src ^ 0xff) & m2;
644 *destPtr = (uint8_t)dest;
645 pLineDst += pDst->m_nStride;
646 pLineSrc += m_nStride;
647 }
648 }
649 break;
650 case JBIG2_COMPOSE_REPLACE: {
651 for(yy = y0; yy < y1; ++yy) {
652 destPtr = pLineDst;
653 srcPtr = pLineSrc + (-x >> 3);
654 src1 = *srcPtr++;
655 xx = x0;
656 for (; xx < x1 - 8; xx += 8) {
657 dest = *destPtr;
658 src0 = src1;
659 src1 = *srcPtr++;
660 src = (((src0 << 8) | src1) >> s1) & 0xff;
661 dest = src;
662 *destPtr++ = (uint8_t)dest;
663 }
664 dest = *destPtr;
665 src0 = src1;
666 if(srcPtr - pLineSrc < m_nStride) {
667 src1 = *srcPtr++;
668 } else {
669 src1 = 0;
670 }
671 src = (((src0 << 8) | src1) >> s1) & 0xff;
672 dest = (src & m2) | (dest & m1);
673 *destPtr = (uint8_t)dest;
674 pLineDst += pDst->m_nStride;
675 pLineSrc += m_nStride;
676 }
677 }
678 break;
679 }
680 }
681 }
682 return TRUE;
683 }
684 FX_BOOL CJBig2_Image::composeFrom(int32_t x, int32_t y, CJBig2_Image *pSrc, JBig 2ComposeOp op)
685 {
686 if (!m_pData) {
687 return FALSE;
688 }
689 return pSrc->composeTo(this, x, y, op);
690 }
691 FX_BOOL CJBig2_Image::composeFrom(int32_t x, int32_t y, CJBig2_Image *pSrc, JBig 2ComposeOp op, const FX_RECT* pSrcRect)
692 {
693 if (!m_pData) {
694 return FALSE;
695 }
696 return pSrc->composeTo(this, x, y, op, pSrcRect);
697 }
698 CJBig2_Image *CJBig2_Image::subImage_unopt(int32_t x, int32_t y, int32_t w, int3 2_t h)
699 {
700 CJBig2_Image *pImage;
701 int32_t i, j;
702 JBIG2_ALLOC(pImage, CJBig2_Image(w, h));
703 for(j = 0; j < h; j++) {
704 for(i = 0; i < w; i++) {
705 pImage->setPixel(i, j, getPixel(x + i, y + j));
706 }
707 }
708 return pImage;
709 }
710 #define JBIG2_GETDWORD(buf) ((FX_DWORD)(((buf)[0] << 24) | ((buf)[1] << 16) | ((buf)[2] << 8) | (buf)[3]))
711 CJBig2_Image *CJBig2_Image::subImage(int32_t x, int32_t y, int32_t w, int32_t h)
712 {
713 CJBig2_Image *pImage;
714 int32_t m, n, j;
715 uint8_t *pLineSrc, *pLineDst;
716 FX_DWORD wTmp;
717 uint8_t *pSrc, *pSrcEnd, *pDst, *pDstEnd;
718 if (w == 0 || h == 0) {
719 return NULL;
720 }
721 JBIG2_ALLOC(pImage, CJBig2_Image(w, h));
722 if (!m_pData) {
723 pImage->fill(0);
724 return pImage;
725 }
726 if (!pImage->m_pData) {
727 return pImage;
728 }
729 pLineSrc = m_pData + m_nStride * y;
730 pLineDst = pImage->m_pData;
731 m = (x >> 5) << 2;
732 n = x & 31;
733 if(n == 0) {
734 for(j = 0; j < h; j++) {
735 pSrc = pLineSrc + m;
736 pSrcEnd = pLineSrc + m_nStride;
737 pDst = pLineDst;
738 pDstEnd = pLineDst + pImage->m_nStride;
739 for(; pDst < pDstEnd; pSrc += 4, pDst += 4) {
740 *((FX_DWORD *)pDst) = *((FX_DWORD *)pSrc);
741 }
742 pLineSrc += m_nStride;
743 pLineDst += pImage->m_nStride;
744 }
745 } else {
746 for(j = 0; j < h; j++) {
747 pSrc = pLineSrc + m;
748 pSrcEnd = pLineSrc + m_nStride;
749 pDst = pLineDst;
750 pDstEnd = pLineDst + pImage->m_nStride;
751 for(; pDst < pDstEnd; pSrc += 4, pDst += 4) {
752 if(pSrc + 4 < pSrcEnd) {
753 wTmp = (JBIG2_GETDWORD(pSrc) << n) | (JBIG2_GETDWORD(pSrc + 4) >> (32 - n));
754 } else {
755 wTmp = JBIG2_GETDWORD(pSrc) << n;
756 }
757 pDst[0] = (uint8_t)(wTmp >> 24);
758 pDst[1] = (uint8_t)(wTmp >> 16);
759 pDst[2] = (uint8_t)(wTmp >> 8);
760 pDst[3] = (uint8_t)wTmp;
761 }
762 pLineSrc += m_nStride;
763 pLineDst += pImage->m_nStride;
764 }
765 }
766 return pImage;
767 }
768 void CJBig2_Image::expand(int32_t h, FX_BOOL v)
769 {
770 if (!m_pData || h <= m_nHeight) {
771 return;
772 }
773 FX_DWORD dwH = pdfium::base::checked_cast<FX_DWORD>(h);
774 FX_DWORD dwStride = pdfium::base::checked_cast<FX_DWORD>(m_nStride);
775 FX_DWORD dwHeight = pdfium::base::checked_cast<FX_DWORD>(m_nHeight);
776 FX_SAFE_DWORD safeMemSize = dwH;
777 safeMemSize *= dwStride;
778 if (!safeMemSize.IsValid()) {
779 return;
780 }
781 //The guaranteed reallocated memory is to be < 4GB (unsigned int).
782 m_pData = (uint8_t*)m_pModule->JBig2_Realloc(m_pData, safeMemSize.ValueOrDie ());
783 //The result of dwHeight * dwStride doesn't overflow after the
784 //checking of safeMemSize.
785 //The same as the result of (dwH - dwHeight) * dwStride) because
786 //dwH - dwHeight is always less than dwH(h) which is checked in
787 //the calculation of dwH * dwStride.
788 JBIG2_memset(m_pData + dwHeight * dwStride, v ? 0xff : 0, (dwH - dwHeight) * dwStride);
789 m_nHeight = h;
790 }
791 FX_BOOL CJBig2_Image::composeTo_opt2(CJBig2_Image *pDst, int32_t x, int32_t y, J Big2ComposeOp op)
792 {
793 int32_t xs0 = 0, ys0 = 0, xs1 = 0, ys1 = 0, xd0 = 0, yd0 = 0 , xd1 = 0,
794 yd1 = 0, xx = 0, yy = 0, w = 0, h = 0, middleDwords = 0, lineLeft = 0;
795
796 FX_DWORD s1 = 0, d1 = 0, d2 = 0, shift = 0, shift1 = 0, shift2 = 0,
797 tmp = 0, tmp1 = 0, tmp2 = 0, maskL = 0, maskR = 0, maskM = 0;
798
799 uint8_t *lineSrc = NULL, *lineDst = NULL, *sp = NULL, *dp = NULL;
800
801 if (!m_pData) {
802 return FALSE;
803 }
804 if (x < -1048576 || x > 1048576 || y < -1048576 || y > 1048576) {
805 return FALSE;
806 }
807 if(y < 0) {
808 ys0 = -y;
809 }
810 if(y + m_nHeight > pDst->m_nHeight) {
811 ys1 = pDst->m_nHeight - y;
812 } else {
813 ys1 = m_nHeight;
814 }
815 if(x < 0) {
816 xs0 = -x;
817 }
818 if(x + m_nWidth > pDst->m_nWidth) {
819 xs1 = pDst->m_nWidth - x;
820 } else {
821 xs1 = m_nWidth;
822 }
823 if((ys0 >= ys1) || (xs0 >= xs1)) {
824 return 0;
825 }
826 w = xs1 - xs0;
827 h = ys1 - ys0;
828 if(y >= 0) {
829 yd0 = y;
830 }
831 if(x >= 0) {
832 xd0 = x;
833 }
834 xd1 = xd0 + w;
835 yd1 = yd0 + h;
836 d1 = xd0 & 31;
837 d2 = xd1 & 31;
838 s1 = xs0 & 31;
839 maskL = 0xffffffff >> d1;
840 maskR = 0xffffffff << ((32 - (xd1 & 31)) % 32);
841 maskM = maskL & maskR;
842 lineSrc = m_pData + ys0 * m_nStride + ((xs0 >> 5) << 2);
843 lineLeft = m_nStride - ((xs0 >> 5) << 2);
844 lineDst = pDst->m_pData + yd0 * pDst->m_nStride + ((xd0 >> 5) << 2);
845 if((xd0 & ~31) == ((xd1 - 1) & ~31)) {
846 if((xs0 & ~31) == ((xs1 - 1) & ~31)) {
847 if(s1 > d1) {
848 shift = s1 - d1;
849 for(yy = yd0; yy < yd1; yy++) {
850 tmp1 = JBIG2_GETDWORD(lineSrc) << shift;
851 tmp2 = JBIG2_GETDWORD(lineDst);
852 switch(op) {
853 case JBIG2_COMPOSE_OR:
854 tmp = (tmp2 & ~maskM) | ((tmp1 | tmp2) & maskM);
855 break;
856 case JBIG2_COMPOSE_AND:
857 tmp = (tmp2 & ~maskM) | ((tmp1 & tmp2) & maskM);
858 break;
859 case JBIG2_COMPOSE_XOR:
860 tmp = (tmp2 & ~maskM) | ((tmp1 ^ tmp2) & maskM);
861 break;
862 case JBIG2_COMPOSE_XNOR:
863 tmp = (tmp2 & ~maskM) | ((~(tmp1 ^ tmp2)) & maskM);
864 break;
865 case JBIG2_COMPOSE_REPLACE:
866 tmp = (tmp2 & ~maskM) | (tmp1 & maskM);
867 break;
868 }
869 lineDst[0] = (uint8_t)(tmp >> 24);
870 lineDst[1] = (uint8_t)(tmp >> 16);
871 lineDst[2] = (uint8_t)(tmp >> 8);
872 lineDst[3] = (uint8_t)tmp;
873 lineSrc += m_nStride;
874 lineDst += pDst->m_nStride;
875 }
876 } else {
877 shift = d1 - s1;
878 for(yy = yd0; yy < yd1; yy++) {
879 tmp1 = JBIG2_GETDWORD(lineSrc) >> shift;
880 tmp2 = JBIG2_GETDWORD(lineDst);
881 switch(op) {
882 case JBIG2_COMPOSE_OR:
883 tmp = (tmp2 & ~maskM) | ((tmp1 | tmp2) & maskM);
884 break;
885 case JBIG2_COMPOSE_AND:
886 tmp = (tmp2 & ~maskM) | ((tmp1 & tmp2) & maskM);
887 break;
888 case JBIG2_COMPOSE_XOR:
889 tmp = (tmp2 & ~maskM) | ((tmp1 ^ tmp2) & maskM);
890 break;
891 case JBIG2_COMPOSE_XNOR:
892 tmp = (tmp2 & ~maskM) | ((~(tmp1 ^ tmp2)) & maskM);
893 break;
894 case JBIG2_COMPOSE_REPLACE:
895 tmp = (tmp2 & ~maskM) | (tmp1 & maskM);
896 break;
897 }
898 lineDst[0] = (uint8_t)(tmp >> 24);
899 lineDst[1] = (uint8_t)(tmp >> 16);
900 lineDst[2] = (uint8_t)(tmp >> 8);
901 lineDst[3] = (uint8_t)tmp;
902 lineSrc += m_nStride;
903 lineDst += pDst->m_nStride;
904 }
905 }
906 } else {
907 shift1 = s1 - d1;
908 shift2 = 32 - shift1;
909 for(yy = yd0; yy < yd1; yy++) {
910 tmp1 = (JBIG2_GETDWORD(lineSrc) << shift1) | (JBIG2_GETDWORD(lin eSrc + 4) >> shift2);
911 tmp2 = JBIG2_GETDWORD(lineDst);
912 switch(op) {
913 case JBIG2_COMPOSE_OR:
914 tmp = (tmp2 & ~maskM) | ((tmp1 | tmp2) & maskM);
915 break;
916 case JBIG2_COMPOSE_AND:
917 tmp = (tmp2 & ~maskM) | ((tmp1 & tmp2) & maskM);
918 break;
919 case JBIG2_COMPOSE_XOR:
920 tmp = (tmp2 & ~maskM) | ((tmp1 ^ tmp2) & maskM);
921 break;
922 case JBIG2_COMPOSE_XNOR:
923 tmp = (tmp2 & ~maskM) | ((~(tmp1 ^ tmp2)) & maskM);
924 break;
925 case JBIG2_COMPOSE_REPLACE:
926 tmp = (tmp2 & ~maskM) | (tmp1 & maskM);
927 break;
928 }
929 lineDst[0] = (uint8_t)(tmp >> 24);
930 lineDst[1] = (uint8_t)(tmp >> 16);
931 lineDst[2] = (uint8_t)(tmp >> 8);
932 lineDst[3] = (uint8_t)tmp;
933 lineSrc += m_nStride;
934 lineDst += pDst->m_nStride;
935 }
936 }
937 } else {
938 if(s1 > d1) {
939 shift1 = s1 - d1;
940 shift2 = 32 - shift1;
941 middleDwords = (xd1 >> 5) - ((xd0 + 31) >> 5);
942 for(yy = yd0; yy < yd1; yy++) {
943 sp = lineSrc;
944 dp = lineDst;
945 if(d1 != 0) {
946 tmp1 = (JBIG2_GETDWORD(sp) << shift1) | (JBIG2_GETDWORD(sp + 4) >> shift2);
947 tmp2 = JBIG2_GETDWORD(dp);
948 switch(op) {
949 case JBIG2_COMPOSE_OR:
950 tmp = (tmp2 & ~maskL) | ((tmp1 | tmp2) & maskL);
951 break;
952 case JBIG2_COMPOSE_AND:
953 tmp = (tmp2 & ~maskL) | ((tmp1 & tmp2) & maskL);
954 break;
955 case JBIG2_COMPOSE_XOR:
956 tmp = (tmp2 & ~maskL) | ((tmp1 ^ tmp2) & maskL);
957 break;
958 case JBIG2_COMPOSE_XNOR:
959 tmp = (tmp2 & ~maskL) | ((~(tmp1 ^ tmp2)) & maskL);
960 break;
961 case JBIG2_COMPOSE_REPLACE:
962 tmp = (tmp2 & ~maskL) | (tmp1 & maskL);
963 break;
964 }
965 dp[0] = (uint8_t)(tmp >> 24);
966 dp[1] = (uint8_t)(tmp >> 16);
967 dp[2] = (uint8_t)(tmp >> 8);
968 dp[3] = (uint8_t)tmp;
969 sp += 4;
970 dp += 4;
971 }
972 for(xx = 0; xx < middleDwords; xx++) {
973 tmp1 = (JBIG2_GETDWORD(sp) << shift1) | (JBIG2_GETDWORD(sp + 4) >> shift2);
974 tmp2 = JBIG2_GETDWORD(dp);
975 switch(op) {
976 case JBIG2_COMPOSE_OR:
977 tmp = tmp1 | tmp2;
978 break;
979 case JBIG2_COMPOSE_AND:
980 tmp = tmp1 & tmp2;
981 break;
982 case JBIG2_COMPOSE_XOR:
983 tmp = tmp1 ^ tmp2;
984 break;
985 case JBIG2_COMPOSE_XNOR:
986 tmp = ~(tmp1 ^ tmp2);
987 break;
988 case JBIG2_COMPOSE_REPLACE:
989 tmp = tmp1;
990 break;
991 }
992 dp[0] = (uint8_t)(tmp >> 24);
993 dp[1] = (uint8_t)(tmp >> 16);
994 dp[2] = (uint8_t)(tmp >> 8);
995 dp[3] = (uint8_t)tmp;
996 sp += 4;
997 dp += 4;
998 }
999 if(d2 != 0) {
1000 tmp1 = (JBIG2_GETDWORD(sp) << shift1) | (
1001 ((sp + 4) < lineSrc + lineLeft ? JBIG2_GETDWORD(s p + 4) : 0) >> shift2);
1002 tmp2 = JBIG2_GETDWORD(dp);
1003 switch(op) {
1004 case JBIG2_COMPOSE_OR:
1005 tmp = (tmp2 & ~maskR) | ((tmp1 | tmp2) & maskR);
1006 break;
1007 case JBIG2_COMPOSE_AND:
1008 tmp = (tmp2 & ~maskR) | ((tmp1 & tmp2) & maskR);
1009 break;
1010 case JBIG2_COMPOSE_XOR:
1011 tmp = (tmp2 & ~maskR) | ((tmp1 ^ tmp2) & maskR);
1012 break;
1013 case JBIG2_COMPOSE_XNOR:
1014 tmp = (tmp2 & ~maskR) | ((~(tmp1 ^ tmp2)) & maskR);
1015 break;
1016 case JBIG2_COMPOSE_REPLACE:
1017 tmp = (tmp2 & ~maskR) | (tmp1 & maskR);
1018 break;
1019 }
1020 dp[0] = (uint8_t)(tmp >> 24);
1021 dp[1] = (uint8_t)(tmp >> 16);
1022 dp[2] = (uint8_t)(tmp >> 8);
1023 dp[3] = (uint8_t)tmp;
1024 }
1025 lineSrc += m_nStride;
1026 lineDst += pDst->m_nStride;
1027 }
1028 } else if(s1 == d1) {
1029 middleDwords = (xd1 >> 5) - ((xd0 + 31) >> 5);
1030 for(yy = yd0; yy < yd1; yy++) {
1031 sp = lineSrc;
1032 dp = lineDst;
1033 if(d1 != 0) {
1034 tmp1 = JBIG2_GETDWORD(sp);
1035 tmp2 = JBIG2_GETDWORD(dp);
1036 switch(op) {
1037 case JBIG2_COMPOSE_OR:
1038 tmp = (tmp2 & ~maskL) | ((tmp1 | tmp2) & maskL);
1039 break;
1040 case JBIG2_COMPOSE_AND:
1041 tmp = (tmp2 & ~maskL) | ((tmp1 & tmp2) & maskL);
1042 break;
1043 case JBIG2_COMPOSE_XOR:
1044 tmp = (tmp2 & ~maskL) | ((tmp1 ^ tmp2) & maskL);
1045 break;
1046 case JBIG2_COMPOSE_XNOR:
1047 tmp = (tmp2 & ~maskL) | ((~(tmp1 ^ tmp2)) & maskL);
1048 break;
1049 case JBIG2_COMPOSE_REPLACE:
1050 tmp = (tmp2 & ~maskL) | (tmp1 & maskL);
1051 break;
1052 }
1053 dp[0] = (uint8_t)(tmp >> 24);
1054 dp[1] = (uint8_t)(tmp >> 16);
1055 dp[2] = (uint8_t)(tmp >> 8);
1056 dp[3] = (uint8_t)tmp;
1057 sp += 4;
1058 dp += 4;
1059 }
1060 for(xx = 0; xx < middleDwords; xx++) {
1061 tmp1 = JBIG2_GETDWORD(sp);
1062 tmp2 = JBIG2_GETDWORD(dp);
1063 switch(op) {
1064 case JBIG2_COMPOSE_OR:
1065 tmp = tmp1 | tmp2;
1066 break;
1067 case JBIG2_COMPOSE_AND:
1068 tmp = tmp1 & tmp2;
1069 break;
1070 case JBIG2_COMPOSE_XOR:
1071 tmp = tmp1 ^ tmp2;
1072 break;
1073 case JBIG2_COMPOSE_XNOR:
1074 tmp = ~(tmp1 ^ tmp2);
1075 break;
1076 case JBIG2_COMPOSE_REPLACE:
1077 tmp = tmp1;
1078 break;
1079 }
1080 dp[0] = (uint8_t)(tmp >> 24);
1081 dp[1] = (uint8_t)(tmp >> 16);
1082 dp[2] = (uint8_t)(tmp >> 8);
1083 dp[3] = (uint8_t)tmp;
1084 sp += 4;
1085 dp += 4;
1086 }
1087 if(d2 != 0) {
1088 tmp1 = JBIG2_GETDWORD(sp);
1089 tmp2 = JBIG2_GETDWORD(dp);
1090 switch(op) {
1091 case JBIG2_COMPOSE_OR:
1092 tmp = (tmp2 & ~maskR) | ((tmp1 | tmp2) & maskR);
1093 break;
1094 case JBIG2_COMPOSE_AND:
1095 tmp = (tmp2 & ~maskR) | ((tmp1 & tmp2) & maskR);
1096 break;
1097 case JBIG2_COMPOSE_XOR:
1098 tmp = (tmp2 & ~maskR) | ((tmp1 ^ tmp2) & maskR);
1099 break;
1100 case JBIG2_COMPOSE_XNOR:
1101 tmp = (tmp2 & ~maskR) | ((~(tmp1 ^ tmp2)) & maskR);
1102 break;
1103 case JBIG2_COMPOSE_REPLACE:
1104 tmp = (tmp2 & ~maskR) | (tmp1 & maskR);
1105 break;
1106 }
1107 dp[0] = (uint8_t)(tmp >> 24);
1108 dp[1] = (uint8_t)(tmp >> 16);
1109 dp[2] = (uint8_t)(tmp >> 8);
1110 dp[3] = (uint8_t)tmp;
1111 }
1112 lineSrc += m_nStride;
1113 lineDst += pDst->m_nStride;
1114 }
1115 } else {
1116 shift1 = d1 - s1;
1117 shift2 = 32 - shift1;
1118 middleDwords = (xd1 >> 5) - ((xd0 + 31) >> 5);
1119 for(yy = yd0; yy < yd1; yy++) {
1120 sp = lineSrc;
1121 dp = lineDst;
1122 if(d1 != 0) {
1123 tmp1 = JBIG2_GETDWORD(sp) >> shift1;
1124 tmp2 = JBIG2_GETDWORD(dp);
1125 switch(op) {
1126 case JBIG2_COMPOSE_OR:
1127 tmp = (tmp2 & ~maskL) | ((tmp1 | tmp2) & maskL);
1128 break;
1129 case JBIG2_COMPOSE_AND:
1130 tmp = (tmp2 & ~maskL) | ((tmp1 & tmp2) & maskL);
1131 break;
1132 case JBIG2_COMPOSE_XOR:
1133 tmp = (tmp2 & ~maskL) | ((tmp1 ^ tmp2) & maskL);
1134 break;
1135 case JBIG2_COMPOSE_XNOR:
1136 tmp = (tmp2 & ~maskL) | ((~(tmp1 ^ tmp2)) & maskL);
1137 break;
1138 case JBIG2_COMPOSE_REPLACE:
1139 tmp = (tmp2 & ~maskL) | (tmp1 & maskL);
1140 break;
1141 }
1142 dp[0] = (uint8_t)(tmp >> 24);
1143 dp[1] = (uint8_t)(tmp >> 16);
1144 dp[2] = (uint8_t)(tmp >> 8);
1145 dp[3] = (uint8_t)tmp;
1146 dp += 4;
1147 }
1148 for(xx = 0; xx < middleDwords; xx++) {
1149 tmp1 = (JBIG2_GETDWORD(sp) << shift2) | ((JBIG2_GETDWORD(sp + 4)) >> shift1);
1150 tmp2 = JBIG2_GETDWORD(dp);
1151 switch(op) {
1152 case JBIG2_COMPOSE_OR:
1153 tmp = tmp1 | tmp2;
1154 break;
1155 case JBIG2_COMPOSE_AND:
1156 tmp = tmp1 & tmp2;
1157 break;
1158 case JBIG2_COMPOSE_XOR:
1159 tmp = tmp1 ^ tmp2;
1160 break;
1161 case JBIG2_COMPOSE_XNOR:
1162 tmp = ~(tmp1 ^ tmp2);
1163 break;
1164 case JBIG2_COMPOSE_REPLACE:
1165 tmp = tmp1;
1166 break;
1167 }
1168 dp[0] = (uint8_t)(tmp >> 24);
1169 dp[1] = (uint8_t)(tmp >> 16);
1170 dp[2] = (uint8_t)(tmp >> 8);
1171 dp[3] = (uint8_t)tmp;
1172 sp += 4;
1173 dp += 4;
1174 }
1175 if(d2 != 0) {
1176 tmp1 = (JBIG2_GETDWORD(sp) << shift2) | (
1177 ((sp + 4) < lineSrc + lineLeft ? JBIG2_GETDWORD(s p + 4) : 0) >> shift1);
1178 tmp2 = JBIG2_GETDWORD(dp);
1179 switch(op) {
1180 case JBIG2_COMPOSE_OR:
1181 tmp = (tmp2 & ~maskR) | ((tmp1 | tmp2) & maskR);
1182 break;
1183 case JBIG2_COMPOSE_AND:
1184 tmp = (tmp2 & ~maskR) | ((tmp1 & tmp2) & maskR);
1185 break;
1186 case JBIG2_COMPOSE_XOR:
1187 tmp = (tmp2 & ~maskR) | ((tmp1 ^ tmp2) & maskR);
1188 break;
1189 case JBIG2_COMPOSE_XNOR:
1190 tmp = (tmp2 & ~maskR) | ((~(tmp1 ^ tmp2)) & maskR);
1191 break;
1192 case JBIG2_COMPOSE_REPLACE:
1193 tmp = (tmp2 & ~maskR) | (tmp1 & maskR);
1194 break;
1195 }
1196 dp[0] = (uint8_t)(tmp >> 24);
1197 dp[1] = (uint8_t)(tmp >> 16);
1198 dp[2] = (uint8_t)(tmp >> 8);
1199 dp[3] = (uint8_t)tmp;
1200 }
1201 lineSrc += m_nStride;
1202 lineDst += pDst->m_nStride;
1203 }
1204 }
1205 }
1206 return 1;
1207 }
1208 FX_BOOL CJBig2_Image::composeTo_opt2(CJBig2_Image *pDst, int32_t x, int32_t y, J Big2ComposeOp op, const FX_RECT* pSrcRect)
1209 {
1210 int32_t xs0, ys0, xs1, ys1, xd0, yd0, xd1, yd1, xx, yy, w, h, middleDwords, lineLeft;
1211 FX_DWORD s1, d1, d2, shift, shift1, shift2, tmp, tmp1, tmp2, maskL, maskR, m askM;
1212 uint8_t *lineSrc, *lineDst, *sp, *dp;
1213 int32_t sw, sh;
1214 if (!m_pData) {
1215 return FALSE;
1216 }
1217 if (x < -1048576 || x > 1048576 || y < -1048576 || y > 1048576) {
1218 return FALSE;
1219 }
1220 sw = pSrcRect->Width();
1221 sh = pSrcRect->Height();
1222 if(y < 0) {
1223 ys0 = -y;
1224 } else {
1225 ys0 = 0;
1226 }
1227 if(y + sh > pDst->m_nHeight) {
1228 ys1 = pDst->m_nHeight - y;
1229 } else {
1230 ys1 = sh;
1231 }
1232 if(x < 0) {
1233 xs0 = -x;
1234 } else {
1235 xs0 = 0;
1236 }
1237 if(x + sw > pDst->m_nWidth) {
1238 xs1 = pDst->m_nWidth - x;
1239 } else {
1240 xs1 = sw;
1241 }
1242 if((ys0 >= ys1) || (xs0 >= xs1)) {
1243 return 0;
1244 }
1245 w = xs1 - xs0;
1246 h = ys1 - ys0;
1247 if(y < 0) {
1248 yd0 = 0;
1249 } else {
1250 yd0 = y;
1251 }
1252 if(x < 0) {
1253 xd0 = 0;
1254 } else {
1255 xd0 = x;
1256 }
1257 xd1 = xd0 + w;
1258 yd1 = yd0 + h;
1259 d1 = xd0 & 31;
1260 d2 = xd1 & 31;
1261 s1 = xs0 & 31;
1262 maskL = 0xffffffff >> d1;
1263 maskR = 0xffffffff << ((32 - (xd1 & 31)) % 32);
1264 maskM = maskL & maskR;
1265 lineSrc = m_pData + (pSrcRect->top + ys0) * m_nStride + (((xs0 + pSrcRect->l eft) >> 5) << 2);
1266 lineLeft = m_nStride - ((xs0 >> 5) << 2);
1267 lineDst = pDst->m_pData + yd0 * pDst->m_nStride + ((xd0 >> 5) << 2);
1268 if((xd0 & ~31) == ((xd1 - 1) & ~31)) {
1269 if((xs0 & ~31) == ((xs1 - 1) & ~31)) {
1270 if(s1 > d1) {
1271 shift = s1 - d1;
1272 for(yy = yd0; yy < yd1; yy++) {
1273 tmp1 = JBIG2_GETDWORD(lineSrc) << shift;
1274 tmp2 = JBIG2_GETDWORD(lineDst);
1275 switch(op) {
1276 case JBIG2_COMPOSE_OR:
1277 tmp = (tmp2 & ~maskM) | ((tmp1 | tmp2) & maskM);
1278 break;
1279 case JBIG2_COMPOSE_AND:
1280 tmp = (tmp2 & ~maskM) | ((tmp1 & tmp2) & maskM);
1281 break;
1282 case JBIG2_COMPOSE_XOR:
1283 tmp = (tmp2 & ~maskM) | ((tmp1 ^ tmp2) & maskM);
1284 break;
1285 case JBIG2_COMPOSE_XNOR:
1286 tmp = (tmp2 & ~maskM) | ((~(tmp1 ^ tmp2)) & maskM);
1287 break;
1288 case JBIG2_COMPOSE_REPLACE:
1289 tmp = (tmp2 & ~maskM) | (tmp1 & maskM);
1290 break;
1291 }
1292 lineDst[0] = (uint8_t)(tmp >> 24);
1293 lineDst[1] = (uint8_t)(tmp >> 16);
1294 lineDst[2] = (uint8_t)(tmp >> 8);
1295 lineDst[3] = (uint8_t)tmp;
1296 lineSrc += m_nStride;
1297 lineDst += pDst->m_nStride;
1298 }
1299 } else {
1300 shift = d1 - s1;
1301 for(yy = yd0; yy < yd1; yy++) {
1302 tmp1 = JBIG2_GETDWORD(lineSrc) >> shift;
1303 tmp2 = JBIG2_GETDWORD(lineDst);
1304 switch(op) {
1305 case JBIG2_COMPOSE_OR:
1306 tmp = (tmp2 & ~maskM) | ((tmp1 | tmp2) & maskM);
1307 break;
1308 case JBIG2_COMPOSE_AND:
1309 tmp = (tmp2 & ~maskM) | ((tmp1 & tmp2) & maskM);
1310 break;
1311 case JBIG2_COMPOSE_XOR:
1312 tmp = (tmp2 & ~maskM) | ((tmp1 ^ tmp2) & maskM);
1313 break;
1314 case JBIG2_COMPOSE_XNOR:
1315 tmp = (tmp2 & ~maskM) | ((~(tmp1 ^ tmp2)) & maskM);
1316 break;
1317 case JBIG2_COMPOSE_REPLACE:
1318 tmp = (tmp2 & ~maskM) | (tmp1 & maskM);
1319 break;
1320 }
1321 lineDst[0] = (uint8_t)(tmp >> 24);
1322 lineDst[1] = (uint8_t)(tmp >> 16);
1323 lineDst[2] = (uint8_t)(tmp >> 8);
1324 lineDst[3] = (uint8_t)tmp;
1325 lineSrc += m_nStride;
1326 lineDst += pDst->m_nStride;
1327 }
1328 }
1329 } else {
1330 shift1 = s1 - d1;
1331 shift2 = 32 - shift1;
1332 for(yy = yd0; yy < yd1; yy++) {
1333 tmp1 = (JBIG2_GETDWORD(lineSrc) << shift1) | (JBIG2_GETDWORD(lin eSrc + 4) >> shift2);
1334 tmp2 = JBIG2_GETDWORD(lineDst);
1335 switch(op) {
1336 case JBIG2_COMPOSE_OR:
1337 tmp = (tmp2 & ~maskM) | ((tmp1 | tmp2) & maskM);
1338 break;
1339 case JBIG2_COMPOSE_AND:
1340 tmp = (tmp2 & ~maskM) | ((tmp1 & tmp2) & maskM);
1341 break;
1342 case JBIG2_COMPOSE_XOR:
1343 tmp = (tmp2 & ~maskM) | ((tmp1 ^ tmp2) & maskM);
1344 break;
1345 case JBIG2_COMPOSE_XNOR:
1346 tmp = (tmp2 & ~maskM) | ((~(tmp1 ^ tmp2)) & maskM);
1347 break;
1348 case JBIG2_COMPOSE_REPLACE:
1349 tmp = (tmp2 & ~maskM) | (tmp1 & maskM);
1350 break;
1351 }
1352 lineDst[0] = (uint8_t)(tmp >> 24);
1353 lineDst[1] = (uint8_t)(tmp >> 16);
1354 lineDst[2] = (uint8_t)(tmp >> 8);
1355 lineDst[3] = (uint8_t)tmp;
1356 lineSrc += m_nStride;
1357 lineDst += pDst->m_nStride;
1358 }
1359 }
1360 } else {
1361 if(s1 > d1) {
1362 shift1 = s1 - d1;
1363 shift2 = 32 - shift1;
1364 middleDwords = (xd1 >> 5) - ((xd0 + 31) >> 5);
1365 for(yy = yd0; yy < yd1; yy++) {
1366 sp = lineSrc;
1367 dp = lineDst;
1368 if(d1 != 0) {
1369 tmp1 = (JBIG2_GETDWORD(sp) << shift1) | (JBIG2_GETDWORD(sp + 4) >> shift2);
1370 tmp2 = JBIG2_GETDWORD(dp);
1371 switch(op) {
1372 case JBIG2_COMPOSE_OR:
1373 tmp = (tmp2 & ~maskL) | ((tmp1 | tmp2) & maskL);
1374 break;
1375 case JBIG2_COMPOSE_AND:
1376 tmp = (tmp2 & ~maskL) | ((tmp1 & tmp2) & maskL);
1377 break;
1378 case JBIG2_COMPOSE_XOR:
1379 tmp = (tmp2 & ~maskL) | ((tmp1 ^ tmp2) & maskL);
1380 break;
1381 case JBIG2_COMPOSE_XNOR:
1382 tmp = (tmp2 & ~maskL) | ((~(tmp1 ^ tmp2)) & maskL);
1383 break;
1384 case JBIG2_COMPOSE_REPLACE:
1385 tmp = (tmp2 & ~maskL) | (tmp1 & maskL);
1386 break;
1387 }
1388 dp[0] = (uint8_t)(tmp >> 24);
1389 dp[1] = (uint8_t)(tmp >> 16);
1390 dp[2] = (uint8_t)(tmp >> 8);
1391 dp[3] = (uint8_t)tmp;
1392 sp += 4;
1393 dp += 4;
1394 }
1395 for(xx = 0; xx < middleDwords; xx++) {
1396 tmp1 = (JBIG2_GETDWORD(sp) << shift1) | (JBIG2_GETDWORD(sp + 4) >> shift2);
1397 tmp2 = JBIG2_GETDWORD(dp);
1398 switch(op) {
1399 case JBIG2_COMPOSE_OR:
1400 tmp = tmp1 | tmp2;
1401 break;
1402 case JBIG2_COMPOSE_AND:
1403 tmp = tmp1 & tmp2;
1404 break;
1405 case JBIG2_COMPOSE_XOR:
1406 tmp = tmp1 ^ tmp2;
1407 break;
1408 case JBIG2_COMPOSE_XNOR:
1409 tmp = ~(tmp1 ^ tmp2);
1410 break;
1411 case JBIG2_COMPOSE_REPLACE:
1412 tmp = tmp1;
1413 break;
1414 }
1415 dp[0] = (uint8_t)(tmp >> 24);
1416 dp[1] = (uint8_t)(tmp >> 16);
1417 dp[2] = (uint8_t)(tmp >> 8);
1418 dp[3] = (uint8_t)tmp;
1419 sp += 4;
1420 dp += 4;
1421 }
1422 if(d2 != 0) {
1423 tmp1 = (JBIG2_GETDWORD(sp) << shift1) | (
1424 ((sp + 4) < lineSrc + lineLeft ? JBIG2_GETDWORD(s p + 4) : 0) >> shift2);
1425 tmp2 = JBIG2_GETDWORD(dp);
1426 switch(op) {
1427 case JBIG2_COMPOSE_OR:
1428 tmp = (tmp2 & ~maskR) | ((tmp1 | tmp2) & maskR);
1429 break;
1430 case JBIG2_COMPOSE_AND:
1431 tmp = (tmp2 & ~maskR) | ((tmp1 & tmp2) & maskR);
1432 break;
1433 case JBIG2_COMPOSE_XOR:
1434 tmp = (tmp2 & ~maskR) | ((tmp1 ^ tmp2) & maskR);
1435 break;
1436 case JBIG2_COMPOSE_XNOR:
1437 tmp = (tmp2 & ~maskR) | ((~(tmp1 ^ tmp2)) & maskR);
1438 break;
1439 case JBIG2_COMPOSE_REPLACE:
1440 tmp = (tmp2 & ~maskR) | (tmp1 & maskR);
1441 break;
1442 }
1443 dp[0] = (uint8_t)(tmp >> 24);
1444 dp[1] = (uint8_t)(tmp >> 16);
1445 dp[2] = (uint8_t)(tmp >> 8);
1446 dp[3] = (uint8_t)tmp;
1447 }
1448 lineSrc += m_nStride;
1449 lineDst += pDst->m_nStride;
1450 }
1451 } else if(s1 == d1) {
1452 middleDwords = (xd1 >> 5) - ((xd0 + 31) >> 5);
1453 for(yy = yd0; yy < yd1; yy++) {
1454 sp = lineSrc;
1455 dp = lineDst;
1456 if(d1 != 0) {
1457 tmp1 = JBIG2_GETDWORD(sp);
1458 tmp2 = JBIG2_GETDWORD(dp);
1459 switch(op) {
1460 case JBIG2_COMPOSE_OR:
1461 tmp = (tmp2 & ~maskL) | ((tmp1 | tmp2) & maskL);
1462 break;
1463 case JBIG2_COMPOSE_AND:
1464 tmp = (tmp2 & ~maskL) | ((tmp1 & tmp2) & maskL);
1465 break;
1466 case JBIG2_COMPOSE_XOR:
1467 tmp = (tmp2 & ~maskL) | ((tmp1 ^ tmp2) & maskL);
1468 break;
1469 case JBIG2_COMPOSE_XNOR:
1470 tmp = (tmp2 & ~maskL) | ((~(tmp1 ^ tmp2)) & maskL);
1471 break;
1472 case JBIG2_COMPOSE_REPLACE:
1473 tmp = (tmp2 & ~maskL) | (tmp1 & maskL);
1474 break;
1475 }
1476 dp[0] = (uint8_t)(tmp >> 24);
1477 dp[1] = (uint8_t)(tmp >> 16);
1478 dp[2] = (uint8_t)(tmp >> 8);
1479 dp[3] = (uint8_t)tmp;
1480 sp += 4;
1481 dp += 4;
1482 }
1483 for(xx = 0; xx < middleDwords; xx++) {
1484 tmp1 = JBIG2_GETDWORD(sp);
1485 tmp2 = JBIG2_GETDWORD(dp);
1486 switch(op) {
1487 case JBIG2_COMPOSE_OR:
1488 tmp = tmp1 | tmp2;
1489 break;
1490 case JBIG2_COMPOSE_AND:
1491 tmp = tmp1 & tmp2;
1492 break;
1493 case JBIG2_COMPOSE_XOR:
1494 tmp = tmp1 ^ tmp2;
1495 break;
1496 case JBIG2_COMPOSE_XNOR:
1497 tmp = ~(tmp1 ^ tmp2);
1498 break;
1499 case JBIG2_COMPOSE_REPLACE:
1500 tmp = tmp1;
1501 break;
1502 }
1503 dp[0] = (uint8_t)(tmp >> 24);
1504 dp[1] = (uint8_t)(tmp >> 16);
1505 dp[2] = (uint8_t)(tmp >> 8);
1506 dp[3] = (uint8_t)tmp;
1507 sp += 4;
1508 dp += 4;
1509 }
1510 if(d2 != 0) {
1511 tmp1 = JBIG2_GETDWORD(sp);
1512 tmp2 = JBIG2_GETDWORD(dp);
1513 switch(op) {
1514 case JBIG2_COMPOSE_OR:
1515 tmp = (tmp2 & ~maskR) | ((tmp1 | tmp2) & maskR);
1516 break;
1517 case JBIG2_COMPOSE_AND:
1518 tmp = (tmp2 & ~maskR) | ((tmp1 & tmp2) & maskR);
1519 break;
1520 case JBIG2_COMPOSE_XOR:
1521 tmp = (tmp2 & ~maskR) | ((tmp1 ^ tmp2) & maskR);
1522 break;
1523 case JBIG2_COMPOSE_XNOR:
1524 tmp = (tmp2 & ~maskR) | ((~(tmp1 ^ tmp2)) & maskR);
1525 break;
1526 case JBIG2_COMPOSE_REPLACE:
1527 tmp = (tmp2 & ~maskR) | (tmp1 & maskR);
1528 break;
1529 }
1530 dp[0] = (uint8_t)(tmp >> 24);
1531 dp[1] = (uint8_t)(tmp >> 16);
1532 dp[2] = (uint8_t)(tmp >> 8);
1533 dp[3] = (uint8_t)tmp;
1534 }
1535 lineSrc += m_nStride;
1536 lineDst += pDst->m_nStride;
1537 }
1538 } else {
1539 shift1 = d1 - s1;
1540 shift2 = 32 - shift1;
1541 middleDwords = (xd1 >> 5) - ((xd0 + 31) >> 5);
1542 for(yy = yd0; yy < yd1; yy++) {
1543 sp = lineSrc;
1544 dp = lineDst;
1545 if(d1 != 0) {
1546 tmp1 = JBIG2_GETDWORD(sp) >> shift1;
1547 tmp2 = JBIG2_GETDWORD(dp);
1548 switch(op) {
1549 case JBIG2_COMPOSE_OR:
1550 tmp = (tmp2 & ~maskL) | ((tmp1 | tmp2) & maskL);
1551 break;
1552 case JBIG2_COMPOSE_AND:
1553 tmp = (tmp2 & ~maskL) | ((tmp1 & tmp2) & maskL);
1554 break;
1555 case JBIG2_COMPOSE_XOR:
1556 tmp = (tmp2 & ~maskL) | ((tmp1 ^ tmp2) & maskL);
1557 break;
1558 case JBIG2_COMPOSE_XNOR:
1559 tmp = (tmp2 & ~maskL) | ((~(tmp1 ^ tmp2)) & maskL);
1560 break;
1561 case JBIG2_COMPOSE_REPLACE:
1562 tmp = (tmp2 & ~maskL) | (tmp1 & maskL);
1563 break;
1564 }
1565 dp[0] = (uint8_t)(tmp >> 24);
1566 dp[1] = (uint8_t)(tmp >> 16);
1567 dp[2] = (uint8_t)(tmp >> 8);
1568 dp[3] = (uint8_t)tmp;
1569 dp += 4;
1570 }
1571 for(xx = 0; xx < middleDwords; xx++) {
1572 tmp1 = (JBIG2_GETDWORD(sp) << shift2) | ((JBIG2_GETDWORD(sp + 4)) >> shift1);
1573 tmp2 = JBIG2_GETDWORD(dp);
1574 switch(op) {
1575 case JBIG2_COMPOSE_OR:
1576 tmp = tmp1 | tmp2;
1577 break;
1578 case JBIG2_COMPOSE_AND:
1579 tmp = tmp1 & tmp2;
1580 break;
1581 case JBIG2_COMPOSE_XOR:
1582 tmp = tmp1 ^ tmp2;
1583 break;
1584 case JBIG2_COMPOSE_XNOR:
1585 tmp = ~(tmp1 ^ tmp2);
1586 break;
1587 case JBIG2_COMPOSE_REPLACE:
1588 tmp = tmp1;
1589 break;
1590 }
1591 dp[0] = (uint8_t)(tmp >> 24);
1592 dp[1] = (uint8_t)(tmp >> 16);
1593 dp[2] = (uint8_t)(tmp >> 8);
1594 dp[3] = (uint8_t)tmp;
1595 sp += 4;
1596 dp += 4;
1597 }
1598 if(d2 != 0) {
1599 tmp1 = (JBIG2_GETDWORD(sp) << shift2) | (
1600 ((sp + 4) < lineSrc + lineLeft ? JBIG2_GETDWORD(s p + 4) : 0) >> shift1);
1601 tmp2 = JBIG2_GETDWORD(dp);
1602 switch(op) {
1603 case JBIG2_COMPOSE_OR:
1604 tmp = (tmp2 & ~maskR) | ((tmp1 | tmp2) & maskR);
1605 break;
1606 case JBIG2_COMPOSE_AND:
1607 tmp = (tmp2 & ~maskR) | ((tmp1 & tmp2) & maskR);
1608 break;
1609 case JBIG2_COMPOSE_XOR:
1610 tmp = (tmp2 & ~maskR) | ((tmp1 ^ tmp2) & maskR);
1611 break;
1612 case JBIG2_COMPOSE_XNOR:
1613 tmp = (tmp2 & ~maskR) | ((~(tmp1 ^ tmp2)) & maskR);
1614 break;
1615 case JBIG2_COMPOSE_REPLACE:
1616 tmp = (tmp2 & ~maskR) | (tmp1 & maskR);
1617 break;
1618 }
1619 dp[0] = (uint8_t)(tmp >> 24);
1620 dp[1] = (uint8_t)(tmp >> 16);
1621 dp[2] = (uint8_t)(tmp >> 8);
1622 dp[3] = (uint8_t)tmp;
1623 }
1624 lineSrc += m_nStride;
1625 lineDst += pDst->m_nStride;
1626 }
1627 }
1628 }
1629 return 1;
1630 }
OLDNEW
« core/src/fpdfapi/fpdf_cmaps/Japan1/UniJIS-UCS2-H_4.cpp ('K') | « core/src/fxcodec/jbig2/JBig2_Image.h ('k') | core/src/fxcodec/jbig2/JBig2_List.h » ('j') | public/fpdf_doc.h » ('J')

Powered by Google App Engine
This is Rietveld 408576698