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 "JBig2_GeneralDecoder.h" | 7 #include "JBig2_GeneralDecoder.h" |
8 #include "JBig2_ArithDecoder.h" | 8 #include "JBig2_ArithDecoder.h" |
9 #include "JBig2_ArithIntDecoder.h" | 9 #include "JBig2_ArithIntDecoder.h" |
10 #include "JBig2_HuffmanDecoder.h" | 10 #include "JBig2_HuffmanDecoder.h" |
(...skipping 16 matching lines...) Expand all Loading... |
27 {0x0221, 37, 34, 0}, {0x0141, 38, 35, 0}, {0x0111, 39, 36, 0}, | 27 {0x0221, 37, 34, 0}, {0x0141, 38, 35, 0}, {0x0111, 39, 36, 0}, |
28 {0x0085, 40, 37, 0}, {0x0049, 41, 38, 0}, {0x0025, 42, 39, 0}, | 28 {0x0085, 40, 37, 0}, {0x0049, 41, 38, 0}, {0x0025, 42, 39, 0}, |
29 {0x0015, 43, 40, 0}, {0x0009, 44, 41, 0}, {0x0005, 45, 42, 0}, | 29 {0x0015, 43, 40, 0}, {0x0009, 44, 41, 0}, {0x0005, 45, 42, 0}, |
30 {0x0001, 45, 43, 0}, {0x5601, 46, 46, 0}}; | 30 {0x0001, 45, 43, 0}, {0x5601, 46, 46, 0}}; |
31 | 31 |
32 extern const unsigned int JBIG2_QE_NUM = FX_ArraySize(QeTable); | 32 extern const unsigned int JBIG2_QE_NUM = FX_ArraySize(QeTable); |
33 | 33 |
34 CJBig2_Image* CJBig2_GRDProc::decode_Arith(CJBig2_ArithDecoder* pArithDecoder, | 34 CJBig2_Image* CJBig2_GRDProc::decode_Arith(CJBig2_ArithDecoder* pArithDecoder, |
35 JBig2ArithCtx* gbContext) { | 35 JBig2ArithCtx* gbContext) { |
36 if (GBW == 0 || GBH == 0) { | 36 if (GBW == 0 || GBH == 0) { |
37 CJBig2_Image* pImage; | 37 return new CJBig2_Image(GBW, GBH); |
38 JBIG2_ALLOC(pImage, CJBig2_Image(GBW, GBH)); | |
39 return pImage; | |
40 } | 38 } |
41 if (GBTEMPLATE == 0) { | 39 if (GBTEMPLATE == 0) { |
42 if ((GBAT[0] == 3) && (GBAT[1] == (int8_t)-1) && (GBAT[2] == (int8_t)-3) && | 40 if ((GBAT[0] == 3) && (GBAT[1] == (int8_t)-1) && (GBAT[2] == (int8_t)-3) && |
43 (GBAT[3] == (int8_t)-1) && (GBAT[4] == 2) && (GBAT[5] == (int8_t)-2) && | 41 (GBAT[3] == (int8_t)-1) && (GBAT[4] == 2) && (GBAT[5] == (int8_t)-2) && |
44 (GBAT[6] == (int8_t)-2) && (GBAT[7] == (int8_t)-2)) { | 42 (GBAT[6] == (int8_t)-2) && (GBAT[7] == (int8_t)-2)) { |
45 return decode_Arith_Template0_opt3(pArithDecoder, gbContext); | 43 return decode_Arith_Template0_opt3(pArithDecoder, gbContext); |
46 } else { | 44 } else { |
47 return decode_Arith_Template0_unopt(pArithDecoder, gbContext); | 45 return decode_Arith_Template0_unopt(pArithDecoder, gbContext); |
48 } | 46 } |
49 } else if (GBTEMPLATE == 1) { | 47 } else if (GBTEMPLATE == 1) { |
(...skipping 14 matching lines...) Expand all Loading... |
64 } else { | 62 } else { |
65 return decode_Arith_Template3_unopt(pArithDecoder, gbContext); | 63 return decode_Arith_Template3_unopt(pArithDecoder, gbContext); |
66 } | 64 } |
67 } | 65 } |
68 } | 66 } |
69 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template0_opt3( | 67 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template0_opt3( |
70 CJBig2_ArithDecoder* pArithDecoder, | 68 CJBig2_ArithDecoder* pArithDecoder, |
71 JBig2ArithCtx* gbContext) { | 69 JBig2ArithCtx* gbContext) { |
72 FX_BOOL LTP, SLTP, bVal; | 70 FX_BOOL LTP, SLTP, bVal; |
73 FX_DWORD CONTEXT; | 71 FX_DWORD CONTEXT; |
74 CJBig2_Image* GBREG; | |
75 FX_DWORD line1, line2; | 72 FX_DWORD line1, line2; |
76 uint8_t *pLine, *pLine1, *pLine2, cVal; | 73 uint8_t *pLine, *pLine1, *pLine2, cVal; |
77 int32_t nStride, nStride2, k; | 74 int32_t nStride, nStride2, k; |
78 int32_t nLineBytes, nBitsLeft, cc; | 75 int32_t nLineBytes, nBitsLeft, cc; |
79 LTP = 0; | 76 LTP = 0; |
80 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH)); | 77 CJBig2_Image* GBREG = new CJBig2_Image(GBW, GBH); |
81 if (GBREG->m_pData == NULL) { | 78 if (GBREG->m_pData == NULL) { |
82 delete GBREG; | 79 delete GBREG; |
83 return NULL; | 80 return NULL; |
84 } | 81 } |
85 pLine = GBREG->m_pData; | 82 pLine = GBREG->m_pData; |
86 nStride = GBREG->m_nStride; | 83 nStride = GBREG->m_nStride; |
87 nStride2 = nStride << 1; | 84 nStride2 = nStride << 1; |
88 nLineBytes = ((GBW + 7) >> 3) - 1; | 85 nLineBytes = ((GBW + 7) >> 3) - 1; |
89 nBitsLeft = GBW - (nLineBytes << 3); | 86 nBitsLeft = GBW - (nLineBytes << 3); |
90 FX_DWORD height = GBH & 0x7fffffff; | 87 FX_DWORD height = GBH & 0x7fffffff; |
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
155 } | 152 } |
156 pLine += nStride; | 153 pLine += nStride; |
157 } | 154 } |
158 return GBREG; | 155 return GBREG; |
159 } | 156 } |
160 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template0_unopt( | 157 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template0_unopt( |
161 CJBig2_ArithDecoder* pArithDecoder, | 158 CJBig2_ArithDecoder* pArithDecoder, |
162 JBig2ArithCtx* gbContext) { | 159 JBig2ArithCtx* gbContext) { |
163 FX_BOOL LTP, SLTP, bVal; | 160 FX_BOOL LTP, SLTP, bVal; |
164 FX_DWORD CONTEXT; | 161 FX_DWORD CONTEXT; |
165 CJBig2_Image* GBREG; | |
166 FX_DWORD line1, line2, line3; | 162 FX_DWORD line1, line2, line3; |
167 LTP = 0; | 163 LTP = 0; |
168 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH)); | 164 CJBig2_Image* GBREG = new CJBig2_Image(GBW, GBH); |
169 GBREG->fill(0); | 165 GBREG->fill(0); |
170 for (FX_DWORD h = 0; h < GBH; h++) { | 166 for (FX_DWORD h = 0; h < GBH; h++) { |
171 if (TPGDON) { | 167 if (TPGDON) { |
172 SLTP = pArithDecoder->DECODE(&gbContext[0x9b25]); | 168 SLTP = pArithDecoder->DECODE(&gbContext[0x9b25]); |
173 LTP = LTP ^ SLTP; | 169 LTP = LTP ^ SLTP; |
174 } | 170 } |
175 if (LTP == 1) { | 171 if (LTP == 1) { |
176 GBREG->copyLine(h, h - 1); | 172 GBREG->copyLine(h, h - 1); |
177 } else { | 173 } else { |
178 line1 = GBREG->getPixel(1, h - 2); | 174 line1 = GBREG->getPixel(1, h - 2); |
(...skipping 24 matching lines...) Expand all Loading... |
203 } | 199 } |
204 } | 200 } |
205 } | 201 } |
206 return GBREG; | 202 return GBREG; |
207 } | 203 } |
208 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template1_opt3( | 204 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template1_opt3( |
209 CJBig2_ArithDecoder* pArithDecoder, | 205 CJBig2_ArithDecoder* pArithDecoder, |
210 JBig2ArithCtx* gbContext) { | 206 JBig2ArithCtx* gbContext) { |
211 FX_BOOL LTP, SLTP, bVal; | 207 FX_BOOL LTP, SLTP, bVal; |
212 FX_DWORD CONTEXT; | 208 FX_DWORD CONTEXT; |
213 CJBig2_Image* GBREG; | |
214 FX_DWORD line1, line2; | 209 FX_DWORD line1, line2; |
215 uint8_t *pLine, *pLine1, *pLine2, cVal; | 210 uint8_t *pLine, *pLine1, *pLine2, cVal; |
216 int32_t nStride, nStride2, k; | 211 int32_t nStride, nStride2, k; |
217 int32_t nLineBytes, nBitsLeft, cc; | 212 int32_t nLineBytes, nBitsLeft, cc; |
218 LTP = 0; | 213 LTP = 0; |
219 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH)); | 214 CJBig2_Image* GBREG = new CJBig2_Image(GBW, GBH); |
220 if (GBREG->m_pData == NULL) { | 215 if (GBREG->m_pData == NULL) { |
221 delete GBREG; | 216 delete GBREG; |
222 return NULL; | 217 return NULL; |
223 } | 218 } |
224 pLine = GBREG->m_pData; | 219 pLine = GBREG->m_pData; |
225 nStride = GBREG->m_nStride; | 220 nStride = GBREG->m_nStride; |
226 nStride2 = nStride << 1; | 221 nStride2 = nStride << 1; |
227 nLineBytes = ((GBW + 7) >> 3) - 1; | 222 nLineBytes = ((GBW + 7) >> 3) - 1; |
228 nBitsLeft = GBW - (nLineBytes << 3); | 223 nBitsLeft = GBW - (nLineBytes << 3); |
229 for (FX_DWORD h = 0; h < GBH; h++) { | 224 for (FX_DWORD h = 0; h < GBH; h++) { |
(...skipping 63 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
293 } | 288 } |
294 pLine += nStride; | 289 pLine += nStride; |
295 } | 290 } |
296 return GBREG; | 291 return GBREG; |
297 } | 292 } |
298 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template1_unopt( | 293 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template1_unopt( |
299 CJBig2_ArithDecoder* pArithDecoder, | 294 CJBig2_ArithDecoder* pArithDecoder, |
300 JBig2ArithCtx* gbContext) { | 295 JBig2ArithCtx* gbContext) { |
301 FX_BOOL LTP, SLTP, bVal; | 296 FX_BOOL LTP, SLTP, bVal; |
302 FX_DWORD CONTEXT; | 297 FX_DWORD CONTEXT; |
303 CJBig2_Image* GBREG; | |
304 FX_DWORD line1, line2, line3; | 298 FX_DWORD line1, line2, line3; |
305 LTP = 0; | 299 LTP = 0; |
306 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH)); | 300 CJBig2_Image* GBREG = new CJBig2_Image(GBW, GBH); |
307 GBREG->fill(0); | 301 GBREG->fill(0); |
308 for (FX_DWORD h = 0; h < GBH; h++) { | 302 for (FX_DWORD h = 0; h < GBH; h++) { |
309 if (TPGDON) { | 303 if (TPGDON) { |
310 SLTP = pArithDecoder->DECODE(&gbContext[0x0795]); | 304 SLTP = pArithDecoder->DECODE(&gbContext[0x0795]); |
311 LTP = LTP ^ SLTP; | 305 LTP = LTP ^ SLTP; |
312 } | 306 } |
313 if (LTP == 1) { | 307 if (LTP == 1) { |
314 GBREG->copyLine(h, h - 1); | 308 GBREG->copyLine(h, h - 1); |
315 } else { | 309 } else { |
316 line1 = GBREG->getPixel(2, h - 2); | 310 line1 = GBREG->getPixel(2, h - 2); |
(...skipping 22 matching lines...) Expand all Loading... |
339 } | 333 } |
340 } | 334 } |
341 } | 335 } |
342 return GBREG; | 336 return GBREG; |
343 } | 337 } |
344 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template2_opt3( | 338 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template2_opt3( |
345 CJBig2_ArithDecoder* pArithDecoder, | 339 CJBig2_ArithDecoder* pArithDecoder, |
346 JBig2ArithCtx* gbContext) { | 340 JBig2ArithCtx* gbContext) { |
347 FX_BOOL LTP, SLTP, bVal; | 341 FX_BOOL LTP, SLTP, bVal; |
348 FX_DWORD CONTEXT; | 342 FX_DWORD CONTEXT; |
349 CJBig2_Image* GBREG; | |
350 FX_DWORD line1, line2; | 343 FX_DWORD line1, line2; |
351 uint8_t *pLine, *pLine1, *pLine2, cVal; | 344 uint8_t *pLine, *pLine1, *pLine2, cVal; |
352 int32_t nStride, nStride2, k; | 345 int32_t nStride, nStride2, k; |
353 int32_t nLineBytes, nBitsLeft, cc; | 346 int32_t nLineBytes, nBitsLeft, cc; |
354 LTP = 0; | 347 LTP = 0; |
355 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH)); | 348 CJBig2_Image* GBREG = new CJBig2_Image(GBW, GBH); |
356 if (GBREG->m_pData == NULL) { | 349 if (GBREG->m_pData == NULL) { |
357 delete GBREG; | 350 delete GBREG; |
358 return NULL; | 351 return NULL; |
359 } | 352 } |
360 pLine = GBREG->m_pData; | 353 pLine = GBREG->m_pData; |
361 nStride = GBREG->m_nStride; | 354 nStride = GBREG->m_nStride; |
362 nStride2 = nStride << 1; | 355 nStride2 = nStride << 1; |
363 nLineBytes = ((GBW + 7) >> 3) - 1; | 356 nLineBytes = ((GBW + 7) >> 3) - 1; |
364 nBitsLeft = GBW - (nLineBytes << 3); | 357 nBitsLeft = GBW - (nLineBytes << 3); |
365 for (FX_DWORD h = 0; h < GBH; h++) { | 358 for (FX_DWORD h = 0; h < GBH; h++) { |
(...skipping 63 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
429 } | 422 } |
430 pLine += nStride; | 423 pLine += nStride; |
431 } | 424 } |
432 return GBREG; | 425 return GBREG; |
433 } | 426 } |
434 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template2_unopt( | 427 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template2_unopt( |
435 CJBig2_ArithDecoder* pArithDecoder, | 428 CJBig2_ArithDecoder* pArithDecoder, |
436 JBig2ArithCtx* gbContext) { | 429 JBig2ArithCtx* gbContext) { |
437 FX_BOOL LTP, SLTP, bVal; | 430 FX_BOOL LTP, SLTP, bVal; |
438 FX_DWORD CONTEXT; | 431 FX_DWORD CONTEXT; |
439 CJBig2_Image* GBREG; | |
440 FX_DWORD line1, line2, line3; | 432 FX_DWORD line1, line2, line3; |
441 LTP = 0; | 433 LTP = 0; |
442 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH)); | 434 CJBig2_Image* GBREG = new CJBig2_Image(GBW, GBH); |
443 GBREG->fill(0); | 435 GBREG->fill(0); |
444 for (FX_DWORD h = 0; h < GBH; h++) { | 436 for (FX_DWORD h = 0; h < GBH; h++) { |
445 if (TPGDON) { | 437 if (TPGDON) { |
446 SLTP = pArithDecoder->DECODE(&gbContext[0x00e5]); | 438 SLTP = pArithDecoder->DECODE(&gbContext[0x00e5]); |
447 LTP = LTP ^ SLTP; | 439 LTP = LTP ^ SLTP; |
448 } | 440 } |
449 if (LTP == 1) { | 441 if (LTP == 1) { |
450 GBREG->copyLine(h, h - 1); | 442 GBREG->copyLine(h, h - 1); |
451 } else { | 443 } else { |
452 line1 = GBREG->getPixel(1, h - 2); | 444 line1 = GBREG->getPixel(1, h - 2); |
(...skipping 20 matching lines...) Expand all Loading... |
473 } | 465 } |
474 } | 466 } |
475 } | 467 } |
476 return GBREG; | 468 return GBREG; |
477 } | 469 } |
478 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template3_opt3( | 470 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template3_opt3( |
479 CJBig2_ArithDecoder* pArithDecoder, | 471 CJBig2_ArithDecoder* pArithDecoder, |
480 JBig2ArithCtx* gbContext) { | 472 JBig2ArithCtx* gbContext) { |
481 FX_BOOL LTP, SLTP, bVal; | 473 FX_BOOL LTP, SLTP, bVal; |
482 FX_DWORD CONTEXT; | 474 FX_DWORD CONTEXT; |
483 CJBig2_Image* GBREG; | |
484 FX_DWORD line1; | 475 FX_DWORD line1; |
485 uint8_t *pLine, *pLine1, cVal; | 476 uint8_t *pLine, *pLine1, cVal; |
486 int32_t nStride, k; | 477 int32_t nStride, k; |
487 int32_t nLineBytes, nBitsLeft, cc; | 478 int32_t nLineBytes, nBitsLeft, cc; |
488 LTP = 0; | 479 LTP = 0; |
489 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH)); | 480 CJBig2_Image* GBREG = new CJBig2_Image(GBW, GBH); |
490 if (GBREG->m_pData == NULL) { | 481 if (GBREG->m_pData == NULL) { |
491 delete GBREG; | 482 delete GBREG; |
492 return NULL; | 483 return NULL; |
493 } | 484 } |
494 pLine = GBREG->m_pData; | 485 pLine = GBREG->m_pData; |
495 nStride = GBREG->m_nStride; | 486 nStride = GBREG->m_nStride; |
496 nLineBytes = ((GBW + 7) >> 3) - 1; | 487 nLineBytes = ((GBW + 7) >> 3) - 1; |
497 nBitsLeft = GBW - (nLineBytes << 3); | 488 nBitsLeft = GBW - (nLineBytes << 3); |
498 for (FX_DWORD h = 0; h < GBH; h++) { | 489 for (FX_DWORD h = 0; h < GBH; h++) { |
499 if (TPGDON) { | 490 if (TPGDON) { |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
549 } | 540 } |
550 pLine += nStride; | 541 pLine += nStride; |
551 } | 542 } |
552 return GBREG; | 543 return GBREG; |
553 } | 544 } |
554 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template3_unopt( | 545 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template3_unopt( |
555 CJBig2_ArithDecoder* pArithDecoder, | 546 CJBig2_ArithDecoder* pArithDecoder, |
556 JBig2ArithCtx* gbContext) { | 547 JBig2ArithCtx* gbContext) { |
557 FX_BOOL LTP, SLTP, bVal; | 548 FX_BOOL LTP, SLTP, bVal; |
558 FX_DWORD CONTEXT; | 549 FX_DWORD CONTEXT; |
559 CJBig2_Image* GBREG; | |
560 FX_DWORD line1, line2; | 550 FX_DWORD line1, line2; |
561 LTP = 0; | 551 LTP = 0; |
562 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH)); | 552 CJBig2_Image* GBREG = new CJBig2_Image(GBW, GBH); |
563 GBREG->fill(0); | 553 GBREG->fill(0); |
564 for (FX_DWORD h = 0; h < GBH; h++) { | 554 for (FX_DWORD h = 0; h < GBH; h++) { |
565 if (TPGDON) { | 555 if (TPGDON) { |
566 SLTP = pArithDecoder->DECODE(&gbContext[0x0195]); | 556 SLTP = pArithDecoder->DECODE(&gbContext[0x0195]); |
567 LTP = LTP ^ SLTP; | 557 LTP = LTP ^ SLTP; |
568 } | 558 } |
569 if (LTP == 1) { | 559 if (LTP == 1) { |
570 GBREG->copyLine(h, h - 1); | 560 GBREG->copyLine(h, h - 1); |
571 } else { | 561 } else { |
572 line1 = GBREG->getPixel(1, h - 1); | 562 line1 = GBREG->getPixel(1, h - 1); |
(...skipping 14 matching lines...) Expand all Loading... |
587 line1 = ((line1 << 1) | GBREG->getPixel(w + 2, h - 1)) & 0x1f; | 577 line1 = ((line1 << 1) | GBREG->getPixel(w + 2, h - 1)) & 0x1f; |
588 line2 = ((line2 << 1) | bVal) & 0x0f; | 578 line2 = ((line2 << 1) | bVal) & 0x0f; |
589 } | 579 } |
590 } | 580 } |
591 } | 581 } |
592 return GBREG; | 582 return GBREG; |
593 } | 583 } |
594 CJBig2_Image* CJBig2_GRRDProc::decode(CJBig2_ArithDecoder* pArithDecoder, | 584 CJBig2_Image* CJBig2_GRRDProc::decode(CJBig2_ArithDecoder* pArithDecoder, |
595 JBig2ArithCtx* grContext) { | 585 JBig2ArithCtx* grContext) { |
596 if (GRW == 0 || GRH == 0) { | 586 if (GRW == 0 || GRH == 0) { |
597 CJBig2_Image* pImage; | 587 return new CJBig2_Image(GRW, GRH); |
598 JBIG2_ALLOC(pImage, CJBig2_Image(GRW, GRH)); | |
599 return pImage; | |
600 } | 588 } |
601 if (GRTEMPLATE == 0) { | 589 if (GRTEMPLATE == 0) { |
602 if ((GRAT[0] == (int8_t)-1) && (GRAT[1] == (int8_t)-1) && | 590 if ((GRAT[0] == (int8_t)-1) && (GRAT[1] == (int8_t)-1) && |
603 (GRAT[2] == (int8_t)-1) && (GRAT[3] == (int8_t)-1) && | 591 (GRAT[2] == (int8_t)-1) && (GRAT[3] == (int8_t)-1) && |
604 (GRREFERENCEDX == 0) && (GRW == (FX_DWORD)GRREFERENCE->m_nWidth)) { | 592 (GRREFERENCEDX == 0) && (GRW == (FX_DWORD)GRREFERENCE->m_nWidth)) { |
605 return decode_Template0_opt(pArithDecoder, grContext); | 593 return decode_Template0_opt(pArithDecoder, grContext); |
606 } else { | 594 } else { |
607 return decode_Template0_unopt(pArithDecoder, grContext); | 595 return decode_Template0_unopt(pArithDecoder, grContext); |
608 } | 596 } |
609 } else { | 597 } else { |
610 if ((GRREFERENCEDX == 0) && (GRW == (FX_DWORD)GRREFERENCE->m_nWidth)) { | 598 if ((GRREFERENCEDX == 0) && (GRW == (FX_DWORD)GRREFERENCE->m_nWidth)) { |
611 return decode_Template1_opt(pArithDecoder, grContext); | 599 return decode_Template1_opt(pArithDecoder, grContext); |
612 } else { | 600 } else { |
613 return decode_Template1_unopt(pArithDecoder, grContext); | 601 return decode_Template1_unopt(pArithDecoder, grContext); |
614 } | 602 } |
615 } | 603 } |
616 } | 604 } |
617 CJBig2_Image* CJBig2_GRRDProc::decode_Template0_unopt( | 605 CJBig2_Image* CJBig2_GRRDProc::decode_Template0_unopt( |
618 CJBig2_ArithDecoder* pArithDecoder, | 606 CJBig2_ArithDecoder* pArithDecoder, |
619 JBig2ArithCtx* grContext) { | 607 JBig2ArithCtx* grContext) { |
620 FX_BOOL LTP, SLTP, bVal; | 608 FX_BOOL LTP, SLTP, bVal; |
621 FX_DWORD CONTEXT; | 609 FX_DWORD CONTEXT; |
622 CJBig2_Image* GRREG; | |
623 FX_DWORD line1, line2, line3, line4, line5; | 610 FX_DWORD line1, line2, line3, line4, line5; |
624 LTP = 0; | 611 LTP = 0; |
625 JBIG2_ALLOC(GRREG, CJBig2_Image(GRW, GRH)); | 612 CJBig2_Image* GRREG = new CJBig2_Image(GRW, GRH); |
626 GRREG->fill(0); | 613 GRREG->fill(0); |
627 for (FX_DWORD h = 0; h < GRH; h++) { | 614 for (FX_DWORD h = 0; h < GRH; h++) { |
628 if (TPGRON) { | 615 if (TPGRON) { |
629 SLTP = pArithDecoder->DECODE(&grContext[0x0010]); | 616 SLTP = pArithDecoder->DECODE(&grContext[0x0010]); |
630 LTP = LTP ^ SLTP; | 617 LTP = LTP ^ SLTP; |
631 } | 618 } |
632 if (LTP == 0) { | 619 if (LTP == 0) { |
633 line1 = GRREG->getPixel(1, h - 1); | 620 line1 = GRREG->getPixel(1, h - 1); |
634 line1 |= GRREG->getPixel(0, h - 1) << 1; | 621 line1 |= GRREG->getPixel(0, h - 1) << 1; |
635 line2 = 0; | 622 line2 = 0; |
(...skipping 91 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
727 } | 714 } |
728 } | 715 } |
729 } | 716 } |
730 return GRREG; | 717 return GRREG; |
731 } | 718 } |
732 CJBig2_Image* CJBig2_GRRDProc::decode_Template0_opt( | 719 CJBig2_Image* CJBig2_GRRDProc::decode_Template0_opt( |
733 CJBig2_ArithDecoder* pArithDecoder, | 720 CJBig2_ArithDecoder* pArithDecoder, |
734 JBig2ArithCtx* grContext) { | 721 JBig2ArithCtx* grContext) { |
735 FX_BOOL LTP, SLTP, bVal; | 722 FX_BOOL LTP, SLTP, bVal; |
736 FX_DWORD CONTEXT; | 723 FX_DWORD CONTEXT; |
737 CJBig2_Image* GRREG; | |
738 FX_DWORD line1, line1_r, line2_r, line3_r; | 724 FX_DWORD line1, line1_r, line2_r, line3_r; |
739 uint8_t *pLine, *pLineR, cVal; | 725 uint8_t *pLine, *pLineR, cVal; |
740 intptr_t nStride, nStrideR, nOffset; | 726 intptr_t nStride, nStrideR, nOffset; |
741 int32_t k, nBits; | 727 int32_t k, nBits; |
742 int32_t GRWR, GRHR; | 728 int32_t GRWR, GRHR; |
743 int32_t GRW, GRH; | 729 int32_t GRW, GRH; |
744 GRW = (int32_t)CJBig2_GRRDProc::GRW; | 730 GRW = (int32_t)CJBig2_GRRDProc::GRW; |
745 GRH = (int32_t)CJBig2_GRRDProc::GRH; | 731 GRH = (int32_t)CJBig2_GRRDProc::GRH; |
746 LTP = 0; | 732 LTP = 0; |
747 JBIG2_ALLOC(GRREG, CJBig2_Image(GRW, GRH)); | 733 CJBig2_Image* GRREG = new CJBig2_Image(GRW, GRH); |
748 if (GRREG->m_pData == NULL) { | 734 if (GRREG->m_pData == NULL) { |
749 delete GRREG; | 735 delete GRREG; |
750 return NULL; | 736 return NULL; |
751 } | 737 } |
752 pLine = GRREG->m_pData; | 738 pLine = GRREG->m_pData; |
753 pLineR = GRREFERENCE->m_pData; | 739 pLineR = GRREFERENCE->m_pData; |
754 nStride = GRREG->m_nStride; | 740 nStride = GRREG->m_nStride; |
755 nStrideR = GRREFERENCE->m_nStride; | 741 nStrideR = GRREFERENCE->m_nStride; |
756 GRWR = (int32_t)GRREFERENCE->m_nWidth; | 742 GRWR = (int32_t)GRREFERENCE->m_nWidth; |
757 GRHR = (int32_t)GRREFERENCE->m_nHeight; | 743 GRHR = (int32_t)GRREFERENCE->m_nHeight; |
(...skipping 104 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
862 pLineR += nStrideR; | 848 pLineR += nStrideR; |
863 } | 849 } |
864 } | 850 } |
865 return GRREG; | 851 return GRREG; |
866 } | 852 } |
867 CJBig2_Image* CJBig2_GRRDProc::decode_Template1_unopt( | 853 CJBig2_Image* CJBig2_GRRDProc::decode_Template1_unopt( |
868 CJBig2_ArithDecoder* pArithDecoder, | 854 CJBig2_ArithDecoder* pArithDecoder, |
869 JBig2ArithCtx* grContext) { | 855 JBig2ArithCtx* grContext) { |
870 FX_BOOL LTP, SLTP, bVal; | 856 FX_BOOL LTP, SLTP, bVal; |
871 FX_DWORD CONTEXT; | 857 FX_DWORD CONTEXT; |
872 CJBig2_Image* GRREG; | |
873 FX_DWORD line1, line2, line3, line4, line5; | 858 FX_DWORD line1, line2, line3, line4, line5; |
874 LTP = 0; | 859 LTP = 0; |
875 JBIG2_ALLOC(GRREG, CJBig2_Image(GRW, GRH)); | 860 CJBig2_Image* GRREG = new CJBig2_Image(GRW, GRH); |
876 GRREG->fill(0); | 861 GRREG->fill(0); |
877 for (FX_DWORD h = 0; h < GRH; h++) { | 862 for (FX_DWORD h = 0; h < GRH; h++) { |
878 if (TPGRON) { | 863 if (TPGRON) { |
879 SLTP = pArithDecoder->DECODE(&grContext[0x0008]); | 864 SLTP = pArithDecoder->DECODE(&grContext[0x0008]); |
880 LTP = LTP ^ SLTP; | 865 LTP = LTP ^ SLTP; |
881 } | 866 } |
882 if (LTP == 0) { | 867 if (LTP == 0) { |
883 line1 = GRREG->getPixel(1, h - 1); | 868 line1 = GRREG->getPixel(1, h - 1); |
884 line1 |= GRREG->getPixel(0, h - 1) << 1; | 869 line1 |= GRREG->getPixel(0, h - 1) << 1; |
885 line1 |= GRREG->getPixel(-1, h - 1) << 2; | 870 line1 |= GRREG->getPixel(-1, h - 1) << 2; |
(...skipping 77 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
963 } | 948 } |
964 } | 949 } |
965 } | 950 } |
966 return GRREG; | 951 return GRREG; |
967 } | 952 } |
968 CJBig2_Image* CJBig2_GRRDProc::decode_Template1_opt( | 953 CJBig2_Image* CJBig2_GRRDProc::decode_Template1_opt( |
969 CJBig2_ArithDecoder* pArithDecoder, | 954 CJBig2_ArithDecoder* pArithDecoder, |
970 JBig2ArithCtx* grContext) { | 955 JBig2ArithCtx* grContext) { |
971 FX_BOOL LTP, SLTP, bVal; | 956 FX_BOOL LTP, SLTP, bVal; |
972 FX_DWORD CONTEXT; | 957 FX_DWORD CONTEXT; |
973 CJBig2_Image* GRREG; | |
974 FX_DWORD line1, line1_r, line2_r, line3_r; | 958 FX_DWORD line1, line1_r, line2_r, line3_r; |
975 uint8_t *pLine, *pLineR, cVal; | 959 uint8_t *pLine, *pLineR, cVal; |
976 intptr_t nStride, nStrideR, nOffset; | 960 intptr_t nStride, nStrideR, nOffset; |
977 int32_t k, nBits; | 961 int32_t k, nBits; |
978 int32_t GRWR, GRHR; | 962 int32_t GRWR, GRHR; |
979 int32_t GRW, GRH; | 963 int32_t GRW, GRH; |
980 GRW = (int32_t)CJBig2_GRRDProc::GRW; | 964 GRW = (int32_t)CJBig2_GRRDProc::GRW; |
981 GRH = (int32_t)CJBig2_GRRDProc::GRH; | 965 GRH = (int32_t)CJBig2_GRRDProc::GRH; |
982 LTP = 0; | 966 LTP = 0; |
983 JBIG2_ALLOC(GRREG, CJBig2_Image(GRW, GRH)); | 967 CJBig2_Image* GRREG = new CJBig2_Image(GRW, GRH); |
984 if (GRREG->m_pData == NULL) { | 968 if (GRREG->m_pData == NULL) { |
985 delete GRREG; | 969 delete GRREG; |
986 return NULL; | 970 return NULL; |
987 } | 971 } |
988 pLine = GRREG->m_pData; | 972 pLine = GRREG->m_pData; |
989 pLineR = GRREFERENCE->m_pData; | 973 pLineR = GRREFERENCE->m_pData; |
990 nStride = GRREG->m_nStride; | 974 nStride = GRREG->m_nStride; |
991 nStrideR = GRREFERENCE->m_nStride; | 975 nStrideR = GRREFERENCE->m_nStride; |
992 GRWR = (int32_t)GRREFERENCE->m_nWidth; | 976 GRWR = (int32_t)GRREFERENCE->m_nWidth; |
993 GRHR = (int32_t)GRREFERENCE->m_nHeight; | 977 GRHR = (int32_t)GRREFERENCE->m_nHeight; |
(...skipping 109 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1103 uint8_t CURT; | 1087 uint8_t CURT; |
1104 int32_t SI, TI; | 1088 int32_t SI, TI; |
1105 FX_DWORD IDI; | 1089 FX_DWORD IDI; |
1106 CJBig2_Image* IBI; | 1090 CJBig2_Image* IBI; |
1107 FX_DWORD WI, HI; | 1091 FX_DWORD WI, HI; |
1108 int32_t IDS; | 1092 int32_t IDS; |
1109 FX_BOOL RI; | 1093 FX_BOOL RI; |
1110 int32_t RDWI, RDHI, RDXI, RDYI; | 1094 int32_t RDWI, RDHI, RDXI, RDYI; |
1111 CJBig2_Image* IBOI; | 1095 CJBig2_Image* IBOI; |
1112 FX_DWORD WOI, HOI; | 1096 FX_DWORD WOI, HOI; |
1113 CJBig2_Image* SBREG; | |
1114 FX_BOOL bFirst; | 1097 FX_BOOL bFirst; |
1115 FX_DWORD nTmp; | 1098 FX_DWORD nTmp; |
1116 int32_t nVal, nBits; | 1099 int32_t nVal, nBits; |
1117 CJBig2_GRRDProc* pGRRD; | 1100 CJBig2_GRRDProc* pGRRD; |
1118 CJBig2_ArithDecoder* pArithDecoder; | 1101 CJBig2_ArithDecoder* pArithDecoder; |
1119 CJBig2_HuffmanDecoder* pHuffmanDecoder = new CJBig2_HuffmanDecoder(pStream); | 1102 CJBig2_HuffmanDecoder* pHuffmanDecoder = new CJBig2_HuffmanDecoder(pStream); |
1120 JBIG2_ALLOC(SBREG, CJBig2_Image(SBW, SBH)); | 1103 CJBig2_Image* SBREG = new CJBig2_Image(SBW, SBH); |
1121 SBREG->fill(SBDEFPIXEL); | 1104 SBREG->fill(SBDEFPIXEL); |
1122 if (pHuffmanDecoder->decodeAValue(SBHUFFDT, &STRIPT) != 0) { | 1105 if (pHuffmanDecoder->decodeAValue(SBHUFFDT, &STRIPT) != 0) { |
1123 goto failed; | 1106 goto failed; |
1124 } | 1107 } |
1125 STRIPT *= SBSTRIPS; | 1108 STRIPT *= SBSTRIPS; |
1126 STRIPT = -STRIPT; | 1109 STRIPT = -STRIPT; |
1127 FIRSTS = 0; | 1110 FIRSTS = 0; |
1128 NINSTANCES = 0; | 1111 NINSTANCES = 0; |
1129 while (NINSTANCES < SBNUMINSTANCES) { | 1112 while (NINSTANCES < SBNUMINSTANCES) { |
1130 if (pHuffmanDecoder->decodeAValue(SBHUFFDT, &DT) != 0) { | 1113 if (pHuffmanDecoder->decodeAValue(SBHUFFDT, &DT) != 0) { |
(...skipping 72 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1203 nTmp = pStream->getOffset(); | 1186 nTmp = pStream->getOffset(); |
1204 IBOI = SBSYMS[IDI]; | 1187 IBOI = SBSYMS[IDI]; |
1205 if (!IBOI) { | 1188 if (!IBOI) { |
1206 goto failed; | 1189 goto failed; |
1207 } | 1190 } |
1208 WOI = IBOI->m_nWidth; | 1191 WOI = IBOI->m_nWidth; |
1209 HOI = IBOI->m_nHeight; | 1192 HOI = IBOI->m_nHeight; |
1210 if ((int)(WOI + RDWI) < 0 || (int)(HOI + RDHI) < 0) { | 1193 if ((int)(WOI + RDWI) < 0 || (int)(HOI + RDHI) < 0) { |
1211 goto failed; | 1194 goto failed; |
1212 } | 1195 } |
1213 JBIG2_ALLOC(pGRRD, CJBig2_GRRDProc()); | 1196 pGRRD = new CJBig2_GRRDProc(); |
1214 pGRRD->GRW = WOI + RDWI; | 1197 pGRRD->GRW = WOI + RDWI; |
1215 pGRRD->GRH = HOI + RDHI; | 1198 pGRRD->GRH = HOI + RDHI; |
1216 pGRRD->GRTEMPLATE = SBRTEMPLATE; | 1199 pGRRD->GRTEMPLATE = SBRTEMPLATE; |
1217 pGRRD->GRREFERENCE = IBOI; | 1200 pGRRD->GRREFERENCE = IBOI; |
1218 pGRRD->GRREFERENCEDX = (RDWI >> 2) + RDXI; | 1201 pGRRD->GRREFERENCEDX = (RDWI >> 2) + RDXI; |
1219 pGRRD->GRREFERENCEDY = (RDHI >> 2) + RDYI; | 1202 pGRRD->GRREFERENCEDY = (RDHI >> 2) + RDYI; |
1220 pGRRD->TPGRON = 0; | 1203 pGRRD->TPGRON = 0; |
1221 pGRRD->GRAT[0] = SBRAT[0]; | 1204 pGRRD->GRAT[0] = SBRAT[0]; |
1222 pGRRD->GRAT[1] = SBRAT[1]; | 1205 pGRRD->GRAT[1] = SBRAT[1]; |
1223 pGRRD->GRAT[2] = SBRAT[2]; | 1206 pGRRD->GRAT[2] = SBRAT[2]; |
(...skipping 121 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1345 IADS = new CJBig2_ArithIntDecoder(); | 1328 IADS = new CJBig2_ArithIntDecoder(); |
1346 IAIT = new CJBig2_ArithIntDecoder(); | 1329 IAIT = new CJBig2_ArithIntDecoder(); |
1347 IARI = new CJBig2_ArithIntDecoder(); | 1330 IARI = new CJBig2_ArithIntDecoder(); |
1348 IARDW = new CJBig2_ArithIntDecoder(); | 1331 IARDW = new CJBig2_ArithIntDecoder(); |
1349 IARDH = new CJBig2_ArithIntDecoder(); | 1332 IARDH = new CJBig2_ArithIntDecoder(); |
1350 IARDX = new CJBig2_ArithIntDecoder(); | 1333 IARDX = new CJBig2_ArithIntDecoder(); |
1351 IARDY = new CJBig2_ArithIntDecoder(); | 1334 IARDY = new CJBig2_ArithIntDecoder(); |
1352 IAID = new CJBig2_ArithIaidDecoder(SBSYMCODELEN); | 1335 IAID = new CJBig2_ArithIaidDecoder(SBSYMCODELEN); |
1353 bRetained = FALSE; | 1336 bRetained = FALSE; |
1354 } | 1337 } |
1355 JBIG2_ALLOC(SBREG, CJBig2_Image(SBW, SBH)); | 1338 SBREG = new CJBig2_Image(SBW, SBH); |
1356 SBREG->fill(SBDEFPIXEL); | 1339 SBREG->fill(SBDEFPIXEL); |
1357 if (IADT->decode(pArithDecoder, &STRIPT) == -1) { | 1340 if (IADT->decode(pArithDecoder, &STRIPT) == -1) { |
1358 goto failed; | 1341 goto failed; |
1359 } | 1342 } |
1360 STRIPT *= SBSTRIPS; | 1343 STRIPT *= SBSTRIPS; |
1361 STRIPT = -STRIPT; | 1344 STRIPT = -STRIPT; |
1362 FIRSTS = 0; | 1345 FIRSTS = 0; |
1363 NINSTANCES = 0; | 1346 NINSTANCES = 0; |
1364 while (NINSTANCES < SBNUMINSTANCES) { | 1347 while (NINSTANCES < SBNUMINSTANCES) { |
1365 if (IADT->decode(pArithDecoder, &DT) == -1) { | 1348 if (IADT->decode(pArithDecoder, &DT) == -1) { |
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1423 (IARDX->decode(pArithDecoder, &RDXI) == -1) || | 1406 (IARDX->decode(pArithDecoder, &RDXI) == -1) || |
1424 (IARDY->decode(pArithDecoder, &RDYI) == -1)) { | 1407 (IARDY->decode(pArithDecoder, &RDYI) == -1)) { |
1425 goto failed; | 1408 goto failed; |
1426 } | 1409 } |
1427 IBOI = SBSYMS[IDI]; | 1410 IBOI = SBSYMS[IDI]; |
1428 WOI = IBOI->m_nWidth; | 1411 WOI = IBOI->m_nWidth; |
1429 HOI = IBOI->m_nHeight; | 1412 HOI = IBOI->m_nHeight; |
1430 if ((int)(WOI + RDWI) < 0 || (int)(HOI + RDHI) < 0) { | 1413 if ((int)(WOI + RDWI) < 0 || (int)(HOI + RDHI) < 0) { |
1431 goto failed; | 1414 goto failed; |
1432 } | 1415 } |
1433 JBIG2_ALLOC(pGRRD, CJBig2_GRRDProc()); | 1416 pGRRD = new CJBig2_GRRDProc(); |
1434 pGRRD->GRW = WOI + RDWI; | 1417 pGRRD->GRW = WOI + RDWI; |
1435 pGRRD->GRH = HOI + RDHI; | 1418 pGRRD->GRH = HOI + RDHI; |
1436 pGRRD->GRTEMPLATE = SBRTEMPLATE; | 1419 pGRRD->GRTEMPLATE = SBRTEMPLATE; |
1437 pGRRD->GRREFERENCE = IBOI; | 1420 pGRRD->GRREFERENCE = IBOI; |
1438 pGRRD->GRREFERENCEDX = (RDWI >> 1) + RDXI; | 1421 pGRRD->GRREFERENCEDX = (RDWI >> 1) + RDXI; |
1439 pGRRD->GRREFERENCEDY = (RDHI >> 1) + RDYI; | 1422 pGRRD->GRREFERENCEDY = (RDHI >> 1) + RDYI; |
1440 pGRRD->TPGRON = 0; | 1423 pGRRD->TPGRON = 0; |
1441 pGRRD->GRAT[0] = SBRAT[0]; | 1424 pGRRD->GRAT[0] = SBRAT[0]; |
1442 pGRRD->GRAT[1] = SBRAT[1]; | 1425 pGRRD->GRAT[1] = SBRAT[1]; |
1443 pGRRD->GRAT[2] = SBRAT[2]; | 1426 pGRRD->GRAT[2] = SBRAT[2]; |
(...skipping 129 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1573 IADS = new CJBig2_ArithIntDecoder(); | 1556 IADS = new CJBig2_ArithIntDecoder(); |
1574 IAIT = new CJBig2_ArithIntDecoder(); | 1557 IAIT = new CJBig2_ArithIntDecoder(); |
1575 IARI = new CJBig2_ArithIntDecoder(); | 1558 IARI = new CJBig2_ArithIntDecoder(); |
1576 IARDW = new CJBig2_ArithIntDecoder(); | 1559 IARDW = new CJBig2_ArithIntDecoder(); |
1577 IARDH = new CJBig2_ArithIntDecoder(); | 1560 IARDH = new CJBig2_ArithIntDecoder(); |
1578 nTmp = 0; | 1561 nTmp = 0; |
1579 while ((FX_DWORD)(1 << nTmp) < (SDNUMINSYMS + SDNUMNEWSYMS)) { | 1562 while ((FX_DWORD)(1 << nTmp) < (SDNUMINSYMS + SDNUMNEWSYMS)) { |
1580 nTmp++; | 1563 nTmp++; |
1581 } | 1564 } |
1582 IAID = new CJBig2_ArithIaidDecoder((uint8_t)nTmp); | 1565 IAID = new CJBig2_ArithIaidDecoder((uint8_t)nTmp); |
1583 SDNEWSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(SDNUMNEWSYMS, | 1566 SDNEWSYMS = FX_Alloc(CJBig2_Image*, SDNUMNEWSYMS); |
1584 sizeof(CJBig2_Image*)); | |
1585 FXSYS_memset(SDNEWSYMS, 0, SDNUMNEWSYMS * sizeof(CJBig2_Image*)); | 1567 FXSYS_memset(SDNEWSYMS, 0, SDNUMNEWSYMS * sizeof(CJBig2_Image*)); |
1586 HCHEIGHT = 0; | 1568 HCHEIGHT = 0; |
1587 NSYMSDECODED = 0; | 1569 NSYMSDECODED = 0; |
1588 while (NSYMSDECODED < SDNUMNEWSYMS) { | 1570 while (NSYMSDECODED < SDNUMNEWSYMS) { |
1589 BS = NULL; | 1571 BS = NULL; |
1590 if (IADH->decode(pArithDecoder, &HCDH) == -1) { | 1572 if (IADH->decode(pArithDecoder, &HCDH) == -1) { |
1591 goto failed; | 1573 goto failed; |
1592 } | 1574 } |
1593 HCHEIGHT = HCHEIGHT + HCDH; | 1575 HCHEIGHT = HCHEIGHT + HCDH; |
1594 if ((int)HCHEIGHT < 0 || (int)HCHEIGHT > JBIG2_MAX_IMAGE_SIZE) { | 1576 if ((int)HCHEIGHT < 0 || (int)HCHEIGHT > JBIG2_MAX_IMAGE_SIZE) { |
(...skipping 16 matching lines...) Expand all Loading... |
1611 goto failed; | 1593 goto failed; |
1612 } else if (HCHEIGHT == 0 || SYMWIDTH == 0) { | 1594 } else if (HCHEIGHT == 0 || SYMWIDTH == 0) { |
1613 TOTWIDTH = TOTWIDTH + SYMWIDTH; | 1595 TOTWIDTH = TOTWIDTH + SYMWIDTH; |
1614 SDNEWSYMS[NSYMSDECODED] = NULL; | 1596 SDNEWSYMS[NSYMSDECODED] = NULL; |
1615 NSYMSDECODED = NSYMSDECODED + 1; | 1597 NSYMSDECODED = NSYMSDECODED + 1; |
1616 continue; | 1598 continue; |
1617 } | 1599 } |
1618 TOTWIDTH = TOTWIDTH + SYMWIDTH; | 1600 TOTWIDTH = TOTWIDTH + SYMWIDTH; |
1619 } | 1601 } |
1620 if (SDREFAGG == 0) { | 1602 if (SDREFAGG == 0) { |
1621 JBIG2_ALLOC(pGRD, CJBig2_GRDProc()); | 1603 pGRD = new CJBig2_GRDProc(); |
1622 pGRD->MMR = 0; | 1604 pGRD->MMR = 0; |
1623 pGRD->GBW = SYMWIDTH; | 1605 pGRD->GBW = SYMWIDTH; |
1624 pGRD->GBH = HCHEIGHT; | 1606 pGRD->GBH = HCHEIGHT; |
1625 pGRD->GBTEMPLATE = SDTEMPLATE; | 1607 pGRD->GBTEMPLATE = SDTEMPLATE; |
1626 pGRD->TPGDON = 0; | 1608 pGRD->TPGDON = 0; |
1627 pGRD->USESKIP = 0; | 1609 pGRD->USESKIP = 0; |
1628 pGRD->GBAT[0] = SDAT[0]; | 1610 pGRD->GBAT[0] = SDAT[0]; |
1629 pGRD->GBAT[1] = SDAT[1]; | 1611 pGRD->GBAT[1] = SDAT[1]; |
1630 pGRD->GBAT[2] = SDAT[2]; | 1612 pGRD->GBAT[2] = SDAT[2]; |
1631 pGRD->GBAT[3] = SDAT[3]; | 1613 pGRD->GBAT[3] = SDAT[3]; |
1632 pGRD->GBAT[4] = SDAT[4]; | 1614 pGRD->GBAT[4] = SDAT[4]; |
1633 pGRD->GBAT[5] = SDAT[5]; | 1615 pGRD->GBAT[5] = SDAT[5]; |
1634 pGRD->GBAT[6] = SDAT[6]; | 1616 pGRD->GBAT[6] = SDAT[6]; |
1635 pGRD->GBAT[7] = SDAT[7]; | 1617 pGRD->GBAT[7] = SDAT[7]; |
1636 BS = pGRD->decode_Arith(pArithDecoder, gbContext); | 1618 BS = pGRD->decode_Arith(pArithDecoder, gbContext); |
1637 if (BS == NULL) { | 1619 if (BS == NULL) { |
1638 delete pGRD; | 1620 delete pGRD; |
1639 goto failed; | 1621 goto failed; |
1640 } | 1622 } |
1641 delete pGRD; | 1623 delete pGRD; |
1642 } else { | 1624 } else { |
1643 if (IAAI->decode(pArithDecoder, (int*)&REFAGGNINST) == -1) { | 1625 if (IAAI->decode(pArithDecoder, (int*)&REFAGGNINST) == -1) { |
1644 goto failed; | 1626 goto failed; |
1645 } | 1627 } |
1646 if (REFAGGNINST > 1) { | 1628 if (REFAGGNINST > 1) { |
1647 CJBig2_TRDProc* pDecoder; | 1629 CJBig2_TRDProc* pDecoder; |
1648 JBIG2_ALLOC(pDecoder, CJBig2_TRDProc()); | 1630 pDecoder = new CJBig2_TRDProc(); |
1649 pDecoder->SBHUFF = SDHUFF; | 1631 pDecoder->SBHUFF = SDHUFF; |
1650 pDecoder->SBREFINE = 1; | 1632 pDecoder->SBREFINE = 1; |
1651 pDecoder->SBW = SYMWIDTH; | 1633 pDecoder->SBW = SYMWIDTH; |
1652 pDecoder->SBH = HCHEIGHT; | 1634 pDecoder->SBH = HCHEIGHT; |
1653 pDecoder->SBNUMINSTANCES = REFAGGNINST; | 1635 pDecoder->SBNUMINSTANCES = REFAGGNINST; |
1654 pDecoder->SBSTRIPS = 1; | 1636 pDecoder->SBSTRIPS = 1; |
1655 pDecoder->SBNUMSYMS = SDNUMINSYMS + NSYMSDECODED; | 1637 pDecoder->SBNUMSYMS = SDNUMINSYMS + NSYMSDECODED; |
1656 SBNUMSYMS = pDecoder->SBNUMSYMS; | 1638 SBNUMSYMS = pDecoder->SBNUMSYMS; |
1657 nTmp = 0; | 1639 nTmp = 0; |
1658 while ((FX_DWORD)(1 << nTmp) < SBNUMSYMS) { | 1640 while ((FX_DWORD)(1 << nTmp) < SBNUMSYMS) { |
1659 nTmp++; | 1641 nTmp++; |
1660 } | 1642 } |
1661 SBSYMCODELEN = (uint8_t)nTmp; | 1643 SBSYMCODELEN = (uint8_t)nTmp; |
1662 pDecoder->SBSYMCODELEN = SBSYMCODELEN; | 1644 pDecoder->SBSYMCODELEN = SBSYMCODELEN; |
1663 SBSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2( | 1645 SBSYMS = FX_Alloc(CJBig2_Image*, SBNUMSYMS); |
1664 SBNUMSYMS, sizeof(CJBig2_Image*)); | |
1665 JBIG2_memcpy(SBSYMS, SDINSYMS, SDNUMINSYMS * sizeof(CJBig2_Image*)); | 1646 JBIG2_memcpy(SBSYMS, SDINSYMS, SDNUMINSYMS * sizeof(CJBig2_Image*)); |
1666 JBIG2_memcpy(SBSYMS + SDNUMINSYMS, SDNEWSYMS, | 1647 JBIG2_memcpy(SBSYMS + SDNUMINSYMS, SDNEWSYMS, |
1667 NSYMSDECODED * sizeof(CJBig2_Image*)); | 1648 NSYMSDECODED * sizeof(CJBig2_Image*)); |
1668 pDecoder->SBSYMS = SBSYMS; | 1649 pDecoder->SBSYMS = SBSYMS; |
1669 pDecoder->SBDEFPIXEL = 0; | 1650 pDecoder->SBDEFPIXEL = 0; |
1670 pDecoder->SBCOMBOP = JBIG2_COMPOSE_OR; | 1651 pDecoder->SBCOMBOP = JBIG2_COMPOSE_OR; |
1671 pDecoder->TRANSPOSED = 0; | 1652 pDecoder->TRANSPOSED = 0; |
1672 pDecoder->REFCORNER = JBIG2_CORNER_TOPLEFT; | 1653 pDecoder->REFCORNER = JBIG2_CORNER_TOPLEFT; |
1673 pDecoder->SBDSOFFSET = 0; | 1654 pDecoder->SBDSOFFSET = 0; |
1674 SBHUFFFS = new CJBig2_HuffmanTable(HuffmanTable_B6, | 1655 SBHUFFFS = new CJBig2_HuffmanTable(HuffmanTable_B6, |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1714 ids.IADS = IADS; | 1695 ids.IADS = IADS; |
1715 ids.IAIT = IAIT; | 1696 ids.IAIT = IAIT; |
1716 ids.IARI = IARI; | 1697 ids.IARI = IARI; |
1717 ids.IARDW = IARDW; | 1698 ids.IARDW = IARDW; |
1718 ids.IARDH = IARDH; | 1699 ids.IARDH = IARDH; |
1719 ids.IARDX = IARDX; | 1700 ids.IARDX = IARDX; |
1720 ids.IARDY = IARDY; | 1701 ids.IARDY = IARDY; |
1721 ids.IAID = IAID; | 1702 ids.IAID = IAID; |
1722 BS = pDecoder->decode_Arith(pArithDecoder, grContext, &ids); | 1703 BS = pDecoder->decode_Arith(pArithDecoder, grContext, &ids); |
1723 if (BS == NULL) { | 1704 if (BS == NULL) { |
1724 m_pModule->JBig2_Free(SBSYMS); | 1705 FX_Free(SBSYMS); |
1725 delete SBHUFFFS; | 1706 delete SBHUFFFS; |
1726 delete SBHUFFDS; | 1707 delete SBHUFFDS; |
1727 delete SBHUFFDT; | 1708 delete SBHUFFDT; |
1728 delete SBHUFFRDW; | 1709 delete SBHUFFRDW; |
1729 delete SBHUFFRDH; | 1710 delete SBHUFFRDH; |
1730 delete SBHUFFRDX; | 1711 delete SBHUFFRDX; |
1731 delete SBHUFFRDY; | 1712 delete SBHUFFRDY; |
1732 delete SBHUFFRSIZE; | 1713 delete SBHUFFRSIZE; |
1733 delete pDecoder; | 1714 delete pDecoder; |
1734 goto failed; | 1715 goto failed; |
1735 } | 1716 } |
1736 m_pModule->JBig2_Free(SBSYMS); | 1717 FX_Free(SBSYMS); |
1737 delete SBHUFFFS; | 1718 delete SBHUFFFS; |
1738 delete SBHUFFDS; | 1719 delete SBHUFFDS; |
1739 delete SBHUFFDT; | 1720 delete SBHUFFDT; |
1740 delete SBHUFFRDW; | 1721 delete SBHUFFRDW; |
1741 delete SBHUFFRDH; | 1722 delete SBHUFFRDH; |
1742 delete SBHUFFRDX; | 1723 delete SBHUFFRDX; |
1743 delete SBHUFFRDY; | 1724 delete SBHUFFRDY; |
1744 delete SBHUFFRSIZE; | 1725 delete SBHUFFRSIZE; |
1745 delete pDecoder; | 1726 delete pDecoder; |
1746 } else if (REFAGGNINST == 1) { | 1727 } else if (REFAGGNINST == 1) { |
1747 SBNUMSYMS = SDNUMINSYMS + NSYMSDECODED; | 1728 SBNUMSYMS = SDNUMINSYMS + NSYMSDECODED; |
1748 if (IAID->decode(pArithDecoder, (int*)&IDI) == -1) { | 1729 if (IAID->decode(pArithDecoder, (int*)&IDI) == -1) { |
1749 goto failed; | 1730 goto failed; |
1750 } | 1731 } |
1751 if ((IARDX->decode(pArithDecoder, &RDXI) == -1) || | 1732 if ((IARDX->decode(pArithDecoder, &RDXI) == -1) || |
1752 (IARDY->decode(pArithDecoder, &RDYI) == -1)) { | 1733 (IARDY->decode(pArithDecoder, &RDYI) == -1)) { |
1753 goto failed; | 1734 goto failed; |
1754 } | 1735 } |
1755 if (IDI >= SBNUMSYMS) { | 1736 if (IDI >= SBNUMSYMS) { |
1756 goto failed; | 1737 goto failed; |
1757 } | 1738 } |
1758 SBSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2( | 1739 SBSYMS = FX_Alloc(CJBig2_Image*, SBNUMSYMS); |
1759 SBNUMSYMS, sizeof(CJBig2_Image*)); | |
1760 JBIG2_memcpy(SBSYMS, SDINSYMS, SDNUMINSYMS * sizeof(CJBig2_Image*)); | 1740 JBIG2_memcpy(SBSYMS, SDINSYMS, SDNUMINSYMS * sizeof(CJBig2_Image*)); |
1761 JBIG2_memcpy(SBSYMS + SDNUMINSYMS, SDNEWSYMS, | 1741 JBIG2_memcpy(SBSYMS + SDNUMINSYMS, SDNEWSYMS, |
1762 NSYMSDECODED * sizeof(CJBig2_Image*)); | 1742 NSYMSDECODED * sizeof(CJBig2_Image*)); |
1763 if (!SBSYMS[IDI]) { | 1743 if (!SBSYMS[IDI]) { |
1764 m_pModule->JBig2_Free(SBSYMS); | 1744 FX_Free(SBSYMS); |
1765 goto failed; | 1745 goto failed; |
1766 } | 1746 } |
1767 JBIG2_ALLOC(pGRRD, CJBig2_GRRDProc()); | 1747 pGRRD = new CJBig2_GRRDProc(); |
1768 pGRRD->GRW = SYMWIDTH; | 1748 pGRRD->GRW = SYMWIDTH; |
1769 pGRRD->GRH = HCHEIGHT; | 1749 pGRRD->GRH = HCHEIGHT; |
1770 pGRRD->GRTEMPLATE = SDRTEMPLATE; | 1750 pGRRD->GRTEMPLATE = SDRTEMPLATE; |
1771 pGRRD->GRREFERENCE = SBSYMS[IDI]; | 1751 pGRRD->GRREFERENCE = SBSYMS[IDI]; |
1772 pGRRD->GRREFERENCEDX = RDXI; | 1752 pGRRD->GRREFERENCEDX = RDXI; |
1773 pGRRD->GRREFERENCEDY = RDYI; | 1753 pGRRD->GRREFERENCEDY = RDYI; |
1774 pGRRD->TPGRON = 0; | 1754 pGRRD->TPGRON = 0; |
1775 pGRRD->GRAT[0] = SDRAT[0]; | 1755 pGRRD->GRAT[0] = SDRAT[0]; |
1776 pGRRD->GRAT[1] = SDRAT[1]; | 1756 pGRRD->GRAT[1] = SDRAT[1]; |
1777 pGRRD->GRAT[2] = SDRAT[2]; | 1757 pGRRD->GRAT[2] = SDRAT[2]; |
1778 pGRRD->GRAT[3] = SDRAT[3]; | 1758 pGRRD->GRAT[3] = SDRAT[3]; |
1779 BS = pGRRD->decode(pArithDecoder, grContext); | 1759 BS = pGRRD->decode(pArithDecoder, grContext); |
1780 if (BS == NULL) { | 1760 if (BS == NULL) { |
1781 m_pModule->JBig2_Free(SBSYMS); | 1761 FX_Free(SBSYMS); |
1782 delete pGRRD; | 1762 delete pGRRD; |
1783 goto failed; | 1763 goto failed; |
1784 } | 1764 } |
1785 m_pModule->JBig2_Free(SBSYMS); | 1765 FX_Free(SBSYMS); |
1786 delete pGRRD; | 1766 delete pGRRD; |
1787 } | 1767 } |
1788 } | 1768 } |
1789 SDNEWSYMS[NSYMSDECODED] = BS; | 1769 SDNEWSYMS[NSYMSDECODED] = BS; |
1790 BS = NULL; | 1770 BS = NULL; |
1791 NSYMSDECODED = NSYMSDECODED + 1; | 1771 NSYMSDECODED = NSYMSDECODED + 1; |
1792 } | 1772 } |
1793 } | 1773 } |
1794 EXINDEX = 0; | 1774 EXINDEX = 0; |
1795 CUREXFLAG = 0; | 1775 CUREXFLAG = 0; |
1796 EXFLAGS = (FX_BOOL*)m_pModule->JBig2_Malloc2(sizeof(FX_BOOL), | 1776 EXFLAGS = FX_Alloc(FX_BOOL, SDNUMINSYMS + SDNUMNEWSYMS); |
1797 (SDNUMINSYMS + SDNUMNEWSYMS)); | |
1798 while (EXINDEX < SDNUMINSYMS + SDNUMNEWSYMS) { | 1777 while (EXINDEX < SDNUMINSYMS + SDNUMNEWSYMS) { |
1799 if (IAEX->decode(pArithDecoder, (int*)&EXRUNLENGTH) == -1) { | 1778 if (IAEX->decode(pArithDecoder, (int*)&EXRUNLENGTH) == -1) { |
1800 m_pModule->JBig2_Free(EXFLAGS); | 1779 FX_Free(EXFLAGS); |
1801 goto failed; | 1780 goto failed; |
1802 } | 1781 } |
1803 if (EXINDEX + EXRUNLENGTH > SDNUMINSYMS + SDNUMNEWSYMS) { | 1782 if (EXINDEX + EXRUNLENGTH > SDNUMINSYMS + SDNUMNEWSYMS) { |
1804 m_pModule->JBig2_Free(EXFLAGS); | 1783 FX_Free(EXFLAGS); |
1805 goto failed; | 1784 goto failed; |
1806 } | 1785 } |
1807 if (EXRUNLENGTH != 0) { | 1786 if (EXRUNLENGTH != 0) { |
1808 for (I = EXINDEX; I < EXINDEX + EXRUNLENGTH; I++) { | 1787 for (I = EXINDEX; I < EXINDEX + EXRUNLENGTH; I++) { |
1809 EXFLAGS[I] = CUREXFLAG; | 1788 EXFLAGS[I] = CUREXFLAG; |
1810 } | 1789 } |
1811 } | 1790 } |
1812 EXINDEX = EXINDEX + EXRUNLENGTH; | 1791 EXINDEX = EXINDEX + EXRUNLENGTH; |
1813 CUREXFLAG = !CUREXFLAG; | 1792 CUREXFLAG = !CUREXFLAG; |
1814 } | 1793 } |
1815 JBIG2_ALLOC(pDict, CJBig2_SymbolDict()); | 1794 pDict = new CJBig2_SymbolDict(); |
1816 pDict->SDNUMEXSYMS = SDNUMEXSYMS; | 1795 pDict->SDNUMEXSYMS = SDNUMEXSYMS; |
1817 pDict->SDEXSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2( | 1796 pDict->SDEXSYMS = FX_Alloc(CJBig2_Image*, SDNUMEXSYMS); |
1818 sizeof(CJBig2_Image*), SDNUMEXSYMS); | |
1819 I = J = 0; | 1797 I = J = 0; |
1820 for (I = 0; I < SDNUMINSYMS + SDNUMNEWSYMS; I++) { | 1798 for (I = 0; I < SDNUMINSYMS + SDNUMNEWSYMS; I++) { |
1821 if (EXFLAGS[I] && J < SDNUMEXSYMS) { | 1799 if (EXFLAGS[I] && J < SDNUMEXSYMS) { |
1822 if (I < SDNUMINSYMS) { | 1800 if (I < SDNUMINSYMS) { |
1823 JBIG2_ALLOC(pDict->SDEXSYMS[J], CJBig2_Image(*SDINSYMS[I])); | 1801 pDict->SDEXSYMS[J] = new CJBig2_Image(*SDINSYMS[I]); |
1824 } else { | 1802 } else { |
1825 pDict->SDEXSYMS[J] = SDNEWSYMS[I - SDNUMINSYMS]; | 1803 pDict->SDEXSYMS[J] = SDNEWSYMS[I - SDNUMINSYMS]; |
1826 } | 1804 } |
1827 J = J + 1; | 1805 J = J + 1; |
1828 } else if (!EXFLAGS[I] && I >= SDNUMINSYMS) { | 1806 } else if (!EXFLAGS[I] && I >= SDNUMINSYMS) { |
1829 delete SDNEWSYMS[I - SDNUMINSYMS]; | 1807 delete SDNEWSYMS[I - SDNUMINSYMS]; |
1830 } | 1808 } |
1831 } | 1809 } |
1832 if (J < SDNUMEXSYMS) { | 1810 if (J < SDNUMEXSYMS) { |
1833 pDict->SDNUMEXSYMS = J; | 1811 pDict->SDNUMEXSYMS = J; |
1834 } | 1812 } |
1835 m_pModule->JBig2_Free(EXFLAGS); | 1813 FX_Free(EXFLAGS); |
1836 m_pModule->JBig2_Free(SDNEWSYMS); | 1814 FX_Free(SDNEWSYMS); |
1837 delete IADH; | 1815 delete IADH; |
1838 delete IADW; | 1816 delete IADW; |
1839 delete IAAI; | 1817 delete IAAI; |
1840 delete IARDX; | 1818 delete IARDX; |
1841 delete IARDY; | 1819 delete IARDY; |
1842 delete IAEX; | 1820 delete IAEX; |
1843 delete IAID; | 1821 delete IAID; |
1844 delete IADT; | 1822 delete IADT; |
1845 delete IAFS; | 1823 delete IAFS; |
1846 delete IADS; | 1824 delete IADS; |
1847 delete IAIT; | 1825 delete IAIT; |
1848 delete IARI; | 1826 delete IARI; |
1849 delete IARDW; | 1827 delete IARDW; |
1850 delete IARDH; | 1828 delete IARDH; |
1851 return pDict; | 1829 return pDict; |
1852 failed: | 1830 failed: |
1853 for (I = 0; I < NSYMSDECODED; I++) { | 1831 for (I = 0; I < NSYMSDECODED; I++) { |
1854 if (SDNEWSYMS[I]) { | 1832 if (SDNEWSYMS[I]) { |
1855 delete SDNEWSYMS[I]; | 1833 delete SDNEWSYMS[I]; |
1856 SDNEWSYMS[I] = NULL; | 1834 SDNEWSYMS[I] = NULL; |
1857 } | 1835 } |
1858 } | 1836 } |
1859 m_pModule->JBig2_Free(SDNEWSYMS); | 1837 FX_Free(SDNEWSYMS); |
1860 delete IADH; | 1838 delete IADH; |
1861 delete IADW; | 1839 delete IADW; |
1862 delete IAAI; | 1840 delete IAAI; |
1863 delete IARDX; | 1841 delete IARDX; |
1864 delete IARDY; | 1842 delete IARDY; |
1865 delete IAEX; | 1843 delete IAEX; |
1866 delete IAID; | 1844 delete IAID; |
1867 delete IADT; | 1845 delete IADT; |
1868 delete IAFS; | 1846 delete IAFS; |
1869 delete IADS; | 1847 delete IADS; |
(...skipping 30 matching lines...) Expand all Loading... |
1900 FX_DWORD stride; | 1878 FX_DWORD stride; |
1901 CJBig2_Image** SBSYMS; | 1879 CJBig2_Image** SBSYMS; |
1902 CJBig2_HuffmanTable *SBHUFFFS, *SBHUFFDS, *SBHUFFDT, *SBHUFFRDW, *SBHUFFRDH, | 1880 CJBig2_HuffmanTable *SBHUFFFS, *SBHUFFDS, *SBHUFFDT, *SBHUFFRDW, *SBHUFFRDH, |
1903 *SBHUFFRDX, *SBHUFFRDY, *SBHUFFRSIZE, *pTable; | 1881 *SBHUFFRDX, *SBHUFFRDY, *SBHUFFRSIZE, *pTable; |
1904 CJBig2_HuffmanDecoder* pHuffmanDecoder; | 1882 CJBig2_HuffmanDecoder* pHuffmanDecoder; |
1905 CJBig2_GRRDProc* pGRRD; | 1883 CJBig2_GRRDProc* pGRRD; |
1906 CJBig2_ArithDecoder* pArithDecoder; | 1884 CJBig2_ArithDecoder* pArithDecoder; |
1907 CJBig2_GRDProc* pGRD; | 1885 CJBig2_GRDProc* pGRD; |
1908 CJBig2_SymbolDict* pDict; | 1886 CJBig2_SymbolDict* pDict; |
1909 pHuffmanDecoder = new CJBig2_HuffmanDecoder(pStream); | 1887 pHuffmanDecoder = new CJBig2_HuffmanDecoder(pStream); |
1910 SDNEWSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(SDNUMNEWSYMS, | 1888 SDNEWSYMS = FX_Alloc(CJBig2_Image*, SDNUMNEWSYMS); |
1911 sizeof(CJBig2_Image*)); | |
1912 FXSYS_memset(SDNEWSYMS, 0, SDNUMNEWSYMS * sizeof(CJBig2_Image*)); | 1889 FXSYS_memset(SDNEWSYMS, 0, SDNUMNEWSYMS * sizeof(CJBig2_Image*)); |
1913 SDNEWSYMWIDTHS = NULL; | 1890 SDNEWSYMWIDTHS = NULL; |
1914 BHC = NULL; | 1891 BHC = NULL; |
1915 if (SDREFAGG == 0) { | 1892 if (SDREFAGG == 0) { |
1916 SDNEWSYMWIDTHS = | 1893 SDNEWSYMWIDTHS = FX_Alloc(FX_DWORD, SDNUMNEWSYMS); |
1917 (FX_DWORD*)m_pModule->JBig2_Malloc2(SDNUMNEWSYMS, sizeof(FX_DWORD)); | |
1918 FXSYS_memset(SDNEWSYMWIDTHS, 0, SDNUMNEWSYMS * sizeof(FX_DWORD)); | 1894 FXSYS_memset(SDNEWSYMWIDTHS, 0, SDNUMNEWSYMS * sizeof(FX_DWORD)); |
1919 } | 1895 } |
1920 HCHEIGHT = 0; | 1896 HCHEIGHT = 0; |
1921 NSYMSDECODED = 0; | 1897 NSYMSDECODED = 0; |
1922 BS = NULL; | 1898 BS = NULL; |
1923 while (NSYMSDECODED < SDNUMNEWSYMS) { | 1899 while (NSYMSDECODED < SDNUMNEWSYMS) { |
1924 if (pHuffmanDecoder->decodeAValue(SDHUFFDH, &HCDH) != 0) { | 1900 if (pHuffmanDecoder->decodeAValue(SDHUFFDH, &HCDH) != 0) { |
1925 goto failed; | 1901 goto failed; |
1926 } | 1902 } |
1927 HCHEIGHT = HCHEIGHT + HCDH; | 1903 HCHEIGHT = HCHEIGHT + HCDH; |
(...skipping 24 matching lines...) Expand all Loading... |
1952 } | 1928 } |
1953 TOTWIDTH = TOTWIDTH + SYMWIDTH; | 1929 TOTWIDTH = TOTWIDTH + SYMWIDTH; |
1954 } | 1930 } |
1955 if (SDREFAGG == 1) { | 1931 if (SDREFAGG == 1) { |
1956 if (pHuffmanDecoder->decodeAValue(SDHUFFAGGINST, (int*)&REFAGGNINST) != | 1932 if (pHuffmanDecoder->decodeAValue(SDHUFFAGGINST, (int*)&REFAGGNINST) != |
1957 0) { | 1933 0) { |
1958 goto failed; | 1934 goto failed; |
1959 } | 1935 } |
1960 BS = NULL; | 1936 BS = NULL; |
1961 if (REFAGGNINST > 1) { | 1937 if (REFAGGNINST > 1) { |
1962 CJBig2_TRDProc* pDecoder; | 1938 CJBig2_TRDProc* pDecoder = new CJBig2_TRDProc(); |
1963 JBIG2_ALLOC(pDecoder, CJBig2_TRDProc()); | |
1964 pDecoder->SBHUFF = SDHUFF; | 1939 pDecoder->SBHUFF = SDHUFF; |
1965 pDecoder->SBREFINE = 1; | 1940 pDecoder->SBREFINE = 1; |
1966 pDecoder->SBW = SYMWIDTH; | 1941 pDecoder->SBW = SYMWIDTH; |
1967 pDecoder->SBH = HCHEIGHT; | 1942 pDecoder->SBH = HCHEIGHT; |
1968 pDecoder->SBNUMINSTANCES = REFAGGNINST; | 1943 pDecoder->SBNUMINSTANCES = REFAGGNINST; |
1969 pDecoder->SBSTRIPS = 1; | 1944 pDecoder->SBSTRIPS = 1; |
1970 pDecoder->SBNUMSYMS = SDNUMINSYMS + NSYMSDECODED; | 1945 pDecoder->SBNUMSYMS = SDNUMINSYMS + NSYMSDECODED; |
1971 SBNUMSYMS = pDecoder->SBNUMSYMS; | 1946 SBNUMSYMS = pDecoder->SBNUMSYMS; |
1972 SBSYMCODES = (JBig2HuffmanCode*)m_pModule->JBig2_Malloc2( | 1947 SBSYMCODES = FX_Alloc(JBig2HuffmanCode, SBNUMSYMS); |
1973 SBNUMSYMS, sizeof(JBig2HuffmanCode)); | |
1974 nTmp = 1; | 1948 nTmp = 1; |
1975 while ((FX_DWORD)(1 << nTmp) < SBNUMSYMS) { | 1949 while ((FX_DWORD)(1 << nTmp) < SBNUMSYMS) { |
1976 nTmp++; | 1950 nTmp++; |
1977 } | 1951 } |
1978 for (I = 0; I < SBNUMSYMS; I++) { | 1952 for (I = 0; I < SBNUMSYMS; I++) { |
1979 SBSYMCODES[I].codelen = nTmp; | 1953 SBSYMCODES[I].codelen = nTmp; |
1980 SBSYMCODES[I].code = I; | 1954 SBSYMCODES[I].code = I; |
1981 } | 1955 } |
1982 pDecoder->SBSYMCODES = SBSYMCODES; | 1956 pDecoder->SBSYMCODES = SBSYMCODES; |
1983 SBSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2( | 1957 SBSYMS = FX_Alloc(CJBig2_Image*, SBNUMSYMS); |
1984 SBNUMSYMS, sizeof(CJBig2_Image*)); | |
1985 JBIG2_memcpy(SBSYMS, SDINSYMS, SDNUMINSYMS * sizeof(CJBig2_Image*)); | 1958 JBIG2_memcpy(SBSYMS, SDINSYMS, SDNUMINSYMS * sizeof(CJBig2_Image*)); |
1986 JBIG2_memcpy(SBSYMS + SDNUMINSYMS, SDNEWSYMS, | 1959 JBIG2_memcpy(SBSYMS + SDNUMINSYMS, SDNEWSYMS, |
1987 NSYMSDECODED * sizeof(CJBig2_Image*)); | 1960 NSYMSDECODED * sizeof(CJBig2_Image*)); |
1988 pDecoder->SBSYMS = SBSYMS; | 1961 pDecoder->SBSYMS = SBSYMS; |
1989 pDecoder->SBDEFPIXEL = 0; | 1962 pDecoder->SBDEFPIXEL = 0; |
1990 pDecoder->SBCOMBOP = JBIG2_COMPOSE_OR; | 1963 pDecoder->SBCOMBOP = JBIG2_COMPOSE_OR; |
1991 pDecoder->TRANSPOSED = 0; | 1964 pDecoder->TRANSPOSED = 0; |
1992 pDecoder->REFCORNER = JBIG2_CORNER_TOPLEFT; | 1965 pDecoder->REFCORNER = JBIG2_CORNER_TOPLEFT; |
1993 pDecoder->SBDSOFFSET = 0; | 1966 pDecoder->SBDSOFFSET = 0; |
1994 SBHUFFFS = new CJBig2_HuffmanTable(HuffmanTable_B6, | 1967 SBHUFFFS = new CJBig2_HuffmanTable(HuffmanTable_B6, |
(...skipping 28 matching lines...) Expand all Loading... |
2023 pDecoder->SBHUFFRDX = SBHUFFRDX; | 1996 pDecoder->SBHUFFRDX = SBHUFFRDX; |
2024 pDecoder->SBHUFFRDY = SBHUFFRDY; | 1997 pDecoder->SBHUFFRDY = SBHUFFRDY; |
2025 pDecoder->SBHUFFRSIZE = SBHUFFRSIZE; | 1998 pDecoder->SBHUFFRSIZE = SBHUFFRSIZE; |
2026 pDecoder->SBRTEMPLATE = SDRTEMPLATE; | 1999 pDecoder->SBRTEMPLATE = SDRTEMPLATE; |
2027 pDecoder->SBRAT[0] = SDRAT[0]; | 2000 pDecoder->SBRAT[0] = SDRAT[0]; |
2028 pDecoder->SBRAT[1] = SDRAT[1]; | 2001 pDecoder->SBRAT[1] = SDRAT[1]; |
2029 pDecoder->SBRAT[2] = SDRAT[2]; | 2002 pDecoder->SBRAT[2] = SDRAT[2]; |
2030 pDecoder->SBRAT[3] = SDRAT[3]; | 2003 pDecoder->SBRAT[3] = SDRAT[3]; |
2031 BS = pDecoder->decode_Huffman(pStream, grContext); | 2004 BS = pDecoder->decode_Huffman(pStream, grContext); |
2032 if (BS == NULL) { | 2005 if (BS == NULL) { |
2033 m_pModule->JBig2_Free(SBSYMCODES); | 2006 FX_Free(SBSYMCODES); |
2034 m_pModule->JBig2_Free(SBSYMS); | 2007 FX_Free(SBSYMS); |
2035 delete SBHUFFFS; | 2008 delete SBHUFFFS; |
2036 delete SBHUFFDS; | 2009 delete SBHUFFDS; |
2037 delete SBHUFFDT; | 2010 delete SBHUFFDT; |
2038 delete SBHUFFRDW; | 2011 delete SBHUFFRDW; |
2039 delete SBHUFFRDH; | 2012 delete SBHUFFRDH; |
2040 delete SBHUFFRDX; | 2013 delete SBHUFFRDX; |
2041 delete SBHUFFRDY; | 2014 delete SBHUFFRDY; |
2042 delete SBHUFFRSIZE; | 2015 delete SBHUFFRSIZE; |
2043 delete pDecoder; | 2016 delete pDecoder; |
2044 goto failed; | 2017 goto failed; |
2045 } | 2018 } |
2046 m_pModule->JBig2_Free(SBSYMCODES); | 2019 FX_Free(SBSYMCODES); |
2047 m_pModule->JBig2_Free(SBSYMS); | 2020 FX_Free(SBSYMS); |
2048 delete SBHUFFFS; | 2021 delete SBHUFFFS; |
2049 delete SBHUFFDS; | 2022 delete SBHUFFDS; |
2050 delete SBHUFFDT; | 2023 delete SBHUFFDT; |
2051 delete SBHUFFRDW; | 2024 delete SBHUFFRDW; |
2052 delete SBHUFFRDH; | 2025 delete SBHUFFRDH; |
2053 delete SBHUFFRDX; | 2026 delete SBHUFFRDX; |
2054 delete SBHUFFRDY; | 2027 delete SBHUFFRDY; |
2055 delete SBHUFFRSIZE; | 2028 delete SBHUFFRSIZE; |
2056 delete pDecoder; | 2029 delete pDecoder; |
2057 } else if (REFAGGNINST == 1) { | 2030 } else if (REFAGGNINST == 1) { |
2058 SBNUMSYMS = SDNUMINSYMS + SDNUMNEWSYMS; | 2031 SBNUMSYMS = SDNUMINSYMS + SDNUMNEWSYMS; |
2059 nTmp = 1; | 2032 nTmp = 1; |
2060 while ((FX_DWORD)(1 << nTmp) < SBNUMSYMS) { | 2033 while ((FX_DWORD)(1 << nTmp) < SBNUMSYMS) { |
2061 nTmp++; | 2034 nTmp++; |
2062 } | 2035 } |
2063 SBSYMCODELEN = (uint8_t)nTmp; | 2036 SBSYMCODELEN = (uint8_t)nTmp; |
2064 SBSYMCODES = (JBig2HuffmanCode*)m_pModule->JBig2_Malloc2( | 2037 SBSYMCODES = FX_Alloc(JBig2HuffmanCode, SBNUMSYMS); |
2065 SBNUMSYMS, sizeof(JBig2HuffmanCode)); | |
2066 for (I = 0; I < SBNUMSYMS; I++) { | 2038 for (I = 0; I < SBNUMSYMS; I++) { |
2067 SBSYMCODES[I].codelen = SBSYMCODELEN; | 2039 SBSYMCODES[I].codelen = SBSYMCODELEN; |
2068 SBSYMCODES[I].code = I; | 2040 SBSYMCODES[I].code = I; |
2069 } | 2041 } |
2070 nVal = 0; | 2042 nVal = 0; |
2071 nBits = 0; | 2043 nBits = 0; |
2072 for (;;) { | 2044 for (;;) { |
2073 if (pStream->read1Bit(&nTmp) != 0) { | 2045 if (pStream->read1Bit(&nTmp) != 0) { |
2074 m_pModule->JBig2_Free(SBSYMCODES); | 2046 FX_Free(SBSYMCODES); |
2075 goto failed; | 2047 goto failed; |
2076 } | 2048 } |
2077 nVal = (nVal << 1) | nTmp; | 2049 nVal = (nVal << 1) | nTmp; |
2078 for (IDI = 0; IDI < SBNUMSYMS; IDI++) { | 2050 for (IDI = 0; IDI < SBNUMSYMS; IDI++) { |
2079 if ((nVal == SBSYMCODES[IDI].code) && | 2051 if ((nVal == SBSYMCODES[IDI].code) && |
2080 (nBits == SBSYMCODES[IDI].codelen)) { | 2052 (nBits == SBSYMCODES[IDI].codelen)) { |
2081 break; | 2053 break; |
2082 } | 2054 } |
2083 } | 2055 } |
2084 if (IDI < SBNUMSYMS) { | 2056 if (IDI < SBNUMSYMS) { |
2085 break; | 2057 break; |
2086 } | 2058 } |
2087 } | 2059 } |
2088 m_pModule->JBig2_Free(SBSYMCODES); | 2060 FX_Free(SBSYMCODES); |
2089 SBHUFFRDX = new CJBig2_HuffmanTable(HuffmanTable_B15, | 2061 SBHUFFRDX = new CJBig2_HuffmanTable(HuffmanTable_B15, |
2090 FX_ArraySize(HuffmanTable_B15), | 2062 FX_ArraySize(HuffmanTable_B15), |
2091 HuffmanTable_HTOOB_B15); | 2063 HuffmanTable_HTOOB_B15); |
2092 SBHUFFRSIZE = new CJBig2_HuffmanTable(HuffmanTable_B1, | 2064 SBHUFFRSIZE = new CJBig2_HuffmanTable(HuffmanTable_B1, |
2093 FX_ArraySize(HuffmanTable_B1), | 2065 FX_ArraySize(HuffmanTable_B1), |
2094 HuffmanTable_HTOOB_B1); | 2066 HuffmanTable_HTOOB_B1); |
2095 if ((pHuffmanDecoder->decodeAValue(SBHUFFRDX, &RDXI) != 0) || | 2067 if ((pHuffmanDecoder->decodeAValue(SBHUFFRDX, &RDXI) != 0) || |
2096 (pHuffmanDecoder->decodeAValue(SBHUFFRDX, &RDYI) != 0) || | 2068 (pHuffmanDecoder->decodeAValue(SBHUFFRDX, &RDYI) != 0) || |
2097 (pHuffmanDecoder->decodeAValue(SBHUFFRSIZE, &nVal) != 0)) { | 2069 (pHuffmanDecoder->decodeAValue(SBHUFFRSIZE, &nVal) != 0)) { |
2098 delete SBHUFFRDX; | 2070 delete SBHUFFRDX; |
2099 delete SBHUFFRSIZE; | 2071 delete SBHUFFRSIZE; |
2100 goto failed; | 2072 goto failed; |
2101 } | 2073 } |
2102 delete SBHUFFRDX; | 2074 delete SBHUFFRDX; |
2103 delete SBHUFFRSIZE; | 2075 delete SBHUFFRSIZE; |
2104 pStream->alignByte(); | 2076 pStream->alignByte(); |
2105 nTmp = pStream->getOffset(); | 2077 nTmp = pStream->getOffset(); |
2106 SBSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2( | 2078 SBSYMS = FX_Alloc(CJBig2_Image*, SBNUMSYMS); |
2107 SBNUMSYMS, sizeof(CJBig2_Image*)); | |
2108 JBIG2_memcpy(SBSYMS, SDINSYMS, SDNUMINSYMS * sizeof(CJBig2_Image*)); | 2079 JBIG2_memcpy(SBSYMS, SDINSYMS, SDNUMINSYMS * sizeof(CJBig2_Image*)); |
2109 JBIG2_memcpy(SBSYMS + SDNUMINSYMS, SDNEWSYMS, | 2080 JBIG2_memcpy(SBSYMS + SDNUMINSYMS, SDNEWSYMS, |
2110 NSYMSDECODED * sizeof(CJBig2_Image*)); | 2081 NSYMSDECODED * sizeof(CJBig2_Image*)); |
2111 JBIG2_ALLOC(pGRRD, CJBig2_GRRDProc()); | 2082 pGRRD = new CJBig2_GRRDProc(); |
2112 pGRRD->GRW = SYMWIDTH; | 2083 pGRRD->GRW = SYMWIDTH; |
2113 pGRRD->GRH = HCHEIGHT; | 2084 pGRRD->GRH = HCHEIGHT; |
2114 pGRRD->GRTEMPLATE = SDRTEMPLATE; | 2085 pGRRD->GRTEMPLATE = SDRTEMPLATE; |
2115 pGRRD->GRREFERENCE = SBSYMS[IDI]; | 2086 pGRRD->GRREFERENCE = SBSYMS[IDI]; |
2116 pGRRD->GRREFERENCEDX = RDXI; | 2087 pGRRD->GRREFERENCEDX = RDXI; |
2117 pGRRD->GRREFERENCEDY = RDYI; | 2088 pGRRD->GRREFERENCEDY = RDYI; |
2118 pGRRD->TPGRON = 0; | 2089 pGRRD->TPGRON = 0; |
2119 pGRRD->GRAT[0] = SDRAT[0]; | 2090 pGRRD->GRAT[0] = SDRAT[0]; |
2120 pGRRD->GRAT[1] = SDRAT[1]; | 2091 pGRRD->GRAT[1] = SDRAT[1]; |
2121 pGRRD->GRAT[2] = SDRAT[2]; | 2092 pGRRD->GRAT[2] = SDRAT[2]; |
2122 pGRRD->GRAT[3] = SDRAT[3]; | 2093 pGRRD->GRAT[3] = SDRAT[3]; |
2123 pArithDecoder = new CJBig2_ArithDecoder(pStream); | 2094 pArithDecoder = new CJBig2_ArithDecoder(pStream); |
2124 BS = pGRRD->decode(pArithDecoder, grContext); | 2095 BS = pGRRD->decode(pArithDecoder, grContext); |
2125 if (BS == NULL) { | 2096 if (BS == NULL) { |
2126 m_pModule->JBig2_Free(SBSYMS); | 2097 FX_Free(SBSYMS); |
2127 delete pGRRD; | 2098 delete pGRRD; |
2128 delete pArithDecoder; | 2099 delete pArithDecoder; |
2129 goto failed; | 2100 goto failed; |
2130 } | 2101 } |
2131 pStream->alignByte(); | 2102 pStream->alignByte(); |
2132 pStream->offset(2); | 2103 pStream->offset(2); |
2133 if ((FX_DWORD)nVal != (pStream->getOffset() - nTmp)) { | 2104 if ((FX_DWORD)nVal != (pStream->getOffset() - nTmp)) { |
2134 delete BS; | 2105 delete BS; |
2135 m_pModule->JBig2_Free(SBSYMS); | 2106 FX_Free(SBSYMS); |
2136 delete pGRRD; | 2107 delete pGRRD; |
2137 delete pArithDecoder; | 2108 delete pArithDecoder; |
2138 goto failed; | 2109 goto failed; |
2139 } | 2110 } |
2140 m_pModule->JBig2_Free(SBSYMS); | 2111 FX_Free(SBSYMS); |
2141 delete pGRRD; | 2112 delete pGRRD; |
2142 delete pArithDecoder; | 2113 delete pArithDecoder; |
2143 } | 2114 } |
2144 SDNEWSYMS[NSYMSDECODED] = BS; | 2115 SDNEWSYMS[NSYMSDECODED] = BS; |
2145 } | 2116 } |
2146 if (SDREFAGG == 0) { | 2117 if (SDREFAGG == 0) { |
2147 SDNEWSYMWIDTHS[NSYMSDECODED] = SYMWIDTH; | 2118 SDNEWSYMWIDTHS[NSYMSDECODED] = SYMWIDTH; |
2148 } | 2119 } |
2149 NSYMSDECODED = NSYMSDECODED + 1; | 2120 NSYMSDECODED = NSYMSDECODED + 1; |
2150 } | 2121 } |
2151 if (SDREFAGG == 0) { | 2122 if (SDREFAGG == 0) { |
2152 if (pHuffmanDecoder->decodeAValue(SDHUFFBMSIZE, (int32_t*)&BMSIZE) != 0) { | 2123 if (pHuffmanDecoder->decodeAValue(SDHUFFBMSIZE, (int32_t*)&BMSIZE) != 0) { |
2153 goto failed; | 2124 goto failed; |
2154 } | 2125 } |
2155 pStream->alignByte(); | 2126 pStream->alignByte(); |
2156 if (BMSIZE == 0) { | 2127 if (BMSIZE == 0) { |
2157 stride = (TOTWIDTH + 7) >> 3; | 2128 stride = (TOTWIDTH + 7) >> 3; |
2158 if (pStream->getByteLeft() >= stride * HCHEIGHT) { | 2129 if (pStream->getByteLeft() >= stride * HCHEIGHT) { |
2159 JBIG2_ALLOC(BHC, CJBig2_Image(TOTWIDTH, HCHEIGHT)); | 2130 BHC = new CJBig2_Image(TOTWIDTH, HCHEIGHT); |
2160 for (I = 0; I < HCHEIGHT; I++) { | 2131 for (I = 0; I < HCHEIGHT; I++) { |
2161 JBIG2_memcpy(BHC->m_pData + I * BHC->m_nStride, | 2132 JBIG2_memcpy(BHC->m_pData + I * BHC->m_nStride, |
2162 pStream->getPointer(), stride); | 2133 pStream->getPointer(), stride); |
2163 pStream->offset(stride); | 2134 pStream->offset(stride); |
2164 } | 2135 } |
2165 } else { | 2136 } else { |
2166 goto failed; | 2137 goto failed; |
2167 } | 2138 } |
2168 } else { | 2139 } else { |
2169 JBIG2_ALLOC(pGRD, CJBig2_GRDProc()); | 2140 pGRD = new CJBig2_GRDProc(); |
2170 pGRD->MMR = 1; | 2141 pGRD->MMR = 1; |
2171 pGRD->GBW = TOTWIDTH; | 2142 pGRD->GBW = TOTWIDTH; |
2172 pGRD->GBH = HCHEIGHT; | 2143 pGRD->GBH = HCHEIGHT; |
2173 FXCODEC_STATUS status = pGRD->Start_decode_MMR(&BHC, pStream); | 2144 FXCODEC_STATUS status = pGRD->Start_decode_MMR(&BHC, pStream); |
2174 while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE) { | 2145 while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE) { |
2175 pGRD->Continue_decode(pPause); | 2146 pGRD->Continue_decode(pPause); |
2176 } | 2147 } |
2177 delete pGRD; | 2148 delete pGRD; |
2178 pStream->alignByte(); | 2149 pStream->alignByte(); |
2179 } | 2150 } |
2180 nTmp = 0; | 2151 nTmp = 0; |
2181 if (!BHC) { | 2152 if (!BHC) { |
2182 continue; | 2153 continue; |
2183 } | 2154 } |
2184 for (I = HCFIRSTSYM; I < NSYMSDECODED; I++) { | 2155 for (I = HCFIRSTSYM; I < NSYMSDECODED; I++) { |
2185 SDNEWSYMS[I] = BHC->subImage(nTmp, 0, SDNEWSYMWIDTHS[I], HCHEIGHT); | 2156 SDNEWSYMS[I] = BHC->subImage(nTmp, 0, SDNEWSYMWIDTHS[I], HCHEIGHT); |
2186 nTmp += SDNEWSYMWIDTHS[I]; | 2157 nTmp += SDNEWSYMWIDTHS[I]; |
2187 } | 2158 } |
2188 delete BHC; | 2159 delete BHC; |
2189 BHC = NULL; | 2160 BHC = NULL; |
2190 } | 2161 } |
2191 } | 2162 } |
2192 EXINDEX = 0; | 2163 EXINDEX = 0; |
2193 CUREXFLAG = 0; | 2164 CUREXFLAG = 0; |
2194 pTable = new CJBig2_HuffmanTable( | 2165 pTable = new CJBig2_HuffmanTable( |
2195 HuffmanTable_B1, FX_ArraySize(HuffmanTable_B1), HuffmanTable_HTOOB_B1); | 2166 HuffmanTable_B1, FX_ArraySize(HuffmanTable_B1), HuffmanTable_HTOOB_B1); |
2196 EXFLAGS = (FX_BOOL*)m_pModule->JBig2_Malloc2(sizeof(FX_BOOL), | 2167 EXFLAGS = FX_Alloc(FX_BOOL, SDNUMINSYMS + SDNUMNEWSYMS); |
2197 (SDNUMINSYMS + SDNUMNEWSYMS)); | |
2198 while (EXINDEX < SDNUMINSYMS + SDNUMNEWSYMS) { | 2168 while (EXINDEX < SDNUMINSYMS + SDNUMNEWSYMS) { |
2199 if (pHuffmanDecoder->decodeAValue(pTable, (int*)&EXRUNLENGTH) != 0) { | 2169 if (pHuffmanDecoder->decodeAValue(pTable, (int*)&EXRUNLENGTH) != 0) { |
2200 delete pTable; | 2170 delete pTable; |
2201 m_pModule->JBig2_Free(EXFLAGS); | 2171 FX_Free(EXFLAGS); |
2202 goto failed; | 2172 goto failed; |
2203 } | 2173 } |
2204 if (EXINDEX + EXRUNLENGTH > SDNUMINSYMS + SDNUMNEWSYMS) { | 2174 if (EXINDEX + EXRUNLENGTH > SDNUMINSYMS + SDNUMNEWSYMS) { |
2205 delete pTable; | 2175 delete pTable; |
2206 m_pModule->JBig2_Free(EXFLAGS); | 2176 FX_Free(EXFLAGS); |
2207 goto failed; | 2177 goto failed; |
2208 } | 2178 } |
2209 if (EXRUNLENGTH != 0) { | 2179 if (EXRUNLENGTH != 0) { |
2210 for (I = EXINDEX; I < EXINDEX + EXRUNLENGTH; I++) { | 2180 for (I = EXINDEX; I < EXINDEX + EXRUNLENGTH; I++) { |
2211 EXFLAGS[I] = CUREXFLAG; | 2181 EXFLAGS[I] = CUREXFLAG; |
2212 } | 2182 } |
2213 } | 2183 } |
2214 EXINDEX = EXINDEX + EXRUNLENGTH; | 2184 EXINDEX = EXINDEX + EXRUNLENGTH; |
2215 CUREXFLAG = !CUREXFLAG; | 2185 CUREXFLAG = !CUREXFLAG; |
2216 } | 2186 } |
2217 delete pTable; | 2187 delete pTable; |
2218 JBIG2_ALLOC(pDict, CJBig2_SymbolDict()); | 2188 pDict = new CJBig2_SymbolDict(); |
2219 pDict->SDNUMEXSYMS = SDNUMEXSYMS; | 2189 pDict->SDNUMEXSYMS = SDNUMEXSYMS; |
2220 pDict->SDEXSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2( | 2190 pDict->SDEXSYMS = FX_Alloc(CJBig2_Image*, SDNUMEXSYMS); |
2221 sizeof(CJBig2_Image*), SDNUMEXSYMS); | |
2222 I = J = 0; | 2191 I = J = 0; |
2223 for (I = 0; I < SDNUMINSYMS + SDNUMNEWSYMS; I++) { | 2192 for (I = 0; I < SDNUMINSYMS + SDNUMNEWSYMS; I++) { |
2224 if (EXFLAGS[I] && J < SDNUMEXSYMS) { | 2193 if (EXFLAGS[I] && J < SDNUMEXSYMS) { |
2225 if (I < SDNUMINSYMS) { | 2194 if (I < SDNUMINSYMS) { |
2226 JBIG2_ALLOC(pDict->SDEXSYMS[J], CJBig2_Image(*SDINSYMS[I])); | 2195 pDict->SDEXSYMS[J] = new CJBig2_Image(*SDINSYMS[I]); |
2227 } else { | 2196 } else { |
2228 pDict->SDEXSYMS[J] = SDNEWSYMS[I - SDNUMINSYMS]; | 2197 pDict->SDEXSYMS[J] = SDNEWSYMS[I - SDNUMINSYMS]; |
2229 } | 2198 } |
2230 J = J + 1; | 2199 J = J + 1; |
2231 } else if (!EXFLAGS[I] && I >= SDNUMINSYMS) { | 2200 } else if (!EXFLAGS[I] && I >= SDNUMINSYMS) { |
2232 delete SDNEWSYMS[I - SDNUMINSYMS]; | 2201 delete SDNEWSYMS[I - SDNUMINSYMS]; |
2233 } | 2202 } |
2234 } | 2203 } |
2235 if (J < SDNUMEXSYMS) { | 2204 if (J < SDNUMEXSYMS) { |
2236 pDict->SDNUMEXSYMS = J; | 2205 pDict->SDNUMEXSYMS = J; |
2237 } | 2206 } |
2238 m_pModule->JBig2_Free(EXFLAGS); | 2207 FX_Free(EXFLAGS); |
2239 m_pModule->JBig2_Free(SDNEWSYMS); | 2208 FX_Free(SDNEWSYMS); |
2240 if (SDREFAGG == 0) { | 2209 if (SDREFAGG == 0) { |
2241 m_pModule->JBig2_Free(SDNEWSYMWIDTHS); | 2210 FX_Free(SDNEWSYMWIDTHS); |
2242 } | 2211 } |
2243 delete pHuffmanDecoder; | 2212 delete pHuffmanDecoder; |
2244 return pDict; | 2213 return pDict; |
2245 failed: | 2214 failed: |
2246 for (I = 0; I < NSYMSDECODED; I++) { | 2215 for (I = 0; I < NSYMSDECODED; I++) { |
2247 delete SDNEWSYMS[I]; | 2216 delete SDNEWSYMS[I]; |
2248 } | 2217 } |
2249 m_pModule->JBig2_Free(SDNEWSYMS); | 2218 FX_Free(SDNEWSYMS); |
2250 if (SDREFAGG == 0) { | 2219 if (SDREFAGG == 0) { |
2251 m_pModule->JBig2_Free(SDNEWSYMWIDTHS); | 2220 FX_Free(SDNEWSYMWIDTHS); |
2252 } | 2221 } |
2253 delete pHuffmanDecoder; | 2222 delete pHuffmanDecoder; |
2254 return NULL; | 2223 return NULL; |
2255 } | 2224 } |
2256 CJBig2_Image* CJBig2_HTRDProc::decode_Arith(CJBig2_ArithDecoder* pArithDecoder, | 2225 CJBig2_Image* CJBig2_HTRDProc::decode_Arith(CJBig2_ArithDecoder* pArithDecoder, |
2257 JBig2ArithCtx* gbContext, | 2226 JBig2ArithCtx* gbContext, |
2258 IFX_Pause* pPause) { | 2227 IFX_Pause* pPause) { |
2259 FX_DWORD ng, mg; | 2228 FX_DWORD ng, mg; |
2260 int32_t x, y; | 2229 int32_t x, y; |
2261 CJBig2_Image* HSKIP; | |
2262 FX_DWORD HBPP; | 2230 FX_DWORD HBPP; |
2263 FX_DWORD* GI; | 2231 FX_DWORD* GI; |
2264 CJBig2_Image* HTREG; | 2232 CJBig2_Image* HSKIP = nullptr; |
2265 CJBig2_GSIDProc* pGID; | 2233 CJBig2_Image* HTREG = new CJBig2_Image(HBW, HBH); |
2266 JBIG2_ALLOC(HTREG, CJBig2_Image(HBW, HBH)); | |
2267 HTREG->fill(HDEFPIXEL); | 2234 HTREG->fill(HDEFPIXEL); |
2268 HSKIP = NULL; | |
2269 if (HENABLESKIP == 1) { | 2235 if (HENABLESKIP == 1) { |
2270 JBIG2_ALLOC(HSKIP, CJBig2_Image(HGW, HGH)); | 2236 HSKIP = new CJBig2_Image(HGW, HGH); |
2271 for (mg = 0; mg < HGH; mg++) { | 2237 for (mg = 0; mg < HGH; mg++) { |
2272 for (ng = 0; ng < HGW; ng++) { | 2238 for (ng = 0; ng < HGW; ng++) { |
2273 x = (HGX + mg * HRY + ng * HRX) >> 8; | 2239 x = (HGX + mg * HRY + ng * HRX) >> 8; |
2274 y = (HGY + mg * HRX - ng * HRY) >> 8; | 2240 y = (HGY + mg * HRX - ng * HRY) >> 8; |
2275 if ((x + HPW <= 0) | (x >= (int32_t)HBW) | (y + HPH <= 0) | | 2241 if ((x + HPW <= 0) | (x >= (int32_t)HBW) | (y + HPH <= 0) | |
2276 (y >= (int32_t)HPH)) { | 2242 (y >= (int32_t)HPH)) { |
2277 HSKIP->setPixel(ng, mg, 1); | 2243 HSKIP->setPixel(ng, mg, 1); |
2278 } else { | 2244 } else { |
2279 HSKIP->setPixel(ng, mg, 0); | 2245 HSKIP->setPixel(ng, mg, 0); |
2280 } | 2246 } |
2281 } | 2247 } |
2282 } | 2248 } |
2283 } | 2249 } |
2284 HBPP = 1; | 2250 HBPP = 1; |
2285 while ((FX_DWORD)(1 << HBPP) < HNUMPATS) { | 2251 while ((FX_DWORD)(1 << HBPP) < HNUMPATS) { |
2286 HBPP++; | 2252 HBPP++; |
2287 } | 2253 } |
2288 JBIG2_ALLOC(pGID, CJBig2_GSIDProc()); | 2254 CJBig2_GSIDProc* pGID = new CJBig2_GSIDProc(); |
2289 pGID->GSMMR = HMMR; | 2255 pGID->GSMMR = HMMR; |
2290 pGID->GSW = HGW; | 2256 pGID->GSW = HGW; |
2291 pGID->GSH = HGH; | 2257 pGID->GSH = HGH; |
2292 pGID->GSBPP = (uint8_t)HBPP; | 2258 pGID->GSBPP = (uint8_t)HBPP; |
2293 pGID->GSUSESKIP = HENABLESKIP; | 2259 pGID->GSUSESKIP = HENABLESKIP; |
2294 pGID->GSKIP = HSKIP; | 2260 pGID->GSKIP = HSKIP; |
2295 pGID->GSTEMPLATE = HTEMPLATE; | 2261 pGID->GSTEMPLATE = HTEMPLATE; |
2296 GI = pGID->decode_Arith(pArithDecoder, gbContext, pPause); | 2262 GI = pGID->decode_Arith(pArithDecoder, gbContext, pPause); |
2297 if (GI == NULL) { | 2263 if (GI == NULL) { |
2298 goto failed; | 2264 goto failed; |
2299 } | 2265 } |
2300 for (mg = 0; mg < HGH; mg++) { | 2266 for (mg = 0; mg < HGH; mg++) { |
2301 for (ng = 0; ng < HGW; ng++) { | 2267 for (ng = 0; ng < HGW; ng++) { |
2302 x = (HGX + mg * HRY + ng * HRX) >> 8; | 2268 x = (HGX + mg * HRY + ng * HRX) >> 8; |
2303 y = (HGY + mg * HRX - ng * HRY) >> 8; | 2269 y = (HGY + mg * HRX - ng * HRY) >> 8; |
2304 FX_DWORD pat_index = GI[mg * HGW + ng]; | 2270 FX_DWORD pat_index = GI[mg * HGW + ng]; |
2305 if (pat_index >= HNUMPATS) { | 2271 if (pat_index >= HNUMPATS) { |
2306 pat_index = HNUMPATS - 1; | 2272 pat_index = HNUMPATS - 1; |
2307 } | 2273 } |
2308 HTREG->composeFrom(x, y, HPATS[pat_index], HCOMBOP); | 2274 HTREG->composeFrom(x, y, HPATS[pat_index], HCOMBOP); |
2309 } | 2275 } |
2310 } | 2276 } |
2311 m_pModule->JBig2_Free(GI); | 2277 FX_Free(GI); |
2312 delete HSKIP; | 2278 delete HSKIP; |
2313 delete pGID; | 2279 delete pGID; |
2314 return HTREG; | 2280 return HTREG; |
2315 failed: | 2281 failed: |
2316 delete HSKIP; | 2282 delete HSKIP; |
2317 delete pGID; | 2283 delete pGID; |
2318 delete HTREG; | 2284 delete HTREG; |
2319 return NULL; | 2285 return NULL; |
2320 } | 2286 } |
2321 CJBig2_Image* CJBig2_HTRDProc::decode_MMR(CJBig2_BitStream* pStream, | 2287 CJBig2_Image* CJBig2_HTRDProc::decode_MMR(CJBig2_BitStream* pStream, |
2322 IFX_Pause* pPause) { | 2288 IFX_Pause* pPause) { |
2323 FX_DWORD ng, mg; | 2289 FX_DWORD ng, mg; |
2324 int32_t x, y; | 2290 int32_t x, y; |
2325 FX_DWORD HBPP; | |
2326 FX_DWORD* GI; | 2291 FX_DWORD* GI; |
2327 CJBig2_Image* HTREG; | 2292 CJBig2_Image* HTREG = new CJBig2_Image(HBW, HBH); |
2328 CJBig2_GSIDProc* pGID; | |
2329 JBIG2_ALLOC(HTREG, CJBig2_Image(HBW, HBH)); | |
2330 HTREG->fill(HDEFPIXEL); | 2293 HTREG->fill(HDEFPIXEL); |
2331 HBPP = 1; | 2294 FX_DWORD HBPP = 1; |
2332 while ((FX_DWORD)(1 << HBPP) < HNUMPATS) { | 2295 while ((FX_DWORD)(1 << HBPP) < HNUMPATS) { |
2333 HBPP++; | 2296 HBPP++; |
2334 } | 2297 } |
2335 JBIG2_ALLOC(pGID, CJBig2_GSIDProc()); | 2298 CJBig2_GSIDProc* pGID = new CJBig2_GSIDProc(); |
2336 pGID->GSMMR = HMMR; | 2299 pGID->GSMMR = HMMR; |
2337 pGID->GSW = HGW; | 2300 pGID->GSW = HGW; |
2338 pGID->GSH = HGH; | 2301 pGID->GSH = HGH; |
2339 pGID->GSBPP = (uint8_t)HBPP; | 2302 pGID->GSBPP = (uint8_t)HBPP; |
2340 pGID->GSUSESKIP = 0; | 2303 pGID->GSUSESKIP = 0; |
2341 GI = pGID->decode_MMR(pStream, pPause); | 2304 GI = pGID->decode_MMR(pStream, pPause); |
2342 if (GI == NULL) { | 2305 if (GI == NULL) { |
2343 goto failed; | 2306 goto failed; |
2344 } | 2307 } |
2345 for (mg = 0; mg < HGH; mg++) { | 2308 for (mg = 0; mg < HGH; mg++) { |
2346 for (ng = 0; ng < HGW; ng++) { | 2309 for (ng = 0; ng < HGW; ng++) { |
2347 x = (HGX + mg * HRY + ng * HRX) >> 8; | 2310 x = (HGX + mg * HRY + ng * HRX) >> 8; |
2348 y = (HGY + mg * HRX - ng * HRY) >> 8; | 2311 y = (HGY + mg * HRX - ng * HRY) >> 8; |
2349 FX_DWORD pat_index = GI[mg * HGW + ng]; | 2312 FX_DWORD pat_index = GI[mg * HGW + ng]; |
2350 if (pat_index >= HNUMPATS) { | 2313 if (pat_index >= HNUMPATS) { |
2351 pat_index = HNUMPATS - 1; | 2314 pat_index = HNUMPATS - 1; |
2352 } | 2315 } |
2353 HTREG->composeFrom(x, y, HPATS[pat_index], HCOMBOP); | 2316 HTREG->composeFrom(x, y, HPATS[pat_index], HCOMBOP); |
2354 } | 2317 } |
2355 } | 2318 } |
2356 m_pModule->JBig2_Free(GI); | 2319 FX_Free(GI); |
2357 delete pGID; | 2320 delete pGID; |
2358 return HTREG; | 2321 return HTREG; |
2359 failed: | 2322 failed: |
2360 delete pGID; | 2323 delete pGID; |
2361 delete HTREG; | 2324 delete HTREG; |
2362 return NULL; | 2325 return NULL; |
2363 } | 2326 } |
2364 CJBig2_PatternDict* CJBig2_PDDProc::decode_Arith( | 2327 CJBig2_PatternDict* CJBig2_PDDProc::decode_Arith( |
2365 CJBig2_ArithDecoder* pArithDecoder, | 2328 CJBig2_ArithDecoder* pArithDecoder, |
2366 JBig2ArithCtx* gbContext, | 2329 JBig2ArithCtx* gbContext, |
2367 IFX_Pause* pPause) { | 2330 IFX_Pause* pPause) { |
2368 FX_DWORD GRAY; | 2331 FX_DWORD GRAY; |
2369 CJBig2_Image* BHDC = NULL; | 2332 CJBig2_Image* BHDC = NULL; |
2370 CJBig2_PatternDict* pDict; | 2333 CJBig2_PatternDict* pDict = new CJBig2_PatternDict(); |
2371 CJBig2_GRDProc* pGRD; | |
2372 pDict = new CJBig2_PatternDict(); | |
2373 pDict->NUMPATS = GRAYMAX + 1; | 2334 pDict->NUMPATS = GRAYMAX + 1; |
2374 pDict->HDPATS = (CJBig2_Image**)m_pModule->JBig2_Malloc2( | 2335 pDict->HDPATS = FX_Alloc(CJBig2_Image*, pDict->NUMPATS); |
2375 sizeof(CJBig2_Image*), pDict->NUMPATS); | |
2376 JBIG2_memset(pDict->HDPATS, 0, sizeof(CJBig2_Image*) * pDict->NUMPATS); | 2336 JBIG2_memset(pDict->HDPATS, 0, sizeof(CJBig2_Image*) * pDict->NUMPATS); |
2377 JBIG2_ALLOC(pGRD, CJBig2_GRDProc()); | 2337 CJBig2_GRDProc* pGRD = new CJBig2_GRDProc(); |
2378 pGRD->MMR = HDMMR; | 2338 pGRD->MMR = HDMMR; |
2379 pGRD->GBW = (GRAYMAX + 1) * HDPW; | 2339 pGRD->GBW = (GRAYMAX + 1) * HDPW; |
2380 pGRD->GBH = HDPH; | 2340 pGRD->GBH = HDPH; |
2381 pGRD->GBTEMPLATE = HDTEMPLATE; | 2341 pGRD->GBTEMPLATE = HDTEMPLATE; |
2382 pGRD->TPGDON = 0; | 2342 pGRD->TPGDON = 0; |
2383 pGRD->USESKIP = 0; | 2343 pGRD->USESKIP = 0; |
2384 pGRD->GBAT[0] = -(int32_t)HDPW; | 2344 pGRD->GBAT[0] = -(int32_t)HDPW; |
2385 pGRD->GBAT[1] = 0; | 2345 pGRD->GBAT[1] = 0; |
2386 if (pGRD->GBTEMPLATE == 0) { | 2346 if (pGRD->GBTEMPLATE == 0) { |
2387 pGRD->GBAT[2] = -3; | 2347 pGRD->GBAT[2] = -3; |
(...skipping 22 matching lines...) Expand all Loading... |
2410 return pDict; | 2370 return pDict; |
2411 failed: | 2371 failed: |
2412 delete pDict; | 2372 delete pDict; |
2413 return NULL; | 2373 return NULL; |
2414 } | 2374 } |
2415 | 2375 |
2416 CJBig2_PatternDict* CJBig2_PDDProc::decode_MMR(CJBig2_BitStream* pStream, | 2376 CJBig2_PatternDict* CJBig2_PDDProc::decode_MMR(CJBig2_BitStream* pStream, |
2417 IFX_Pause* pPause) { | 2377 IFX_Pause* pPause) { |
2418 FX_DWORD GRAY; | 2378 FX_DWORD GRAY; |
2419 CJBig2_Image* BHDC = NULL; | 2379 CJBig2_Image* BHDC = NULL; |
2420 CJBig2_GRDProc* pGRD; | |
2421 CJBig2_PatternDict* pDict = new CJBig2_PatternDict(); | 2380 CJBig2_PatternDict* pDict = new CJBig2_PatternDict(); |
2422 pDict->NUMPATS = GRAYMAX + 1; | 2381 pDict->NUMPATS = GRAYMAX + 1; |
2423 pDict->HDPATS = (CJBig2_Image**)m_pModule->JBig2_Malloc2( | 2382 pDict->HDPATS = FX_Alloc(CJBig2_Image*, pDict->NUMPATS); |
2424 sizeof(CJBig2_Image*), pDict->NUMPATS); | |
2425 JBIG2_memset(pDict->HDPATS, 0, sizeof(CJBig2_Image*) * pDict->NUMPATS); | 2383 JBIG2_memset(pDict->HDPATS, 0, sizeof(CJBig2_Image*) * pDict->NUMPATS); |
2426 JBIG2_ALLOC(pGRD, CJBig2_GRDProc()); | 2384 CJBig2_GRDProc* pGRD = new CJBig2_GRDProc(); |
2427 pGRD->MMR = HDMMR; | 2385 pGRD->MMR = HDMMR; |
2428 pGRD->GBW = (GRAYMAX + 1) * HDPW; | 2386 pGRD->GBW = (GRAYMAX + 1) * HDPW; |
2429 pGRD->GBH = HDPH; | 2387 pGRD->GBH = HDPH; |
2430 FXCODEC_STATUS status = pGRD->Start_decode_MMR(&BHDC, pStream); | 2388 FXCODEC_STATUS status = pGRD->Start_decode_MMR(&BHDC, pStream); |
2431 while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE) { | 2389 while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE) { |
2432 pGRD->Continue_decode(pPause); | 2390 pGRD->Continue_decode(pPause); |
2433 } | 2391 } |
2434 if (BHDC == NULL) { | 2392 if (BHDC == NULL) { |
2435 delete pGRD; | 2393 delete pGRD; |
2436 goto failed; | 2394 goto failed; |
(...skipping 10 matching lines...) Expand all Loading... |
2447 delete pDict; | 2405 delete pDict; |
2448 return NULL; | 2406 return NULL; |
2449 } | 2407 } |
2450 FX_DWORD* CJBig2_GSIDProc::decode_Arith(CJBig2_ArithDecoder* pArithDecoder, | 2408 FX_DWORD* CJBig2_GSIDProc::decode_Arith(CJBig2_ArithDecoder* pArithDecoder, |
2451 JBig2ArithCtx* gbContext, | 2409 JBig2ArithCtx* gbContext, |
2452 IFX_Pause* pPause) { | 2410 IFX_Pause* pPause) { |
2453 CJBig2_Image** GSPLANES; | 2411 CJBig2_Image** GSPLANES; |
2454 int32_t J, K; | 2412 int32_t J, K; |
2455 FX_DWORD x, y; | 2413 FX_DWORD x, y; |
2456 FX_DWORD* GSVALS; | 2414 FX_DWORD* GSVALS; |
2457 CJBig2_GRDProc* pGRD; | 2415 GSPLANES = FX_Alloc(CJBig2_Image*, GSBPP); |
2458 GSPLANES = | |
2459 (CJBig2_Image**)m_pModule->JBig2_Malloc2(sizeof(CJBig2_Image*), GSBPP); | |
2460 if (!GSPLANES) { | 2416 if (!GSPLANES) { |
2461 return NULL; | 2417 return NULL; |
2462 } | 2418 } |
2463 GSVALS = (FX_DWORD*)m_pModule->JBig2_Malloc3(sizeof(FX_DWORD), GSW, GSH); | 2419 GSVALS = FX_Alloc2D(FX_DWORD, GSW, GSH); |
2464 if (!GSVALS) { | 2420 if (!GSVALS) { |
2465 m_pModule->JBig2_Free(GSPLANES); | 2421 FX_Free(GSPLANES); |
2466 return NULL; | 2422 return NULL; |
2467 } | 2423 } |
2468 JBIG2_memset(GSPLANES, 0, sizeof(CJBig2_Image*) * GSBPP); | 2424 JBIG2_memset(GSPLANES, 0, sizeof(CJBig2_Image*) * GSBPP); |
2469 JBIG2_memset(GSVALS, 0, sizeof(FX_DWORD) * GSW * GSH); | 2425 JBIG2_memset(GSVALS, 0, sizeof(FX_DWORD) * GSW * GSH); |
2470 JBIG2_ALLOC(pGRD, CJBig2_GRDProc()); | 2426 CJBig2_GRDProc* pGRD = new CJBig2_GRDProc(); |
2471 pGRD->MMR = GSMMR; | 2427 pGRD->MMR = GSMMR; |
2472 pGRD->GBW = GSW; | 2428 pGRD->GBW = GSW; |
2473 pGRD->GBH = GSH; | 2429 pGRD->GBH = GSH; |
2474 pGRD->GBTEMPLATE = GSTEMPLATE; | 2430 pGRD->GBTEMPLATE = GSTEMPLATE; |
2475 pGRD->TPGDON = 0; | 2431 pGRD->TPGDON = 0; |
2476 pGRD->USESKIP = GSUSESKIP; | 2432 pGRD->USESKIP = GSUSESKIP; |
2477 pGRD->SKIP = GSKIP; | 2433 pGRD->SKIP = GSKIP; |
2478 if (GSTEMPLATE <= 1) { | 2434 if (GSTEMPLATE <= 1) { |
2479 pGRD->GBAT[0] = 3; | 2435 pGRD->GBAT[0] = 3; |
2480 } else { | 2436 } else { |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2516 for (y = 0; y < GSH; y++) { | 2472 for (y = 0; y < GSH; y++) { |
2517 for (x = 0; x < GSW; x++) { | 2473 for (x = 0; x < GSW; x++) { |
2518 for (J = 0; J < GSBPP; J++) { | 2474 for (J = 0; J < GSBPP; J++) { |
2519 GSVALS[y * GSW + x] |= GSPLANES[J]->getPixel(x, y) << J; | 2475 GSVALS[y * GSW + x] |= GSPLANES[J]->getPixel(x, y) << J; |
2520 } | 2476 } |
2521 } | 2477 } |
2522 } | 2478 } |
2523 for (J = 0; J < GSBPP; J++) { | 2479 for (J = 0; J < GSBPP; J++) { |
2524 delete GSPLANES[J]; | 2480 delete GSPLANES[J]; |
2525 } | 2481 } |
2526 m_pModule->JBig2_Free(GSPLANES); | 2482 FX_Free(GSPLANES); |
2527 delete pGRD; | 2483 delete pGRD; |
2528 return GSVALS; | 2484 return GSVALS; |
2529 failed: | 2485 failed: |
2530 m_pModule->JBig2_Free(GSPLANES); | 2486 FX_Free(GSPLANES); |
2531 delete pGRD; | 2487 delete pGRD; |
2532 m_pModule->JBig2_Free(GSVALS); | 2488 FX_Free(GSVALS); |
2533 return NULL; | 2489 return NULL; |
2534 } | 2490 } |
2535 FX_DWORD* CJBig2_GSIDProc::decode_MMR(CJBig2_BitStream* pStream, | 2491 FX_DWORD* CJBig2_GSIDProc::decode_MMR(CJBig2_BitStream* pStream, |
2536 IFX_Pause* pPause) { | 2492 IFX_Pause* pPause) { |
2537 CJBig2_Image** GSPLANES; | 2493 CJBig2_Image** GSPLANES; |
2538 int32_t J, K; | 2494 int32_t J, K; |
2539 FX_DWORD x, y; | 2495 FX_DWORD x, y; |
2540 FX_DWORD* GSVALS; | 2496 FX_DWORD* GSVALS; |
2541 CJBig2_GRDProc* pGRD; | 2497 GSPLANES = FX_Alloc(CJBig2_Image*, GSBPP); |
2542 GSPLANES = | |
2543 (CJBig2_Image**)m_pModule->JBig2_Malloc2(sizeof(CJBig2_Image*), GSBPP); | |
2544 if (!GSPLANES) { | 2498 if (!GSPLANES) { |
2545 return NULL; | 2499 return NULL; |
2546 } | 2500 } |
2547 GSVALS = (FX_DWORD*)m_pModule->JBig2_Malloc3(sizeof(FX_DWORD), GSW, GSH); | 2501 GSVALS = FX_Alloc2D(FX_DWORD, GSW, GSH); |
2548 if (!GSVALS) { | 2502 if (!GSVALS) { |
2549 if (GSPLANES) { | 2503 FX_Free(GSPLANES); |
2550 m_pModule->JBig2_Free(GSPLANES); | |
2551 } | |
2552 return NULL; | 2504 return NULL; |
2553 } | 2505 } |
2554 JBIG2_memset(GSPLANES, 0, sizeof(CJBig2_Image*) * GSBPP); | 2506 JBIG2_memset(GSPLANES, 0, sizeof(CJBig2_Image*) * GSBPP); |
2555 JBIG2_memset(GSVALS, 0, sizeof(FX_DWORD) * GSW * GSH); | 2507 JBIG2_memset(GSVALS, 0, sizeof(FX_DWORD) * GSW * GSH); |
2556 JBIG2_ALLOC(pGRD, CJBig2_GRDProc()); | 2508 CJBig2_GRDProc* pGRD = new CJBig2_GRDProc(); |
2557 pGRD->MMR = GSMMR; | 2509 pGRD->MMR = GSMMR; |
2558 pGRD->GBW = GSW; | 2510 pGRD->GBW = GSW; |
2559 pGRD->GBH = GSH; | 2511 pGRD->GBH = GSH; |
2560 FXCODEC_STATUS status = pGRD->Start_decode_MMR(&GSPLANES[GSBPP - 1], pStream); | 2512 FXCODEC_STATUS status = pGRD->Start_decode_MMR(&GSPLANES[GSBPP - 1], pStream); |
2561 while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE) { | 2513 while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE) { |
2562 pGRD->Continue_decode(pPause); | 2514 pGRD->Continue_decode(pPause); |
2563 } | 2515 } |
2564 if (GSPLANES[GSBPP - 1] == NULL) { | 2516 if (GSPLANES[GSBPP - 1] == NULL) { |
2565 goto failed; | 2517 goto failed; |
2566 } | 2518 } |
(...skipping 19 matching lines...) Expand all Loading... |
2586 for (y = 0; y < GSH; y++) { | 2538 for (y = 0; y < GSH; y++) { |
2587 for (x = 0; x < GSW; x++) { | 2539 for (x = 0; x < GSW; x++) { |
2588 for (J = 0; J < GSBPP; J++) { | 2540 for (J = 0; J < GSBPP; J++) { |
2589 GSVALS[y * GSW + x] |= GSPLANES[J]->getPixel(x, y) << J; | 2541 GSVALS[y * GSW + x] |= GSPLANES[J]->getPixel(x, y) << J; |
2590 } | 2542 } |
2591 } | 2543 } |
2592 } | 2544 } |
2593 for (J = 0; J < GSBPP; J++) { | 2545 for (J = 0; J < GSBPP; J++) { |
2594 delete GSPLANES[J]; | 2546 delete GSPLANES[J]; |
2595 } | 2547 } |
2596 m_pModule->JBig2_Free(GSPLANES); | 2548 FX_Free(GSPLANES); |
2597 delete pGRD; | 2549 delete pGRD; |
2598 return GSVALS; | 2550 return GSVALS; |
2599 failed: | 2551 failed: |
2600 m_pModule->JBig2_Free(GSPLANES); | 2552 FX_Free(GSPLANES); |
2601 delete pGRD; | 2553 delete pGRD; |
2602 m_pModule->JBig2_Free(GSVALS); | 2554 FX_Free(GSVALS); |
2603 return NULL; | 2555 return NULL; |
2604 } | 2556 } |
2605 FXCODEC_STATUS CJBig2_GRDProc::Start_decode_Arith( | 2557 FXCODEC_STATUS CJBig2_GRDProc::Start_decode_Arith( |
2606 CJBig2_Image** pImage, | 2558 CJBig2_Image** pImage, |
2607 CJBig2_ArithDecoder* pArithDecoder, | 2559 CJBig2_ArithDecoder* pArithDecoder, |
2608 JBig2ArithCtx* gbContext, | 2560 JBig2ArithCtx* gbContext, |
2609 IFX_Pause* pPause) { | 2561 IFX_Pause* pPause) { |
2610 if (GBW == 0 || GBH == 0) { | 2562 if (GBW == 0 || GBH == 0) { |
2611 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH; | 2563 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH; |
2612 return FXCODEC_STATUS_DECODE_FINISH; | 2564 return FXCODEC_STATUS_DECODE_FINISH; |
2613 } | 2565 } |
2614 m_ProssiveStatus = FXCODEC_STATUS_DECODE_READY; | 2566 m_ProssiveStatus = FXCODEC_STATUS_DECODE_READY; |
2615 m_pPause = pPause; | 2567 m_pPause = pPause; |
2616 if (*pImage == NULL) { | 2568 if (!*pImage) |
2617 JBIG2_ALLOC((*pImage), CJBig2_Image(GBW, GBH)); | 2569 *pImage = new CJBig2_Image(GBW, GBH); |
2618 } | |
2619 if ((*pImage)->m_pData == NULL) { | 2570 if ((*pImage)->m_pData == NULL) { |
2620 delete *pImage; | 2571 delete *pImage; |
2621 *pImage = NULL; | 2572 *pImage = NULL; |
2622 m_ProssiveStatus = FXCODEC_STATUS_ERROR; | 2573 m_ProssiveStatus = FXCODEC_STATUS_ERROR; |
2623 return FXCODEC_STATUS_ERROR; | 2574 return FXCODEC_STATUS_ERROR; |
2624 } | 2575 } |
2625 m_DecodeType = 1; | 2576 m_DecodeType = 1; |
2626 m_pImage = pImage; | 2577 m_pImage = pImage; |
2627 (*m_pImage)->fill(0); | 2578 (*m_pImage)->fill(0); |
2628 m_pArithDecoder = pArithDecoder; | 2579 m_pArithDecoder = pArithDecoder; |
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2676 m_ReplaceRect.bottom = m_loopIndex; | 2627 m_ReplaceRect.bottom = m_loopIndex; |
2677 if (m_ProssiveStatus == FXCODEC_STATUS_DECODE_FINISH) { | 2628 if (m_ProssiveStatus == FXCODEC_STATUS_DECODE_FINISH) { |
2678 m_loopIndex = 0; | 2629 m_loopIndex = 0; |
2679 } | 2630 } |
2680 return m_ProssiveStatus; | 2631 return m_ProssiveStatus; |
2681 } | 2632 } |
2682 FXCODEC_STATUS CJBig2_GRDProc::Start_decode_MMR(CJBig2_Image** pImage, | 2633 FXCODEC_STATUS CJBig2_GRDProc::Start_decode_MMR(CJBig2_Image** pImage, |
2683 CJBig2_BitStream* pStream, | 2634 CJBig2_BitStream* pStream, |
2684 IFX_Pause* pPause) { | 2635 IFX_Pause* pPause) { |
2685 int bitpos, i; | 2636 int bitpos, i; |
2686 JBIG2_ALLOC((*pImage), CJBig2_Image(GBW, GBH)); | 2637 *pImage = new CJBig2_Image(GBW, GBH); |
2687 if ((*pImage)->m_pData == NULL) { | 2638 if ((*pImage)->m_pData == NULL) { |
2688 delete (*pImage); | 2639 delete (*pImage); |
2689 (*pImage) = NULL; | 2640 (*pImage) = NULL; |
2690 m_ProssiveStatus = FXCODEC_STATUS_ERROR; | 2641 m_ProssiveStatus = FXCODEC_STATUS_ERROR; |
2691 return m_ProssiveStatus; | 2642 return m_ProssiveStatus; |
2692 } | 2643 } |
2693 bitpos = (int)pStream->getBitPos(); | 2644 bitpos = (int)pStream->getBitPos(); |
2694 _FaxG4Decode(m_pModule, pStream->getBuf(), pStream->getLength(), &bitpos, | 2645 _FaxG4Decode(pStream->getBuf(), pStream->getLength(), &bitpos, |
2695 (*pImage)->m_pData, GBW, GBH, (*pImage)->m_nStride); | 2646 (*pImage)->m_pData, GBW, GBH, (*pImage)->m_nStride); |
2696 pStream->setBitPos(bitpos); | 2647 pStream->setBitPos(bitpos); |
2697 for (i = 0; (FX_DWORD)i < (*pImage)->m_nStride * GBH; i++) { | 2648 for (i = 0; (FX_DWORD)i < (*pImage)->m_nStride * GBH; i++) { |
2698 (*pImage)->m_pData[i] = ~(*pImage)->m_pData[i]; | 2649 (*pImage)->m_pData[i] = ~(*pImage)->m_pData[i]; |
2699 } | 2650 } |
2700 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH; | 2651 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH; |
2701 return m_ProssiveStatus; | 2652 return m_ProssiveStatus; |
2702 } | 2653 } |
2703 | 2654 |
2704 FXCODEC_STATUS CJBig2_GRDProc::Continue_decode(IFX_Pause* pPause) { | 2655 FXCODEC_STATUS CJBig2_GRDProc::Continue_decode(IFX_Pause* pPause) { |
(...skipping 559 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3264 } | 3215 } |
3265 if (pPause && pPause->NeedToPauseNow()) { | 3216 if (pPause && pPause->NeedToPauseNow()) { |
3266 m_loopIndex++; | 3217 m_loopIndex++; |
3267 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE; | 3218 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE; |
3268 return FXCODEC_STATUS_DECODE_TOBECONTINUE; | 3219 return FXCODEC_STATUS_DECODE_TOBECONTINUE; |
3269 } | 3220 } |
3270 } | 3221 } |
3271 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH; | 3222 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH; |
3272 return FXCODEC_STATUS_DECODE_FINISH; | 3223 return FXCODEC_STATUS_DECODE_FINISH; |
3273 } | 3224 } |
OLD | NEW |