| OLD | NEW |
|---|
| 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 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1265503005:
clang-format all pdfium code. (Closed)
Base URL: https://pdfium.googlesource.com/pdfium.git@master