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

Issues Search
    My Issues | Starred     Open | Closed | All

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

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

Powered by Google App Engine
This is Rietveld 408576698