core/src/fxcodec/jbig2/JBig2_GeneralDecoder.cpp - Issue 453133004: clang-format all code

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

Issue 453133004: clang-format all code (Closed) Base URL: https://pdfium.googlesource.com/pdfium.git@master

Patch Set: Created 6 years, 4 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

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"

11 #include "JBig2_HuffmanTable.h"	11 #include "JBig2_HuffmanTable.h"

12 #include "JBig2_PatternDict.h"	12 #include "JBig2_PatternDict.h"

13 CJBig2_Image CJBig2_GRDProc::decode_Arith(CJBig2_ArithDecoder pArithDecoder, J Big2ArithCtx *gbContext)	13 CJBig2_Image* CJBig2_GRDProc::decode_Arith(CJBig2_ArithDecoder* pArithDecoder,

14 {	14 JBig2ArithCtx* gbContext) {

15 if (GBW == 0 \|\| GBH == 0) {	15 if (GBW == 0 \|\| GBH == 0) {

16 CJBig2_Image* pImage;	16 CJBig2_Image* pImage;

17 JBIG2_ALLOC(pImage, CJBig2_Image(GBW, GBH));	17 JBIG2_ALLOC(pImage, CJBig2_Image(GBW, GBH));

18 return pImage;	18 return pImage;

19 }	19 }

20 if(GBTEMPLATE == 0) {	20 if (GBTEMPLATE == 0) {

21 if((GBAT[0] == 3) && (GBAT[1] == (signed char) - 1)	21 if ((GBAT[0] == 3) && (GBAT[1] == (signed char)-1) &&

22 && (GBAT[2] == (signed char) - 3) && (GBAT[3] == (signed char) - 1)	22 (GBAT[2] == (signed char)-3) && (GBAT[3] == (signed char)-1) &&

23 && (GBAT[4] == 2) && (GBAT[5] == (signed char) - 2)	23 (GBAT[4] == 2) && (GBAT[5] == (signed char)-2) &&

24 && (GBAT[6] == (signed char) - 2) && (GBAT[7] == (signed char) - 2)) {	24 (GBAT[6] == (signed char)-2) && (GBAT[7] == (signed char)-2)) {

25 return decode_Arith_Template0_opt3(pArithDecoder, gbContext);	25 return decode_Arith_Template0_opt3(pArithDecoder, gbContext);

	26 } else {

	27 return decode_Arith_Template0_unopt(pArithDecoder, gbContext);

	28 }

	29 } else if (GBTEMPLATE == 1) {

	30 if ((GBAT[0] == 3) && (GBAT[1] == (signed char)-1)) {

	31 return decode_Arith_Template1_opt3(pArithDecoder, gbContext);

	32 } else {

	33 return decode_Arith_Template1_unopt(pArithDecoder, gbContext);

	34 }

	35 } else if (GBTEMPLATE == 2) {

	36 if ((GBAT[0] == 2) && (GBAT[1] == (signed char)-1)) {

	37 return decode_Arith_Template2_opt3(pArithDecoder, gbContext);

	38 } else {

	39 return decode_Arith_Template2_unopt(pArithDecoder, gbContext);

	40 }

	41 } else {

	42 if ((GBAT[0] == 2) && (GBAT[1] == (signed char)-1)) {

	43 return decode_Arith_Template3_opt3(pArithDecoder, gbContext);

	44 } else {

	45 return decode_Arith_Template3_unopt(pArithDecoder, gbContext);

	46 }

	47 }

	48 }

	49 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template0_opt(

	50 CJBig2_ArithDecoder* pArithDecoder,

	51 JBig2ArithCtx* gbContext) {

	52 FX_BOOL LTP, SLTP, bVal;

	53 FX_DWORD CONTEXT;

	54 CJBig2_Image* GBREG;

	55 FX_DWORD line1, line2, line3;

	56 LTP = 0;

	57 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));

	58 GBREG->fill(0);

	59 for (FX_DWORD h = 0; h < GBH; h++) {

	60 if (TPGDON) {

	61 SLTP = pArithDecoder->DECODE(&gbContext[0x9b25]);

	62 LTP = LTP ^ SLTP;

	63 }

	64 if (LTP == 1) {

	65 GBREG->copyLine(h, h - 1);

	66 } else {

	67 line1 = GBREG->getPixel(2, h - 2);

	68 line1 \|= GBREG->getPixel(1, h - 2) << 1;

	69 line1 \|= GBREG->getPixel(0, h - 2) << 2;

	70 line2 = GBREG->getPixel(3, h - 1);

	71 line2 \|= GBREG->getPixel(2, h - 1) << 1;

	72 line2 \|= GBREG->getPixel(1, h - 1) << 2;

	73 line2 \|= GBREG->getPixel(0, h - 1) << 3;

	74 line3 = 0;

	75 for (FX_DWORD w = 0; w < GBW; w++) {

	76 if (USESKIP && SKIP->getPixel(w, h)) {

	77 bVal = 0;

26 } else {	78 } else {

27 return decode_Arith_Template0_unopt(pArithDecoder, gbContext);	79 CONTEXT = line3;

28 }	80 CONTEXT \|= line2 << 4;

29 } else if(GBTEMPLATE == 1) {	81 CONTEXT \|= line1 << 11;

30 if((GBAT[0] == 3) && (GBAT[1] == (signed char) - 1)) {	82 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

31 return decode_Arith_Template1_opt3(pArithDecoder, gbContext);	83 }

	84 if (bVal) {

	85 GBREG->setPixel(w, h, bVal);

	86 }

	87 line1 = ((line1 << 1) \| GBREG->getPixel(w + 3, h - 2)) & 0x1f;

	88 line2 = ((line2 << 1) \| GBREG->getPixel(w + 4, h - 1)) & 0x7f;

	89 line3 = ((line3 << 1) \| bVal) & 0x0f;

	90 }

	91 }

	92 }

	93 return GBREG;

	94 }

	95 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template0_opt2(

	96 CJBig2_ArithDecoder* pArithDecoder,

	97 JBig2ArithCtx* gbContext) {

	98 FX_BOOL LTP, SLTP, bVal;

	99 FX_DWORD CONTEXT;

	100 CJBig2_Image* GBREG;

	101 FX_DWORD line1, line2;

	102 FX_BYTE* pLine, cVal;

	103 FX_INTPTR nStride, nStride2;

	104 FX_INT32 nBits, k;

	105 LTP = 0;

	106 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));

	107 if (GBREG->m_pData == NULL) {

	108 delete GBREG;

	109 m_pModule->JBig2_Error(

	110 "Generic region decoding procedure: Create Image Failed with width = "

	111 "%d, height = %d\n",

	112 GBW,

	113 GBH);

	114 return NULL;

	115 }

	116 pLine = GBREG->m_pData;

	117 nStride = GBREG->m_nStride;

	118 nStride2 = nStride << 1;

	119 for (FX_DWORD h = 0; h < GBH; h++) {

	120 if (TPGDON) {

	121 SLTP = pArithDecoder->DECODE(&gbContext[0x9b25]);

	122 LTP = LTP ^ SLTP;

	123 }

	124 if (LTP == 1) {

	125 GBREG->copyLine(h, h - 1);

	126 } else {

	127 line1 = (h > 1) ? pLine[-nStride2] << 6 : 0;

	128 line2 = (h > 0) ? pLine[-nStride] : 0;

	129 CONTEXT = (line1 & 0xf800) \| (line2 & 0x07f0);

	130 for (FX_DWORD w = 0; w < GBW; w += 8) {

	131 if (w + 8 < GBW) {

	132 nBits = 8;

	133 if (h > 1) {

	134 line1 = (line1 << 8) \| (pLine[-nStride2 + (w >> 3) + 1] << 6);

	135 }

	136 if (h > 0) {

	137 line2 = (line2 << 8) \| (pLine[-nStride + (w >> 3) + 1]);

	138 }

32 } else {	139 } else {

33 return decode_Arith_Template1_unopt(pArithDecoder, gbContext);	140 nBits = GBW - w;

34 }	141 if (h > 1) {

35 } else if(GBTEMPLATE == 2) {	142 line1 <<= 8;

36 if((GBAT[0] == 2) && (GBAT[1] == (signed char) - 1)) {	143 }

37 return decode_Arith_Template2_opt3(pArithDecoder, gbContext);	144 if (h > 0) {

	145 line2 <<= 8;

	146 }

	147 }

	148 cVal = 0;

	149 for (k = 0; k < nBits; k++) {

	150 if (USESKIP && SKIP->getPixel(w, h)) {

	151 bVal = 0;

	152 } else {

	153 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	154 }

	155 cVal \|= bVal << (7 - k);

	156 CONTEXT = ((CONTEXT & 0x7bf7) << 1) \| bVal \|

	157 ((line1 >> (7 - k)) & 0x0800) \|

	158 ((line2 >> (7 - k)) & 0x0010);

	159 }

	160 pLine[w >> 3] = cVal;

	161 }

	162 }

	163 pLine += nStride;

	164 }

	165 return GBREG;

	166 }

	167 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template0_opt3(

	168 CJBig2_ArithDecoder* pArithDecoder,

	169 JBig2ArithCtx* gbContext) {

	170 FX_BOOL LTP, SLTP, bVal;

	171 FX_DWORD CONTEXT;

	172 CJBig2_Image* GBREG;

	173 FX_DWORD line1, line2;

	174 FX_BYTE* pLine, pLine1, pLine2, cVal;

	175 FX_INT32 nStride, nStride2, k;

	176 FX_INT32 nLineBytes, nBitsLeft, cc;

	177 LTP = 0;

	178 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));

	179 if (GBREG->m_pData == NULL) {

	180 delete GBREG;

	181 m_pModule->JBig2_Error(

	182 "Generic region decoding procedure: Create Image Failed with width = "

	183 "%d, height = %d\n",

	184 GBW,

	185 GBH);

	186 return NULL;

	187 }

	188 pLine = GBREG->m_pData;

	189 nStride = GBREG->m_nStride;

	190 nStride2 = nStride << 1;

	191 nLineBytes = ((GBW + 7) >> 3) - 1;

	192 nBitsLeft = GBW - (nLineBytes << 3);

	193 FX_DWORD height = GBH & 0x7fffffff;

	194 for (FX_DWORD h = 0; h < height; h++) {

	195 if (TPGDON) {

	196 SLTP = pArithDecoder->DECODE(&gbContext[0x9b25]);

	197 LTP = LTP ^ SLTP;

	198 }

	199 if (LTP == 1) {

	200 GBREG->copyLine(h, h - 1);

	201 } else {

	202 if (h > 1) {

	203 pLine1 = pLine - nStride2;

	204 pLine2 = pLine - nStride;

	205 line1 = (*pLine1++) << 6;

	206 line2 = *pLine2++;

	207 CONTEXT = ((line1 & 0xf800) \| (line2 & 0x07f0));

	208 for (cc = 0; cc < nLineBytes; cc++) {

	209 line1 = (line1 << 8) \| ((*pLine1++) << 6);

	210 line2 = (line2 << 8) \| (*pLine2++);

	211 cVal = 0;

	212 for (k = 7; k >= 0; k--) {

	213 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	214 cVal \|= bVal << k;

	215 CONTEXT = (((CONTEXT & 0x7bf7) << 1) \| bVal \|

	216 ((line1 >> k) & 0x0800) \| ((line2 >> k) & 0x0010));

	217 }

	218 pLine[cc] = cVal;

	219 }

	220 line1 <<= 8;

	221 line2 <<= 8;

	222 cVal = 0;

	223 for (k = 0; k < nBitsLeft; k++) {

	224 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	225 cVal \|= bVal << (7 - k);

	226 CONTEXT =

	227 (((CONTEXT & 0x7bf7) << 1) \| bVal \|

	228 ((line1 >> (7 - k)) & 0x0800) \| ((line2 >> (7 - k)) & 0x0010));

	229 }

	230 pLine[nLineBytes] = cVal;

	231 } else {

	232 pLine2 = pLine - nStride;

	233 line2 = (h & 1) ? (*pLine2++) : 0;

	234 CONTEXT = (line2 & 0x07f0);

	235 for (cc = 0; cc < nLineBytes; cc++) {

	236 if (h & 1) {

	237 line2 = (line2 << 8) \| (*pLine2++);

	238 }

	239 cVal = 0;

	240 for (k = 7; k >= 0; k--) {

	241 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	242 cVal \|= bVal << k;

	243 CONTEXT =

	244 (((CONTEXT & 0x7bf7) << 1) \| bVal \| ((line2 >> k) & 0x0010));

	245 }

	246 pLine[cc] = cVal;

	247 }

	248 line2 <<= 8;

	249 cVal = 0;

	250 for (k = 0; k < nBitsLeft; k++) {

	251 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	252 cVal \|= bVal << (7 - k);

	253 CONTEXT = (((CONTEXT & 0x7bf7) << 1) \| bVal \|

	254 (((line2 >> (7 - k))) & 0x0010));

	255 }

	256 pLine[nLineBytes] = cVal;

	257 }

	258 }

	259 pLine += nStride;

	260 }

	261 return GBREG;

	262 }

	263 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template0_unopt(

	264 CJBig2_ArithDecoder* pArithDecoder,

	265 JBig2ArithCtx* gbContext) {

	266 FX_BOOL LTP, SLTP, bVal;

	267 FX_DWORD CONTEXT;

	268 CJBig2_Image* GBREG;

	269 FX_DWORD line1, line2, line3;

	270 LTP = 0;

	271 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));

	272 GBREG->fill(0);

	273 for (FX_DWORD h = 0; h < GBH; h++) {

	274 if (TPGDON) {

	275 SLTP = pArithDecoder->DECODE(&gbContext[0x9b25]);

	276 LTP = LTP ^ SLTP;

	277 }

	278 if (LTP == 1) {

	279 GBREG->copyLine(h, h - 1);

	280 } else {

	281 line1 = GBREG->getPixel(1, h - 2);

	282 line1 \|= GBREG->getPixel(0, h - 2) << 1;

	283 line2 = GBREG->getPixel(2, h - 1);

	284 line2 \|= GBREG->getPixel(1, h - 1) << 1;

	285 line2 \|= GBREG->getPixel(0, h - 1) << 2;

	286 line3 = 0;

	287 for (FX_DWORD w = 0; w < GBW; w++) {

	288 if (USESKIP && SKIP->getPixel(w, h)) {

	289 bVal = 0;

38 } else {	290 } else {

39 return decode_Arith_Template2_unopt(pArithDecoder, gbContext);	291 CONTEXT = line3;

40 }	292 CONTEXT \|= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 4;

41 } else {	293 CONTEXT \|= line2 << 5;

42 if((GBAT[0] == 2) && (GBAT[1] == (signed char) - 1)) {	294 CONTEXT \|= GBREG->getPixel(w + GBAT[2], h + GBAT[3]) << 10;

43 return decode_Arith_Template3_opt3(pArithDecoder, gbContext);	295 CONTEXT \|= GBREG->getPixel(w + GBAT[4], h + GBAT[5]) << 11;

	296 CONTEXT \|= line1 << 12;

	297 CONTEXT \|= GBREG->getPixel(w + GBAT[6], h + GBAT[7]) << 15;

	298 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	299 }

	300 if (bVal) {

	301 GBREG->setPixel(w, h, bVal);

	302 }

	303 line1 = ((line1 << 1) \| GBREG->getPixel(w + 2, h - 2)) & 0x07;

	304 line2 = ((line2 << 1) \| GBREG->getPixel(w + 3, h - 1)) & 0x1f;

	305 line3 = ((line3 << 1) \| bVal) & 0x0f;

	306 }

	307 }

	308 }

	309 return GBREG;

	310 }

	311 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template1_opt(

	312 CJBig2_ArithDecoder* pArithDecoder,

	313 JBig2ArithCtx* gbContext) {

	314 FX_BOOL LTP, SLTP, bVal;

	315 FX_DWORD CONTEXT;

	316 CJBig2_Image* GBREG;

	317 FX_DWORD line1, line2, line3;

	318 LTP = 0;

	319 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));

	320 GBREG->fill(0);

	321 for (FX_DWORD h = 0; h < GBH; h++) {

	322 if (TPGDON) {

	323 SLTP = pArithDecoder->DECODE(&gbContext[0x0795]);

	324 LTP = LTP ^ SLTP;

	325 }

	326 if (LTP == 1) {

	327 GBREG->copyLine(h, h - 1);

	328 } else {

	329 line1 = GBREG->getPixel(2, h - 2);

	330 line1 \|= GBREG->getPixel(1, h - 2) << 1;

	331 line1 \|= GBREG->getPixel(0, h - 2) << 2;

	332 line2 = GBREG->getPixel(3, h - 1);

	333 line2 \|= GBREG->getPixel(2, h - 1) << 1;

	334 line2 \|= GBREG->getPixel(1, h - 1) << 2;

	335 line2 \|= GBREG->getPixel(0, h - 1) << 3;

	336 line3 = 0;

	337 for (FX_DWORD w = 0; w < GBW; w++) {

	338 if (USESKIP && SKIP->getPixel(w, h)) {

	339 bVal = 0;

44 } else {	340 } else {

45 return decode_Arith_Template3_unopt(pArithDecoder, gbContext);	341 CONTEXT = line3;

46 }	342 CONTEXT \|= line2 << 3;

47 }	343 CONTEXT \|= line1 << 9;

48 }	344 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

49 CJBig2_Image CJBig2_GRDProc::decode_Arith_Template0_opt(CJBig2_ArithDecoder pA rithDecoder, JBig2ArithCtx *gbContext)	345 }

50 {	346 if (bVal) {

51 FX_BOOL LTP, SLTP, bVal;	347 GBREG->setPixel(w, h, bVal);

52 FX_DWORD CONTEXT;	348 }

53 CJBig2_Image *GBREG;	349 line1 = ((line1 << 1) \| GBREG->getPixel(w + 3, h - 2)) & 0x0f;

54 FX_DWORD line1, line2, line3;	350 line2 = ((line2 << 1) \| GBREG->getPixel(w + 4, h - 1)) & 0x3f;

55 LTP = 0;	351 line3 = ((line3 << 1) \| bVal) & 0x07;

56 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));	352 }

57 GBREG->fill(0);	353 }

58 for(FX_DWORD h = 0; h < GBH; h++) {	354 }

59 if(TPGDON) {	355 return GBREG;

60 SLTP = pArithDecoder->DECODE(&gbContext[0x9b25]);	356 }

61 LTP = LTP ^ SLTP;	357 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template1_opt2(

62 }	358 CJBig2_ArithDecoder* pArithDecoder,

63 if(LTP == 1) {	359 JBig2ArithCtx* gbContext) {

64 GBREG->copyLine(h, h - 1);	360 FX_BOOL LTP, SLTP, bVal;

	361 FX_DWORD CONTEXT;

	362 CJBig2_Image* GBREG;

	363 FX_DWORD line1, line2;

	364 FX_BYTE* pLine, cVal;

	365 FX_INTPTR nStride, nStride2;

	366 FX_INT32 nBits, k;

	367 LTP = 0;

	368 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));

	369 if (GBREG->m_pData == NULL) {

	370 delete GBREG;

	371 m_pModule->JBig2_Error(

	372 "Generic region decoding procedure: Create Image Failed with width = "

	373 "%d, height = %d\n",

	374 GBW,

	375 GBH);

	376 return NULL;

	377 }

	378 pLine = GBREG->m_pData;

	379 nStride = GBREG->m_nStride;

	380 nStride2 = nStride << 1;

	381 for (FX_DWORD h = 0; h < GBH; h++) {

	382 if (TPGDON) {

	383 SLTP = pArithDecoder->DECODE(&gbContext[0x0795]);

	384 LTP = LTP ^ SLTP;

	385 }

	386 if (LTP == 1) {

	387 GBREG->copyLine(h, h - 1);

	388 } else {

	389 line1 = (h > 1) ? pLine[-nStride2] << 4 : 0;

	390 line2 = (h > 0) ? pLine[-nStride] : 0;

	391 CONTEXT = (line1 & 0x1e00) \| ((line2 >> 1) & 0x01f8);

	392 for (FX_DWORD w = 0; w < GBW; w += 8) {

	393 if (w + 8 < GBW) {

	394 nBits = 8;

	395 if (h > 1) {

	396 line1 = (line1 << 8) \| (pLine[-nStride2 + (w >> 3) + 1] << 4);

	397 }

	398 if (h > 0) {

	399 line2 = (line2 << 8) \| (pLine[-nStride + (w >> 3) + 1]);

	400 }

65 } else {	401 } else {

66 line1 = GBREG->getPixel(2, h - 2);	402 nBits = GBW - w;

67 line1 \|= GBREG->getPixel(1, h - 2) << 1;	403 if (h > 1) {

68 line1 \|= GBREG->getPixel(0, h - 2) << 2;	404 line1 <<= 8;

69 line2 = GBREG->getPixel(3, h - 1);	405 }

70 line2 \|= GBREG->getPixel(2, h - 1) << 1;	406 if (h > 0) {

71 line2 \|= GBREG->getPixel(1, h - 1) << 2;	407 line2 <<= 8;

72 line2 \|= GBREG->getPixel(0, h - 1) << 3;	408 }

73 line3 = 0;	409 }

74 for(FX_DWORD w = 0; w < GBW; w++) {	410 cVal = 0;

75 if(USESKIP && SKIP->getPixel(w, h)) {	411 for (k = 0; k < nBits; k++) {

76 bVal = 0;	412 if (USESKIP && SKIP->getPixel(w, h)) {

77 } else {	413 bVal = 0;

78 CONTEXT = line3;	414 } else {

79 CONTEXT \|= line2 << 4;	415 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

80 CONTEXT \|= line1 << 11;	416 }

81 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);	417 cVal \|= bVal << (7 - k);

82 }	418 CONTEXT = ((CONTEXT & 0x0efb) << 1) \| bVal \|

83 if(bVal) {	419 ((line1 >> (7 - k)) & 0x0200) \|

84 GBREG->setPixel(w, h, bVal);	420 ((line2 >> (8 - k)) & 0x0008);

85 }	421 }

86 line1 = ((line1 << 1) \| GBREG->getPixel(w + 3, h - 2)) & 0x1f;	422 pLine[w >> 3] = cVal;

87 line2 = ((line2 << 1) \| GBREG->getPixel(w + 4, h - 1)) & 0x7f;	423 }

88 line3 = ((line3 << 1) \| bVal) & 0x0f;	424 }

	425 pLine += nStride;

	426 }

	427 return GBREG;

	428 }

	429 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template1_opt3(

	430 CJBig2_ArithDecoder* pArithDecoder,

	431 JBig2ArithCtx* gbContext) {

	432 FX_BOOL LTP, SLTP, bVal;

	433 FX_DWORD CONTEXT;

	434 CJBig2_Image* GBREG;

	435 FX_DWORD line1, line2;

	436 FX_BYTE* pLine, pLine1, pLine2, cVal;

	437 FX_INT32 nStride, nStride2, k;

	438 FX_INT32 nLineBytes, nBitsLeft, cc;

	439 LTP = 0;

	440 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));

	441 if (GBREG->m_pData == NULL) {

	442 delete GBREG;

	443 m_pModule->JBig2_Error(

	444 "Generic region decoding procedure: Create Image Failed with width = "

	445 "%d, height = %d\n",

	446 GBW,

	447 GBH);

	448 return NULL;

	449 }

	450 pLine = GBREG->m_pData;

	451 nStride = GBREG->m_nStride;

	452 nStride2 = nStride << 1;

	453 nLineBytes = ((GBW + 7) >> 3) - 1;

	454 nBitsLeft = GBW - (nLineBytes << 3);

	455 for (FX_DWORD h = 0; h < GBH; h++) {

	456 if (TPGDON) {

	457 SLTP = pArithDecoder->DECODE(&gbContext[0x0795]);

	458 LTP = LTP ^ SLTP;

	459 }

	460 if (LTP == 1) {

	461 GBREG->copyLine(h, h - 1);

	462 } else {

	463 if (h > 1) {

	464 pLine1 = pLine - nStride2;

	465 pLine2 = pLine - nStride;

	466 line1 = (*pLine1++) << 4;

	467 line2 = *pLine2++;

	468 CONTEXT = (line1 & 0x1e00) \| ((line2 >> 1) & 0x01f8);

	469 for (cc = 0; cc < nLineBytes; cc++) {

	470 line1 = (line1 << 8) \| ((*pLine1++) << 4);

	471 line2 = (line2 << 8) \| (*pLine2++);

	472 cVal = 0;

	473 for (k = 7; k >= 0; k--) {

	474 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	475 cVal \|= bVal << k;

	476 CONTEXT = ((CONTEXT & 0x0efb) << 1) \| bVal \|

	477 ((line1 >> k) & 0x0200) \| ((line2 >> (k + 1)) & 0x0008);

	478 }

	479 pLine[cc] = cVal;

	480 }

	481 line1 <<= 8;

	482 line2 <<= 8;

	483 cVal = 0;

	484 for (k = 0; k < nBitsLeft; k++) {

	485 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	486 cVal \|= bVal << (7 - k);

	487 CONTEXT = ((CONTEXT & 0x0efb) << 1) \| bVal \|

	488 ((line1 >> (7 - k)) & 0x0200) \|

	489 ((line2 >> (8 - k)) & 0x0008);

	490 }

	491 pLine[nLineBytes] = cVal;

	492 } else {

	493 pLine2 = pLine - nStride;

	494 line2 = (h & 1) ? (*pLine2++) : 0;

	495 CONTEXT = (line2 >> 1) & 0x01f8;

	496 for (cc = 0; cc < nLineBytes; cc++) {

	497 if (h & 1) {

	498 line2 = (line2 << 8) \| (*pLine2++);

	499 }

	500 cVal = 0;

	501 for (k = 7; k >= 0; k--) {

	502 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	503 cVal \|= bVal << k;

	504 CONTEXT = ((CONTEXT & 0x0efb) << 1) \| bVal \|

	505 ((line2 >> (k + 1)) & 0x0008);

	506 }

	507 pLine[cc] = cVal;

	508 }

	509 line2 <<= 8;

	510 cVal = 0;

	511 for (k = 0; k < nBitsLeft; k++) {

	512 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	513 cVal \|= bVal << (7 - k);

	514 CONTEXT =

	515 ((CONTEXT & 0x0efb) << 1) \| bVal \| ((line2 >> (8 - k)) & 0x0008);

	516 }

	517 pLine[nLineBytes] = cVal;

	518 }

	519 }

	520 pLine += nStride;

	521 }

	522 return GBREG;

	523 }

	524 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template1_unopt(

	525 CJBig2_ArithDecoder* pArithDecoder,

	526 JBig2ArithCtx* gbContext) {

	527 FX_BOOL LTP, SLTP, bVal;

	528 FX_DWORD CONTEXT;

	529 CJBig2_Image* GBREG;

	530 FX_DWORD line1, line2, line3;

	531 LTP = 0;

	532 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));

	533 GBREG->fill(0);

	534 for (FX_DWORD h = 0; h < GBH; h++) {

	535 if (TPGDON) {

	536 SLTP = pArithDecoder->DECODE(&gbContext[0x0795]);

	537 LTP = LTP ^ SLTP;

	538 }

	539 if (LTP == 1) {

	540 GBREG->copyLine(h, h - 1);

	541 } else {

	542 line1 = GBREG->getPixel(2, h - 2);

	543 line1 \|= GBREG->getPixel(1, h - 2) << 1;

	544 line1 \|= GBREG->getPixel(0, h - 2) << 2;

	545 line2 = GBREG->getPixel(2, h - 1);

	546 line2 \|= GBREG->getPixel(1, h - 1) << 1;

	547 line2 \|= GBREG->getPixel(0, h - 1) << 2;

	548 line3 = 0;

	549 for (FX_DWORD w = 0; w < GBW; w++) {

	550 if (USESKIP && SKIP->getPixel(w, h)) {

	551 bVal = 0;

	552 } else {

	553 CONTEXT = line3;

	554 CONTEXT \|= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 3;

	555 CONTEXT \|= line2 << 4;

	556 CONTEXT \|= line1 << 9;

	557 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	558 }

	559 if (bVal) {

	560 GBREG->setPixel(w, h, bVal);

	561 }

	562 line1 = ((line1 << 1) \| GBREG->getPixel(w + 3, h - 2)) & 0x0f;

	563 line2 = ((line2 << 1) \| GBREG->getPixel(w + 3, h - 1)) & 0x1f;

	564 line3 = ((line3 << 1) \| bVal) & 0x07;

	565 }

	566 }

	567 }

	568 return GBREG;

	569 }

	570 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template2_opt(

	571 CJBig2_ArithDecoder* pArithDecoder,

	572 JBig2ArithCtx* gbContext) {

	573 FX_BOOL LTP, SLTP, bVal;

	574 FX_DWORD CONTEXT;

	575 CJBig2_Image* GBREG;

	576 FX_DWORD line1, line2, line3;

	577 LTP = 0;

	578 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));

	579 GBREG->fill(0);

	580 for (FX_DWORD h = 0; h < GBH; h++) {

	581 if (TPGDON) {

	582 SLTP = pArithDecoder->DECODE(&gbContext[0x00e5]);

	583 LTP = LTP ^ SLTP;

	584 }

	585 if (LTP == 1) {

	586 GBREG->copyLine(h, h - 1);

	587 } else {

	588 line1 = GBREG->getPixel(1, h - 2);

	589 line1 \|= GBREG->getPixel(0, h - 2) << 1;

	590 line2 = GBREG->getPixel(2, h - 1);

	591 line2 \|= GBREG->getPixel(1, h - 1) << 1;

	592 line2 \|= GBREG->getPixel(0, h - 1) << 2;

	593 line3 = 0;

	594 for (FX_DWORD w = 0; w < GBW; w++) {

	595 if (USESKIP && SKIP->getPixel(w, h)) {

	596 bVal = 0;

	597 } else {

	598 CONTEXT = line3;

	599 CONTEXT \|= line2 << 2;

	600 CONTEXT \|= line1 << 7;

	601 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	602 }

	603 if (bVal) {

	604 GBREG->setPixel(w, h, bVal);

	605 }

	606 line1 = ((line1 << 1) \| GBREG->getPixel(w + 2, h - 2)) & 0x07;

	607 line2 = ((line2 << 1) \| GBREG->getPixel(w + 3, h - 1)) & 0x1f;

	608 line3 = ((line3 << 1) \| bVal) & 0x03;

	609 }

	610 }

	611 }

	612 return GBREG;

	613 }

	614 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template2_opt2(

	615 CJBig2_ArithDecoder* pArithDecoder,

	616 JBig2ArithCtx* gbContext) {

	617 FX_BOOL LTP, SLTP, bVal;

	618 FX_DWORD CONTEXT;

	619 CJBig2_Image* GBREG;

	620 FX_DWORD line1, line2;

	621 FX_BYTE* pLine, cVal;

	622 FX_INTPTR nStride, nStride2;

	623 FX_INT32 nBits, k;

	624 LTP = 0;

	625 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));

	626 if (GBREG->m_pData == NULL) {

	627 delete GBREG;

	628 m_pModule->JBig2_Error(

	629 "Generic region decoding procedure: Create Image Failed with width = "

	630 "%d, height = %d\n",

	631 GBW,

	632 GBH);

	633 return NULL;

	634 }

	635 pLine = GBREG->m_pData;

	636 nStride = GBREG->m_nStride;

	637 nStride2 = nStride << 1;

	638 for (FX_DWORD h = 0; h < GBH; h++) {

	639 if (TPGDON) {

	640 SLTP = pArithDecoder->DECODE(&gbContext[0x00e5]);

	641 LTP = LTP ^ SLTP;

	642 }

	643 if (LTP == 1) {

	644 GBREG->copyLine(h, h - 1);

	645 } else {

	646 line1 = (h > 1) ? pLine[-nStride2] << 1 : 0;

	647 line2 = (h > 0) ? pLine[-nStride] : 0;

	648 CONTEXT = (line1 & 0x0380) \| ((line2 >> 3) & 0x007c);

	649 for (FX_DWORD w = 0; w < GBW; w += 8) {

	650 if (w + 8 < GBW) {

	651 nBits = 8;

	652 if (h > 1) {

	653 line1 = (line1 << 8) \| (pLine[-nStride2 + (w >> 3) + 1] << 1);

	654 }

	655 if (h > 0) {

	656 line2 = (line2 << 8) \| (pLine[-nStride + (w >> 3) + 1]);

	657 }

	658 } else {

	659 nBits = GBW - w;

	660 if (h > 1) {

	661 line1 <<= 8;

	662 }

	663 if (h > 0) {

	664 line2 <<= 8;

	665 }

	666 }

	667 cVal = 0;

	668 for (k = 0; k < nBits; k++) {

	669 if (USESKIP && SKIP->getPixel(w, h)) {

	670 bVal = 0;

	671 } else {

	672 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	673 }

	674 cVal \|= bVal << (7 - k);

	675 CONTEXT = ((CONTEXT & 0x01bd) << 1) \| bVal \|

	676 ((line1 >> (7 - k)) & 0x0080) \|

	677 ((line2 >> (10 - k)) & 0x0004);

	678 }

	679 pLine[w >> 3] = cVal;

	680 }

	681 }

	682 pLine += nStride;

	683 }

	684 return GBREG;

	685 }

	686 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template2_opt3(

	687 CJBig2_ArithDecoder* pArithDecoder,

	688 JBig2ArithCtx* gbContext) {

	689 FX_BOOL LTP, SLTP, bVal;

	690 FX_DWORD CONTEXT;

	691 CJBig2_Image* GBREG;

	692 FX_DWORD line1, line2;

	693 FX_BYTE* pLine, pLine1, pLine2, cVal;

	694 FX_INT32 nStride, nStride2, k;

	695 FX_INT32 nLineBytes, nBitsLeft, cc;

	696 LTP = 0;

	697 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));

	698 if (GBREG->m_pData == NULL) {

	699 delete GBREG;

	700 m_pModule->JBig2_Error(

	701 "Generic region decoding procedure: Create Image Failed with width = "

	702 "%d, height = %d\n",

	703 GBW,

	704 GBH);

	705 return NULL;

	706 }

	707 pLine = GBREG->m_pData;

	708 nStride = GBREG->m_nStride;

	709 nStride2 = nStride << 1;

	710 nLineBytes = ((GBW + 7) >> 3) - 1;

	711 nBitsLeft = GBW - (nLineBytes << 3);

	712 for (FX_DWORD h = 0; h < GBH; h++) {

	713 if (TPGDON) {

	714 SLTP = pArithDecoder->DECODE(&gbContext[0x00e5]);

	715 LTP = LTP ^ SLTP;

	716 }

	717 if (LTP == 1) {

	718 GBREG->copyLine(h, h - 1);

	719 } else {

	720 if (h > 1) {

	721 pLine1 = pLine - nStride2;

	722 pLine2 = pLine - nStride;

	723 line1 = (*pLine1++) << 1;

	724 line2 = *pLine2++;

	725 CONTEXT = (line1 & 0x0380) \| ((line2 >> 3) & 0x007c);

	726 for (cc = 0; cc < nLineBytes; cc++) {

	727 line1 = (line1 << 8) \| ((*pLine1++) << 1);

	728 line2 = (line2 << 8) \| (*pLine2++);

	729 cVal = 0;

	730 for (k = 7; k >= 0; k--) {

	731 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	732 cVal \|= bVal << k;

	733 CONTEXT = ((CONTEXT & 0x01bd) << 1) \| bVal \|

	734 ((line1 >> k) & 0x0080) \| ((line2 >> (k + 3)) & 0x0004);

	735 }

	736 pLine[cc] = cVal;

	737 }

	738 line1 <<= 8;

	739 line2 <<= 8;

	740 cVal = 0;

	741 for (k = 0; k < nBitsLeft; k++) {

	742 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	743 cVal \|= bVal << (7 - k);

	744 CONTEXT = ((CONTEXT & 0x01bd) << 1) \| bVal \|

	745 ((line1 >> (7 - k)) & 0x0080) \|

	746 ((line2 >> (10 - k)) & 0x0004);

	747 }

	748 pLine[nLineBytes] = cVal;

	749 } else {

	750 pLine2 = pLine - nStride;

	751 line2 = (h & 1) ? (*pLine2++) : 0;

	752 CONTEXT = (line2 >> 3) & 0x007c;

	753 for (cc = 0; cc < nLineBytes; cc++) {

	754 if (h & 1) {

	755 line2 = (line2 << 8) \| (*pLine2++);

	756 }

	757 cVal = 0;

	758 for (k = 7; k >= 0; k--) {

	759 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	760 cVal \|= bVal << k;

	761 CONTEXT = ((CONTEXT & 0x01bd) << 1) \| bVal \|

	762 ((line2 >> (k + 3)) & 0x0004);

	763 }

	764 pLine[cc] = cVal;

	765 }

	766 line2 <<= 8;

	767 cVal = 0;

	768 for (k = 0; k < nBitsLeft; k++) {

	769 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	770 cVal \|= bVal << (7 - k);

	771 CONTEXT = ((CONTEXT & 0x01bd) << 1) \| bVal \|

	772 (((line2 >> (10 - k))) & 0x0004);

	773 }

	774 pLine[nLineBytes] = cVal;

	775 }

	776 }

	777 pLine += nStride;

	778 }

	779 return GBREG;

	780 }

	781 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template2_unopt(

	782 CJBig2_ArithDecoder* pArithDecoder,

	783 JBig2ArithCtx* gbContext) {

	784 FX_BOOL LTP, SLTP, bVal;

	785 FX_DWORD CONTEXT;

	786 CJBig2_Image* GBREG;

	787 FX_DWORD line1, line2, line3;

	788 LTP = 0;

	789 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));

	790 GBREG->fill(0);

	791 for (FX_DWORD h = 0; h < GBH; h++) {

	792 if (TPGDON) {

	793 SLTP = pArithDecoder->DECODE(&gbContext[0x00e5]);

	794 LTP = LTP ^ SLTP;

	795 }

	796 if (LTP == 1) {

	797 GBREG->copyLine(h, h - 1);

	798 } else {

	799 line1 = GBREG->getPixel(1, h - 2);

	800 line1 \|= GBREG->getPixel(0, h - 2) << 1;

	801 line2 = GBREG->getPixel(1, h - 1);

	802 line2 \|= GBREG->getPixel(0, h - 1) << 1;

	803 line3 = 0;

	804 for (FX_DWORD w = 0; w < GBW; w++) {

	805 if (USESKIP && SKIP->getPixel(w, h)) {

	806 bVal = 0;

	807 } else {

	808 CONTEXT = line3;

	809 CONTEXT \|= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 2;

	810 CONTEXT \|= line2 << 3;

	811 CONTEXT \|= line1 << 7;

	812 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	813 }

	814 if (bVal) {

	815 GBREG->setPixel(w, h, bVal);

	816 }

	817 line1 = ((line1 << 1) \| GBREG->getPixel(w + 2, h - 2)) & 0x07;

	818 line2 = ((line2 << 1) \| GBREG->getPixel(w + 2, h - 1)) & 0x0f;

	819 line3 = ((line3 << 1) \| bVal) & 0x03;

	820 }

	821 }

	822 }

	823 return GBREG;

	824 }

	825 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template3_opt(

	826 CJBig2_ArithDecoder* pArithDecoder,

	827 JBig2ArithCtx* gbContext) {

	828 FX_BOOL LTP, SLTP, bVal;

	829 FX_DWORD CONTEXT;

	830 CJBig2_Image* GBREG;

	831 FX_DWORD line1, line2;

	832 LTP = 0;

	833 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));

	834 GBREG->fill(0);

	835 for (FX_DWORD h = 0; h < GBH; h++) {

	836 if (TPGDON) {

	837 SLTP = pArithDecoder->DECODE(&gbContext[0x0195]);

	838 LTP = LTP ^ SLTP;

	839 }

	840 if (LTP == 1) {

	841 GBREG->copyLine(h, h - 1);

	842 } else {

	843 line1 = GBREG->getPixel(2, h - 1);

	844 line1 \|= GBREG->getPixel(1, h - 1) << 1;

	845 line1 \|= GBREG->getPixel(0, h - 1) << 2;

	846 line2 = 0;

	847 for (FX_DWORD w = 0; w < GBW; w++) {

	848 if (USESKIP && SKIP->getPixel(w, h)) {

	849 bVal = 0;

	850 } else {

	851 CONTEXT = line2;

	852 CONTEXT \|= line1 << 4;

	853 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	854 }

	855 if (bVal) {

	856 GBREG->setPixel(w, h, bVal);

	857 }

	858 line1 = ((line1 << 1) \| GBREG->getPixel(w + 3, h - 1)) & 0x3f;

	859 line2 = ((line2 << 1) \| bVal) & 0x0f;

	860 }

	861 }

	862 }

	863 return GBREG;

	864 }

	865 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template3_opt2(

	866 CJBig2_ArithDecoder* pArithDecoder,

	867 JBig2ArithCtx* gbContext) {

	868 FX_BOOL LTP, SLTP, bVal;

	869 FX_DWORD CONTEXT;

	870 CJBig2_Image* GBREG;

	871 FX_DWORD line1;

	872 FX_BYTE* pLine, cVal;

	873 FX_INTPTR nStride, nStride2;

	874 FX_INT32 nBits, k;

	875 LTP = 0;

	876 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));

	877 if (GBREG->m_pData == NULL) {

	878 delete GBREG;

	879 m_pModule->JBig2_Error(

	880 "Generic region decoding procedure: Create Image Failed with width = "

	881 "%d, height = %d\n",

	882 GBW,

	883 GBH);

	884 return NULL;

	885 }

	886 pLine = GBREG->m_pData;

	887 nStride = GBREG->m_nStride;

	888 nStride2 = nStride << 1;

	889 for (FX_DWORD h = 0; h < GBH; h++) {

	890 if (TPGDON) {

	891 SLTP = pArithDecoder->DECODE(&gbContext[0x0195]);

	892 LTP = LTP ^ SLTP;

	893 }

	894 if (LTP == 1) {

	895 GBREG->copyLine(h, h - 1);

	896 } else {

	897 line1 = (h > 0) ? pLine[-nStride] : 0;

	898 CONTEXT = (line1 >> 1) & 0x03f0;

	899 for (FX_DWORD w = 0; w < GBW; w += 8) {

	900 if (w + 8 < GBW) {

	901 nBits = 8;

	902 if (h > 0) {

	903 line1 = (line1 << 8) \| (pLine[-nStride + (w >> 3) + 1]);

	904 }

	905 } else {

	906 nBits = GBW - w;

	907 if (h > 0) {

	908 line1 <<= 8;

	909 }

	910 }

	911 cVal = 0;

	912 for (k = 0; k < nBits; k++) {

	913 if (USESKIP && SKIP->getPixel(w, h)) {

	914 bVal = 0;

	915 } else {

	916 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	917 }

	918 cVal \|= bVal << (7 - k);

	919 CONTEXT =

	920 ((CONTEXT & 0x01f7) << 1) \| bVal \| ((line1 >> (8 - k)) & 0x0010);

	921 }

	922 pLine[w >> 3] = cVal;

	923 }

	924 }

	925 pLine += nStride;

	926 }

	927 return GBREG;

	928 }

	929 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template3_opt3(

	930 CJBig2_ArithDecoder* pArithDecoder,

	931 JBig2ArithCtx* gbContext) {

	932 FX_BOOL LTP, SLTP, bVal;

	933 FX_DWORD CONTEXT;

	934 CJBig2_Image* GBREG;

	935 FX_DWORD line1;

	936 FX_BYTE* pLine, *pLine1, cVal;

	937 FX_INT32 nStride, k;

	938 FX_INT32 nLineBytes, nBitsLeft, cc;

	939 LTP = 0;

	940 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));

	941 if (GBREG->m_pData == NULL) {

	942 delete GBREG;

	943 m_pModule->JBig2_Error(

	944 "Generic region decoding procedure: Create Image Failed with width = "

	945 "%d, height = %d\n",

	946 GBW,

	947 GBH);

	948 return NULL;

	949 }

	950 pLine = GBREG->m_pData;

	951 nStride = GBREG->m_nStride;

	952 nLineBytes = ((GBW + 7) >> 3) - 1;

	953 nBitsLeft = GBW - (nLineBytes << 3);

	954 for (FX_DWORD h = 0; h < GBH; h++) {

	955 if (TPGDON) {

	956 SLTP = pArithDecoder->DECODE(&gbContext[0x0195]);

	957 LTP = LTP ^ SLTP;

	958 }

	959 if (LTP == 1) {

	960 GBREG->copyLine(h, h - 1);

	961 } else {

	962 if (h > 0) {

	963 pLine1 = pLine - nStride;

	964 line1 = *pLine1++;

	965 CONTEXT = (line1 >> 1) & 0x03f0;

	966 for (cc = 0; cc < nLineBytes; cc++) {

	967 line1 = (line1 << 8) \| (*pLine1++);

	968 cVal = 0;

	969 for (k = 7; k >= 0; k--) {

	970 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	971 cVal \|= bVal << k;

	972 CONTEXT = ((CONTEXT & 0x01f7) << 1) \| bVal \|

	973 ((line1 >> (k + 1)) & 0x0010);

	974 }

	975 pLine[cc] = cVal;

	976 }

	977 line1 <<= 8;

	978 cVal = 0;

	979 for (k = 0; k < nBitsLeft; k++) {

	980 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	981 cVal \|= bVal << (7 - k);

	982 CONTEXT =

	983 ((CONTEXT & 0x01f7) << 1) \| bVal \| ((line1 >> (8 - k)) & 0x0010);

	984 }

	985 pLine[nLineBytes] = cVal;

	986 } else {

	987 CONTEXT = 0;

	988 for (cc = 0; cc < nLineBytes; cc++) {

	989 cVal = 0;

	990 for (k = 7; k >= 0; k--) {

	991 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	992 cVal \|= bVal << k;

	993 CONTEXT = ((CONTEXT & 0x01f7) << 1) \| bVal;

	994 }

	995 pLine[cc] = cVal;

	996 }

	997 cVal = 0;

	998 for (k = 0; k < nBitsLeft; k++) {

	999 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	1000 cVal \|= bVal << (7 - k);

	1001 CONTEXT = ((CONTEXT & 0x01f7) << 1) \| bVal;

	1002 }

	1003 pLine[nLineBytes] = cVal;

	1004 }

	1005 }

	1006 pLine += nStride;

	1007 }

	1008 return GBREG;

	1009 }

	1010 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template3_unopt(

	1011 CJBig2_ArithDecoder* pArithDecoder,

	1012 JBig2ArithCtx* gbContext) {

	1013 FX_BOOL LTP, SLTP, bVal;

	1014 FX_DWORD CONTEXT;

	1015 CJBig2_Image* GBREG;

	1016 FX_DWORD line1, line2;

	1017 LTP = 0;

	1018 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));

	1019 GBREG->fill(0);

	1020 for (FX_DWORD h = 0; h < GBH; h++) {

	1021 if (TPGDON) {

	1022 SLTP = pArithDecoder->DECODE(&gbContext[0x0195]);

	1023 LTP = LTP ^ SLTP;

	1024 }

	1025 if (LTP == 1) {

	1026 GBREG->copyLine(h, h - 1);

	1027 } else {

	1028 line1 = GBREG->getPixel(1, h - 1);

	1029 line1 \|= GBREG->getPixel(0, h - 1) << 1;

	1030 line2 = 0;

	1031 for (FX_DWORD w = 0; w < GBW; w++) {

	1032 if (USESKIP && SKIP->getPixel(w, h)) {

	1033 bVal = 0;

	1034 } else {

	1035 CONTEXT = line2;

	1036 CONTEXT \|= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 4;

	1037 CONTEXT \|= line1 << 5;

	1038 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	1039 }

	1040 if (bVal) {

	1041 GBREG->setPixel(w, h, bVal);

	1042 }

	1043 line1 = ((line1 << 1) \| GBREG->getPixel(w + 2, h - 1)) & 0x1f;

	1044 line2 = ((line2 << 1) \| bVal) & 0x0f;

	1045 }

	1046 }

	1047 }

	1048 return GBREG;

	1049 }

	1050 CJBig2_Image* CJBig2_GRDProc::decode_Arith_V2(

	1051 CJBig2_ArithDecoder* pArithDecoder,

	1052 JBig2ArithCtx* gbContext) {

	1053 FX_BOOL LTP, SLTP, bVal;

	1054 FX_DWORD CONTEXT;

	1055 CJBig2_Image* GBREG;

	1056 FX_DWORD line1, line2, line3;

	1057 LTP = 0;

	1058 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));

	1059 GBREG->fill(0);

	1060 for (FX_DWORD h = 0; h < GBH; h++) {

	1061 if (TPGDON) {

	1062 switch (GBTEMPLATE) {

	1063 case 0:

	1064 CONTEXT = 0x9b25;

	1065 break;

	1066 case 1:

	1067 CONTEXT = 0x0795;

	1068 break;

	1069 case 2:

	1070 CONTEXT = 0x00e5;

	1071 break;

	1072 case 3:

	1073 CONTEXT = 0x0195;

	1074 break;

	1075 }

	1076 SLTP = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	1077 LTP = LTP ^ SLTP;

	1078 }

	1079 if (LTP == 1) {

	1080 GBREG->copyLine(h, h - 1);

	1081 } else {

	1082 switch (GBTEMPLATE) {

	1083 case 0: {

	1084 line1 = GBREG->getPixel(1, h - 2);

	1085 line1 \|= GBREG->getPixel(0, h - 2) << 1;

	1086 line2 = GBREG->getPixel(2, h - 1);

	1087 line2 \|= GBREG->getPixel(1, h - 1) << 1;

	1088 line2 \|= GBREG->getPixel(0, h - 1) << 2;

	1089 line3 = 0;

	1090 for (FX_DWORD w = 0; w < GBW; w++) {

	1091 if (USESKIP && SKIP->getPixel(w, h)) {

	1092 bVal = 0;

	1093 } else {

	1094 CONTEXT = line3;

	1095 CONTEXT \|= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 4;

	1096 CONTEXT \|= line2 << 5;

	1097 CONTEXT \|= GBREG->getPixel(w + GBAT[2], h + GBAT[3]) << 10;

	1098 CONTEXT \|= GBREG->getPixel(w + GBAT[4], h + GBAT[5]) << 11;

	1099 CONTEXT \|= line1 << 12;

	1100 CONTEXT \|= GBREG->getPixel(w + GBAT[6], h + GBAT[7]) << 15;

	1101 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

89 }	1102 }

90 }	1103 if (bVal) {

91 }	1104 GBREG->setPixel(w, h, bVal);

92 return GBREG;	1105 }

93 }	1106 line1 = ((line1 << 1) \| GBREG->getPixel(w + 2, h - 2)) & 0x07;

94 CJBig2_Image CJBig2_GRDProc::decode_Arith_Template0_opt2(CJBig2_ArithDecoder p ArithDecoder, JBig2ArithCtx *gbContext)	1107 line2 = ((line2 << 1) \| GBREG->getPixel(w + 3, h - 1)) & 0x1f;

95 {	1108 line3 = ((line3 << 1) \| bVal) & 0x0f;

96 FX_BOOL LTP, SLTP, bVal;	1109 }

97 FX_DWORD CONTEXT;	1110 } break;

98 CJBig2_Image *GBREG;	1111 case 1: {

99 FX_DWORD line1, line2;	1112 line1 = GBREG->getPixel(2, h - 2);

100 FX_BYTE *pLine, cVal;	1113 line1 \|= GBREG->getPixel(1, h - 2) << 1;

101 FX_INTPTR nStride, nStride2;	1114 line1 \|= GBREG->getPixel(0, h - 2) << 2;

102 FX_INT32 nBits, k;	1115 line2 = GBREG->getPixel(2, h - 1);

103 LTP = 0;	1116 line2 \|= GBREG->getPixel(1, h - 1) << 1;

104 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));	1117 line2 \|= GBREG->getPixel(0, h - 1) << 2;

105 if (GBREG->m_pData == NULL) {	1118 line3 = 0;

106 delete GBREG;	1119 for (FX_DWORD w = 0; w < GBW; w++) {

107 m_pModule->JBig2_Error("Generic region decoding procedure: Create Image Failed with width = %d, height = %d\n", GBW, GBH);	1120 if (USESKIP && SKIP->getPixel(w, h)) {

108 return NULL;	1121 bVal = 0;

109 }	1122 } else {

110 pLine = GBREG->m_pData;	1123 CONTEXT = line3;

111 nStride = GBREG->m_nStride;	1124 CONTEXT \|= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 3;

112 nStride2 = nStride << 1;	1125 CONTEXT \|= line2 << 4;

113 for(FX_DWORD h = 0; h < GBH; h++) {	1126 CONTEXT \|= line1 << 9;

114 if(TPGDON) {	1127 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

115 SLTP = pArithDecoder->DECODE(&gbContext[0x9b25]);	1128 }

116 LTP = LTP ^ SLTP;	1129 if (bVal) {

117 }	1130 GBREG->setPixel(w, h, bVal);

118 if(LTP == 1) {	1131 }

119 GBREG->copyLine(h, h - 1);	1132 line1 = ((line1 << 1) \| GBREG->getPixel(w + 3, h - 2)) & 0x0f;

	1133 line2 = ((line2 << 1) \| GBREG->getPixel(w + 3, h - 1)) & 0x1f;

	1134 line3 = ((line3 << 1) \| bVal) & 0x07;

	1135 }

	1136 } break;

	1137 case 2: {

	1138 line1 = GBREG->getPixel(1, h - 2);

	1139 line1 \|= GBREG->getPixel(0, h - 2) << 1;

	1140 line2 = GBREG->getPixel(1, h - 1);

	1141 line2 \|= GBREG->getPixel(0, h - 1) << 1;

	1142 line3 = 0;

	1143 for (FX_DWORD w = 0; w < GBW; w++) {

	1144 if (USESKIP && SKIP->getPixel(w, h)) {

	1145 bVal = 0;

	1146 } else {

	1147 CONTEXT = line3;

	1148 CONTEXT \|= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 2;

	1149 CONTEXT \|= line2 << 3;

	1150 CONTEXT \|= line1 << 7;

	1151 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	1152 }

	1153 if (bVal) {

	1154 GBREG->setPixel(w, h, bVal);

	1155 }

	1156 line1 = ((line1 << 1) \| GBREG->getPixel(w + 2, h - 2)) & 0x07;

	1157 line2 = ((line2 << 1) \| GBREG->getPixel(w + 2, h - 1)) & 0x0f;

	1158 line3 = ((line3 << 1) \| bVal) & 0x03;

	1159 }

	1160 } break;

	1161 case 3: {

	1162 line1 = GBREG->getPixel(1, h - 1);

	1163 line1 \|= GBREG->getPixel(0, h - 1) << 1;

	1164 line2 = 0;

	1165 for (FX_DWORD w = 0; w < GBW; w++) {

	1166 if (USESKIP && SKIP->getPixel(w, h)) {

	1167 bVal = 0;

	1168 } else {

	1169 CONTEXT = line2;

	1170 CONTEXT \|= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 4;

	1171 CONTEXT \|= line1 << 5;

	1172 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	1173 }

	1174 if (bVal) {

	1175 GBREG->setPixel(w, h, bVal);

	1176 }

	1177 line1 = ((line1 << 1) \| GBREG->getPixel(w + 2, h - 1)) & 0x1f;

	1178 line2 = ((line2 << 1) \| bVal) & 0x0f;

	1179 }

	1180 } break;

	1181 }

	1182 }

	1183 }

	1184 return GBREG;

	1185 }

	1186 CJBig2_Image* CJBig2_GRDProc::decode_Arith_V1(

	1187 CJBig2_ArithDecoder* pArithDecoder,

	1188 JBig2ArithCtx* gbContext) {

	1189 FX_BOOL LTP, SLTP, bVal;

	1190 FX_DWORD CONTEXT = 0;

	1191 CJBig2_Image* GBREG;

	1192 LTP = 0;

	1193 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));

	1194 GBREG->fill(0);

	1195 for (FX_DWORD h = 0; h < GBH; h++) {

	1196 if (TPGDON) {

	1197 switch (GBTEMPLATE) {

	1198 case 0:

	1199 CONTEXT = 0x9b25;

	1200 break;

	1201 case 1:

	1202 CONTEXT = 0x0795;

	1203 break;

	1204 case 2:

	1205 CONTEXT = 0x00e5;

	1206 break;

	1207 case 3:

	1208 CONTEXT = 0x0195;

	1209 break;

	1210 }

	1211 SLTP = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	1212 LTP = LTP ^ SLTP;

	1213 }

	1214 if (LTP == 1) {

	1215 for (FX_DWORD w = 0; w < GBW; w++) {

	1216 GBREG->setPixel(w, h, GBREG->getPixel(w, h - 1));

	1217 }

	1218 } else {

	1219 for (FX_DWORD w = 0; w < GBW; w++) {

	1220 if (USESKIP && SKIP->getPixel(w, h)) {

	1221 GBREG->setPixel(w, h, 0);

120 } else {	1222 } else {

121 line1 = (h > 1) ? pLine[-nStride2] << 6 : 0;	1223 CONTEXT = 0;

122 line2 = (h > 0) ? pLine[-nStride] : 0;	1224 switch (GBTEMPLATE) {

123 CONTEXT = (line1 & 0xf800) \| (line2 & 0x07f0);	1225 case 0:

124 for(FX_DWORD w = 0; w < GBW; w += 8) {	1226 CONTEXT \|= GBREG->getPixel(w - 1, h);

125 if(w + 8 < GBW) {	1227 CONTEXT \|= GBREG->getPixel(w - 2, h) << 1;

126 nBits = 8;	1228 CONTEXT \|= GBREG->getPixel(w - 3, h) << 2;

127 if(h > 1) {	1229 CONTEXT \|= GBREG->getPixel(w - 4, h) << 3;

128 line1 = (line1 << 8) \| (pLine[-nStride2 + (w >> 3) + 1] << 6);	1230 CONTEXT \|= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 4;

129 }	1231 CONTEXT \|= GBREG->getPixel(w + 2, h - 1) << 5;

130 if(h > 0) {	1232 CONTEXT \|= GBREG->getPixel(w + 1, h - 1) << 6;

131 line2 = (line2 << 8) \| (pLine[-nStride + (w >> 3) + 1]);	1233 CONTEXT \|= GBREG->getPixel(w, h - 1) << 7;

132 }	1234 CONTEXT \|= GBREG->getPixel(w - 1, h - 1) << 8;

133 } else {	1235 CONTEXT \|= GBREG->getPixel(w - 2, h - 1) << 9;

134 nBits = GBW - w;	1236 CONTEXT \|= GBREG->getPixel(w + GBAT[2], h + GBAT[3]) << 10;

135 if(h > 1) {	1237 CONTEXT \|= GBREG->getPixel(w + GBAT[4], h + GBAT[5]) << 11;

136 line1 <<= 8;	1238 CONTEXT \|= GBREG->getPixel(w + 1, h - 2) << 12;

137 }	1239 CONTEXT \|= GBREG->getPixel(w, h - 2) << 13;

138 if(h > 0) {	1240 CONTEXT \|= GBREG->getPixel(w - 1, h - 2) << 14;

139 line2 <<= 8;	1241 CONTEXT \|= GBREG->getPixel(w + GBAT[6], h + GBAT[7]) << 15;

140 }	1242 break;

141 }	1243 case 1:

142 cVal = 0;	1244 CONTEXT \|= GBREG->getPixel(w - 1, h);

143 for(k = 0; k < nBits; k++) {	1245 CONTEXT \|= GBREG->getPixel(w - 2, h) << 1;

144 if(USESKIP && SKIP->getPixel(w, h)) {	1246 CONTEXT \|= GBREG->getPixel(w - 3, h) << 2;

145 bVal = 0;	1247 CONTEXT \|= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 3;

146 } else {	1248 CONTEXT \|= GBREG->getPixel(w + 2, h - 1) << 4;

147 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);	1249 CONTEXT \|= GBREG->getPixel(w + 1, h - 1) << 5;

148 }	1250 CONTEXT \|= GBREG->getPixel(w, h - 1) << 6;

149 cVal \|= bVal << (7 - k);	1251 CONTEXT \|= GBREG->getPixel(w - 1, h - 1) << 7;

150 CONTEXT = ((CONTEXT & 0x7bf7) << 1) \| bVal	1252 CONTEXT \|= GBREG->getPixel(w - 2, h - 1) << 8;

151 \| ((line1 >> (7 - k)) & 0x0800)	1253 CONTEXT \|= GBREG->getPixel(w + 2, h - 2) << 9;

152 \| ((line2 >> (7 - k)) & 0x0010);	1254 CONTEXT \|= GBREG->getPixel(w + 1, h - 2) << 10;

153 }	1255 CONTEXT \|= GBREG->getPixel(w, h - 2) << 11;

154 pLine[w >> 3] = cVal;	1256 CONTEXT \|= GBREG->getPixel(w - 1, h - 2) << 12;

155 }	1257 break;

156 }	1258 case 2:

157 pLine += nStride;	1259 CONTEXT \|= GBREG->getPixel(w - 1, h);

158 }	1260 CONTEXT \|= GBREG->getPixel(w - 2, h) << 1;

159 return GBREG;	1261 CONTEXT \|= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 2;

160 }	1262 CONTEXT \|= GBREG->getPixel(w + 1, h - 1) << 3;

161 CJBig2_Image CJBig2_GRDProc::decode_Arith_Template0_opt3(CJBig2_ArithDecoder p ArithDecoder, JBig2ArithCtx *gbContext)	1263 CONTEXT \|= GBREG->getPixel(w, h - 1) << 4;

162 {	1264 CONTEXT \|= GBREG->getPixel(w - 1, h - 1) << 5;

163 FX_BOOL LTP, SLTP, bVal;	1265 CONTEXT \|= GBREG->getPixel(w - 2, h - 1) << 6;

164 FX_DWORD CONTEXT;	1266 CONTEXT \|= GBREG->getPixel(w + 1, h - 2) << 7;

165 CJBig2_Image *GBREG;	1267 CONTEXT \|= GBREG->getPixel(w, h - 2) << 8;

166 FX_DWORD line1, line2;	1268 CONTEXT \|= GBREG->getPixel(w - 1, h - 2) << 9;

167 FX_BYTE pLine, pLine1, *pLine2, cVal;	1269 break;

168 FX_INT32 nStride, nStride2, k;	1270 case 3:

169 FX_INT32 nLineBytes, nBitsLeft, cc;	1271 CONTEXT \|= GBREG->getPixel(w - 1, h);

170 LTP = 0;	1272 CONTEXT \|= GBREG->getPixel(w - 2, h) << 1;

171 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));	1273 CONTEXT \|= GBREG->getPixel(w - 3, h) << 2;

172 if (GBREG->m_pData == NULL) {	1274 CONTEXT \|= GBREG->getPixel(w - 4, h) << 3;

173 delete GBREG;	1275 CONTEXT \|= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 4;

174 m_pModule->JBig2_Error("Generic region decoding procedure: Create Image Failed with width = %d, height = %d\n", GBW, GBH);	1276 CONTEXT \|= GBREG->getPixel(w + 1, h - 1) << 5;

175 return NULL;	1277 CONTEXT \|= GBREG->getPixel(w, h - 1) << 6;

176 }	1278 CONTEXT \|= GBREG->getPixel(w - 1, h - 1) << 7;

177 pLine = GBREG->m_pData;	1279 CONTEXT \|= GBREG->getPixel(w - 2, h - 1) << 8;

178 nStride = GBREG->m_nStride;	1280 CONTEXT \|= GBREG->getPixel(w - 3, h - 1) << 9;

179 nStride2 = nStride << 1;	1281 break;

180 nLineBytes = ((GBW + 7) >> 3) - 1;	1282 }

181 nBitsLeft = GBW - (nLineBytes << 3);	1283 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

182 FX_DWORD height = GBH & 0x7fffffff;	1284 GBREG->setPixel(w, h, bVal);

183 for(FX_DWORD h = 0; h < height; h++) {	1285 }

184 if(TPGDON) {	1286 }

185 SLTP = pArithDecoder->DECODE(&gbContext[0x9b25]);	1287 }

186 LTP = LTP ^ SLTP;	1288 }

187 }	1289 return GBREG;

188 if(LTP == 1) {	1290 }

189 GBREG->copyLine(h, h - 1);	1291 CJBig2_Image* CJBig2_GRDProc::decode_MMR(CJBig2_BitStream* pStream) {

	1292 int bitpos, i;

	1293 CJBig2_Image* pImage;

	1294 JBIG2_ALLOC(pImage, CJBig2_Image(GBW, GBH));

	1295 if (pImage->m_pData == NULL) {

	1296 delete pImage;

	1297 m_pModule->JBig2_Error(

	1298 "Generic region decoding procedure: Create Image Failed with width = "

	1299 "%d, height = %d\n",

	1300 GBW,

	1301 GBH);

	1302 return NULL;

	1303 }

	1304 bitpos = (int)pStream->getBitPos();

	1305 _FaxG4Decode(m_pModule,

	1306 pStream->getBuf(),

	1307 pStream->getLength(),

	1308 &bitpos,

	1309 pImage->m_pData,

	1310 GBW,

	1311 GBH,

	1312 pImage->m_nStride);

	1313 pStream->setBitPos(bitpos);

	1314 for (i = 0; (FX_DWORD)i < pImage->m_nStride * GBH; i++) {

	1315 pImage->m_pData[i] = ~pImage->m_pData[i];

	1316 }

	1317 return pImage;

	1318 }

	1319 CJBig2_Image* CJBig2_GRRDProc::decode(CJBig2_ArithDecoder* pArithDecoder,

	1320 JBig2ArithCtx* grContext) {

	1321 if (GRW == 0 \|\| GRH == 0) {

	1322 CJBig2_Image* pImage;

	1323 JBIG2_ALLOC(pImage, CJBig2_Image(GRW, GRH));

	1324 return pImage;

	1325 }

	1326 if (GRTEMPLATE == 0) {

	1327 if ((GRAT[0] == (signed char)-1) && (GRAT[1] == (signed char)-1) &&

	1328 (GRAT[2] == (signed char)-1) && (GRAT[3] == (signed char)-1) &&

	1329 (GRREFERENCEDX == 0) && (GRW == (FX_DWORD)GRREFERENCE->m_nWidth)) {

	1330 return decode_Template0_opt(pArithDecoder, grContext);

	1331 } else {

	1332 return decode_Template0_unopt(pArithDecoder, grContext);

	1333 }

	1334 } else {

	1335 if ((GRREFERENCEDX == 0) && (GRW == (FX_DWORD)GRREFERENCE->m_nWidth)) {

	1336 return decode_Template1_opt(pArithDecoder, grContext);

	1337 } else {

	1338 return decode_Template1_unopt(pArithDecoder, grContext);

	1339 }

	1340 }

	1341 }

	1342 CJBig2_Image* CJBig2_GRRDProc::decode_Template0_unopt(

	1343 CJBig2_ArithDecoder* pArithDecoder,

	1344 JBig2ArithCtx* grContext) {

	1345 FX_BOOL LTP, SLTP, bVal;

	1346 FX_DWORD CONTEXT;

	1347 CJBig2_Image* GRREG;

	1348 FX_DWORD line1, line2, line3, line4, line5;

	1349 LTP = 0;

	1350 JBIG2_ALLOC(GRREG, CJBig2_Image(GRW, GRH));

	1351 GRREG->fill(0);

	1352 for (FX_DWORD h = 0; h < GRH; h++) {

	1353 if (TPGRON) {

	1354 SLTP = pArithDecoder->DECODE(&grContext[0x0010]);

	1355 LTP = LTP ^ SLTP;

	1356 }

	1357 if (LTP == 0) {

	1358 line1 = GRREG->getPixel(1, h - 1);

	1359 line1 \|= GRREG->getPixel(0, h - 1) << 1;

	1360 line2 = 0;

	1361 line3 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY - 1);

	1362 line3 \|= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY - 1)

	1363 << 1;

	1364 line4 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY);

	1365 line4 \|= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY) << 1;

	1366 line4 \|= GRREFERENCE->getPixel(-GRREFERENCEDX - 1, h - GRREFERENCEDY)

	1367 << 2;

	1368 line5 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY + 1);

	1369 line5 \|= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY + 1)

	1370 << 1;

	1371 line5 \|= GRREFERENCE->getPixel(-GRREFERENCEDX - 1, h - GRREFERENCEDY + 1)

	1372 << 2;

	1373 for (FX_DWORD w = 0; w < GRW; w++) {

	1374 CONTEXT = line5;

	1375 CONTEXT \|= line4 << 3;

	1376 CONTEXT \|= line3 << 6;

	1377 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX + GRAT[2],

	1378 h - GRREFERENCEDY + GRAT[3])

	1379 << 8;

	1380 CONTEXT \|= line2 << 9;

	1381 CONTEXT \|= line1 << 10;

	1382 CONTEXT \|= GRREG->getPixel(w + GRAT[0], h + GRAT[1]) << 12;

	1383 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);

	1384 GRREG->setPixel(w, h, bVal);

	1385 line1 = ((line1 << 1) \| GRREG->getPixel(w + 2, h - 1)) & 0x03;

	1386 line2 = ((line2 << 1) \| bVal) & 0x01;

	1387 line3 = ((line3 << 1) \|

	1388 GRREFERENCE->getPixel(w - GRREFERENCEDX + 2,

	1389 h - GRREFERENCEDY - 1)) &

	1390 0x03;

	1391 line4 =

	1392 ((line4 << 1) \|

	1393 GRREFERENCE->getPixel(w - GRREFERENCEDX + 2, h - GRREFERENCEDY)) &

	1394 0x07;

	1395 line5 = ((line5 << 1) \|

	1396 GRREFERENCE->getPixel(w - GRREFERENCEDX + 2,

	1397 h - GRREFERENCEDY + 1)) &

	1398 0x07;

	1399 }

	1400 } else {

	1401 line1 = GRREG->getPixel(1, h - 1);

	1402 line1 \|= GRREG->getPixel(0, h - 1) << 1;

	1403 line2 = 0;

	1404 line3 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY - 1);

	1405 line3 \|= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY - 1)

	1406 << 1;

	1407 line4 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY);

	1408 line4 \|= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY) << 1;

	1409 line4 \|= GRREFERENCE->getPixel(-GRREFERENCEDX - 1, h - GRREFERENCEDY)

	1410 << 2;

	1411 line5 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY + 1);

	1412 line5 \|= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY + 1)

	1413 << 1;

	1414 line5 \|= GRREFERENCE->getPixel(-GRREFERENCEDX - 1, h - GRREFERENCEDY + 1)

	1415 << 2;

	1416 for (FX_DWORD w = 0; w < GRW; w++) {

	1417 bVal = GRREFERENCE->getPixel(w, h);

	1418 if (!(TPGRON && (bVal == GRREFERENCE->getPixel(w - 1, h - 1)) &&

	1419 (bVal == GRREFERENCE->getPixel(w, h - 1)) &&

	1420 (bVal == GRREFERENCE->getPixel(w + 1, h - 1)) &&

	1421 (bVal == GRREFERENCE->getPixel(w - 1, h)) &&

	1422 (bVal == GRREFERENCE->getPixel(w + 1, h)) &&

	1423 (bVal == GRREFERENCE->getPixel(w - 1, h + 1)) &&

	1424 (bVal == GRREFERENCE->getPixel(w, h + 1)) &&

	1425 (bVal == GRREFERENCE->getPixel(w + 1, h + 1)))) {

	1426 CONTEXT = line5;

	1427 CONTEXT \|= line4 << 3;

	1428 CONTEXT \|= line3 << 6;

	1429 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX + GRAT[2],

	1430 h - GRREFERENCEDY + GRAT[3])

	1431 << 8;

	1432 CONTEXT \|= line2 << 9;

	1433 CONTEXT \|= line1 << 10;

	1434 CONTEXT \|= GRREG->getPixel(w + GRAT[0], h + GRAT[1]) << 12;

	1435 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);

	1436 }

	1437 GRREG->setPixel(w, h, bVal);

	1438 line1 = ((line1 << 1) \| GRREG->getPixel(w + 2, h - 1)) & 0x03;

	1439 line2 = ((line2 << 1) \| bVal) & 0x01;

	1440 line3 = ((line3 << 1) \|

	1441 GRREFERENCE->getPixel(w - GRREFERENCEDX + 2,

	1442 h - GRREFERENCEDY - 1)) &

	1443 0x03;

	1444 line4 =

	1445 ((line4 << 1) \|

	1446 GRREFERENCE->getPixel(w - GRREFERENCEDX + 2, h - GRREFERENCEDY)) &

	1447 0x07;

	1448 line5 = ((line5 << 1) \|

	1449 GRREFERENCE->getPixel(w - GRREFERENCEDX + 2,

	1450 h - GRREFERENCEDY + 1)) &

	1451 0x07;

	1452 }

	1453 }

	1454 }

	1455 return GRREG;

	1456 }

	1457 CJBig2_Image* CJBig2_GRRDProc::decode_Template0_opt(

	1458 CJBig2_ArithDecoder* pArithDecoder,

	1459 JBig2ArithCtx* grContext) {

	1460 FX_BOOL LTP, SLTP, bVal;

	1461 FX_DWORD CONTEXT;

	1462 CJBig2_Image* GRREG;

	1463 FX_DWORD line1, line1_r, line2_r, line3_r;

	1464 FX_BYTE* pLine, *pLineR, cVal;

	1465 FX_INTPTR nStride, nStrideR, nOffset;

	1466 FX_INT32 k, nBits;

	1467 FX_INT32 GRWR, GRHR;

	1468 FX_INT32 GRW, GRH;

	1469 GRW = (FX_INT32)CJBig2_GRRDProc::GRW;

	1470 GRH = (FX_INT32)CJBig2_GRRDProc::GRH;

	1471 LTP = 0;

	1472 JBIG2_ALLOC(GRREG, CJBig2_Image(GRW, GRH));

	1473 if (GRREG->m_pData == NULL) {

	1474 delete GRREG;

	1475 m_pModule->JBig2_Error(

	1476 "Generic refinement region decoding procedure: Create Image Failed "

	1477 "with width = %d, height = %d\n",

	1478 GRW,

	1479 GRH);

	1480 return NULL;

	1481 }

	1482 pLine = GRREG->m_pData;

	1483 pLineR = GRREFERENCE->m_pData;

	1484 nStride = GRREG->m_nStride;

	1485 nStrideR = GRREFERENCE->m_nStride;

	1486 GRWR = (FX_INT32)GRREFERENCE->m_nWidth;

	1487 GRHR = (FX_INT32)GRREFERENCE->m_nHeight;

	1488 if (GRREFERENCEDY < -GRHR + 1 \|\| GRREFERENCEDY > GRHR - 1) {

	1489 GRREFERENCEDY = 0;

	1490 }

	1491 nOffset = -GRREFERENCEDY * nStrideR;

	1492 for (FX_INT32 h = 0; h < GRH; h++) {

	1493 if (TPGRON) {

	1494 SLTP = pArithDecoder->DECODE(&grContext[0x0010]);

	1495 LTP = LTP ^ SLTP;

	1496 }

	1497 line1 = (h > 0) ? pLine[-nStride] << 4 : 0;

	1498 FX_INT32 reference_h = h - GRREFERENCEDY;

	1499 FX_BOOL line1_r_ok = (reference_h > 0 && reference_h < GRHR + 1);

	1500 FX_BOOL line2_r_ok = (reference_h > -1 && reference_h < GRHR);

	1501 FX_BOOL line3_r_ok = (reference_h > -2 && reference_h < GRHR - 1);

	1502 line1_r = line1_r_ok ? pLineR[nOffset - nStrideR] : 0;

	1503 line2_r = line2_r_ok ? pLineR[nOffset] : 0;

	1504 line3_r = line3_r_ok ? pLineR[nOffset + nStrideR] : 0;

	1505 if (LTP == 0) {

	1506 CONTEXT = (line1 & 0x1c00) \| (line1_r & 0x01c0) \|

	1507 ((line2_r >> 3) & 0x0038) \| ((line3_r >> 6) & 0x0007);

	1508 for (FX_INT32 w = 0; w < GRW; w += 8) {

	1509 nBits = GRW - w > 8 ? 8 : GRW - w;

	1510 if (h > 0)

	1511 line1 = (line1 << 8) \|

	1512 (w + 8 < GRW ? pLine[-nStride + (w >> 3) + 1] << 4 : 0);

	1513 if (h > GRHR + GRREFERENCEDY + 1) {

	1514 line1_r = 0;

	1515 line2_r = 0;

	1516 line3_r = 0;

190 } else {	1517 } else {

191 if(h > 1) {	1518 if (line1_r_ok)

192 pLine1 = pLine - nStride2;	1519 line1_r =

193 pLine2 = pLine - nStride;	1520 (line1_r << 8) \|

194 line1 = (*pLine1++) << 6;	1521 (w + 8 < GRWR ? pLineR[nOffset - nStrideR + (w >> 3) + 1] : 0);

195 line2 = *pLine2++;	1522 if (line2_r_ok)

196 CONTEXT = ((line1 & 0xf800) \| (line2 & 0x07f0));	1523 line2_r = (line2_r << 8) \|

197 for(cc = 0; cc < nLineBytes; cc++) {	1524 (w + 8 < GRWR ? pLineR[nOffset + (w >> 3) + 1] : 0);

198 line1 = (line1 << 8) \| ((*pLine1++) << 6);	1525 if (line3_r_ok)

199 line2 = (line2 << 8) \| (*pLine2++);	1526 line3_r =

200 cVal = 0;	1527 (line3_r << 8) \|

201 for(k = 7; k >= 0; k--) {	1528 (w + 8 < GRWR ? pLineR[nOffset + nStrideR + (w >> 3) + 1] : 0);

202 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);	1529 else {

203 cVal \|= bVal << k;	1530 line3_r = 0;

204 CONTEXT = (((CONTEXT & 0x7bf7) << 1) \| bVal	1531 }

205 \| ((line1 >> k) & 0x0800)	1532 }

206 \| ((line2 >> k) & 0x0010));	1533 cVal = 0;

207 }	1534 for (k = 0; k < nBits; k++) {

208 pLine[cc] = cVal;	1535 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);

209 }	1536 cVal \|= bVal << (7 - k);

210 line1 <<= 8;	1537 CONTEXT = ((CONTEXT & 0x0cdb) << 1) \| (bVal << 9) \|

211 line2 <<= 8;	1538 ((line1 >> (7 - k)) & 0x0400) \|

212 cVal = 0;	1539 ((line1_r >> (7 - k)) & 0x0040) \|

213 for(k = 0; k < nBitsLeft; k++) {	1540 ((line2_r >> (10 - k)) & 0x0008) \|

214 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);	1541 ((line3_r >> (13 - k)) & 0x0001);

215 cVal \|= bVal << (7 - k);	1542 }

216 CONTEXT = (((CONTEXT & 0x7bf7) << 1) \| bVal	1543 pLine[w >> 3] = cVal;

217 \| ((line1 >> (7 - k)) & 0x0800)	1544 }

218 \| ((line2 >> (7 - k)) & 0x0010));	1545 } else {

219 }	1546 CONTEXT = (line1 & 0x1c00) \| (line1_r & 0x01c0) \|

220 pLine[nLineBytes] = cVal;	1547 ((line2_r >> 3) & 0x0038) \| ((line3_r >> 6) & 0x0007);

221 } else {	1548 for (FX_INT32 w = 0; w < GRW; w += 8) {

222 pLine2 = pLine - nStride;	1549 nBits = GRW - w > 8 ? 8 : GRW - w;

223 line2 = (h & 1) ? (*pLine2++) : 0;	1550 if (h > 0)

224 CONTEXT = (line2 & 0x07f0);	1551 line1 = (line1 << 8) \|

225 for(cc = 0; cc < nLineBytes; cc++) {	1552 (w + 8 < GRW ? pLine[-nStride + (w >> 3) + 1] << 4 : 0);

226 if(h & 1) {	1553 if (line1_r_ok)

227 line2 = (line2 << 8) \| (*pLine2++);	1554 line1_r =

228 }	1555 (line1_r << 8) \|

229 cVal = 0;	1556 (w + 8 < GRWR ? pLineR[nOffset - nStrideR + (w >> 3) + 1] : 0);

230 for(k = 7; k >= 0; k--) {	1557 if (line2_r_ok)

231 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);	1558 line2_r = (line2_r << 8) \|

232 cVal \|= bVal << k;	1559 (w + 8 < GRWR ? pLineR[nOffset + (w >> 3) + 1] : 0);

233 CONTEXT = (((CONTEXT & 0x7bf7) << 1) \| bVal	1560 if (line3_r_ok)

234 \| ((line2 >> k) & 0x0010));	1561 line3_r =

235 }	1562 (line3_r << 8) \|

236 pLine[cc] = cVal;	1563 (w + 8 < GRWR ? pLineR[nOffset + nStrideR + (w >> 3) + 1] : 0);

237 }	1564 else {

238 line2 <<= 8;	1565 line3_r = 0;

239 cVal = 0;	1566 }

240 for(k = 0; k < nBitsLeft; k++) {	1567 cVal = 0;

241 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);	1568 for (k = 0; k < nBits; k++) {

242 cVal \|= bVal << (7 - k);	1569 bVal = GRREFERENCE->getPixel(w + k, h);

243 CONTEXT = (((CONTEXT & 0x7bf7) << 1) \| bVal	1570 if (!(TPGRON && (bVal == GRREFERENCE->getPixel(w + k - 1, h - 1)) &&

244 \| (((line2 >> (7 - k))) & 0x0010));	1571 (bVal == GRREFERENCE->getPixel(w + k, h - 1)) &&

245 }	1572 (bVal == GRREFERENCE->getPixel(w + k + 1, h - 1)) &&

246 pLine[nLineBytes] = cVal;	1573 (bVal == GRREFERENCE->getPixel(w + k - 1, h)) &&

247 }	1574 (bVal == GRREFERENCE->getPixel(w + k + 1, h)) &&

248 }	1575 (bVal == GRREFERENCE->getPixel(w + k - 1, h + 1)) &&

249 pLine += nStride;	1576 (bVal == GRREFERENCE->getPixel(w + k, h + 1)) &&

250 }	1577 (bVal == GRREFERENCE->getPixel(w + k + 1, h + 1)))) {

251 return GBREG;	1578 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);

252 }	1579 }

253 CJBig2_Image CJBig2_GRDProc::decode_Arith_Template0_unopt(CJBig2_ArithDecoder pArithDecoder, JBig2ArithCtx *gbContext)	1580 cVal \|= bVal << (7 - k);

254 {	1581 CONTEXT = ((CONTEXT & 0x0cdb) << 1) \| (bVal << 9) \|

255 FX_BOOL LTP, SLTP, bVal;	1582 ((line1 >> (7 - k)) & 0x0400) \|

256 FX_DWORD CONTEXT;	1583 ((line1_r >> (7 - k)) & 0x0040) \|

257 CJBig2_Image *GBREG;	1584 ((line2_r >> (10 - k)) & 0x0008) \|

258 FX_DWORD line1, line2, line3;	1585 ((line3_r >> (13 - k)) & 0x0001);

259 LTP = 0;	1586 }

260 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));	1587 pLine[w >> 3] = cVal;

261 GBREG->fill(0);	1588 }

262 for(FX_DWORD h = 0; h < GBH; h++) {	1589 }

263 if(TPGDON) {	1590 pLine += nStride;

264 SLTP = pArithDecoder->DECODE(&gbContext[0x9b25]);	1591 if (h < GRHR + GRREFERENCEDY) {

265 LTP = LTP ^ SLTP;	1592 pLineR += nStrideR;

266 }	1593 }

267 if(LTP == 1) {	1594 }

268 GBREG->copyLine(h, h - 1);	1595 return GRREG;

	1596 }

	1597 CJBig2_Image* CJBig2_GRRDProc::decode_Template1_unopt(

	1598 CJBig2_ArithDecoder* pArithDecoder,

	1599 JBig2ArithCtx* grContext) {

	1600 FX_BOOL LTP, SLTP, bVal;

	1601 FX_DWORD CONTEXT;

	1602 CJBig2_Image* GRREG;

	1603 FX_DWORD line1, line2, line3, line4, line5;

	1604 LTP = 0;

	1605 JBIG2_ALLOC(GRREG, CJBig2_Image(GRW, GRH));

	1606 GRREG->fill(0);

	1607 for (FX_DWORD h = 0; h < GRH; h++) {

	1608 if (TPGRON) {

	1609 SLTP = pArithDecoder->DECODE(&grContext[0x0008]);

	1610 LTP = LTP ^ SLTP;

	1611 }

	1612 if (LTP == 0) {

	1613 line1 = GRREG->getPixel(1, h - 1);

	1614 line1 \|= GRREG->getPixel(0, h - 1) << 1;

	1615 line1 \|= GRREG->getPixel(-1, h - 1) << 2;

	1616 line2 = 0;

	1617 line3 = GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY - 1);

	1618 line4 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY);

	1619 line4 \|= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY) << 1;

	1620 line4 \|= GRREFERENCE->getPixel(-GRREFERENCEDX - 1, h - GRREFERENCEDY)

	1621 << 2;

	1622 line5 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY + 1);

	1623 line5 \|= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY + 1)

	1624 << 1;

	1625 for (FX_DWORD w = 0; w < GRW; w++) {

	1626 CONTEXT = line5;

	1627 CONTEXT \|= line4 << 2;

	1628 CONTEXT \|= line3 << 5;

	1629 CONTEXT \|= line2 << 6;

	1630 CONTEXT \|= line1 << 7;

	1631 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);

	1632 GRREG->setPixel(w, h, bVal);

	1633 line1 = ((line1 << 1) \| GRREG->getPixel(w + 2, h - 1)) & 0x07;

	1634 line2 = ((line2 << 1) \| bVal) & 0x01;

	1635 line3 = ((line3 << 1) \|

	1636 GRREFERENCE->getPixel(w - GRREFERENCEDX + 1,

	1637 h - GRREFERENCEDY - 1)) &

	1638 0x01;

	1639 line4 =

	1640 ((line4 << 1) \|

	1641 GRREFERENCE->getPixel(w - GRREFERENCEDX + 2, h - GRREFERENCEDY)) &

	1642 0x07;

	1643 line5 = ((line5 << 1) \|

	1644 GRREFERENCE->getPixel(w - GRREFERENCEDX + 2,

	1645 h - GRREFERENCEDY + 1)) &

	1646 0x03;

	1647 }

	1648 } else {

	1649 line1 = GRREG->getPixel(1, h - 1);

	1650 line1 \|= GRREG->getPixel(0, h - 1) << 1;

	1651 line1 \|= GRREG->getPixel(-1, h - 1) << 2;

	1652 line2 = 0;

	1653 line3 = GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY - 1);

	1654 line4 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY);

	1655 line4 \|= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY) << 1;

	1656 line4 \|= GRREFERENCE->getPixel(-GRREFERENCEDX - 1, h - GRREFERENCEDY)

	1657 << 2;

	1658 line5 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY + 1);

	1659 line5 \|= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY + 1)

	1660 << 1;

	1661 for (FX_DWORD w = 0; w < GRW; w++) {

	1662 bVal = GRREFERENCE->getPixel(w, h);

	1663 if (!(TPGRON && (bVal == GRREFERENCE->getPixel(w - 1, h - 1)) &&

	1664 (bVal == GRREFERENCE->getPixel(w, h - 1)) &&

	1665 (bVal == GRREFERENCE->getPixel(w + 1, h - 1)) &&

	1666 (bVal == GRREFERENCE->getPixel(w - 1, h)) &&

	1667 (bVal == GRREFERENCE->getPixel(w + 1, h)) &&

	1668 (bVal == GRREFERENCE->getPixel(w - 1, h + 1)) &&

	1669 (bVal == GRREFERENCE->getPixel(w, h + 1)) &&

	1670 (bVal == GRREFERENCE->getPixel(w + 1, h + 1)))) {

	1671 CONTEXT = line5;

	1672 CONTEXT \|= line4 << 2;

	1673 CONTEXT \|= line3 << 5;

	1674 CONTEXT \|= line2 << 6;

	1675 CONTEXT \|= line1 << 7;

	1676 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);

	1677 }

	1678 GRREG->setPixel(w, h, bVal);

	1679 line1 = ((line1 << 1) \| GRREG->getPixel(w + 2, h - 1)) & 0x07;

	1680 line2 = ((line2 << 1) \| bVal) & 0x01;

	1681 line3 = ((line3 << 1) \|

	1682 GRREFERENCE->getPixel(w - GRREFERENCEDX + 1,

	1683 h - GRREFERENCEDY - 1)) &

	1684 0x01;

	1685 line4 =

	1686 ((line4 << 1) \|

	1687 GRREFERENCE->getPixel(w - GRREFERENCEDX + 2, h - GRREFERENCEDY)) &

	1688 0x07;

	1689 line5 = ((line5 << 1) \|

	1690 GRREFERENCE->getPixel(w - GRREFERENCEDX + 2,

	1691 h - GRREFERENCEDY + 1)) &

	1692 0x03;

	1693 }

	1694 }

	1695 }

	1696 return GRREG;

	1697 }

	1698 CJBig2_Image* CJBig2_GRRDProc::decode_Template1_opt(

	1699 CJBig2_ArithDecoder* pArithDecoder,

	1700 JBig2ArithCtx* grContext) {

	1701 FX_BOOL LTP, SLTP, bVal;

	1702 FX_DWORD CONTEXT;

	1703 CJBig2_Image* GRREG;

	1704 FX_DWORD line1, line1_r, line2_r, line3_r;

	1705 FX_BYTE* pLine, *pLineR, cVal;

	1706 FX_INTPTR nStride, nStrideR, nOffset;

	1707 FX_INT32 k, nBits;

	1708 FX_INT32 GRWR, GRHR;

	1709 FX_INT32 GRW, GRH;

	1710 GRW = (FX_INT32)CJBig2_GRRDProc::GRW;

	1711 GRH = (FX_INT32)CJBig2_GRRDProc::GRH;

	1712 LTP = 0;

	1713 JBIG2_ALLOC(GRREG, CJBig2_Image(GRW, GRH));

	1714 if (GRREG->m_pData == NULL) {

	1715 delete GRREG;

	1716 m_pModule->JBig2_Error(

	1717 "Generic refinement region decoding procedure: Create Image Failed "

	1718 "with width = %d, height = %d\n",

	1719 GRW,

	1720 GRH);

	1721 return NULL;

	1722 }

	1723 pLine = GRREG->m_pData;

	1724 pLineR = GRREFERENCE->m_pData;

	1725 nStride = GRREG->m_nStride;

	1726 nStrideR = GRREFERENCE->m_nStride;

	1727 GRWR = (FX_INT32)GRREFERENCE->m_nWidth;

	1728 GRHR = (FX_INT32)GRREFERENCE->m_nHeight;

	1729 if (GRREFERENCEDY < -GRHR + 1 \|\| GRREFERENCEDY > GRHR - 1) {

	1730 GRREFERENCEDY = 0;

	1731 }

	1732 nOffset = -GRREFERENCEDY * nStrideR;

	1733 for (FX_INT32 h = 0; h < GRH; h++) {

	1734 if (TPGRON) {

	1735 SLTP = pArithDecoder->DECODE(&grContext[0x0008]);

	1736 LTP = LTP ^ SLTP;

	1737 }

	1738 line1 = (h > 0) ? pLine[-nStride] << 1 : 0;

	1739 FX_INT32 reference_h = h - GRREFERENCEDY;

	1740 FX_BOOL line1_r_ok = (reference_h > 0 && reference_h < GRHR + 1);

	1741 FX_BOOL line2_r_ok = (reference_h > -1 && reference_h < GRHR);

	1742 FX_BOOL line3_r_ok = (reference_h > -2 && reference_h < GRHR - 1);

	1743 line1_r = line1_r_ok ? pLineR[nOffset - nStrideR] : 0;

	1744 line2_r = line2_r_ok ? pLineR[nOffset] : 0;

	1745 line3_r = line3_r_ok ? pLineR[nOffset + nStrideR] : 0;

	1746 if (LTP == 0) {

	1747 CONTEXT = (line1 & 0x0380) \| ((line1_r >> 2) & 0x0020) \|

	1748 ((line2_r >> 4) & 0x001c) \| ((line3_r >> 6) & 0x0003);

	1749 for (FX_INT32 w = 0; w < GRW; w += 8) {

	1750 nBits = GRW - w > 8 ? 8 : GRW - w;

	1751 if (h > 0)

	1752 line1 = (line1 << 8) \|

	1753 (w + 8 < GRW ? pLine[-nStride + (w >> 3) + 1] << 1 : 0);

	1754 if (line1_r_ok)

	1755 line1_r =

	1756 (line1_r << 8) \|

	1757 (w + 8 < GRWR ? pLineR[nOffset - nStrideR + (w >> 3) + 1] : 0);

	1758 if (line2_r_ok)

	1759 line2_r = (line2_r << 8) \|

	1760 (w + 8 < GRWR ? pLineR[nOffset + (w >> 3) + 1] : 0);

	1761 if (line3_r_ok)

	1762 line3_r =

	1763 (line3_r << 8) \|

	1764 (w + 8 < GRWR ? pLineR[nOffset + nStrideR + (w >> 3) + 1] : 0);

	1765 else {

	1766 line3_r = 0;

	1767 }

	1768 cVal = 0;

	1769 for (k = 0; k < nBits; k++) {

	1770 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);

	1771 cVal \|= bVal << (7 - k);

	1772 CONTEXT = ((CONTEXT & 0x018d) << 1) \| (bVal << 6) \|

	1773 ((line1 >> (7 - k)) & 0x0080) \|

	1774 ((line1_r >> (9 - k)) & 0x0020) \|

	1775 ((line2_r >> (11 - k)) & 0x0004) \|

	1776 ((line3_r >> (13 - k)) & 0x0001);

	1777 }

	1778 pLine[w >> 3] = cVal;

	1779 }

	1780 } else {

	1781 CONTEXT = (line1 & 0x0380) \| ((line1_r >> 2) & 0x0020) \|

	1782 ((line2_r >> 4) & 0x001c) \| ((line3_r >> 6) & 0x0003);

	1783 for (FX_INT32 w = 0; w < GRW; w += 8) {

	1784 nBits = GRW - w > 8 ? 8 : GRW - w;

	1785 if (h > 0)

	1786 line1 = (line1 << 8) \|

	1787 (w + 8 < GRW ? pLine[-nStride + (w >> 3) + 1] << 1 : 0);

	1788 if (line1_r_ok)

	1789 line1_r =

	1790 (line1_r << 8) \|

	1791 (w + 8 < GRWR ? pLineR[nOffset - nStrideR + (w >> 3) + 1] : 0);

	1792 if (line2_r_ok)

	1793 line2_r = (line2_r << 8) \|

	1794 (w + 8 < GRWR ? pLineR[nOffset + (w >> 3) + 1] : 0);

	1795 if (line3_r_ok)

	1796 line3_r =

	1797 (line3_r << 8) \|

	1798 (w + 8 < GRWR ? pLineR[nOffset + nStrideR + (w >> 3) + 1] : 0);

	1799 else {

	1800 line3_r = 0;

	1801 }

	1802 cVal = 0;

	1803 for (k = 0; k < nBits; k++) {

	1804 bVal = GRREFERENCE->getPixel(w + k, h);

	1805 if (!(TPGRON && (bVal == GRREFERENCE->getPixel(w + k - 1, h - 1)) &&

	1806 (bVal == GRREFERENCE->getPixel(w + k, h - 1)) &&

	1807 (bVal == GRREFERENCE->getPixel(w + k + 1, h - 1)) &&

	1808 (bVal == GRREFERENCE->getPixel(w + k - 1, h)) &&

	1809 (bVal == GRREFERENCE->getPixel(w + k + 1, h)) &&

	1810 (bVal == GRREFERENCE->getPixel(w + k - 1, h + 1)) &&

	1811 (bVal == GRREFERENCE->getPixel(w + k, h + 1)) &&

	1812 (bVal == GRREFERENCE->getPixel(w + k + 1, h + 1)))) {

	1813 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);

	1814 }

	1815 cVal \|= bVal << (7 - k);

	1816 CONTEXT = ((CONTEXT & 0x018d) << 1) \| (bVal << 6) \|

	1817 ((line1 >> (7 - k)) & 0x0080) \|

	1818 ((line1_r >> (9 - k)) & 0x0020) \|

	1819 ((line2_r >> (11 - k)) & 0x0004) \|

	1820 ((line3_r >> (13 - k)) & 0x0001);

	1821 }

	1822 pLine[w >> 3] = cVal;

	1823 }

	1824 }

	1825 pLine += nStride;

	1826 if (h < GRHR + GRREFERENCEDY) {

	1827 pLineR += nStrideR;

	1828 }

	1829 }

	1830 return GRREG;

	1831 }

	1832 CJBig2_Image* CJBig2_GRRDProc::decode_V1(CJBig2_ArithDecoder* pArithDecoder,

	1833 JBig2ArithCtx* grContext) {

	1834 FX_BOOL LTP, SLTP, bVal;

	1835 FX_BOOL TPGRPIX, TPGRVAL;

	1836 FX_DWORD CONTEXT;

	1837 CJBig2_Image* GRREG;

	1838 LTP = 0;

	1839 JBIG2_ALLOC(GRREG, CJBig2_Image(GRW, GRH));

	1840 GRREG->fill(0);

	1841 for (FX_DWORD h = 0; h < GRH; h++) {

	1842 if (TPGRON) {

	1843 switch (GRTEMPLATE) {

	1844 case 0:

	1845 CONTEXT = 0x0010;

	1846 break;

	1847 case 1:

	1848 CONTEXT = 0x0008;

	1849 break;

	1850 }

	1851 SLTP = pArithDecoder->DECODE(&grContext[CONTEXT]);

	1852 LTP = LTP ^ SLTP;

	1853 }

	1854 if (LTP == 0) {

	1855 for (FX_DWORD w = 0; w < GRW; w++) {

	1856 CONTEXT = 0;

	1857 switch (GRTEMPLATE) {

	1858 case 0:

	1859 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX + 1,

	1860 h - GRREFERENCEDY + 1);

	1861 CONTEXT \|=

	1862 GRREFERENCE->getPixel(w - GRREFERENCEDX, h - GRREFERENCEDY + 1)

	1863 << 1;

	1864 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX - 1,

	1865 h - GRREFERENCEDY + 1)

	1866 << 2;

	1867 CONTEXT \|=

	1868 GRREFERENCE->getPixel(w - GRREFERENCEDX + 1, h - GRREFERENCEDY)

	1869 << 3;

	1870 CONTEXT \|=

	1871 GRREFERENCE->getPixel(w - GRREFERENCEDX, h - GRREFERENCEDY)

	1872 << 4;

	1873 CONTEXT \|=

	1874 GRREFERENCE->getPixel(w - GRREFERENCEDX - 1, h - GRREFERENCEDY)

	1875 << 5;

	1876 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX + 1,

	1877 h - GRREFERENCEDY - 1)

	1878 << 6;

	1879 CONTEXT \|=

	1880 GRREFERENCE->getPixel(w - GRREFERENCEDX, h - GRREFERENCEDY - 1)

	1881 << 7;

	1882 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX + GRAT[2],

	1883 h - GRREFERENCEDY + GRAT[3])

	1884 << 8;

	1885 CONTEXT \|= GRREG->getPixel(w - 1, h) << 9;

	1886 CONTEXT \|= GRREG->getPixel(w + 1, h - 1) << 10;

	1887 CONTEXT \|= GRREG->getPixel(w, h - 1) << 11;

	1888 CONTEXT \|= GRREG->getPixel(w + GRAT[0], h + GRAT[1]) << 12;

	1889 break;

	1890 case 1:

	1891 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX + 1,

	1892 h - GRREFERENCEDY + 1);

	1893 CONTEXT \|=

	1894 GRREFERENCE->getPixel(w - GRREFERENCEDX, h - GRREFERENCEDY + 1)

	1895 << 1;

	1896 CONTEXT \|=

	1897 GRREFERENCE->getPixel(w - GRREFERENCEDX + 1, h - GRREFERENCEDY)

	1898 << 2;

	1899 CONTEXT \|=

	1900 GRREFERENCE->getPixel(w - GRREFERENCEDX, h - GRREFERENCEDY)

	1901 << 3;

	1902 CONTEXT \|=

	1903 GRREFERENCE->getPixel(w - GRREFERENCEDX - 1, h - GRREFERENCEDY)

	1904 << 4;

	1905 CONTEXT \|=

	1906 GRREFERENCE->getPixel(w - GRREFERENCEDX, h - GRREFERENCEDY - 1)

	1907 << 5;

	1908 CONTEXT \|= GRREG->getPixel(w - 1, h) << 6;

	1909 CONTEXT \|= GRREG->getPixel(w + 1, h - 1) << 7;

	1910 CONTEXT \|= GRREG->getPixel(w, h - 1) << 8;

	1911 CONTEXT \|= GRREG->getPixel(w - 1, h - 1) << 9;

	1912 break;

	1913 }

	1914 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);

	1915 GRREG->setPixel(w, h, bVal);

	1916 }

	1917 } else {

	1918 for (FX_DWORD w = 0; w < GRW; w++) {

	1919 bVal = GRREFERENCE->getPixel(w, h);

	1920 if (TPGRON && (bVal == GRREFERENCE->getPixel(w - 1, h - 1)) &&

	1921 (bVal == GRREFERENCE->getPixel(w, h - 1)) &&

	1922 (bVal == GRREFERENCE->getPixel(w + 1, h - 1)) &&

	1923 (bVal == GRREFERENCE->getPixel(w - 1, h)) &&

	1924 (bVal == GRREFERENCE->getPixel(w + 1, h)) &&

	1925 (bVal == GRREFERENCE->getPixel(w - 1, h + 1)) &&

	1926 (bVal == GRREFERENCE->getPixel(w, h + 1)) &&

	1927 (bVal == GRREFERENCE->getPixel(w + 1, h + 1))) {

	1928 TPGRPIX = 1;

	1929 TPGRVAL = bVal;

269 } else {	1930 } else {

270 line1 = GBREG->getPixel(1, h - 2);	1931 TPGRPIX = 0;

271 line1 \|= GBREG->getPixel(0, h - 2) << 1;	1932 }

272 line2 = GBREG->getPixel(2, h - 1);	1933 if (TPGRPIX) {

273 line2 \|= GBREG->getPixel(1, h - 1) << 1;	1934 GRREG->setPixel(w, h, TPGRVAL);

274 line2 \|= GBREG->getPixel(0, h - 1) << 2;

275 line3 = 0;

276 for(FX_DWORD w = 0; w < GBW; w++) {

277 if(USESKIP && SKIP->getPixel(w, h)) {

278 bVal = 0;

279 } else {

280 CONTEXT = line3;

281 CONTEXT \|= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 4;

282 CONTEXT \|= line2 << 5;

283 CONTEXT \|= GBREG->getPixel(w + GBAT[2], h + GBAT[3]) << 10;

284 CONTEXT \|= GBREG->getPixel(w + GBAT[4], h + GBAT[5]) << 11;

285 CONTEXT \|= line1 << 12;

286 CONTEXT \|= GBREG->getPixel(w + GBAT[6], h + GBAT[7]) << 15;

287 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

288 }

289 if(bVal) {

290 GBREG->setPixel(w, h, bVal);

291 }

292 line1 = ((line1 << 1) \| GBREG->getPixel(w + 2, h - 2)) & 0x07;

293 line2 = ((line2 << 1) \| GBREG->getPixel(w + 3, h - 1)) & 0x1f;

294 line3 = ((line3 << 1) \| bVal) & 0x0f;

295 }

296 }

297 }

298 return GBREG;

299 }

300 CJBig2_Image CJBig2_GRDProc::decode_Arith_Template1_opt(CJBig2_ArithDecoder pA rithDecoder, JBig2ArithCtx *gbContext)

301 {

302 FX_BOOL LTP, SLTP, bVal;

303 FX_DWORD CONTEXT;

304 CJBig2_Image *GBREG;

305 FX_DWORD line1, line2, line3;

306 LTP = 0;

307 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));

308 GBREG->fill(0);

309 for(FX_DWORD h = 0; h < GBH; h++) {

310 if(TPGDON) {

311 SLTP = pArithDecoder->DECODE(&gbContext[0x0795]);

312 LTP = LTP ^ SLTP;

313 }

314 if(LTP == 1) {

315 GBREG->copyLine(h, h - 1);

316 } else {	1935 } else {

317 line1 = GBREG->getPixel(2, h - 2);	1936 CONTEXT = 0;

318 line1 \|= GBREG->getPixel(1, h - 2) << 1;	1937 switch (GRTEMPLATE) {

319 line1 \|= GBREG->getPixel(0, h - 2) << 2;	1938 case 0:

320 line2 = GBREG->getPixel(3, h - 1);	1939 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX + 1,

321 line2 \|= GBREG->getPixel(2, h - 1) << 1;	1940 h - GRREFERENCEDY + 1);

322 line2 \|= GBREG->getPixel(1, h - 1) << 2;	1941 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX,

323 line2 \|= GBREG->getPixel(0, h - 1) << 3;	1942 h - GRREFERENCEDY + 1)

324 line3 = 0;	1943 << 1;

325 for(FX_DWORD w = 0; w < GBW; w++) {	1944 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX - 1,

326 if(USESKIP && SKIP->getPixel(w, h)) {	1945 h - GRREFERENCEDY + 1)

327 bVal = 0;	1946 << 2;

328 } else {	1947 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX + 1,

329 CONTEXT = line3;	1948 h - GRREFERENCEDY)

330 CONTEXT \|= line2 << 3;	1949 << 3;

331 CONTEXT \|= line1 << 9;	1950 CONTEXT \|=

332 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);	1951 GRREFERENCE->getPixel(w - GRREFERENCEDX, h - GRREFERENCEDY)

333 }	1952 << 4;

334 if(bVal) {	1953 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX - 1,

335 GBREG->setPixel(w, h, bVal);	1954 h - GRREFERENCEDY)

336 }	1955 << 5;

337 line1 = ((line1 << 1) \| GBREG->getPixel(w + 3, h - 2)) & 0x0f;	1956 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX + 1,

338 line2 = ((line2 << 1) \| GBREG->getPixel(w + 4, h - 1)) & 0x3f;	1957 h - GRREFERENCEDY - 1)

339 line3 = ((line3 << 1) \| bVal) & 0x07;	1958 << 6;

340 }	1959 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX,

341 }	1960 h - GRREFERENCEDY - 1)

342 }	1961 << 7;

343 return GBREG;	1962 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX + GRAT[2],

344 }	1963 h - GRREFERENCEDY + GRAT[3])

345 CJBig2_Image CJBig2_GRDProc::decode_Arith_Template1_opt2(CJBig2_ArithDecoder p ArithDecoder, JBig2ArithCtx *gbContext)	1964 << 8;

346 {	1965 CONTEXT \|= GRREG->getPixel(w - 1, h) << 9;

347 FX_BOOL LTP, SLTP, bVal;	1966 CONTEXT \|= GRREG->getPixel(w + 1, h - 1) << 10;

348 FX_DWORD CONTEXT;	1967 CONTEXT \|= GRREG->getPixel(w, h - 1) << 11;

349 CJBig2_Image *GBREG;	1968 CONTEXT \|= GRREG->getPixel(w + GRAT[0], h + GRAT[1]) << 12;

350 FX_DWORD line1, line2;	1969 break;

351 FX_BYTE *pLine, cVal;	1970 case 1:

352 FX_INTPTR nStride, nStride2;	1971 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX + 1,

353 FX_INT32 nBits, k;	1972 h - GRREFERENCEDY + 1);

354 LTP = 0;	1973 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX,

355 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));	1974 h - GRREFERENCEDY + 1)

356 if (GBREG->m_pData == NULL) {	1975 << 1;

357 delete GBREG;	1976 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX + 1,

358 m_pModule->JBig2_Error("Generic region decoding procedure: Create Image Failed with width = %d, height = %d\n", GBW, GBH);	1977 h - GRREFERENCEDY)

359 return NULL;	1978 << 2;

360 }	1979 CONTEXT \|=

361 pLine = GBREG->m_pData;	1980 GRREFERENCE->getPixel(w - GRREFERENCEDX, h - GRREFERENCEDY)

362 nStride = GBREG->m_nStride;	1981 << 3;

363 nStride2 = nStride << 1;	1982 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX - 1,

364 for(FX_DWORD h = 0; h < GBH; h++) {	1983 h - GRREFERENCEDY)

365 if(TPGDON) {	1984 << 4;

366 SLTP = pArithDecoder->DECODE(&gbContext[0x0795]);	1985 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX,

367 LTP = LTP ^ SLTP;	1986 h - GRREFERENCEDY - 1)

368 }	1987 << 5;

369 if(LTP == 1) {	1988 CONTEXT \|= GRREG->getPixel(w - 1, h) << 6;

370 GBREG->copyLine(h, h - 1);	1989 CONTEXT \|= GRREG->getPixel(w + 1, h - 1) << 7;

	1990 CONTEXT \|= GRREG->getPixel(w, h - 1) << 8;

	1991 CONTEXT \|= GRREG->getPixel(w - 1, h - 1) << 9;

	1992 break;

	1993 }

	1994 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);

	1995 GRREG->setPixel(w, h, bVal);

	1996 }

	1997 }

	1998 }

	1999 }

	2000 return GRREG;

	2001 }

	2002 CJBig2_Image* CJBig2_TRDProc::decode_Huffman(CJBig2_BitStream* pStream,

	2003 JBig2ArithCtx* grContext) {

	2004 FX_INT32 STRIPT, FIRSTS;

	2005 FX_DWORD NINSTANCES;

	2006 FX_INT32 DT, DFS, CURS;

	2007 FX_BYTE CURT;

	2008 FX_INT32 SI, TI;

	2009 FX_DWORD IDI;

	2010 CJBig2_Image* IBI;

	2011 FX_DWORD WI, HI;

	2012 FX_INT32 IDS;

	2013 FX_BOOL RI;

	2014 FX_INT32 RDWI, RDHI, RDXI, RDYI;

	2015 CJBig2_Image* IBOI;

	2016 FX_DWORD WOI, HOI;

	2017 CJBig2_Image* SBREG;

	2018 FX_BOOL bFirst;

	2019 FX_DWORD nTmp;

	2020 FX_INT32 nVal, nBits;

	2021 CJBig2_HuffmanDecoder* pHuffmanDecoder;

	2022 CJBig2_GRRDProc* pGRRD;

	2023 CJBig2_ArithDecoder* pArithDecoder;

	2024 JBIG2_ALLOC(pHuffmanDecoder, CJBig2_HuffmanDecoder(pStream));

	2025 JBIG2_ALLOC(SBREG, CJBig2_Image(SBW, SBH));

	2026 SBREG->fill(SBDEFPIXEL);

	2027 if (pHuffmanDecoder->decodeAValue(SBHUFFDT, &STRIPT) != 0) {

	2028 m_pModule->JBig2_Error(

	2029 "text region decoding procedure (huffman): too short.");

	2030 goto failed;

	2031 }

	2032 STRIPT *= SBSTRIPS;

	2033 STRIPT = -STRIPT;

	2034 FIRSTS = 0;

	2035 NINSTANCES = 0;

	2036 while (NINSTANCES < SBNUMINSTANCES) {

	2037 if (pHuffmanDecoder->decodeAValue(SBHUFFDT, &DT) != 0) {

	2038 m_pModule->JBig2_Error(

	2039 "text region decoding procedure (huffman): too short.");

	2040 goto failed;

	2041 }

	2042 DT *= SBSTRIPS;

	2043 STRIPT = STRIPT + DT;

	2044 bFirst = TRUE;

	2045 for (;;) {

	2046 if (bFirst) {

	2047 if (pHuffmanDecoder->decodeAValue(SBHUFFFS, &DFS) != 0) {

	2048 m_pModule->JBig2_Error(

	2049 "text region decoding procedure (huffman): too short.");

	2050 goto failed;

	2051 }

	2052 FIRSTS = FIRSTS + DFS;

	2053 CURS = FIRSTS;

	2054 bFirst = FALSE;

	2055 } else {

	2056 nVal = pHuffmanDecoder->decodeAValue(SBHUFFDS, &IDS);

	2057 if (nVal == JBIG2_OOB) {

	2058 break;

	2059 } else if (nVal != 0) {

	2060 m_pModule->JBig2_Error(

	2061 "text region decoding procedure (huffman): too short.");

	2062 goto failed;

371 } else {	2063 } else {

372 line1 = (h > 1) ? pLine[-nStride2] << 4 : 0;	2064 CURS = CURS + IDS + SBDSOFFSET;

373 line2 = (h > 0) ? pLine[-nStride] : 0;	2065 }

374 CONTEXT = (line1 & 0x1e00) \| ((line2 >> 1) & 0x01f8);	2066 }

375 for(FX_DWORD w = 0; w < GBW; w += 8) {	2067 if (SBSTRIPS == 1) {

376 if(w + 8 < GBW) {	2068 CURT = 0;

377 nBits = 8;	2069 } else {

378 if(h > 1) {	2070 nTmp = 1;

379 line1 = (line1 << 8) \| (pLine[-nStride2 + (w >> 3) + 1] << 4);	2071 while ((FX_DWORD)(1 << nTmp) < SBSTRIPS) {

380 }	2072 nTmp++;

381 if(h > 0) {	2073 }

382 line2 = (line2 << 8) \| (pLine[-nStride + (w >> 3) + 1]);	2074 if (pStream->readNBits(nTmp, &nVal) != 0) {

383 }	2075 m_pModule->JBig2_Error(

384 } else {	2076 "text region decoding procedure (huffman): too short.");

385 nBits = GBW - w;	2077 goto failed;

386 if(h > 1) {	2078 }

387 line1 <<= 8;	2079 CURT = nVal;

388 }	2080 }

389 if(h > 0) {	2081 TI = STRIPT + CURT;

390 line2 <<= 8;	2082 nVal = 0;

391 }	2083 nBits = 0;

392 }	2084 for (;;) {

393 cVal = 0;	2085 if (pStream->read1Bit(&nTmp) != 0) {

394 for(k = 0; k < nBits; k++) {	2086 m_pModule->JBig2_Error(

395 if(USESKIP && SKIP->getPixel(w, h)) {	2087 "text region decoding procedure (huffman): too short.");

396 bVal = 0;	2088 goto failed;

397 } else {	2089 }

398 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);	2090 nVal = (nVal << 1) \| nTmp;

399 }	2091 nBits++;

400 cVal \|= bVal << (7 - k);	2092 for (IDI = 0; IDI < SBNUMSYMS; IDI++) {

401 CONTEXT = ((CONTEXT & 0x0efb) << 1) \| bVal	2093 if ((nBits == SBSYMCODES[IDI].codelen) &&

402 \| ((line1 >> (7 - k)) & 0x0200)	2094 (nVal == SBSYMCODES[IDI].code)) {

403 \| ((line2 >> (8 - k)) & 0x0008);	2095 break;

404 }	2096 }

405 pLine[w >> 3] = cVal;	2097 }

406 }	2098 if (IDI < SBNUMSYMS) {

407 }	2099 break;

408 pLine += nStride;	2100 }

409 }	2101 }

410 return GBREG;	2102 if (SBREFINE == 0) {

411 }	2103 RI = 0;

412 CJBig2_Image CJBig2_GRDProc::decode_Arith_Template1_opt3(CJBig2_ArithDecoder p ArithDecoder, JBig2ArithCtx *gbContext)	2104 } else {

413 {	2105 if (pStream->read1Bit(&RI) != 0) {

414 FX_BOOL LTP, SLTP, bVal;	2106 m_pModule->JBig2_Error(

415 FX_DWORD CONTEXT;	2107 "text region decoding procedure (huffman): too short.");

416 CJBig2_Image *GBREG;	2108 goto failed;

417 FX_DWORD line1, line2;	2109 }

418 FX_BYTE pLine, pLine1, *pLine2, cVal;	2110 }

419 FX_INT32 nStride, nStride2, k;	2111 if (RI == 0) {

420 FX_INT32 nLineBytes, nBitsLeft, cc;	2112 IBI = SBSYMS[IDI];

421 LTP = 0;	2113 } else {

422 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));	2114 if ((pHuffmanDecoder->decodeAValue(SBHUFFRDW, &RDWI) != 0) \|\|

423 if (GBREG->m_pData == NULL) {	2115 (pHuffmanDecoder->decodeAValue(SBHUFFRDH, &RDHI) != 0) \|\|

424 delete GBREG;	2116 (pHuffmanDecoder->decodeAValue(SBHUFFRDX, &RDXI) != 0) \|\|

425 m_pModule->JBig2_Error("Generic region decoding procedure: Create Image Failed with width = %d, height = %d\n", GBW, GBH);	2117 (pHuffmanDecoder->decodeAValue(SBHUFFRDY, &RDYI) != 0) \|\|

426 return NULL;	2118 (pHuffmanDecoder->decodeAValue(SBHUFFRSIZE, &nVal) != 0)) {

427 }	2119 m_pModule->JBig2_Error(

428 pLine = GBREG->m_pData;	2120 "text region decoding procedure (huffman): too short.");

429 nStride = GBREG->m_nStride;	2121 goto failed;

430 nStride2 = nStride << 1;	2122 }

431 nLineBytes = ((GBW + 7) >> 3) - 1;	2123 pStream->alignByte();

432 nBitsLeft = GBW - (nLineBytes << 3);	2124 nTmp = pStream->getOffset();

433 for(FX_DWORD h = 0; h < GBH; h++) {	2125 IBOI = SBSYMS[IDI];

434 if(TPGDON) {	2126 if (!IBOI) {

435 SLTP = pArithDecoder->DECODE(&gbContext[0x0795]);	2127 goto failed;

436 LTP = LTP ^ SLTP;	2128 }

437 }	2129 WOI = IBOI->m_nWidth;

438 if(LTP == 1) {	2130 HOI = IBOI->m_nHeight;

439 GBREG->copyLine(h, h - 1);	2131 if ((int)(WOI + RDWI) < 0 \|\| (int)(HOI + RDHI) < 0) {

440 } else {	2132 m_pModule->JBig2_Error(

441 if(h > 1) {	2133 "text region decoding procedure (huffman): Invalid RDWI or RDHI "

442 pLine1 = pLine - nStride2;	2134 "value.");

443 pLine2 = pLine - nStride;	2135 goto failed;

444 line1 = (*pLine1++) << 4;	2136 }

445 line2 = *pLine2++;	2137 JBIG2_ALLOC(pGRRD, CJBig2_GRRDProc());

446 CONTEXT = (line1 & 0x1e00) \| ((line2 >> 1) & 0x01f8);	2138 pGRRD->GRW = WOI + RDWI;

447 for(cc = 0; cc < nLineBytes; cc++) {	2139 pGRRD->GRH = HOI + RDHI;

448 line1 = (line1 << 8) \| ((*pLine1++) << 4);	2140 pGRRD->GRTEMPLATE = SBRTEMPLATE;

449 line2 = (line2 << 8) \| (*pLine2++);	2141 pGRRD->GRREFERENCE = IBOI;

450 cVal = 0;	2142 pGRRD->GRREFERENCEDX = (RDWI >> 2) + RDXI;

451 for(k = 7; k >= 0; k--) {	2143 pGRRD->GRREFERENCEDY = (RDHI >> 2) + RDYI;

452 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);	2144 pGRRD->TPGRON = 0;

453 cVal \|= bVal << k;	2145 pGRRD->GRAT[0] = SBRAT[0];

454 CONTEXT = ((CONTEXT & 0x0efb) << 1) \| bVal	2146 pGRRD->GRAT[1] = SBRAT[1];

455 \| ((line1 >> k) & 0x0200)	2147 pGRRD->GRAT[2] = SBRAT[2];

456 \| ((line2 >> (k + 1)) & 0x0008);	2148 pGRRD->GRAT[3] = SBRAT[3];

457 }	2149 JBIG2_ALLOC(pArithDecoder, CJBig2_ArithDecoder(pStream));

458 pLine[cc] = cVal;	2150 IBI = pGRRD->decode(pArithDecoder, grContext);

459 }	2151 if (IBI == NULL) {

460 line1 <<= 8;	2152 delete pGRRD;

461 line2 <<= 8;	2153 delete pArithDecoder;

462 cVal = 0;	2154 goto failed;

463 for(k = 0; k < nBitsLeft; k++) {	2155 }

464 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);	2156 delete pArithDecoder;

465 cVal \|= bVal << (7 - k);	2157 pStream->alignByte();

466 CONTEXT = ((CONTEXT & 0x0efb) << 1) \| bVal	2158 pStream->offset(2);

467 \| ((line1 >> (7 - k)) & 0x0200)	2159 if ((FX_DWORD)nVal != (pStream->getOffset() - nTmp)) {

468 \| ((line2 >> (8 - k)) & 0x0008);	2160 delete IBI;

469 }	2161 delete pGRRD;

470 pLine[nLineBytes] = cVal;	2162 m_pModule->JBig2_Error(

471 } else {	2163 "text region decoding procedure (huffman):"

472 pLine2 = pLine - nStride;	2164 "bytes processed by generic refinement region decoding procedure "

473 line2 = (h & 1) ? (*pLine2++) : 0;	2165 "doesn't equal SBHUFFRSIZE.");

474 CONTEXT = (line2 >> 1) & 0x01f8;	2166 goto failed;

475 for(cc = 0; cc < nLineBytes; cc++) {	2167 }

476 if(h & 1) {	2168 delete pGRRD;

477 line2 = (line2 << 8) \| (*pLine2++);	2169 }

478 }	2170 if (!IBI) {

479 cVal = 0;	2171 continue;

480 for(k = 7; k >= 0; k--) {	2172 }

481 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);	2173 WI = IBI->m_nWidth;

482 cVal \|= bVal << k;	2174 HI = IBI->m_nHeight;

483 CONTEXT = ((CONTEXT & 0x0efb) << 1) \| bVal	2175 if (TRANSPOSED == 0 && ((REFCORNER == JBIG2_CORNER_TOPRIGHT) \|\|

484 \| ((line2 >> (k + 1)) & 0x0008);	2176 (REFCORNER == JBIG2_CORNER_BOTTOMRIGHT))) {

485 }	2177 CURS = CURS + WI - 1;

486 pLine[cc] = cVal;	2178 } else if (TRANSPOSED == 1 && ((REFCORNER == JBIG2_CORNER_BOTTOMLEFT) \|\|

487 }	2179 (REFCORNER == JBIG2_CORNER_BOTTOMRIGHT))) {

488 line2 <<= 8;	2180 CURS = CURS + HI - 1;

489 cVal = 0;	2181 }

490 for(k = 0; k < nBitsLeft; k++) {	2182 SI = CURS;

491 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);	2183 if (TRANSPOSED == 0) {

492 cVal \|= bVal << (7 - k);	2184 switch (REFCORNER) {

493 CONTEXT = ((CONTEXT & 0x0efb) << 1) \| bVal	2185 case JBIG2_CORNER_TOPLEFT:

494 \| ((line2 >> (8 - k)) & 0x0008);	2186 SBREG->composeFrom(SI, TI, IBI, SBCOMBOP);

495 }	2187 break;

496 pLine[nLineBytes] = cVal;	2188 case JBIG2_CORNER_TOPRIGHT:

497 }	2189 SBREG->composeFrom(SI - WI + 1, TI, IBI, SBCOMBOP);

498 }	2190 break;

499 pLine += nStride;	2191 case JBIG2_CORNER_BOTTOMLEFT:

500 }	2192 SBREG->composeFrom(SI, TI - HI + 1, IBI, SBCOMBOP);

501 return GBREG;	2193 break;

502 }	2194 case JBIG2_CORNER_BOTTOMRIGHT:

503 CJBig2_Image CJBig2_GRDProc::decode_Arith_Template1_unopt(CJBig2_ArithDecoder pArithDecoder, JBig2ArithCtx *gbContext)	2195 SBREG->composeFrom(SI - WI + 1, TI - HI + 1, IBI, SBCOMBOP);

504 {	2196 break;

505 FX_BOOL LTP, SLTP, bVal;	2197 }

506 FX_DWORD CONTEXT;	2198 } else {

507 CJBig2_Image *GBREG;	2199 switch (REFCORNER) {

508 FX_DWORD line1, line2, line3;	2200 case JBIG2_CORNER_TOPLEFT:

509 LTP = 0;	2201 SBREG->composeFrom(TI, SI, IBI, SBCOMBOP);

510 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));	2202 break;

511 GBREG->fill(0);	2203 case JBIG2_CORNER_TOPRIGHT:

512 for(FX_DWORD h = 0; h < GBH; h++) {	2204 SBREG->composeFrom(TI - WI + 1, SI, IBI, SBCOMBOP);

513 if(TPGDON) {	2205 break;

514 SLTP = pArithDecoder->DECODE(&gbContext[0x0795]);	2206 case JBIG2_CORNER_BOTTOMLEFT:

515 LTP = LTP ^ SLTP;	2207 SBREG->composeFrom(TI, SI - HI + 1, IBI, SBCOMBOP);

516 }	2208 break;

517 if(LTP == 1) {	2209 case JBIG2_CORNER_BOTTOMRIGHT:

518 GBREG->copyLine(h, h - 1);	2210 SBREG->composeFrom(TI - WI + 1, SI - HI + 1, IBI, SBCOMBOP);

519 } else {	2211 break;

520 line1 = GBREG->getPixel(2, h - 2);	2212 }

521 line1 \|= GBREG->getPixel(1, h - 2) << 1;	2213 }

522 line1 \|= GBREG->getPixel(0, h - 2) << 2;	2214 if (RI != 0) {

523 line2 = GBREG->getPixel(2, h - 1);	2215 delete IBI;

524 line2 \|= GBREG->getPixel(1, h - 1) << 1;	2216 }

525 line2 \|= GBREG->getPixel(0, h - 1) << 2;	2217 if (TRANSPOSED == 0 && ((REFCORNER == JBIG2_CORNER_TOPLEFT) \|\|

526 line3 = 0;	2218 (REFCORNER == JBIG2_CORNER_BOTTOMLEFT))) {

527 for(FX_DWORD w = 0; w < GBW; w++) {	2219 CURS = CURS + WI - 1;

528 if(USESKIP && SKIP->getPixel(w, h)) {	2220 } else if (TRANSPOSED == 1 && ((REFCORNER == JBIG2_CORNER_TOPLEFT) \|\|

529 bVal = 0;	2221 (REFCORNER == JBIG2_CORNER_TOPRIGHT))) {

530 } else {	2222 CURS = CURS + HI - 1;

531 CONTEXT = line3;	2223 }

532 CONTEXT \|= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 3;	2224 NINSTANCES = NINSTANCES + 1;

533 CONTEXT \|= line2 << 4;	2225 }

534 CONTEXT \|= line1 << 9;	2226 }

535 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);	2227 delete pHuffmanDecoder;

536 }	2228 return SBREG;

537 if(bVal) {

538 GBREG->setPixel(w, h, bVal);

539 }

540 line1 = ((line1 << 1) \| GBREG->getPixel(w + 3, h - 2)) & 0x0f;

541 line2 = ((line2 << 1) \| GBREG->getPixel(w + 3, h - 1)) & 0x1f;

542 line3 = ((line3 << 1) \| bVal) & 0x07;

543 }

544 }

545 }

546 return GBREG;

547 }

548 CJBig2_Image CJBig2_GRDProc::decode_Arith_Template2_opt(CJBig2_ArithDecoder pA rithDecoder, JBig2ArithCtx *gbContext)

549 {

550 FX_BOOL LTP, SLTP, bVal;

551 FX_DWORD CONTEXT;

552 CJBig2_Image *GBREG;

553 FX_DWORD line1, line2, line3;

554 LTP = 0;

555 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));

556 GBREG->fill(0);

557 for(FX_DWORD h = 0; h < GBH; h++) {

558 if(TPGDON) {

559 SLTP = pArithDecoder->DECODE(&gbContext[0x00e5]);

560 LTP = LTP ^ SLTP;

561 }

562 if(LTP == 1) {

563 GBREG->copyLine(h, h - 1);

564 } else {

565 line1 = GBREG->getPixel(1, h - 2);

566 line1 \|= GBREG->getPixel(0, h - 2) << 1;

567 line2 = GBREG->getPixel(2, h - 1);

568 line2 \|= GBREG->getPixel(1, h - 1) << 1;

569 line2 \|= GBREG->getPixel(0, h - 1) << 2;

570 line3 = 0;

571 for(FX_DWORD w = 0; w < GBW; w++) {

572 if(USESKIP && SKIP->getPixel(w, h)) {

573 bVal = 0;

574 } else {

575 CONTEXT = line3;

576 CONTEXT \|= line2 << 2;

577 CONTEXT \|= line1 << 7;

578 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

579 }

580 if(bVal) {

581 GBREG->setPixel(w, h, bVal);

582 }

583 line1 = ((line1 << 1) \| GBREG->getPixel(w + 2, h - 2)) & 0x07;

584 line2 = ((line2 << 1) \| GBREG->getPixel(w + 3, h - 1)) & 0x1f;

585 line3 = ((line3 << 1) \| bVal) & 0x03;

586 }

587 }

588 }

589 return GBREG;

590 }

591 CJBig2_Image CJBig2_GRDProc::decode_Arith_Template2_opt2(CJBig2_ArithDecoder p ArithDecoder, JBig2ArithCtx *gbContext)

592 {

593 FX_BOOL LTP, SLTP, bVal;

594 FX_DWORD CONTEXT;

595 CJBig2_Image *GBREG;

596 FX_DWORD line1, line2;

597 FX_BYTE *pLine, cVal;

598 FX_INTPTR nStride, nStride2;

599 FX_INT32 nBits, k;

600 LTP = 0;

601 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));

602 if (GBREG->m_pData == NULL) {

603 delete GBREG;

604 m_pModule->JBig2_Error("Generic region decoding procedure: Create Image Failed with width = %d, height = %d\n", GBW, GBH);

605 return NULL;

606 }

607 pLine = GBREG->m_pData;

608 nStride = GBREG->m_nStride;

609 nStride2 = nStride << 1;

610 for(FX_DWORD h = 0; h < GBH; h++) {

611 if(TPGDON) {

612 SLTP = pArithDecoder->DECODE(&gbContext[0x00e5]);

613 LTP = LTP ^ SLTP;

614 }

615 if(LTP == 1) {

616 GBREG->copyLine(h, h - 1);

617 } else {

618 line1 = (h > 1) ? pLine[-nStride2] << 1 : 0;

619 line2 = (h > 0) ? pLine[-nStride] : 0;

620 CONTEXT = (line1 & 0x0380) \| ((line2 >> 3) & 0x007c);

621 for(FX_DWORD w = 0; w < GBW; w += 8) {

622 if(w + 8 < GBW) {

623 nBits = 8;

624 if(h > 1) {

625 line1 = (line1 << 8) \| (pLine[-nStride2 + (w >> 3) + 1] << 1);

626 }

627 if(h > 0) {

628 line2 = (line2 << 8) \| (pLine[-nStride + (w >> 3) + 1]);

629 }

630 } else {

631 nBits = GBW - w;

632 if(h > 1) {

633 line1 <<= 8;

634 }

635 if(h > 0) {

636 line2 <<= 8;

637 }

638 }

639 cVal = 0;

640 for(k = 0; k < nBits; k++) {

641 if(USESKIP && SKIP->getPixel(w, h)) {

642 bVal = 0;

643 } else {

644 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

645 }

646 cVal \|= bVal << (7 - k);

647 CONTEXT = ((CONTEXT & 0x01bd) << 1) \| bVal

648 \| ((line1 >> (7 - k)) & 0x0080)

649 \| ((line2 >> (10 - k)) & 0x0004);

650 }

651 pLine[w >> 3] = cVal;

652 }

653 }

654 pLine += nStride;

655 }

656 return GBREG;

657 }

658 CJBig2_Image CJBig2_GRDProc::decode_Arith_Template2_opt3(CJBig2_ArithDecoder p ArithDecoder, JBig2ArithCtx *gbContext)

659 {

660 FX_BOOL LTP, SLTP, bVal;

661 FX_DWORD CONTEXT;

662 CJBig2_Image *GBREG;

663 FX_DWORD line1, line2;

664 FX_BYTE pLine, pLine1, *pLine2, cVal;

665 FX_INT32 nStride, nStride2, k;

666 FX_INT32 nLineBytes, nBitsLeft, cc;

667 LTP = 0;

668 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));

669 if (GBREG->m_pData == NULL) {

670 delete GBREG;

671 m_pModule->JBig2_Error("Generic region decoding procedure: Create Image Failed with width = %d, height = %d\n", GBW, GBH);

672 return NULL;

673 }

674 pLine = GBREG->m_pData;

675 nStride = GBREG->m_nStride;

676 nStride2 = nStride << 1;

677 nLineBytes = ((GBW + 7) >> 3) - 1;

678 nBitsLeft = GBW - (nLineBytes << 3);

679 for(FX_DWORD h = 0; h < GBH; h++) {

680 if(TPGDON) {

681 SLTP = pArithDecoder->DECODE(&gbContext[0x00e5]);

682 LTP = LTP ^ SLTP;

683 }

684 if(LTP == 1) {

685 GBREG->copyLine(h, h - 1);

686 } else {

687 if(h > 1) {

688 pLine1 = pLine - nStride2;

689 pLine2 = pLine - nStride;

690 line1 = (*pLine1++) << 1;

691 line2 = *pLine2++;

692 CONTEXT = (line1 & 0x0380) \| ((line2 >> 3) & 0x007c);

693 for(cc = 0; cc < nLineBytes; cc++) {

694 line1 = (line1 << 8) \| ((*pLine1++) << 1);

695 line2 = (line2 << 8) \| (*pLine2++);

696 cVal = 0;

697 for(k = 7; k >= 0; k--) {

698 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

699 cVal \|= bVal << k;

700 CONTEXT = ((CONTEXT & 0x01bd) << 1) \| bVal

701 \| ((line1 >> k) & 0x0080)

702 \| ((line2 >> (k + 3)) & 0x0004);

703 }

704 pLine[cc] = cVal;

705 }

706 line1 <<= 8;

707 line2 <<= 8;

708 cVal = 0;

709 for(k = 0; k < nBitsLeft; k++) {

710 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

711 cVal \|= bVal << (7 - k);

712 CONTEXT = ((CONTEXT & 0x01bd) << 1) \| bVal

713 \| ((line1 >> (7 - k)) & 0x0080)

714 \| ((line2 >> (10 - k)) & 0x0004);

715 }

716 pLine[nLineBytes] = cVal;

717 } else {

718 pLine2 = pLine - nStride;

719 line2 = (h & 1) ? (*pLine2++) : 0;

720 CONTEXT = (line2 >> 3) & 0x007c;

721 for(cc = 0; cc < nLineBytes; cc++) {

722 if(h & 1) {

723 line2 = (line2 << 8) \| (*pLine2++);

724 }

725 cVal = 0;

726 for(k = 7; k >= 0; k--) {

727 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

728 cVal \|= bVal << k;

729 CONTEXT = ((CONTEXT & 0x01bd) << 1) \| bVal

730 \| ((line2 >> (k + 3)) & 0x0004);

731 }

732 pLine[cc] = cVal;

733 }

734 line2 <<= 8;

735 cVal = 0;

736 for(k = 0; k < nBitsLeft; k++) {

737 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

738 cVal \|= bVal << (7 - k);

739 CONTEXT = ((CONTEXT & 0x01bd) << 1) \| bVal

740 \| (((line2 >> (10 - k))) & 0x0004);

741 }

742 pLine[nLineBytes] = cVal;

743 }

744 }

745 pLine += nStride;

746 }

747 return GBREG;

748 }

749 CJBig2_Image CJBig2_GRDProc::decode_Arith_Template2_unopt(CJBig2_ArithDecoder pArithDecoder, JBig2ArithCtx *gbContext)

750 {

751 FX_BOOL LTP, SLTP, bVal;

752 FX_DWORD CONTEXT;

753 CJBig2_Image *GBREG;

754 FX_DWORD line1, line2, line3;

755 LTP = 0;

756 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));

757 GBREG->fill(0);

758 for(FX_DWORD h = 0; h < GBH; h++) {

759 if(TPGDON) {

760 SLTP = pArithDecoder->DECODE(&gbContext[0x00e5]);

761 LTP = LTP ^ SLTP;

762 }

763 if(LTP == 1) {

764 GBREG->copyLine(h, h - 1);

765 } else {

766 line1 = GBREG->getPixel(1, h - 2);

767 line1 \|= GBREG->getPixel(0, h - 2) << 1;

768 line2 = GBREG->getPixel(1, h - 1);

769 line2 \|= GBREG->getPixel(0, h - 1) << 1;

770 line3 = 0;

771 for(FX_DWORD w = 0; w < GBW; w++) {

772 if(USESKIP && SKIP->getPixel(w, h)) {

773 bVal = 0;

774 } else {

775 CONTEXT = line3;

776 CONTEXT \|= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 2;

777 CONTEXT \|= line2 << 3;

778 CONTEXT \|= line1 << 7;

779 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

780 }

781 if(bVal) {

782 GBREG->setPixel(w, h, bVal);

783 }

784 line1 = ((line1 << 1) \| GBREG->getPixel(w + 2, h - 2)) & 0x07;

785 line2 = ((line2 << 1) \| GBREG->getPixel(w + 2, h - 1)) & 0x0f;

786 line3 = ((line3 << 1) \| bVal) & 0x03;

787 }

788 }

789 }

790 return GBREG;

791 }

792 CJBig2_Image CJBig2_GRDProc::decode_Arith_Template3_opt(CJBig2_ArithDecoder pA rithDecoder, JBig2ArithCtx *gbContext)

793 {

794 FX_BOOL LTP, SLTP, bVal;

795 FX_DWORD CONTEXT;

796 CJBig2_Image *GBREG;

797 FX_DWORD line1, line2;

798 LTP = 0;

799 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));

800 GBREG->fill(0);

801 for(FX_DWORD h = 0; h < GBH; h++) {

802 if(TPGDON) {

803 SLTP = pArithDecoder->DECODE(&gbContext[0x0195]);

804 LTP = LTP ^ SLTP;

805 }

806 if(LTP == 1) {

807 GBREG->copyLine(h, h - 1);

808 } else {

809 line1 = GBREG->getPixel(2, h - 1);

810 line1 \|= GBREG->getPixel(1, h - 1) << 1;

811 line1 \|= GBREG->getPixel(0, h - 1) << 2;

812 line2 = 0;

813 for(FX_DWORD w = 0; w < GBW; w++) {

814 if(USESKIP && SKIP->getPixel(w, h)) {

815 bVal = 0;

816 } else {

817 CONTEXT = line2;

818 CONTEXT \|= line1 << 4;

819 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

820 }

821 if(bVal) {

822 GBREG->setPixel(w, h, bVal);

823 }

824 line1 = ((line1 << 1) \| GBREG->getPixel(w + 3, h - 1)) & 0x3f;

825 line2 = ((line2 << 1) \| bVal) & 0x0f;

826 }

827 }

828 }

829 return GBREG;

830 }

831 CJBig2_Image CJBig2_GRDProc::decode_Arith_Template3_opt2(CJBig2_ArithDecoder p ArithDecoder, JBig2ArithCtx *gbContext)

832 {

833 FX_BOOL LTP, SLTP, bVal;

834 FX_DWORD CONTEXT;

835 CJBig2_Image *GBREG;

836 FX_DWORD line1;

837 FX_BYTE *pLine, cVal;

838 FX_INTPTR nStride, nStride2;

839 FX_INT32 nBits, k;

840 LTP = 0;

841 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));

842 if (GBREG->m_pData == NULL) {

843 delete GBREG;

844 m_pModule->JBig2_Error("Generic region decoding procedure: Create Image Failed with width = %d, height = %d\n", GBW, GBH);

845 return NULL;

846 }

847 pLine = GBREG->m_pData;

848 nStride = GBREG->m_nStride;

849 nStride2 = nStride << 1;

850 for(FX_DWORD h = 0; h < GBH; h++) {

851 if(TPGDON) {

852 SLTP = pArithDecoder->DECODE(&gbContext[0x0195]);

853 LTP = LTP ^ SLTP;

854 }

855 if(LTP == 1) {

856 GBREG->copyLine(h, h - 1);

857 } else {

858 line1 = (h > 0) ? pLine[-nStride] : 0;

859 CONTEXT = (line1 >> 1) & 0x03f0;

860 for(FX_DWORD w = 0; w < GBW; w += 8) {

861 if(w + 8 < GBW) {

862 nBits = 8;

863 if(h > 0) {

864 line1 = (line1 << 8) \| (pLine[-nStride + (w >> 3) + 1]);

865 }

866 } else {

867 nBits = GBW - w;

868 if(h > 0) {

869 line1 <<= 8;

870 }

871 }

872 cVal = 0;

873 for(k = 0; k < nBits; k++) {

874 if(USESKIP && SKIP->getPixel(w, h)) {

875 bVal = 0;

876 } else {

877 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

878 }

879 cVal \|= bVal << (7 - k);

880 CONTEXT = ((CONTEXT & 0x01f7) << 1) \| bVal

881 \| ((line1 >> (8 - k)) & 0x0010);

882 }

883 pLine[w >> 3] = cVal;

884 }

885 }

886 pLine += nStride;

887 }

888 return GBREG;

889 }

890 CJBig2_Image CJBig2_GRDProc::decode_Arith_Template3_opt3(CJBig2_ArithDecoder p ArithDecoder, JBig2ArithCtx *gbContext)

891 {

892 FX_BOOL LTP, SLTP, bVal;

893 FX_DWORD CONTEXT;

894 CJBig2_Image *GBREG;

895 FX_DWORD line1;

896 FX_BYTE pLine, pLine1, cVal;

897 FX_INT32 nStride, k;

898 FX_INT32 nLineBytes, nBitsLeft, cc;

899 LTP = 0;

900 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));

901 if (GBREG->m_pData == NULL) {

902 delete GBREG;

903 m_pModule->JBig2_Error("Generic region decoding procedure: Create Image Failed with width = %d, height = %d\n", GBW, GBH);

904 return NULL;

905 }

906 pLine = GBREG->m_pData;

907 nStride = GBREG->m_nStride;

908 nLineBytes = ((GBW + 7) >> 3) - 1;

909 nBitsLeft = GBW - (nLineBytes << 3);

910 for(FX_DWORD h = 0; h < GBH; h++) {

911 if(TPGDON) {

912 SLTP = pArithDecoder->DECODE(&gbContext[0x0195]);

913 LTP = LTP ^ SLTP;

914 }

915 if(LTP == 1) {

916 GBREG->copyLine(h, h - 1);

917 } else {

918 if(h > 0) {

919 pLine1 = pLine - nStride;

920 line1 = *pLine1++;

921 CONTEXT = (line1 >> 1) & 0x03f0;

922 for(cc = 0; cc < nLineBytes; cc++) {

923 line1 = (line1 << 8) \| (*pLine1++);

924 cVal = 0;

925 for(k = 7; k >= 0; k--) {

926 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

927 cVal \|= bVal << k;

928 CONTEXT = ((CONTEXT & 0x01f7) << 1) \| bVal

929 \| ((line1 >> (k + 1)) & 0x0010);

930 }

931 pLine[cc] = cVal;

932 }

933 line1 <<= 8;

934 cVal = 0;

935 for(k = 0; k < nBitsLeft; k++) {

936 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

937 cVal \|= bVal << (7 - k);

938 CONTEXT = ((CONTEXT & 0x01f7) << 1) \| bVal

939 \| ((line1 >> (8 - k)) & 0x0010);

940 }

941 pLine[nLineBytes] = cVal;

942 } else {

943 CONTEXT = 0;

944 for(cc = 0; cc < nLineBytes; cc++) {

945 cVal = 0;

946 for(k = 7; k >= 0; k--) {

947 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

948 cVal \|= bVal << k;

949 CONTEXT = ((CONTEXT & 0x01f7) << 1) \| bVal;

950 }

951 pLine[cc] = cVal;

952 }

953 cVal = 0;

954 for(k = 0; k < nBitsLeft; k++) {

955 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

956 cVal \|= bVal << (7 - k);

957 CONTEXT = ((CONTEXT & 0x01f7) << 1) \| bVal;

958 }

959 pLine[nLineBytes] = cVal;

960 }

961 }

962 pLine += nStride;

963 }

964 return GBREG;

965 }

966 CJBig2_Image CJBig2_GRDProc::decode_Arith_Template3_unopt(CJBig2_ArithDecoder pArithDecoder, JBig2ArithCtx *gbContext)

967 {

968 FX_BOOL LTP, SLTP, bVal;

969 FX_DWORD CONTEXT;

970 CJBig2_Image *GBREG;

971 FX_DWORD line1, line2;

972 LTP = 0;

973 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));

974 GBREG->fill(0);

975 for(FX_DWORD h = 0; h < GBH; h++) {

976 if(TPGDON) {

977 SLTP = pArithDecoder->DECODE(&gbContext[0x0195]);

978 LTP = LTP ^ SLTP;

979 }

980 if(LTP == 1) {

981 GBREG->copyLine(h, h - 1);

982 } else {

983 line1 = GBREG->getPixel(1, h - 1);

984 line1 \|= GBREG->getPixel(0, h - 1) << 1;

985 line2 = 0;

986 for(FX_DWORD w = 0; w < GBW; w++) {

987 if(USESKIP && SKIP->getPixel(w, h)) {

988 bVal = 0;

989 } else {

990 CONTEXT = line2;

991 CONTEXT \|= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 4;

992 CONTEXT \|= line1 << 5;

993 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

994 }

995 if(bVal) {

996 GBREG->setPixel(w, h, bVal);

997 }

998 line1 = ((line1 << 1) \| GBREG->getPixel(w + 2, h - 1)) & 0x1f;

999 line2 = ((line2 << 1) \| bVal) & 0x0f;

1000 }

1001 }

1002 }

1003 return GBREG;

1004 }

1005 CJBig2_Image CJBig2_GRDProc::decode_Arith_V2(CJBig2_ArithDecoder pArithDecoder , JBig2ArithCtx *gbContext)

1006 {

1007 FX_BOOL LTP, SLTP, bVal;

1008 FX_DWORD CONTEXT;

1009 CJBig2_Image *GBREG;

1010 FX_DWORD line1, line2, line3;

1011 LTP = 0;

1012 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));

1013 GBREG->fill(0);

1014 for(FX_DWORD h = 0; h < GBH; h++) {

1015 if(TPGDON) {

1016 switch(GBTEMPLATE) {

1017 case 0:

1018 CONTEXT = 0x9b25;

1019 break;

1020 case 1:

1021 CONTEXT = 0x0795;

1022 break;

1023 case 2:

1024 CONTEXT = 0x00e5;

1025 break;

1026 case 3:

1027 CONTEXT = 0x0195;

1028 break;

1029 }

1030 SLTP = pArithDecoder->DECODE(&gbContext[CONTEXT]);

1031 LTP = LTP ^ SLTP;

1032 }

1033 if(LTP == 1) {

1034 GBREG->copyLine(h, h - 1);

1035 } else {

1036 switch(GBTEMPLATE) {

1037 case 0: {

1038 line1 = GBREG->getPixel(1, h - 2);

1039 line1 \|= GBREG->getPixel(0, h - 2) << 1;

1040 line2 = GBREG->getPixel(2, h - 1);

1041 line2 \|= GBREG->getPixel(1, h - 1) << 1;

1042 line2 \|= GBREG->getPixel(0, h - 1) << 2;

1043 line3 = 0;

1044 for(FX_DWORD w = 0; w < GBW; w++) {

1045 if(USESKIP && SKIP->getPixel(w, h)) {

1046 bVal = 0;

1047 } else {

1048 CONTEXT = line3;

1049 CONTEXT \|= GBREG->getPixel(w + GBAT[0], h + GBAT [1]) << 4;

1050 CONTEXT \|= line2 << 5;

1051 CONTEXT \|= GBREG->getPixel(w + GBAT[2], h + GBAT [3]) << 10;

1052 CONTEXT \|= GBREG->getPixel(w + GBAT[4], h + GBAT [5]) << 11;

1053 CONTEXT \|= line1 << 12;

1054 CONTEXT \|= GBREG->getPixel(w + GBAT[6], h + GBAT [7]) << 15;

1055 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT] );

1056 }

1057 if(bVal) {

1058 GBREG->setPixel(w, h, bVal);

1059 }

1060 line1 = ((line1 << 1) \| GBREG->getPixel(w + 2, h - 2 )) & 0x07;

1061 line2 = ((line2 << 1) \| GBREG->getPixel(w + 3, h - 1 )) & 0x1f;

1062 line3 = ((line3 << 1) \| bVal) & 0x0f;

1063 }

1064 }

1065 break;

1066 case 1: {

1067 line1 = GBREG->getPixel(2, h - 2);

1068 line1 \|= GBREG->getPixel(1, h - 2) << 1;

1069 line1 \|= GBREG->getPixel(0, h - 2) << 2;

1070 line2 = GBREG->getPixel(2, h - 1);

1071 line2 \|= GBREG->getPixel(1, h - 1) << 1;

1072 line2 \|= GBREG->getPixel(0, h - 1) << 2;

1073 line3 = 0;

1074 for(FX_DWORD w = 0; w < GBW; w++) {

1075 if(USESKIP && SKIP->getPixel(w, h)) {

1076 bVal = 0;

1077 } else {

1078 CONTEXT = line3;

1079 CONTEXT \|= GBREG->getPixel(w + GBAT[0], h + GBAT [1]) << 3;

1080 CONTEXT \|= line2 << 4;

1081 CONTEXT \|= line1 << 9;

1082 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT] );

1083 }

1084 if(bVal) {

1085 GBREG->setPixel(w, h, bVal);

1086 }

1087 line1 = ((line1 << 1) \| GBREG->getPixel(w + 3, h - 2 )) & 0x0f;

1088 line2 = ((line2 << 1) \| GBREG->getPixel(w + 3, h - 1 )) & 0x1f;

1089 line3 = ((line3 << 1) \| bVal) & 0x07;

1090 }

1091 }

1092 break;

1093 case 2: {

1094 line1 = GBREG->getPixel(1, h - 2);

1095 line1 \|= GBREG->getPixel(0, h - 2) << 1;

1096 line2 = GBREG->getPixel(1, h - 1);

1097 line2 \|= GBREG->getPixel(0, h - 1) << 1;

1098 line3 = 0;

1099 for(FX_DWORD w = 0; w < GBW; w++) {

1100 if(USESKIP && SKIP->getPixel(w, h)) {

1101 bVal = 0;

1102 } else {

1103 CONTEXT = line3;

1104 CONTEXT \|= GBREG->getPixel(w + GBAT[0], h + GBAT [1]) << 2;

1105 CONTEXT \|= line2 << 3;

1106 CONTEXT \|= line1 << 7;

1107 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT] );

1108 }

1109 if(bVal) {

1110 GBREG->setPixel(w, h, bVal);

1111 }

1112 line1 = ((line1 << 1) \| GBREG->getPixel(w + 2, h - 2 )) & 0x07;

1113 line2 = ((line2 << 1) \| GBREG->getPixel(w + 2, h - 1 )) & 0x0f;

1114 line3 = ((line3 << 1) \| bVal) & 0x03;

1115 }

1116 }

1117 break;

1118 case 3: {

1119 line1 = GBREG->getPixel(1, h - 1);

1120 line1 \|= GBREG->getPixel(0, h - 1) << 1;

1121 line2 = 0;

1122 for(FX_DWORD w = 0; w < GBW; w++) {

1123 if(USESKIP && SKIP->getPixel(w, h)) {

1124 bVal = 0;

1125 } else {

1126 CONTEXT = line2;

1127 CONTEXT \|= GBREG->getPixel(w + GBAT[0], h + GBAT [1]) << 4;

1128 CONTEXT \|= line1 << 5;

1129 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT] );

1130 }

1131 if(bVal) {

1132 GBREG->setPixel(w, h, bVal);

1133 }

1134 line1 = ((line1 << 1) \| GBREG->getPixel(w + 2, h - 1 )) & 0x1f;

1135 line2 = ((line2 << 1) \| bVal) & 0x0f;

1136 }

1137 }

1138 break;

1139 }

1140 }

1141 }

1142 return GBREG;

1143 }

1144 CJBig2_Image CJBig2_GRDProc::decode_Arith_V1(CJBig2_ArithDecoder pArithDecoder , JBig2ArithCtx *gbContext)

1145 {

1146 FX_BOOL LTP, SLTP, bVal;

1147 FX_DWORD CONTEXT = 0;

1148 CJBig2_Image *GBREG;

1149 LTP = 0;

1150 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));

1151 GBREG->fill(0);

1152 for(FX_DWORD h = 0; h < GBH; h++) {

1153 if(TPGDON) {

1154 switch(GBTEMPLATE) {

1155 case 0:

1156 CONTEXT = 0x9b25;

1157 break;

1158 case 1:

1159 CONTEXT = 0x0795;

1160 break;

1161 case 2:

1162 CONTEXT = 0x00e5;

1163 break;

1164 case 3:

1165 CONTEXT = 0x0195;

1166 break;

1167 }

1168 SLTP = pArithDecoder->DECODE(&gbContext[CONTEXT]);

1169 LTP = LTP ^ SLTP;

1170 }

1171 if(LTP == 1) {

1172 for(FX_DWORD w = 0; w < GBW; w++) {

1173 GBREG->setPixel(w, h, GBREG->getPixel(w, h - 1));

1174 }

1175 } else {

1176 for(FX_DWORD w = 0; w < GBW; w++) {

1177 if(USESKIP && SKIP->getPixel(w, h)) {

1178 GBREG->setPixel(w, h, 0);

1179 } else {

1180 CONTEXT = 0;

1181 switch(GBTEMPLATE) {

1182 case 0:

1183 CONTEXT \|= GBREG->getPixel(w - 1, h);

1184 CONTEXT \|= GBREG->getPixel(w - 2, h) << 1;

1185 CONTEXT \|= GBREG->getPixel(w - 3, h) << 2;

1186 CONTEXT \|= GBREG->getPixel(w - 4, h) << 3;

1187 CONTEXT \|= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 4;

1188 CONTEXT \|= GBREG->getPixel(w + 2, h - 1) << 5;

1189 CONTEXT \|= GBREG->getPixel(w + 1, h - 1) << 6;

1190 CONTEXT \|= GBREG->getPixel(w, h - 1) << 7;

1191 CONTEXT \|= GBREG->getPixel(w - 1, h - 1) << 8;

1192 CONTEXT \|= GBREG->getPixel(w - 2, h - 1) << 9;

1193 CONTEXT \|= GBREG->getPixel(w + GBAT[2], h + GBAT[3]) << 10;

1194 CONTEXT \|= GBREG->getPixel(w + GBAT[4], h + GBAT[5]) << 11;

1195 CONTEXT \|= GBREG->getPixel(w + 1, h - 2) << 12;

1196 CONTEXT \|= GBREG->getPixel(w, h - 2) << 13;

1197 CONTEXT \|= GBREG->getPixel(w - 1, h - 2) << 14;

1198 CONTEXT \|= GBREG->getPixel(w + GBAT[6], h + GBAT[7]) << 15;

1199 break;

1200 case 1:

1201 CONTEXT \|= GBREG->getPixel(w - 1, h);

1202 CONTEXT \|= GBREG->getPixel(w - 2, h) << 1;

1203 CONTEXT \|= GBREG->getPixel(w - 3, h) << 2;

1204 CONTEXT \|= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 3;

1205 CONTEXT \|= GBREG->getPixel(w + 2, h - 1) << 4;

1206 CONTEXT \|= GBREG->getPixel(w + 1, h - 1) << 5;

1207 CONTEXT \|= GBREG->getPixel(w, h - 1) << 6;

1208 CONTEXT \|= GBREG->getPixel(w - 1, h - 1) << 7;

1209 CONTEXT \|= GBREG->getPixel(w - 2, h - 1) << 8;

1210 CONTEXT \|= GBREG->getPixel(w + 2, h - 2) << 9;

1211 CONTEXT \|= GBREG->getPixel(w + 1, h - 2) << 10;

1212 CONTEXT \|= GBREG->getPixel(w, h - 2) << 11;

1213 CONTEXT \|= GBREG->getPixel(w - 1, h - 2) << 12;

1214 break;

1215 case 2:

1216 CONTEXT \|= GBREG->getPixel(w - 1, h);

1217 CONTEXT \|= GBREG->getPixel(w - 2, h) << 1;

1218 CONTEXT \|= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 2;

1219 CONTEXT \|= GBREG->getPixel(w + 1, h - 1) << 3;

1220 CONTEXT \|= GBREG->getPixel(w, h - 1) << 4;

1221 CONTEXT \|= GBREG->getPixel(w - 1, h - 1) << 5;

1222 CONTEXT \|= GBREG->getPixel(w - 2, h - 1) << 6;

1223 CONTEXT \|= GBREG->getPixel(w + 1, h - 2) << 7;

1224 CONTEXT \|= GBREG->getPixel(w, h - 2) << 8;

1225 CONTEXT \|= GBREG->getPixel(w - 1, h - 2) << 9;

1226 break;

1227 case 3:

1228 CONTEXT \|= GBREG->getPixel(w - 1, h);

1229 CONTEXT \|= GBREG->getPixel(w - 2, h) << 1;

1230 CONTEXT \|= GBREG->getPixel(w - 3, h) << 2;

1231 CONTEXT \|= GBREG->getPixel(w - 4, h) << 3;

1232 CONTEXT \|= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 4;

1233 CONTEXT \|= GBREG->getPixel(w + 1, h - 1) << 5;

1234 CONTEXT \|= GBREG->getPixel(w, h - 1) << 6;

1235 CONTEXT \|= GBREG->getPixel(w - 1, h - 1) << 7;

1236 CONTEXT \|= GBREG->getPixel(w - 2, h - 1) << 8;

1237 CONTEXT \|= GBREG->getPixel(w - 3, h - 1) << 9;

1238 break;

1239 }

1240 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

1241 GBREG->setPixel(w, h, bVal);

1242 }

1243 }

1244 }

1245 }

1246 return GBREG;

1247 }

1248 CJBig2_Image CJBig2_GRDProc::decode_MMR(CJBig2_BitStream pStream)

1249 {

1250 int bitpos, i;

1251 CJBig2_Image *pImage;

1252 JBIG2_ALLOC(pImage, CJBig2_Image(GBW, GBH));

1253 if (pImage->m_pData == NULL) {

1254 delete pImage;

1255 m_pModule->JBig2_Error("Generic region decoding procedure: Create Image Failed with width = %d, height = %d\n", GBW, GBH);

1256 return NULL;

1257 }

1258 bitpos = (int)pStream->getBitPos();

1259 _FaxG4Decode(m_pModule, pStream->getBuf(), pStream->getLength(), &bitpos, pI mage->m_pData, GBW, GBH, pImage->m_nStride);

1260 pStream->setBitPos(bitpos);

1261 for(i = 0; (FX_DWORD)i < pImage->m_nStride * GBH; i++) {

1262 pImage->m_pData[i] = ~pImage->m_pData[i];

1263 }

1264 return pImage;

1265 }

1266 CJBig2_Image CJBig2_GRRDProc::decode(CJBig2_ArithDecoder pArithDecoder, JBig2A rithCtx *grContext)

1267 {

1268 if (GRW == 0 \|\| GRH == 0) {

1269 CJBig2_Image* pImage;

1270 JBIG2_ALLOC(pImage, CJBig2_Image(GRW, GRH));

1271 return pImage;

1272 }

1273 if(GRTEMPLATE == 0) {

1274 if((GRAT[0] == (signed char) - 1) && (GRAT[1] == (signed char) - 1)

1275 && (GRAT[2] == (signed char) - 1) && (GRAT[3] == (signed char) - 1)

1276 && (GRREFERENCEDX == 0) && (GRW == (FX_DWORD)GRREFERENCE->m_nWid th)) {

1277 return decode_Template0_opt(pArithDecoder, grContext);

1278 } else {

1279 return decode_Template0_unopt(pArithDecoder, grContext);

1280 }

1281 } else {

1282 if((GRREFERENCEDX == 0) && (GRW == (FX_DWORD)GRREFERENCE->m_nWidth)) {

1283 return decode_Template1_opt(pArithDecoder, grContext);

1284 } else {

1285 return decode_Template1_unopt(pArithDecoder, grContext);

1286 }

1287 }

1288 }

1289 CJBig2_Image CJBig2_GRRDProc::decode_Template0_unopt(CJBig2_ArithDecoder pArit hDecoder, JBig2ArithCtx *grContext)

1290 {

1291 FX_BOOL LTP, SLTP, bVal;

1292 FX_DWORD CONTEXT;

1293 CJBig2_Image *GRREG;

1294 FX_DWORD line1, line2, line3, line4, line5;

1295 LTP = 0;

1296 JBIG2_ALLOC(GRREG, CJBig2_Image(GRW, GRH));

1297 GRREG->fill(0);

1298 for(FX_DWORD h = 0; h < GRH; h++) {

1299 if(TPGRON) {

1300 SLTP = pArithDecoder->DECODE(&grContext[0x0010]);

1301 LTP = LTP ^ SLTP;

1302 }

1303 if(LTP == 0) {

1304 line1 = GRREG->getPixel(1, h - 1);

1305 line1 \|= GRREG->getPixel(0, h - 1) << 1;

1306 line2 = 0;

1307 line3 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY - 1);

1308 line3 \|= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY - 1 ) << 1;

1309 line4 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY) ;

1310 line4 \|= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY) << 1;

1311 line4 \|= GRREFERENCE->getPixel(-GRREFERENCEDX - 1, h - GRREFERENCEDY ) << 2;

1312 line5 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY + 1);

1313 line5 \|= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY + 1 ) << 1;

1314 line5 \|= GRREFERENCE->getPixel(-GRREFERENCEDX - 1, h - GRREFERENCEDY + 1) << 2;

1315 for(FX_DWORD w = 0; w < GRW; w++) {

1316 CONTEXT = line5;

1317 CONTEXT \|= line4 << 3;

1318 CONTEXT \|= line3 << 6;

1319 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX + GRAT[2], h - GRREFERENCEDY + GRAT[3]) << 8;

1320 CONTEXT \|= line2 << 9;

1321 CONTEXT \|= line1 << 10;

1322 CONTEXT \|= GRREG->getPixel(w + GRAT[0], h + GRAT[1]) << 12;

1323 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);

1324 GRREG->setPixel(w, h, bVal);

1325 line1 = ((line1 << 1) \| GRREG->getPixel(w + 2, h - 1)) & 0x03;

1326 line2 = ((line2 << 1) \| bVal) & 0x01;

1327 line3 = ((line3 << 1) \| GRREFERENCE->getPixel(w - GRREFERENCEDX + 2, h - GRREFERENCEDY - 1)) & 0x03;

1328 line4 = ((line4 << 1) \| GRREFERENCE->getPixel(w - GRREFERENCEDX + 2, h - GRREFERENCEDY)) & 0x07;

1329 line5 = ((line5 << 1) \| GRREFERENCE->getPixel(w - GRREFERENCEDX + 2, h - GRREFERENCEDY + 1)) & 0x07;

1330 }

1331 } else {

1332 line1 = GRREG->getPixel(1, h - 1);

1333 line1 \|= GRREG->getPixel(0, h - 1) << 1;

1334 line2 = 0;

1335 line3 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY - 1);

1336 line3 \|= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY - 1 ) << 1;

1337 line4 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY) ;

1338 line4 \|= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY) << 1;

1339 line4 \|= GRREFERENCE->getPixel(-GRREFERENCEDX - 1, h - GRREFERENCEDY ) << 2;

1340 line5 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY + 1);

1341 line5 \|= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY + 1 ) << 1;

1342 line5 \|= GRREFERENCE->getPixel(-GRREFERENCEDX - 1, h - GRREFERENCEDY + 1) << 2;

1343 for(FX_DWORD w = 0; w < GRW; w++) {

1344 bVal = GRREFERENCE->getPixel(w, h);

1345 if(!(TPGRON && (bVal == GRREFERENCE->getPixel(w - 1, h - 1))

1346 && (bVal == GRREFERENCE->getPixel(w, h - 1))

1347 && (bVal == GRREFERENCE->getPixel(w + 1, h - 1))

1348 && (bVal == GRREFERENCE->getPixel(w - 1, h))

1349 && (bVal == GRREFERENCE->getPixel(w + 1, h))

1350 && (bVal == GRREFERENCE->getPixel(w - 1, h + 1))

1351 && (bVal == GRREFERENCE->getPixel(w, h + 1))

1352 && (bVal == GRREFERENCE->getPixel(w + 1, h + 1)))) {

1353 CONTEXT = line5;

1354 CONTEXT \|= line4 << 3;

1355 CONTEXT \|= line3 << 6;

1356 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX + GRAT[2] , h - GRREFERENCEDY + GRAT[3]) << 8;

1357 CONTEXT \|= line2 << 9;

1358 CONTEXT \|= line1 << 10;

1359 CONTEXT \|= GRREG->getPixel(w + GRAT[0], h + GRAT[1]) << 12;

1360 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);

1361 }

1362 GRREG->setPixel(w, h, bVal);

1363 line1 = ((line1 << 1) \| GRREG->getPixel(w + 2, h - 1)) & 0x03;

1364 line2 = ((line2 << 1) \| bVal) & 0x01;

1365 line3 = ((line3 << 1) \| GRREFERENCE->getPixel(w - GRREFERENCEDX + 2, h - GRREFERENCEDY - 1)) & 0x03;

1366 line4 = ((line4 << 1) \| GRREFERENCE->getPixel(w - GRREFERENCEDX + 2, h - GRREFERENCEDY)) & 0x07;

1367 line5 = ((line5 << 1) \| GRREFERENCE->getPixel(w - GRREFERENCEDX + 2, h - GRREFERENCEDY + 1)) & 0x07;

1368 }

1369 }

1370 }

1371 return GRREG;

1372 }

1373 CJBig2_Image CJBig2_GRRDProc::decode_Template0_opt(CJBig2_ArithDecoder pArithD ecoder, JBig2ArithCtx *grContext)

1374 {

1375 FX_BOOL LTP, SLTP, bVal;

1376 FX_DWORD CONTEXT;

1377 CJBig2_Image *GRREG;

1378 FX_DWORD line1, line1_r, line2_r, line3_r;

1379 FX_BYTE pLine, pLineR, cVal;

1380 FX_INTPTR nStride, nStrideR, nOffset;

1381 FX_INT32 k, nBits;

1382 FX_INT32 GRWR, GRHR;

1383 FX_INT32 GRW, GRH;

1384 GRW = (FX_INT32)CJBig2_GRRDProc::GRW;

1385 GRH = (FX_INT32)CJBig2_GRRDProc::GRH;

1386 LTP = 0;

1387 JBIG2_ALLOC(GRREG, CJBig2_Image(GRW, GRH));

1388 if (GRREG->m_pData == NULL) {

1389 delete GRREG;

1390 m_pModule->JBig2_Error("Generic refinement region decoding procedure: Cr eate Image Failed with width = %d, height = %d\n", GRW, GRH);

1391 return NULL;

1392 }

1393 pLine = GRREG->m_pData;

1394 pLineR = GRREFERENCE->m_pData;

1395 nStride = GRREG->m_nStride;

1396 nStrideR = GRREFERENCE->m_nStride;

1397 GRWR = (FX_INT32)GRREFERENCE->m_nWidth;

1398 GRHR = (FX_INT32)GRREFERENCE->m_nHeight;

1399 if (GRREFERENCEDY < -GRHR + 1 \|\| GRREFERENCEDY > GRHR - 1) {

1400 GRREFERENCEDY = 0;

1401 }

1402 nOffset = -GRREFERENCEDY * nStrideR;

1403 for (FX_INT32 h = 0; h < GRH; h++) {

1404 if(TPGRON) {

1405 SLTP = pArithDecoder->DECODE(&grContext[0x0010]);

1406 LTP = LTP ^ SLTP;

1407 }

1408 line1 = (h > 0) ? pLine[-nStride] << 4 : 0;

1409 FX_INT32 reference_h = h - GRREFERENCEDY;

1410 FX_BOOL line1_r_ok = (reference_h > 0 && reference_h < GRHR + 1);

1411 FX_BOOL line2_r_ok = (reference_h > -1 && reference_h < GRHR);

1412 FX_BOOL line3_r_ok = (reference_h > -2 && reference_h < GRHR - 1);

1413 line1_r = line1_r_ok ? pLineR[nOffset - nStrideR] : 0;

1414 line2_r = line2_r_ok ? pLineR[nOffset] : 0;

1415 line3_r = line3_r_ok ? pLineR[nOffset + nStrideR] : 0;

1416 if(LTP == 0) {

1417 CONTEXT = (line1 & 0x1c00) \| (line1_r & 0x01c0)

1418 \| ((line2_r >> 3) & 0x0038) \| ((line3_r >> 6) & 0x0007);

1419 for (FX_INT32 w = 0; w < GRW; w += 8) {

1420 nBits = GRW - w > 8 ? 8 : GRW - w;

1421 if (h > 0)

1422 line1 = (line1 << 8) \|

1423 (w + 8 < GRW ? pLine[-nStride + (w >> 3) + 1] << 4 : 0);

1424 if (h > GRHR + GRREFERENCEDY + 1) {

1425 line1_r = 0;

1426 line2_r = 0;

1427 line3_r = 0;

1428 } else {

1429 if(line1_r_ok)

1430 line1_r = (line1_r << 8) \|

1431 (w + 8 < GRWR ? pLineR[nOffset - nStrideR + (w >> 3) + 1] : 0);

1432 if(line2_r_ok)

1433 line2_r = (line2_r << 8) \|

1434 (w + 8 < GRWR ? pLineR[nOffset + (w >> 3) + 1] : 0);

1435 if(line3_r_ok)

1436 line3_r = (line3_r << 8) \|

1437 (w + 8 < GRWR ? pLineR[nOffset + nStrideR + (w >> 3) + 1] : 0);

1438 else {

1439 line3_r = 0;

1440 }

1441 }

1442 cVal = 0;

1443 for (k = 0; k < nBits; k++) {

1444 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);

1445 cVal \|= bVal << (7 - k);

1446 CONTEXT = ((CONTEXT & 0x0cdb) << 1) \| (bVal << 9) \|

1447 ((line1 >> (7 - k)) & 0x0400) \|

1448 ((line1_r >> (7 - k)) & 0x0040) \|

1449 ((line2_r >> (10 - k)) & 0x0008) \|

1450 ((line3_r >> (13 - k)) & 0x0001);

1451 }

1452 pLine[w >> 3] = cVal;

1453 }

1454 } else {

1455 CONTEXT = (line1 & 0x1c00) \| (line1_r & 0x01c0)

1456 \| ((line2_r >> 3) & 0x0038) \| ((line3_r >> 6) & 0x0007);

1457 for (FX_INT32 w = 0; w < GRW; w += 8) {

1458 nBits = GRW - w > 8 ? 8 : GRW - w;

1459 if (h > 0)

1460 line1 = (line1 << 8) \|

1461 (w + 8 < GRW ? pLine[-nStride + (w >> 3) + 1] << 4 : 0);

1462 if(line1_r_ok)

1463 line1_r = (line1_r << 8) \|

1464 (w + 8 < GRWR ? pLineR[nOffset - nStrideR + (w >> 3) + 1] : 0);

1465 if(line2_r_ok)

1466 line2_r = (line2_r << 8) \|

1467 (w + 8 < GRWR ? pLineR[nOffset + (w >> 3) + 1] : 0 );

1468 if(line3_r_ok)

1469 line3_r = (line3_r << 8) \|

1470 (w + 8 < GRWR ? pLineR[nOffset + nStrideR + (w >> 3) + 1] : 0);

1471 else {

1472 line3_r = 0;

1473 }

1474 cVal = 0;

1475 for (k = 0; k < nBits; k++) {

1476 bVal = GRREFERENCE->getPixel(w + k, h);

1477 if(!(TPGRON && (bVal == GRREFERENCE->getPixel(w + k - 1, h - 1))

1478 && (bVal == GRREFERENCE->getPixel(w + k, h - 1))

1479 && (bVal == GRREFERENCE->getPixel(w + k + 1, h - 1))

1480 && (bVal == GRREFERENCE->getPixel(w + k - 1, h))

1481 && (bVal == GRREFERENCE->getPixel(w + k + 1, h))

1482 && (bVal == GRREFERENCE->getPixel(w + k - 1, h + 1))

1483 && (bVal == GRREFERENCE->getPixel(w + k, h + 1))

1484 && (bVal == GRREFERENCE->getPixel(w + k + 1, h + 1)) )) {

1485 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);

1486 }

1487 cVal \|= bVal << (7 - k);

1488 CONTEXT = ((CONTEXT & 0x0cdb) << 1) \| (bVal << 9) \|

1489 ((line1 >> (7 - k)) & 0x0400) \|

1490 ((line1_r >> (7 - k)) & 0x0040) \|

1491 ((line2_r >> (10 - k)) & 0x0008) \|

1492 ((line3_r >> (13 - k)) & 0x0001);

1493 }

1494 pLine[w >> 3] = cVal;

1495 }

1496 }

1497 pLine += nStride;

1498 if (h < GRHR + GRREFERENCEDY) {

1499 pLineR += nStrideR;

1500 }

1501 }

1502 return GRREG;

1503 }

1504 CJBig2_Image CJBig2_GRRDProc::decode_Template1_unopt(CJBig2_ArithDecoder pArit hDecoder, JBig2ArithCtx *grContext)

1505 {

1506 FX_BOOL LTP, SLTP, bVal;

1507 FX_DWORD CONTEXT;

1508 CJBig2_Image *GRREG;

1509 FX_DWORD line1, line2, line3, line4, line5;

1510 LTP = 0;

1511 JBIG2_ALLOC(GRREG, CJBig2_Image(GRW, GRH));

1512 GRREG->fill(0);

1513 for(FX_DWORD h = 0; h < GRH; h++) {

1514 if(TPGRON) {

1515 SLTP = pArithDecoder->DECODE(&grContext[0x0008]);

1516 LTP = LTP ^ SLTP;

1517 }

1518 if(LTP == 0) {

1519 line1 = GRREG->getPixel(1, h - 1);

1520 line1 \|= GRREG->getPixel(0, h - 1) << 1;

1521 line1 \|= GRREG->getPixel(-1, h - 1) << 2;

1522 line2 = 0;

1523 line3 = GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY - 1) ;

1524 line4 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY) ;

1525 line4 \|= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY) << 1;

1526 line4 \|= GRREFERENCE->getPixel(-GRREFERENCEDX - 1, h - GRREFERENCEDY ) << 2;

1527 line5 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY + 1);

1528 line5 \|= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY + 1 ) << 1;

1529 for(FX_DWORD w = 0; w < GRW; w++) {

1530 CONTEXT = line5;

1531 CONTEXT \|= line4 << 2;

1532 CONTEXT \|= line3 << 5;

1533 CONTEXT \|= line2 << 6;

1534 CONTEXT \|= line1 << 7;

1535 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);

1536 GRREG->setPixel(w, h, bVal);

1537 line1 = ((line1 << 1) \| GRREG->getPixel(w + 2, h - 1)) & 0x07;

1538 line2 = ((line2 << 1) \| bVal) & 0x01;

1539 line3 = ((line3 << 1) \| GRREFERENCE->getPixel(w - GRREFERENCEDX + 1, h - GRREFERENCEDY - 1)) & 0x01;

1540 line4 = ((line4 << 1) \| GRREFERENCE->getPixel(w - GRREFERENCEDX + 2, h - GRREFERENCEDY)) & 0x07;

1541 line5 = ((line5 << 1) \| GRREFERENCE->getPixel(w - GRREFERENCEDX + 2, h - GRREFERENCEDY + 1)) & 0x03;

1542 }

1543 } else {

1544 line1 = GRREG->getPixel(1, h - 1);

1545 line1 \|= GRREG->getPixel(0, h - 1) << 1;

1546 line1 \|= GRREG->getPixel(-1, h - 1) << 2;

1547 line2 = 0;

1548 line3 = GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY - 1) ;

1549 line4 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY) ;

1550 line4 \|= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY) << 1;

1551 line4 \|= GRREFERENCE->getPixel(-GRREFERENCEDX - 1, h - GRREFERENCEDY ) << 2;

1552 line5 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY + 1);

1553 line5 \|= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY + 1 ) << 1;

1554 for(FX_DWORD w = 0; w < GRW; w++) {

1555 bVal = GRREFERENCE->getPixel(w, h);

1556 if(!(TPGRON && (bVal == GRREFERENCE->getPixel(w - 1, h - 1))

1557 && (bVal == GRREFERENCE->getPixel(w, h - 1))

1558 && (bVal == GRREFERENCE->getPixel(w + 1, h - 1))

1559 && (bVal == GRREFERENCE->getPixel(w - 1, h))

1560 && (bVal == GRREFERENCE->getPixel(w + 1, h))

1561 && (bVal == GRREFERENCE->getPixel(w - 1, h + 1))

1562 && (bVal == GRREFERENCE->getPixel(w, h + 1))

1563 && (bVal == GRREFERENCE->getPixel(w + 1, h + 1)))) {

1564 CONTEXT = line5;

1565 CONTEXT \|= line4 << 2;

1566 CONTEXT \|= line3 << 5;

1567 CONTEXT \|= line2 << 6;

1568 CONTEXT \|= line1 << 7;

1569 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);

1570 }

1571 GRREG->setPixel(w, h, bVal);

1572 line1 = ((line1 << 1) \| GRREG->getPixel(w + 2, h - 1)) & 0x07;

1573 line2 = ((line2 << 1) \| bVal) & 0x01;

1574 line3 = ((line3 << 1) \| GRREFERENCE->getPixel(w - GRREFERENCEDX + 1, h - GRREFERENCEDY - 1)) & 0x01;

1575 line4 = ((line4 << 1) \| GRREFERENCE->getPixel(w - GRREFERENCEDX + 2, h - GRREFERENCEDY)) & 0x07;

1576 line5 = ((line5 << 1) \| GRREFERENCE->getPixel(w - GRREFERENCEDX + 2, h - GRREFERENCEDY + 1)) & 0x03;

1577 }

1578 }

1579 }

1580 return GRREG;

1581 }

1582 CJBig2_Image CJBig2_GRRDProc::decode_Template1_opt(CJBig2_ArithDecoder pArithD ecoder, JBig2ArithCtx *grContext)

1583 {

1584 FX_BOOL LTP, SLTP, bVal;

1585 FX_DWORD CONTEXT;

1586 CJBig2_Image *GRREG;

1587 FX_DWORD line1, line1_r, line2_r, line3_r;

1588 FX_BYTE pLine, pLineR, cVal;

1589 FX_INTPTR nStride, nStrideR, nOffset;

1590 FX_INT32 k, nBits;

1591 FX_INT32 GRWR, GRHR;

1592 FX_INT32 GRW, GRH;

1593 GRW = (FX_INT32)CJBig2_GRRDProc::GRW;

1594 GRH = (FX_INT32)CJBig2_GRRDProc::GRH;

1595 LTP = 0;

1596 JBIG2_ALLOC(GRREG, CJBig2_Image(GRW, GRH));

1597 if (GRREG->m_pData == NULL) {

1598 delete GRREG;

1599 m_pModule->JBig2_Error("Generic refinement region decoding procedure: Cr eate Image Failed with width = %d, height = %d\n", GRW, GRH);

1600 return NULL;

1601 }

1602 pLine = GRREG->m_pData;

1603 pLineR = GRREFERENCE->m_pData;

1604 nStride = GRREG->m_nStride;

1605 nStrideR = GRREFERENCE->m_nStride;

1606 GRWR = (FX_INT32)GRREFERENCE->m_nWidth;

1607 GRHR = (FX_INT32)GRREFERENCE->m_nHeight;

1608 if (GRREFERENCEDY < -GRHR + 1 \|\| GRREFERENCEDY > GRHR - 1) {

1609 GRREFERENCEDY = 0;

1610 }

1611 nOffset = -GRREFERENCEDY * nStrideR;

1612 for (FX_INT32 h = 0; h < GRH; h++) {

1613 if(TPGRON) {

1614 SLTP = pArithDecoder->DECODE(&grContext[0x0008]);

1615 LTP = LTP ^ SLTP;

1616 }

1617 line1 = (h > 0) ? pLine[-nStride] << 1 : 0;

1618 FX_INT32 reference_h = h - GRREFERENCEDY;

1619 FX_BOOL line1_r_ok = (reference_h > 0 && reference_h < GRHR + 1);

1620 FX_BOOL line2_r_ok = (reference_h > -1 && reference_h < GRHR);

1621 FX_BOOL line3_r_ok = (reference_h > -2 && reference_h < GRHR - 1);

1622 line1_r = line1_r_ok ? pLineR[nOffset - nStrideR] : 0;

1623 line2_r = line2_r_ok ? pLineR[nOffset] : 0;

1624 line3_r = line3_r_ok ? pLineR[nOffset + nStrideR] : 0;

1625 if(LTP == 0) {

1626 CONTEXT = (line1 & 0x0380) \| ((line1_r >> 2) & 0x0020)

1627 \| ((line2_r >> 4) & 0x001c) \| ((line3_r >> 6) & 0x0003);

1628 for (FX_INT32 w = 0; w < GRW; w += 8) {

1629 nBits = GRW - w > 8 ? 8 : GRW - w;

1630 if (h > 0)

1631 line1 = (line1 << 8) \|

1632 (w + 8 < GRW ? pLine[-nStride + (w >> 3) + 1] << 1 : 0);

1633 if(line1_r_ok)

1634 line1_r = (line1_r << 8) \|

1635 (w + 8 < GRWR ? pLineR[nOffset - nStrideR + (w >> 3) + 1] : 0);

1636 if(line2_r_ok)

1637 line2_r = (line2_r << 8) \|

1638 (w + 8 < GRWR ? pLineR[nOffset + (w >> 3) + 1] : 0 );

1639 if(line3_r_ok)

1640 line3_r = (line3_r << 8) \|

1641 (w + 8 < GRWR ? pLineR[nOffset + nStrideR + (w >> 3) + 1] : 0);

1642 else {

1643 line3_r = 0;

1644 }

1645 cVal = 0;

1646 for (k = 0; k < nBits; k++) {

1647 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);

1648 cVal \|= bVal << (7 - k);

1649 CONTEXT = ((CONTEXT & 0x018d) << 1) \| (bVal << 6) \|

1650 ((line1 >> (7 - k)) & 0x0080) \|

1651 ((line1_r >> (9 - k)) & 0x0020) \|

1652 ((line2_r >> (11 - k)) & 0x0004) \|

1653 ((line3_r >> (13 - k)) & 0x0001);

1654 }

1655 pLine[w >> 3] = cVal;

1656 }

1657 } else {

1658 CONTEXT = (line1 & 0x0380) \| ((line1_r >> 2) & 0x0020)

1659 \| ((line2_r >> 4) & 0x001c) \| ((line3_r >> 6) & 0x0003);

1660 for (FX_INT32 w = 0; w < GRW; w += 8) {

1661 nBits = GRW - w > 8 ? 8 : GRW - w;

1662 if (h > 0)

1663 line1 = (line1 << 8) \|

1664 (w + 8 < GRW ? pLine[-nStride + (w >> 3) + 1] << 1 : 0);

1665 if(line1_r_ok)

1666 line1_r = (line1_r << 8) \|

1667 (w + 8 < GRWR ? pLineR[nOffset - nStrideR + (w >> 3) + 1] : 0);

1668 if(line2_r_ok)

1669 line2_r = (line2_r << 8) \|

1670 (w + 8 < GRWR ? pLineR[nOffset + (w >> 3) + 1] : 0 );

1671 if(line3_r_ok)

1672 line3_r = (line3_r << 8) \|

1673 (w + 8 < GRWR ? pLineR[nOffset + nStrideR + (w >> 3) + 1] : 0);

1674 else {

1675 line3_r = 0;

1676 }

1677 cVal = 0;

1678 for (k = 0; k < nBits; k++) {

1679 bVal = GRREFERENCE->getPixel(w + k, h);

1680 if(!(TPGRON && (bVal == GRREFERENCE->getPixel(w + k - 1, h - 1))

1681 && (bVal == GRREFERENCE->getPixel(w + k, h - 1))

1682 && (bVal == GRREFERENCE->getPixel(w + k + 1, h - 1))

1683 && (bVal == GRREFERENCE->getPixel(w + k - 1, h))

1684 && (bVal == GRREFERENCE->getPixel(w + k + 1, h))

1685 && (bVal == GRREFERENCE->getPixel(w + k - 1, h + 1))

1686 && (bVal == GRREFERENCE->getPixel(w + k, h + 1))

1687 && (bVal == GRREFERENCE->getPixel(w + k + 1, h + 1)) )) {

1688 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);

1689 }

1690 cVal \|= bVal << (7 - k);

1691 CONTEXT = ((CONTEXT & 0x018d) << 1) \| (bVal << 6) \|

1692 ((line1 >> (7 - k)) & 0x0080) \|

1693 ((line1_r >> (9 - k)) & 0x0020) \|

1694 ((line2_r >> (11 - k)) & 0x0004) \|

1695 ((line3_r >> (13 - k)) & 0x0001);

1696 }

1697 pLine[w >> 3] = cVal;

1698 }

1699 }

1700 pLine += nStride;

1701 if (h < GRHR + GRREFERENCEDY) {

1702 pLineR += nStrideR;

1703 }

1704 }

1705 return GRREG;

1706 }

1707 CJBig2_Image CJBig2_GRRDProc::decode_V1(CJBig2_ArithDecoder pArithDecoder, JBi g2ArithCtx *grContext)

1708 {

1709 FX_BOOL LTP, SLTP, bVal;

1710 FX_BOOL TPGRPIX, TPGRVAL;

1711 FX_DWORD CONTEXT;

1712 CJBig2_Image *GRREG;

1713 LTP = 0;

1714 JBIG2_ALLOC(GRREG, CJBig2_Image(GRW, GRH));

1715 GRREG->fill(0);

1716 for(FX_DWORD h = 0; h < GRH; h++) {

1717 if(TPGRON) {

1718 switch(GRTEMPLATE) {

1719 case 0:

1720 CONTEXT = 0x0010;

1721 break;

1722 case 1:

1723 CONTEXT = 0x0008;

1724 break;

1725 }

1726 SLTP = pArithDecoder->DECODE(&grContext[CONTEXT]);

1727 LTP = LTP ^ SLTP;

1728 }

1729 if(LTP == 0) {

1730 for(FX_DWORD w = 0; w < GRW; w++) {

1731 CONTEXT = 0;

1732 switch(GRTEMPLATE) {

1733 case 0:

1734 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX + 1, h - GRREFERENCEDY + 1);

1735 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX, h - GRREFERENCEDY + 1) << 1;

1736 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX - 1, h - GRREFERENCEDY + 1) << 2;

1737 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX + 1, h - GRREFERENCEDY) << 3;

1738 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX, h - GRREFERENCEDY) << 4;

1739 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX - 1, h - GRREFERENCEDY) << 5;

1740 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX + 1, h - GRREFERENCEDY - 1) << 6;

1741 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX, h - GRREFERENCEDY - 1) << 7;

1742 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX + GRA T[2], h - GRREFERENCEDY + GRAT[3]) << 8;

1743 CONTEXT \|= GRREG->getPixel(w - 1, h) << 9;

1744 CONTEXT \|= GRREG->getPixel(w + 1, h - 1) << 10;

1745 CONTEXT \|= GRREG->getPixel(w, h - 1) << 11;

1746 CONTEXT \|= GRREG->getPixel(w + GRAT[0], h + GRAT[1]) << 12;

1747 break;

1748 case 1:

1749 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX + 1, h - GRREFERENCEDY + 1);

1750 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX, h - GRREFERENCEDY + 1) << 1;

1751 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX + 1, h - GRREFERENCEDY) << 2;

1752 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX, h - GRREFERENCEDY) << 3;

1753 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX - 1, h - GRREFERENCEDY) << 4;

1754 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX, h - GRREFERENCEDY - 1) << 5;

1755 CONTEXT \|= GRREG->getPixel(w - 1, h) << 6;

1756 CONTEXT \|= GRREG->getPixel(w + 1, h - 1) << 7;

1757 CONTEXT \|= GRREG->getPixel(w, h - 1) << 8;

1758 CONTEXT \|= GRREG->getPixel(w - 1, h - 1) << 9;

1759 break;

1760 }

1761 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);

1762 GRREG->setPixel(w, h, bVal);

1763 }

1764 } else {

1765 for(FX_DWORD w = 0; w < GRW; w++) {

1766 bVal = GRREFERENCE->getPixel(w, h);

1767 if(TPGRON && (bVal == GRREFERENCE->getPixel(w - 1, h - 1))

1768 && (bVal == GRREFERENCE->getPixel(w, h - 1))

1769 && (bVal == GRREFERENCE->getPixel(w + 1, h - 1))

1770 && (bVal == GRREFERENCE->getPixel(w - 1, h))

1771 && (bVal == GRREFERENCE->getPixel(w + 1, h))

1772 && (bVal == GRREFERENCE->getPixel(w - 1, h + 1))

1773 && (bVal == GRREFERENCE->getPixel(w, h + 1))

1774 && (bVal == GRREFERENCE->getPixel(w + 1, h + 1))) {

1775 TPGRPIX = 1;

1776 TPGRVAL = bVal;

1777 } else {

1778 TPGRPIX = 0;

1779 }

1780 if(TPGRPIX) {

1781 GRREG->setPixel(w, h, TPGRVAL);

1782 } else {

1783 CONTEXT = 0;

1784 switch(GRTEMPLATE) {

1785 case 0:

1786 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX + 1, h - GRREFERENCEDY + 1);

1787 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX, h - GRREFERENCEDY + 1) << 1;

1788 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX - 1, h - GRREFERENCEDY + 1) << 2;

1789 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX + 1, h - GRREFERENCEDY) << 3;

1790 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX, h - GRREFERENCEDY) << 4;

1791 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX - 1, h - GRREFERENCEDY) << 5;

1792 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX + 1, h - GRREFERENCEDY - 1) << 6;

1793 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX, h - GRREFERENCEDY - 1) << 7;

1794 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX + GRAT[2], h - GRREFERENCEDY + GRAT[3]) << 8;

1795 CONTEXT \|= GRREG->getPixel(w - 1, h) << 9;

1796 CONTEXT \|= GRREG->getPixel(w + 1, h - 1) << 10;

1797 CONTEXT \|= GRREG->getPixel(w, h - 1) << 11;

1798 CONTEXT \|= GRREG->getPixel(w + GRAT[0], h + GRAT[1]) << 12;

1799 break;

1800 case 1:

1801 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX + 1, h - GRREFERENCEDY + 1);

1802 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX, h - GRREFERENCEDY + 1) << 1;

1803 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX + 1, h - GRREFERENCEDY) << 2;

1804 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX, h - GRREFERENCEDY) << 3;

1805 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX - 1, h - GRREFERENCEDY) << 4;

1806 CONTEXT \|= GRREFERENCE->getPixel(w - GRREFERENCEDX, h - GRREFERENCEDY - 1) << 5;

1807 CONTEXT \|= GRREG->getPixel(w - 1, h) << 6;

1808 CONTEXT \|= GRREG->getPixel(w + 1, h - 1) << 7;

1809 CONTEXT \|= GRREG->getPixel(w, h - 1) << 8;

1810 CONTEXT \|= GRREG->getPixel(w - 1, h - 1) << 9;

1811 break;

1812 }

1813 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);

1814 GRREG->setPixel(w, h, bVal);

1815 }

1816 }

1817 }

1818 }

1819 return GRREG;

1820 }

1821 CJBig2_Image CJBig2_TRDProc::decode_Huffman(CJBig2_BitStream pStream, JBig2Ari thCtx *grContext)

1822 {

1823 FX_INT32 STRIPT, FIRSTS;

1824 FX_DWORD NINSTANCES;

1825 FX_INT32 DT, DFS, CURS;

1826 FX_BYTE CURT;

1827 FX_INT32 SI, TI;

1828 FX_DWORD IDI;

1829 CJBig2_Image *IBI;

1830 FX_DWORD WI, HI;

1831 FX_INT32 IDS;

1832 FX_BOOL RI;

1833 FX_INT32 RDWI, RDHI, RDXI, RDYI;

1834 CJBig2_Image *IBOI;

1835 FX_DWORD WOI, HOI;

1836 CJBig2_Image *SBREG;

1837 FX_BOOL bFirst;

1838 FX_DWORD nTmp;

1839 FX_INT32 nVal, nBits;

1840 CJBig2_HuffmanDecoder *pHuffmanDecoder;

1841 CJBig2_GRRDProc *pGRRD;

1842 CJBig2_ArithDecoder *pArithDecoder;

1843 JBIG2_ALLOC(pHuffmanDecoder, CJBig2_HuffmanDecoder(pStream));

1844 JBIG2_ALLOC(SBREG, CJBig2_Image(SBW, SBH));

1845 SBREG->fill(SBDEFPIXEL);

1846 if(pHuffmanDecoder->decodeAValue(SBHUFFDT, &STRIPT) != 0) {

1847 m_pModule->JBig2_Error("text region decoding procedure (huffman): too sh ort.");

1848 goto failed;

1849 }

1850 STRIPT *= SBSTRIPS;

1851 STRIPT = -STRIPT;

1852 FIRSTS = 0;

1853 NINSTANCES = 0;

1854 while(NINSTANCES < SBNUMINSTANCES) {

1855 if(pHuffmanDecoder->decodeAValue(SBHUFFDT, &DT) != 0) {

1856 m_pModule->JBig2_Error("text region decoding procedure (huffman): to o short.");

1857 goto failed;

1858 }

1859 DT *= SBSTRIPS;

1860 STRIPT = STRIPT + DT;

1861 bFirst = TRUE;

1862 for(;;) {

1863 if(bFirst) {

1864 if(pHuffmanDecoder->decodeAValue(SBHUFFFS, &DFS) != 0) {

1865 m_pModule->JBig2_Error("text region decoding procedure (huff man): too short.");

1866 goto failed;

1867 }

1868 FIRSTS = FIRSTS + DFS;

1869 CURS = FIRSTS;

1870 bFirst = FALSE;

1871 } else {

1872 nVal = pHuffmanDecoder->decodeAValue(SBHUFFDS, &IDS);

1873 if(nVal == JBIG2_OOB) {

1874 break;

1875 } else if(nVal != 0) {

1876 m_pModule->JBig2_Error("text region decoding procedure (huff man): too short.");

1877 goto failed;

1878 } else {

1879 CURS = CURS + IDS + SBDSOFFSET;

1880 }

1881 }

1882 if(SBSTRIPS == 1) {

1883 CURT = 0;

1884 } else {

1885 nTmp = 1;

1886 while((FX_DWORD)(1 << nTmp) < SBSTRIPS) {

1887 nTmp ++;

1888 }

1889 if(pStream->readNBits(nTmp, &nVal) != 0) {

1890 m_pModule->JBig2_Error("text region decoding procedure (huff man): too short.");

1891 goto failed;

1892 }

1893 CURT = nVal;

1894 }

1895 TI = STRIPT + CURT;

1896 nVal = 0;

1897 nBits = 0;

1898 for(;;) {

1899 if(pStream->read1Bit(&nTmp) != 0) {

1900 m_pModule->JBig2_Error("text region decoding procedure (huff man): too short.");

1901 goto failed;

1902 }

1903 nVal = (nVal << 1) \| nTmp;

1904 nBits ++;

1905 for(IDI = 0; IDI < SBNUMSYMS; IDI++) {

1906 if((nBits == SBSYMCODES[IDI].codelen) && (nVal == SBSYMCODES [IDI].code)) {

1907 break;

1908 }

1909 }

1910 if(IDI < SBNUMSYMS) {

1911 break;

1912 }

1913 }

1914 if(SBREFINE == 0) {

1915 RI = 0;

1916 } else {

1917 if(pStream->read1Bit(&RI) != 0) {

1918 m_pModule->JBig2_Error("text region decoding procedure (huff man): too short.");

1919 goto failed;

1920 }

1921 }

1922 if(RI == 0) {

1923 IBI = SBSYMS[IDI];

1924 } else {

1925 if((pHuffmanDecoder->decodeAValue(SBHUFFRDW, &RDWI) != 0)

1926 \|\| (pHuffmanDecoder->decodeAValue(SBHUFFRDH, &RDHI) != 0 )

1927 \|\| (pHuffmanDecoder->decodeAValue(SBHUFFRDX, &RDXI) != 0 )

1928 \|\| (pHuffmanDecoder->decodeAValue(SBHUFFRDY, &RDYI) != 0 )

1929 \|\| (pHuffmanDecoder->decodeAValue(SBHUFFRSIZE, &nVal) != 0)) {

1930 m_pModule->JBig2_Error("text region decoding procedure (huff man): too short.");

1931 goto failed;

1932 }

1933 pStream->alignByte();

1934 nTmp = pStream->getOffset();

1935 IBOI = SBSYMS[IDI];

1936 if (!IBOI) {

1937 goto failed;

1938 }

1939 WOI = IBOI->m_nWidth;

1940 HOI = IBOI->m_nHeight;

1941 if ((int)(WOI + RDWI) < 0 \|\| (int)(HOI + RDHI) < 0) {

1942 m_pModule->JBig2_Error("text region decoding procedure (huff man): Invalid RDWI or RDHI value.");

1943 goto failed;

1944 }

1945 JBIG2_ALLOC(pGRRD, CJBig2_GRRDProc());

1946 pGRRD->GRW = WOI + RDWI;

1947 pGRRD->GRH = HOI + RDHI;

1948 pGRRD->GRTEMPLATE = SBRTEMPLATE;

1949 pGRRD->GRREFERENCE = IBOI;

1950 pGRRD->GRREFERENCEDX = (RDWI >> 2) + RDXI;

1951 pGRRD->GRREFERENCEDY = (RDHI >> 2) + RDYI;

1952 pGRRD->TPGRON = 0;

1953 pGRRD->GRAT[0] = SBRAT[0];

1954 pGRRD->GRAT[1] = SBRAT[1];

1955 pGRRD->GRAT[2] = SBRAT[2];

1956 pGRRD->GRAT[3] = SBRAT[3];

1957 JBIG2_ALLOC(pArithDecoder, CJBig2_ArithDecoder(pStream));

1958 IBI = pGRRD->decode(pArithDecoder, grContext);

1959 if(IBI == NULL) {

1960 delete pGRRD;

1961 delete pArithDecoder;

1962 goto failed;

1963 }

1964 delete pArithDecoder;

1965 pStream->alignByte();

1966 pStream->offset(2);

1967 if((FX_DWORD)nVal != (pStream->getOffset() - nTmp)) {

1968 delete IBI;

1969 delete pGRRD;

1970 m_pModule->JBig2_Error("text region decoding procedure (huff man):"

1971 "bytes processed by generic refinemen t region decoding procedure doesn't equal SBHUFFRSIZE.");

1972 goto failed;

1973 }

1974 delete pGRRD;

1975 }

1976 if (!IBI) {

1977 continue;

1978 }

1979 WI = IBI->m_nWidth;

1980 HI = IBI->m_nHeight;

1981 if(TRANSPOSED == 0 && ((REFCORNER == JBIG2_CORNER_TOPRIGHT)

1982 \|\| (REFCORNER == JBIG2_CORNER_BOTTOMRIGHT))) {

1983 CURS = CURS + WI - 1;

1984 } else if(TRANSPOSED == 1 && ((REFCORNER == JBIG2_CORNER_BOTTOMLEFT)

1985 \|\| (REFCORNER == JBIG2_CORNER_BOTTOMRI GHT))) {

1986 CURS = CURS + HI - 1;

1987 }

1988 SI = CURS;

1989 if(TRANSPOSED == 0) {

1990 switch(REFCORNER) {

1991 case JBIG2_CORNER_TOPLEFT:

1992 SBREG->composeFrom(SI, TI, IBI, SBCOMBOP);

1993 break;

1994 case JBIG2_CORNER_TOPRIGHT:

1995 SBREG->composeFrom(SI - WI + 1, TI, IBI, SBCOMBOP);

1996 break;

1997 case JBIG2_CORNER_BOTTOMLEFT:

1998 SBREG->composeFrom(SI, TI - HI + 1, IBI, SBCOMBOP);

1999 break;

2000 case JBIG2_CORNER_BOTTOMRIGHT:

2001 SBREG->composeFrom(SI - WI + 1, TI - HI + 1, IBI, SBCOMB OP);

2002 break;

2003 }

2004 } else {

2005 switch(REFCORNER) {

2006 case JBIG2_CORNER_TOPLEFT:

2007 SBREG->composeFrom(TI, SI, IBI, SBCOMBOP);

2008 break;

2009 case JBIG2_CORNER_TOPRIGHT:

2010 SBREG->composeFrom(TI - WI + 1, SI, IBI, SBCOMBOP);

2011 break;

2012 case JBIG2_CORNER_BOTTOMLEFT:

2013 SBREG->composeFrom(TI, SI - HI + 1, IBI, SBCOMBOP);

2014 break;

2015 case JBIG2_CORNER_BOTTOMRIGHT:

2016 SBREG->composeFrom(TI - WI + 1, SI - HI + 1, IBI, SBCOMB OP);

2017 break;

2018 }

2019 }

2020 if(RI != 0) {

2021 delete IBI;

2022 }

2023 if(TRANSPOSED == 0 && ((REFCORNER == JBIG2_CORNER_TOPLEFT)

2024 \|\| (REFCORNER == JBIG2_CORNER_BOTTOMLEFT))) {

2025 CURS = CURS + WI - 1;

2026 } else if(TRANSPOSED == 1 && ((REFCORNER == JBIG2_CORNER_TOPLEFT)

2027 \|\| (REFCORNER == JBIG2_CORNER_TOPRIGHT ))) {

2028 CURS = CURS + HI - 1;

2029 }

2030 NINSTANCES = NINSTANCES + 1;

2031 }

2032 }

2033 delete pHuffmanDecoder;

2034 return SBREG;

2035 failed:	2229 failed:

2036 delete pHuffmanDecoder;	2230 delete pHuffmanDecoder;

2037 delete SBREG;	2231 delete SBREG;

2038 return NULL;	2232 return NULL;

2039 }	2233 }

2040 CJBig2_Image CJBig2_TRDProc::decode_Arith(CJBig2_ArithDecoder pArithDecoder, J Big2ArithCtx *grContext,	2234 CJBig2_Image* CJBig2_TRDProc::decode_Arith(CJBig2_ArithDecoder* pArithDecoder,

2041 JBig2IntDecoderState *pIDS)	2235 JBig2ArithCtx* grContext,

2042 {	2236 JBig2IntDecoderState* pIDS) {

2043 FX_INT32 STRIPT, FIRSTS;	2237 FX_INT32 STRIPT, FIRSTS;

2044 FX_DWORD NINSTANCES;	2238 FX_DWORD NINSTANCES;

2045 FX_INT32 DT, DFS, CURS;	2239 FX_INT32 DT, DFS, CURS;

2046 FX_INT32 CURT;	2240 FX_INT32 CURT;

2047 FX_INT32 SI, TI;	2241 FX_INT32 SI, TI;

2048 FX_DWORD IDI;	2242 FX_DWORD IDI;

2049 CJBig2_Image *IBI;	2243 CJBig2_Image* IBI;

2050 FX_DWORD WI, HI;	2244 FX_DWORD WI, HI;

2051 FX_INT32 IDS;	2245 FX_INT32 IDS;

2052 FX_BOOL RI;	2246 FX_BOOL RI;

2053 FX_INT32 RDWI, RDHI, RDXI, RDYI;	2247 FX_INT32 RDWI, RDHI, RDXI, RDYI;

2054 CJBig2_Image *IBOI;	2248 CJBig2_Image* IBOI;

2055 FX_DWORD WOI, HOI;	2249 FX_DWORD WOI, HOI;

2056 CJBig2_Image *SBREG;	2250 CJBig2_Image* SBREG;

2057 FX_BOOL bFirst;	2251 FX_BOOL bFirst;

2058 FX_INT32 nRet, nVal;	2252 FX_INT32 nRet, nVal;

2059 FX_INT32 bRetained;	2253 FX_INT32 bRetained;

2060 CJBig2_ArithIntDecoder IADT, IAFS, IADS, IAIT, IARI, IARDW, IARDH, I ARDX, *IARDY;	2254 CJBig2_ArithIntDecoder* IADT, IAFS, IADS, IAIT, IARI, IARDW, IARDH,

2061 CJBig2_ArithIaidDecoder *IAID;	2255 IARDX, IARDY;

2062 CJBig2_GRRDProc *pGRRD;	2256 CJBig2_ArithIaidDecoder* IAID;

2063 if(pIDS) {	2257 CJBig2_GRRDProc* pGRRD;

2064 IADT = pIDS->IADT;	2258 if (pIDS) {

2065 IAFS = pIDS->IAFS;	2259 IADT = pIDS->IADT;

2066 IADS = pIDS->IADS;	2260 IAFS = pIDS->IAFS;

2067 IAIT = pIDS->IAIT;	2261 IADS = pIDS->IADS;

2068 IARI = pIDS->IARI;	2262 IAIT = pIDS->IAIT;

2069 IARDW = pIDS->IARDW;	2263 IARI = pIDS->IARI;

2070 IARDH = pIDS->IARDH;	2264 IARDW = pIDS->IARDW;

2071 IARDX = pIDS->IARDX;	2265 IARDH = pIDS->IARDH;

2072 IARDY = pIDS->IARDY;	2266 IARDX = pIDS->IARDX;

2073 IAID = pIDS->IAID;	2267 IARDY = pIDS->IARDY;

2074 bRetained = TRUE;	2268 IAID = pIDS->IAID;

2075 } else {	2269 bRetained = TRUE;

2076 JBIG2_ALLOC(IADT, CJBig2_ArithIntDecoder());	2270 } else {

2077 JBIG2_ALLOC(IAFS, CJBig2_ArithIntDecoder());

2078 JBIG2_ALLOC(IADS, CJBig2_ArithIntDecoder());

2079 JBIG2_ALLOC(IAIT, CJBig2_ArithIntDecoder());

2080 JBIG2_ALLOC(IARI, CJBig2_ArithIntDecoder());

2081 JBIG2_ALLOC(IARDW, CJBig2_ArithIntDecoder());

2082 JBIG2_ALLOC(IARDH, CJBig2_ArithIntDecoder());

2083 JBIG2_ALLOC(IARDX, CJBig2_ArithIntDecoder());

2084 JBIG2_ALLOC(IARDY, CJBig2_ArithIntDecoder());

2085 JBIG2_ALLOC(IAID , CJBig2_ArithIaidDecoder(SBSYMCODELEN));

2086 bRetained = FALSE;

2087 }

2088 JBIG2_ALLOC(SBREG, CJBig2_Image(SBW, SBH));

2089 SBREG->fill(SBDEFPIXEL);

2090 if(IADT->decode(pArithDecoder, &STRIPT) == -1) {

2091 m_pModule->JBig2_Error("text region decoding procedure (arith): too shor t.");

2092 goto failed;

2093 }

2094 STRIPT *= SBSTRIPS;

2095 STRIPT = -STRIPT;

2096 FIRSTS = 0;

2097 NINSTANCES = 0;

2098 while(NINSTANCES < SBNUMINSTANCES) {

2099 if(IADT->decode(pArithDecoder, &DT) == -1) {

2100 m_pModule->JBig2_Error("text region decoding procedure (arith): too short.");

2101 goto failed;

2102 }

2103 DT *= SBSTRIPS;

2104 STRIPT = STRIPT + DT;

2105 bFirst = TRUE;

2106 for(;;) {

2107 if(bFirst) {

2108 if(IAFS->decode(pArithDecoder, &DFS) == -1) {

2109 m_pModule->JBig2_Error("text region decoding procedure (arit h): too short.");

2110 goto failed;

2111 }

2112 FIRSTS = FIRSTS + DFS;

2113 CURS = FIRSTS;

2114 bFirst = FALSE;

2115 } else {

2116 nRet = IADS->decode(pArithDecoder, &IDS);

2117 if(nRet == JBIG2_OOB) {

2118 break;

2119 } else if(nRet != 0) {

2120 m_pModule->JBig2_Error("text region decoding procedure (arit h): too short.");

2121 goto failed;

2122 } else {

2123 CURS = CURS + IDS + SBDSOFFSET;

2124 }

2125 }

2126 if (NINSTANCES >= SBNUMINSTANCES) {

2127 break;

2128 }

2129 if(SBSTRIPS == 1) {

2130 CURT = 0;

2131 } else {

2132 if(IAIT->decode(pArithDecoder, &nVal) == -1) {

2133 m_pModule->JBig2_Error("text region decoding procedure (arit h): too short.");

2134 goto failed;

2135 }

2136 CURT = nVal;

2137 }

2138 TI = STRIPT + CURT;

2139 if(IAID->decode(pArithDecoder, &nVal) == -1) {

2140 m_pModule->JBig2_Error("text region decoding procedure (arith): too short.");

2141 goto failed;

2142 }

2143 IDI = nVal;

2144 if(IDI >= SBNUMSYMS) {

2145 m_pModule->JBig2_Error("text region decoding procedure (arith): symbol id out of range.(%d/%d)",

2146 IDI, SBNUMSYMS);

2147 goto failed;

2148 }

2149 if(SBREFINE == 0) {

2150 RI = 0;

2151 } else {

2152 if(IARI->decode(pArithDecoder, &RI) == -1) {

2153 m_pModule->JBig2_Error("text region decoding procedure (arit h): too short.");

2154 goto failed;

2155 }

2156 }

2157 if (!SBSYMS[IDI]) {

2158 goto failed;

2159 }

2160 if(RI == 0) {

2161 IBI = SBSYMS[IDI];

2162 } else {

2163 if((IARDW->decode(pArithDecoder, &RDWI) == -1)

2164 \|\| (IARDH->decode(pArithDecoder, &RDHI) == -1)

2165 \|\| (IARDX->decode(pArithDecoder, &RDXI) == -1)

2166 \|\| (IARDY->decode(pArithDecoder, &RDYI) == -1)) {

2167 m_pModule->JBig2_Error("text region decoding procedure (arit h): too short.");

2168 goto failed;

2169 }

2170 IBOI = SBSYMS[IDI];

2171 WOI = IBOI->m_nWidth;

2172 HOI = IBOI->m_nHeight;

2173 if ((int)(WOI + RDWI) < 0 \|\| (int)(HOI + RDHI) < 0) {

2174 m_pModule->JBig2_Error("text region decoding procedure (arit h): Invalid RDWI or RDHI value.");

2175 goto failed;

2176 }

2177 JBIG2_ALLOC(pGRRD, CJBig2_GRRDProc());

2178 pGRRD->GRW = WOI + RDWI;

2179 pGRRD->GRH = HOI + RDHI;

2180 pGRRD->GRTEMPLATE = SBRTEMPLATE;

2181 pGRRD->GRREFERENCE = IBOI;

2182 pGRRD->GRREFERENCEDX = (RDWI >> 1) + RDXI;

2183 pGRRD->GRREFERENCEDY = (RDHI >> 1) + RDYI;

2184 pGRRD->TPGRON = 0;

2185 pGRRD->GRAT[0] = SBRAT[0];

2186 pGRRD->GRAT[1] = SBRAT[1];

2187 pGRRD->GRAT[2] = SBRAT[2];

2188 pGRRD->GRAT[3] = SBRAT[3];

2189 IBI = pGRRD->decode(pArithDecoder, grContext);

2190 if(IBI == NULL) {

2191 delete pGRRD;

2192 goto failed;

2193 }

2194 delete pGRRD;

2195 }

2196 WI = IBI->m_nWidth;

2197 HI = IBI->m_nHeight;

2198 if(TRANSPOSED == 0 && ((REFCORNER == JBIG2_CORNER_TOPRIGHT)

2199 \|\| (REFCORNER == JBIG2_CORNER_BOTTOMRIGHT))) {

2200 CURS = CURS + WI - 1;

2201 } else if(TRANSPOSED == 1 && ((REFCORNER == JBIG2_CORNER_BOTTOMLEFT)

2202 \|\| (REFCORNER == JBIG2_CORNER_BOTTOMRI GHT))) {

2203 CURS = CURS + HI - 1;

2204 }

2205 SI = CURS;

2206 if(TRANSPOSED == 0) {

2207 switch(REFCORNER) {

2208 case JBIG2_CORNER_TOPLEFT:

2209 SBREG->composeFrom(SI, TI, IBI, SBCOMBOP);

2210 break;

2211 case JBIG2_CORNER_TOPRIGHT:

2212 SBREG->composeFrom(SI - WI + 1, TI, IBI, SBCOMBOP);

2213 break;

2214 case JBIG2_CORNER_BOTTOMLEFT:

2215 SBREG->composeFrom(SI, TI - HI + 1, IBI, SBCOMBOP);

2216 break;

2217 case JBIG2_CORNER_BOTTOMRIGHT:

2218 SBREG->composeFrom(SI - WI + 1, TI - HI + 1, IBI, SBCOMB OP);

2219 break;

2220 }

2221 } else {

2222 switch(REFCORNER) {

2223 case JBIG2_CORNER_TOPLEFT:

2224 SBREG->composeFrom(TI, SI, IBI, SBCOMBOP);

2225 break;

2226 case JBIG2_CORNER_TOPRIGHT:

2227 SBREG->composeFrom(TI - WI + 1, SI, IBI, SBCOMBOP);

2228 break;

2229 case JBIG2_CORNER_BOTTOMLEFT:

2230 SBREG->composeFrom(TI, SI - HI + 1, IBI, SBCOMBOP);

2231 break;

2232 case JBIG2_CORNER_BOTTOMRIGHT:

2233 SBREG->composeFrom(TI - WI + 1, SI - HI + 1, IBI, SBCOMB OP);

2234 break;

2235 }

2236 }

2237 if(RI != 0) {

2238 delete IBI;

2239 }

2240 if(TRANSPOSED == 0 && ((REFCORNER == JBIG2_CORNER_TOPLEFT)

2241 \|\| (REFCORNER == JBIG2_CORNER_BOTTOMLEFT))) {

2242 CURS = CURS + WI - 1;

2243 } else if(TRANSPOSED == 1 && ((REFCORNER == JBIG2_CORNER_TOPLEFT)

2244 \|\| (REFCORNER == JBIG2_CORNER_TOPRIGHT ))) {

2245 CURS = CURS + HI - 1;

2246 }

2247 NINSTANCES = NINSTANCES + 1;

2248 }

2249 }

2250 if(bRetained == FALSE) {

2251 delete IADT;

2252 delete IAFS;

2253 delete IADS;

2254 delete IAIT;

2255 delete IARI;

2256 delete IARDW;

2257 delete IARDH;

2258 delete IARDX;

2259 delete IARDY;

2260 delete IAID;

2261 }

2262 return SBREG;

2263 failed:

2264 if(bRetained == FALSE) {

2265 delete IADT;

2266 delete IAFS;

2267 delete IADS;

2268 delete IAIT;

2269 delete IARI;

2270 delete IARDW;

2271 delete IARDH;

2272 delete IARDX;

2273 delete IARDY;

2274 delete IAID;

2275 }

2276 delete SBREG;

2277 return NULL;

2278 }

2279 CJBig2_SymbolDict CJBig2_SDDProc::decode_Arith(CJBig2_ArithDecoder pArithDecod er,

2280 JBig2ArithCtx gbContext, JBig2ArithCtx grContext)

2281 {

2282 CJBig2_Image **SDNEWSYMS;

2283 FX_DWORD HCHEIGHT, NSYMSDECODED;

2284 FX_INT32 HCDH;

2285 FX_DWORD SYMWIDTH, TOTWIDTH, HCFIRSTSYM;

2286 FX_INT32 DW;

2287 CJBig2_Image *BS;

2288 FX_DWORD I, J, REFAGGNINST;

2289 FX_BOOL *EXFLAGS;

2290 FX_DWORD EXINDEX;

2291 FX_BOOL CUREXFLAG;

2292 FX_DWORD EXRUNLENGTH;

2293 FX_INT32 nVal;

2294 FX_DWORD nTmp;

2295 FX_BOOL SBHUFF;

2296 FX_DWORD SBNUMSYMS;

2297 FX_BYTE SBSYMCODELEN;

2298 FX_DWORD IDI;

2299 FX_INT32 RDXI, RDYI;

2300 CJBig2_Image **SBSYMS;

2301 CJBig2_HuffmanTable SBHUFFFS, SBHUFFDS, SBHUFFDT, SBHUFFRDW, SBHUFFRDH, SBHUFFRDX, *SBHUFFRDY,

2302 *SBHUFFRSIZE;

2303 CJBig2_GRRDProc *pGRRD;

2304 CJBig2_GRDProc *pGRD;

2305 CJBig2_ArithIntDecoder IADH, IADW, IAAI, IARDX, IARDY, IAEX,

2306 IADT, IAFS, IADS, IAIT, IARI, IARDW, *IARDH;

2307 CJBig2_ArithIaidDecoder *IAID;

2308 CJBig2_SymbolDict *pDict;

2309 JBIG2_ALLOC(IADH, CJBig2_ArithIntDecoder());

2310 JBIG2_ALLOC(IADW, CJBig2_ArithIntDecoder());

2311 JBIG2_ALLOC(IAAI, CJBig2_ArithIntDecoder());

2312 JBIG2_ALLOC(IARDX, CJBig2_ArithIntDecoder());

2313 JBIG2_ALLOC(IARDY, CJBig2_ArithIntDecoder());

2314 JBIG2_ALLOC(IAEX, CJBig2_ArithIntDecoder());

2315 JBIG2_ALLOC(IADT, CJBig2_ArithIntDecoder());	2271 JBIG2_ALLOC(IADT, CJBig2_ArithIntDecoder());

2316 JBIG2_ALLOC(IAFS, CJBig2_ArithIntDecoder());	2272 JBIG2_ALLOC(IAFS, CJBig2_ArithIntDecoder());

2317 JBIG2_ALLOC(IADS, CJBig2_ArithIntDecoder());	2273 JBIG2_ALLOC(IADS, CJBig2_ArithIntDecoder());

2318 JBIG2_ALLOC(IAIT, CJBig2_ArithIntDecoder());	2274 JBIG2_ALLOC(IAIT, CJBig2_ArithIntDecoder());

2319 JBIG2_ALLOC(IARI, CJBig2_ArithIntDecoder());	2275 JBIG2_ALLOC(IARI, CJBig2_ArithIntDecoder());

2320 JBIG2_ALLOC(IARDW, CJBig2_ArithIntDecoder());	2276 JBIG2_ALLOC(IARDW, CJBig2_ArithIntDecoder());

2321 JBIG2_ALLOC(IARDH, CJBig2_ArithIntDecoder());	2277 JBIG2_ALLOC(IARDH, CJBig2_ArithIntDecoder());

2322 nTmp = 0;	2278 JBIG2_ALLOC(IARDX, CJBig2_ArithIntDecoder());

2323 while((FX_DWORD)(1 << nTmp) < (SDNUMINSYMS + SDNUMNEWSYMS)) {	2279 JBIG2_ALLOC(IARDY, CJBig2_ArithIntDecoder());

2324 nTmp ++;	2280 JBIG2_ALLOC(IAID, CJBig2_ArithIaidDecoder(SBSYMCODELEN));

	2281 bRetained = FALSE;

	2282 }

	2283 JBIG2_ALLOC(SBREG, CJBig2_Image(SBW, SBH));

	2284 SBREG->fill(SBDEFPIXEL);

	2285 if (IADT->decode(pArithDecoder, &STRIPT) == -1) {

	2286 m_pModule->JBig2_Error(

	2287 "text region decoding procedure (arith): too short.");

	2288 goto failed;

	2289 }

	2290 STRIPT *= SBSTRIPS;

	2291 STRIPT = -STRIPT;

	2292 FIRSTS = 0;

	2293 NINSTANCES = 0;

	2294 while (NINSTANCES < SBNUMINSTANCES) {

	2295 if (IADT->decode(pArithDecoder, &DT) == -1) {

	2296 m_pModule->JBig2_Error(

	2297 "text region decoding procedure (arith): too short.");

	2298 goto failed;

2325 }	2299 }

2326 JBIG2_ALLOC(IAID, CJBig2_ArithIaidDecoder((FX_BYTE)nTmp));	2300 DT *= SBSTRIPS;

2327 SDNEWSYMS = (CJBig2_Image*)m_pModule->JBig2_Malloc2(SDNUMNEWSYMS, sizeof(CJ Big2_Image));	2301 STRIPT = STRIPT + DT;

2328 FXSYS_memset32(SDNEWSYMS, 0 , SDNUMNEWSYMS * sizeof(CJBig2_Image*));	2302 bFirst = TRUE;

2329 HCHEIGHT = 0;	2303 for (;;) {

2330 NSYMSDECODED = 0;	2304 if (bFirst) {

2331 while(NSYMSDECODED < SDNUMNEWSYMS) {	2305 if (IAFS->decode(pArithDecoder, &DFS) == -1) {

2332 BS = NULL;	2306 m_pModule->JBig2_Error(

2333 if(IADH->decode(pArithDecoder, &HCDH) == -1) {	2307 "text region decoding procedure (arith): too short.");

2334 m_pModule->JBig2_Error("symbol dictionary decoding procedure (arith) : too short.");	2308 goto failed;

2335 goto failed;

2336 }	2309 }

2337 HCHEIGHT = HCHEIGHT + HCDH;	2310 FIRSTS = FIRSTS + DFS;

2338 if ((int)HCHEIGHT < 0 \|\| (int)HCHEIGHT > JBIG2_MAX_IMAGE_SIZE) {	2311 CURS = FIRSTS;

2339 m_pModule->JBig2_Error("symbol dictionary decoding procedure (arith) : invalid HCHEIGHT value.");	2312 bFirst = FALSE;

2340 goto failed;	2313 } else {

	2314 nRet = IADS->decode(pArithDecoder, &IDS);

	2315 if (nRet == JBIG2_OOB) {

	2316 break;

	2317 } else if (nRet != 0) {

	2318 m_pModule->JBig2_Error(

	2319 "text region decoding procedure (arith): too short.");

	2320 goto failed;

	2321 } else {

	2322 CURS = CURS + IDS + SBDSOFFSET;

2341 }	2323 }

2342 SYMWIDTH = 0;	2324 }

2343 TOTWIDTH = 0;	2325 if (NINSTANCES >= SBNUMINSTANCES) {

2344 HCFIRSTSYM = NSYMSDECODED;	2326 break;

2345 for(;;) {	2327 }

2346 nVal = IADW->decode(pArithDecoder, &DW);	2328 if (SBSTRIPS == 1) {

2347 if(nVal == JBIG2_OOB) {	2329 CURT = 0;

2348 break;	2330 } else {

2349 } else if(nVal != 0) {	2331 if (IAIT->decode(pArithDecoder, &nVal) == -1) {

2350 m_pModule->JBig2_Error("symbol dictionary decoding procedure (ar ith): too short.");	2332 m_pModule->JBig2_Error(

2351 goto failed;	2333 "text region decoding procedure (arith): too short.");

2352 } else {	2334 goto failed;

2353 if (NSYMSDECODED >= SDNUMNEWSYMS) {

2354 m_pModule->JBig2_Error("symbol dictionary decoding procedure (arith): NSYMSDECODED >= SDNUMNEWSYMS.");

2355 goto failed;

2356 }

2357 SYMWIDTH = SYMWIDTH + DW;

2358 if ((int)SYMWIDTH < 0 \|\| (int)SYMWIDTH > JBIG2_MAX_IMAGE_SIZE) {

2359 m_pModule->JBig2_Error("symbol dictionary decoding procedure (arith): invalid SYMWIDTH value.");

2360 goto failed;

2361 } else if (HCHEIGHT == 0 \|\| SYMWIDTH == 0) {

2362 TOTWIDTH = TOTWIDTH + SYMWIDTH;

2363 SDNEWSYMS[NSYMSDECODED] = NULL;

2364 NSYMSDECODED = NSYMSDECODED + 1;

2365 continue;

2366 }

2367 TOTWIDTH = TOTWIDTH + SYMWIDTH;

2368 }

2369 if(SDREFAGG == 0) {

2370 JBIG2_ALLOC(pGRD, CJBig2_GRDProc());

2371 pGRD->MMR = 0;

2372 pGRD->GBW = SYMWIDTH;

2373 pGRD->GBH = HCHEIGHT;

2374 pGRD->GBTEMPLATE = SDTEMPLATE;

2375 pGRD->TPGDON = 0;

2376 pGRD->USESKIP = 0;

2377 pGRD->GBAT[0] = SDAT[0];

2378 pGRD->GBAT[1] = SDAT[1];

2379 pGRD->GBAT[2] = SDAT[2];

2380 pGRD->GBAT[3] = SDAT[3];

2381 pGRD->GBAT[4] = SDAT[4];

2382 pGRD->GBAT[5] = SDAT[5];

2383 pGRD->GBAT[6] = SDAT[6];

2384 pGRD->GBAT[7] = SDAT[7];

2385 BS = pGRD->decode_Arith(pArithDecoder, gbContext);

2386 if(BS == NULL) {

2387 delete pGRD;

2388 goto failed;

2389 }

2390 delete pGRD;

2391 } else {

2392 if(IAAI->decode(pArithDecoder, (int*)&REFAGGNINST) == -1) {

2393 m_pModule->JBig2_Error("symbol dictionary decoding procedure (arith): too short.");

2394 goto failed;

2395 }

2396 if(REFAGGNINST > 1) {

2397 CJBig2_TRDProc *pDecoder;

2398 JBIG2_ALLOC(pDecoder, CJBig2_TRDProc());

2399 pDecoder->SBHUFF = SDHUFF;

2400 pDecoder->SBREFINE = 1;

2401 pDecoder->SBW = SYMWIDTH;

2402 pDecoder->SBH = HCHEIGHT;

2403 pDecoder->SBNUMINSTANCES = REFAGGNINST;

2404 pDecoder->SBSTRIPS = 1;

2405 pDecoder->SBNUMSYMS = SDNUMINSYMS + NSYMSDECODED;

2406 SBNUMSYMS = pDecoder->SBNUMSYMS;

2407 nTmp = 0;

2408 while((FX_DWORD)(1 << nTmp) < SBNUMSYMS) {

2409 nTmp ++;

2410 }

2411 SBSYMCODELEN = (FX_BYTE)nTmp;

2412 pDecoder->SBSYMCODELEN = SBSYMCODELEN;

2413 SBSYMS = (CJBig2_Image*)m_pModule->JBig2_Malloc2(SBNUMSYMS, sizeof(CJBig2_Image));

2414 JBIG2_memcpy(SBSYMS, SDINSYMS, SDNUMINSYMS * sizeof(CJBig2_I mage*));

2415 JBIG2_memcpy(SBSYMS + SDNUMINSYMS, SDNEWSYMS, NSYMSDECODED * sizeof(CJBig2_Image*));

2416 pDecoder->SBSYMS = SBSYMS;

2417 pDecoder->SBDEFPIXEL = 0;

2418 pDecoder->SBCOMBOP = JBIG2_COMPOSE_OR;

2419 pDecoder->TRANSPOSED = 0;

2420 pDecoder->REFCORNER = JBIG2_CORNER_TOPLEFT;

2421 pDecoder->SBDSOFFSET = 0;

2422 JBIG2_ALLOC(SBHUFFFS, CJBig2_HuffmanTable(HuffmanTable_B6,

2423 sizeof(HuffmanTable_B6) / sizeof(JBig2TableLine) , HuffmanTable_HTOOB_B6));

2424 JBIG2_ALLOC(SBHUFFDS, CJBig2_HuffmanTable(HuffmanTable_B8,

2425 sizeof(HuffmanTable_B8) / sizeof(JBig2TableLine) , HuffmanTable_HTOOB_B8));

2426 JBIG2_ALLOC(SBHUFFDT, CJBig2_HuffmanTable(HuffmanTable_B11,

2427 sizeof(HuffmanTable_B11) / sizeof(JBig2TableLine ), HuffmanTable_HTOOB_B11));

2428 JBIG2_ALLOC(SBHUFFRDW, CJBig2_HuffmanTable(HuffmanTable_B15,

2429 sizeof(HuffmanTable_B15) / sizeof(JBig2TableLine ), HuffmanTable_HTOOB_B15));

2430 JBIG2_ALLOC(SBHUFFRDH, CJBig2_HuffmanTable(HuffmanTable_B15,

2431 sizeof(HuffmanTable_B15) / sizeof(JBig2TableLine ), HuffmanTable_HTOOB_B15));

2432 JBIG2_ALLOC(SBHUFFRDX, CJBig2_HuffmanTable(HuffmanTable_B15,

2433 sizeof(HuffmanTable_B15) / sizeof(JBig2TableLine ), HuffmanTable_HTOOB_B15));

2434 JBIG2_ALLOC(SBHUFFRDY, CJBig2_HuffmanTable(HuffmanTable_B15,

2435 sizeof(HuffmanTable_B15) / sizeof(JBig2TableLine ), HuffmanTable_HTOOB_B15));

2436 JBIG2_ALLOC(SBHUFFRSIZE, CJBig2_HuffmanTable(HuffmanTable_B1 ,

2437 sizeof(HuffmanTable_B1) / sizeof(JBig2TableLine) , HuffmanTable_HTOOB_B1));

2438 pDecoder->SBHUFFFS = SBHUFFFS;

2439 pDecoder->SBHUFFDS = SBHUFFDS;

2440 pDecoder->SBHUFFDT = SBHUFFDT;

2441 pDecoder->SBHUFFRDW = SBHUFFRDW;

2442 pDecoder->SBHUFFRDH = SBHUFFRDH;

2443 pDecoder->SBHUFFRDX = SBHUFFRDX;

2444 pDecoder->SBHUFFRDY = SBHUFFRDY;

2445 pDecoder->SBHUFFRSIZE = SBHUFFRSIZE;

2446 pDecoder->SBRTEMPLATE = SDRTEMPLATE;

2447 pDecoder->SBRAT[0] = SDRAT[0];

2448 pDecoder->SBRAT[1] = SDRAT[1];

2449 pDecoder->SBRAT[2] = SDRAT[2];

2450 pDecoder->SBRAT[3] = SDRAT[3];

2451 JBig2IntDecoderState ids;

2452 ids.IADT = IADT;

2453 ids.IAFS = IAFS;

2454 ids.IADS = IADS;

2455 ids.IAIT = IAIT;

2456 ids.IARI = IARI;

2457 ids.IARDW = IARDW;

2458 ids.IARDH = IARDH;

2459 ids.IARDX = IARDX;

2460 ids.IARDY = IARDY;

2461 ids.IAID = IAID;

2462 BS = pDecoder->decode_Arith(pArithDecoder, grContext, &ids);

2463 if(BS == NULL) {

2464 m_pModule->JBig2_Free(SBSYMS);

2465 delete SBHUFFFS;

2466 delete SBHUFFDS;

2467 delete SBHUFFDT;

2468 delete SBHUFFRDW;

2469 delete SBHUFFRDH;

2470 delete SBHUFFRDX;

2471 delete SBHUFFRDY;

2472 delete SBHUFFRSIZE;

2473 delete pDecoder;

2474 goto failed;

2475 }

2476 m_pModule->JBig2_Free(SBSYMS);

2477 delete SBHUFFFS;

2478 delete SBHUFFDS;

2479 delete SBHUFFDT;

2480 delete SBHUFFRDW;

2481 delete SBHUFFRDH;

2482 delete SBHUFFRDX;

2483 delete SBHUFFRDY;

2484 delete SBHUFFRSIZE;

2485 delete pDecoder;

2486 } else if(REFAGGNINST == 1) {

2487 SBHUFF = SDHUFF;

2488 SBNUMSYMS = SDNUMINSYMS + NSYMSDECODED;

2489 if(IAID->decode(pArithDecoder, (int*)&IDI) == -1) {

2490 m_pModule->JBig2_Error("symbol dictionary decoding proce dure (arith): too short.");

2491 goto failed;

2492 }

2493 if((IARDX->decode(pArithDecoder, &RDXI) == -1)

2494 \|\| (IARDY->decode(pArithDecoder, &RDYI) == -1)) {

2495 m_pModule->JBig2_Error("symbol dictionary decoding proce dure (arith): too short.");

2496 goto failed;

2497 }

2498 if (IDI >= SBNUMSYMS) {

2499 m_pModule->JBig2_Error("symbol dictionary decoding proce dure (arith):"

2500 " refinement references unknown s ymbol %d", IDI);

2501 goto failed;

2502 }

2503 SBSYMS = (CJBig2_Image*)m_pModule->JBig2_Malloc2(SBNUMSYMS, sizeof(CJBig2_Image));

2504 JBIG2_memcpy(SBSYMS, SDINSYMS, SDNUMINSYMS * sizeof(CJBig2_I mage*));

2505 JBIG2_memcpy(SBSYMS + SDNUMINSYMS, SDNEWSYMS, NSYMSDECODED * sizeof(CJBig2_Image*));

2506 if (!SBSYMS[IDI]) {

2507 m_pModule->JBig2_Free(SBSYMS);

2508 goto failed;

2509 }

2510 JBIG2_ALLOC(pGRRD, CJBig2_GRRDProc());

2511 pGRRD->GRW = SYMWIDTH;

2512 pGRRD->GRH = HCHEIGHT;

2513 pGRRD->GRTEMPLATE = SDRTEMPLATE;

2514 pGRRD->GRREFERENCE = SBSYMS[IDI];

2515 pGRRD->GRREFERENCEDX = RDXI;

2516 pGRRD->GRREFERENCEDY = RDYI;

2517 pGRRD->TPGRON = 0;

2518 pGRRD->GRAT[0] = SDRAT[0];

2519 pGRRD->GRAT[1] = SDRAT[1];

2520 pGRRD->GRAT[2] = SDRAT[2];

2521 pGRRD->GRAT[3] = SDRAT[3];

2522 BS = pGRRD->decode(pArithDecoder, grContext);

2523 if(BS == NULL) {

2524 m_pModule->JBig2_Free(SBSYMS);

2525 delete pGRRD;

2526 goto failed;

2527 }

2528 m_pModule->JBig2_Free(SBSYMS);

2529 delete pGRRD;

2530 }

2531 }

2532 SDNEWSYMS[NSYMSDECODED] = BS;

2533 BS = NULL;

2534 NSYMSDECODED = NSYMSDECODED + 1;

2535 }	2335 }

	2336 CURT = nVal;

	2337 }

	2338 TI = STRIPT + CURT;

	2339 if (IAID->decode(pArithDecoder, &nVal) == -1) {

	2340 m_pModule->JBig2_Error(

	2341 "text region decoding procedure (arith): too short.");

	2342 goto failed;

	2343 }

	2344 IDI = nVal;

	2345 if (IDI >= SBNUMSYMS) {

	2346 m_pModule->JBig2_Error(

	2347 "text region decoding procedure (arith): symbol id out of "

	2348 "range.(%d/%d)",

	2349 IDI,

	2350 SBNUMSYMS);

	2351 goto failed;

	2352 }

	2353 if (SBREFINE == 0) {

	2354 RI = 0;

	2355 } else {

	2356 if (IARI->decode(pArithDecoder, &RI) == -1) {

	2357 m_pModule->JBig2_Error(

	2358 "text region decoding procedure (arith): too short.");

	2359 goto failed;

	2360 }

	2361 }

	2362 if (!SBSYMS[IDI]) {

	2363 goto failed;

	2364 }

	2365 if (RI == 0) {

	2366 IBI = SBSYMS[IDI];

	2367 } else {

	2368 if ((IARDW->decode(pArithDecoder, &RDWI) == -1) \|\|

	2369 (IARDH->decode(pArithDecoder, &RDHI) == -1) \|\|

	2370 (IARDX->decode(pArithDecoder, &RDXI) == -1) \|\|

	2371 (IARDY->decode(pArithDecoder, &RDYI) == -1)) {

	2372 m_pModule->JBig2_Error(

	2373 "text region decoding procedure (arith): too short.");

	2374 goto failed;

	2375 }

	2376 IBOI = SBSYMS[IDI];

	2377 WOI = IBOI->m_nWidth;

	2378 HOI = IBOI->m_nHeight;

	2379 if ((int)(WOI + RDWI) < 0 \|\| (int)(HOI + RDHI) < 0) {

	2380 m_pModule->JBig2_Error(

	2381 "text region decoding procedure (arith): Invalid RDWI or RDHI "

	2382 "value.");

	2383 goto failed;

	2384 }

	2385 JBIG2_ALLOC(pGRRD, CJBig2_GRRDProc());

	2386 pGRRD->GRW = WOI + RDWI;

	2387 pGRRD->GRH = HOI + RDHI;

	2388 pGRRD->GRTEMPLATE = SBRTEMPLATE;

	2389 pGRRD->GRREFERENCE = IBOI;

	2390 pGRRD->GRREFERENCEDX = (RDWI >> 1) + RDXI;

	2391 pGRRD->GRREFERENCEDY = (RDHI >> 1) + RDYI;

	2392 pGRRD->TPGRON = 0;

	2393 pGRRD->GRAT[0] = SBRAT[0];

	2394 pGRRD->GRAT[1] = SBRAT[1];

	2395 pGRRD->GRAT[2] = SBRAT[2];

	2396 pGRRD->GRAT[3] = SBRAT[3];

	2397 IBI = pGRRD->decode(pArithDecoder, grContext);

	2398 if (IBI == NULL) {

	2399 delete pGRRD;

	2400 goto failed;

	2401 }

	2402 delete pGRRD;

	2403 }

	2404 WI = IBI->m_nWidth;

	2405 HI = IBI->m_nHeight;

	2406 if (TRANSPOSED == 0 && ((REFCORNER == JBIG2_CORNER_TOPRIGHT) \|\|

	2407 (REFCORNER == JBIG2_CORNER_BOTTOMRIGHT))) {

	2408 CURS = CURS + WI - 1;

	2409 } else if (TRANSPOSED == 1 && ((REFCORNER == JBIG2_CORNER_BOTTOMLEFT) \|\|

	2410 (REFCORNER == JBIG2_CORNER_BOTTOMRIGHT))) {

	2411 CURS = CURS + HI - 1;

	2412 }

	2413 SI = CURS;

	2414 if (TRANSPOSED == 0) {

	2415 switch (REFCORNER) {

	2416 case JBIG2_CORNER_TOPLEFT:

	2417 SBREG->composeFrom(SI, TI, IBI, SBCOMBOP);

	2418 break;

	2419 case JBIG2_CORNER_TOPRIGHT:

	2420 SBREG->composeFrom(SI - WI + 1, TI, IBI, SBCOMBOP);

	2421 break;

	2422 case JBIG2_CORNER_BOTTOMLEFT:

	2423 SBREG->composeFrom(SI, TI - HI + 1, IBI, SBCOMBOP);

	2424 break;

	2425 case JBIG2_CORNER_BOTTOMRIGHT:

	2426 SBREG->composeFrom(SI - WI + 1, TI - HI + 1, IBI, SBCOMBOP);

	2427 break;

	2428 }

	2429 } else {

	2430 switch (REFCORNER) {

	2431 case JBIG2_CORNER_TOPLEFT:

	2432 SBREG->composeFrom(TI, SI, IBI, SBCOMBOP);

	2433 break;

	2434 case JBIG2_CORNER_TOPRIGHT:

	2435 SBREG->composeFrom(TI - WI + 1, SI, IBI, SBCOMBOP);

	2436 break;

	2437 case JBIG2_CORNER_BOTTOMLEFT:

	2438 SBREG->composeFrom(TI, SI - HI + 1, IBI, SBCOMBOP);

	2439 break;

	2440 case JBIG2_CORNER_BOTTOMRIGHT:

	2441 SBREG->composeFrom(TI - WI + 1, SI - HI + 1, IBI, SBCOMBOP);

	2442 break;

	2443 }

	2444 }

	2445 if (RI != 0) {

	2446 delete IBI;

	2447 }

	2448 if (TRANSPOSED == 0 && ((REFCORNER == JBIG2_CORNER_TOPLEFT) \|\|

	2449 (REFCORNER == JBIG2_CORNER_BOTTOMLEFT))) {

	2450 CURS = CURS + WI - 1;

	2451 } else if (TRANSPOSED == 1 && ((REFCORNER == JBIG2_CORNER_TOPLEFT) \|\|

	2452 (REFCORNER == JBIG2_CORNER_TOPRIGHT))) {

	2453 CURS = CURS + HI - 1;

	2454 }

	2455 NINSTANCES = NINSTANCES + 1;

2536 }	2456 }

2537 EXINDEX = 0;	2457 }

2538 CUREXFLAG = 0;	2458 if (bRetained == FALSE) {

2539 EXFLAGS = (FX_BOOL*)m_pModule->JBig2_Malloc2(sizeof(FX_BOOL), (SDNUMINSYMS + SDNUMNEWSYMS));

2540 while(EXINDEX < SDNUMINSYMS + SDNUMNEWSYMS) {

2541 if(IAEX->decode(pArithDecoder, (int*)&EXRUNLENGTH) == -1) {

2542 m_pModule->JBig2_Free(EXFLAGS);

2543 m_pModule->JBig2_Error("symbol dictionary decoding procedure (arith) : too short.");

2544 goto failed;

2545 }

2546 if (EXINDEX + EXRUNLENGTH > SDNUMINSYMS + SDNUMNEWSYMS) {

2547 m_pModule->JBig2_Free(EXFLAGS);

2548 m_pModule->JBig2_Error("symbol dictionary decoding procedure (arith) : Invalid EXRUNLENGTH value.");

2549 goto failed;

2550 }

2551 if(EXRUNLENGTH != 0) {

2552 for(I = EXINDEX; I < EXINDEX + EXRUNLENGTH; I++) {

2553 EXFLAGS[I] = CUREXFLAG;

2554 }

2555 }

2556 EXINDEX = EXINDEX + EXRUNLENGTH;

2557 CUREXFLAG = !CUREXFLAG;

2558 }

2559 JBIG2_ALLOC(pDict, CJBig2_SymbolDict());

2560 pDict->SDNUMEXSYMS = SDNUMEXSYMS;

2561 pDict->SDEXSYMS = (CJBig2_Image*)m_pModule->JBig2_Malloc2(sizeof(CJBig2_Ima ge), SDNUMEXSYMS);

2562 I = J = 0;

2563 for(I = 0; I < SDNUMINSYMS + SDNUMNEWSYMS; I++) {

2564 if(EXFLAGS[I] && J < SDNUMEXSYMS) {

2565 if(I < SDNUMINSYMS) {

2566 JBIG2_ALLOC(pDict->SDEXSYMS[J], CJBig2_Image(*SDINSYMS[I]));

2567 } else {

2568 pDict->SDEXSYMS[J] = SDNEWSYMS[I - SDNUMINSYMS];

2569 }

2570 J = J + 1;

2571 } else if (!EXFLAGS[I] && I >= SDNUMINSYMS) {

2572 delete SDNEWSYMS[I - SDNUMINSYMS];

2573 }

2574 }

2575 if (J < SDNUMEXSYMS) {

2576 pDict->SDNUMEXSYMS = J;

2577 }

2578 m_pModule->JBig2_Free(EXFLAGS);

2579 m_pModule->JBig2_Free(SDNEWSYMS);

2580 delete IADH;

2581 delete IADW;

2582 delete IAAI;

2583 delete IARDX;

2584 delete IARDY;

2585 delete IAEX;

2586 delete IAID;

2587 delete IADT;	2459 delete IADT;

2588 delete IAFS;	2460 delete IAFS;

2589 delete IADS;	2461 delete IADS;

2590 delete IAIT;	2462 delete IAIT;

2591 delete IARI;	2463 delete IARI;

2592 delete IARDW;	2464 delete IARDW;

2593 delete IARDH;	2465 delete IARDH;

2594 return pDict;

2595 failed:

2596 for(I = 0; I < NSYMSDECODED; I++) {

2597 if (SDNEWSYMS[I]) {

2598 delete SDNEWSYMS[I];

2599 SDNEWSYMS[I] = NULL;

2600 }

2601 }

2602 m_pModule->JBig2_Free(SDNEWSYMS);

2603 delete IADH;

2604 delete IADW;

2605 delete IAAI;

2606 delete IARDX;	2466 delete IARDX;

2607 delete IARDY;	2467 delete IARDY;

2608 delete IAEX;

2609 delete IAID;	2468 delete IAID;

	2469 }

	2470 return SBREG;

	2471 failed:

	2472 if (bRetained == FALSE) {

2610 delete IADT;	2473 delete IADT;

2611 delete IAFS;	2474 delete IAFS;

2612 delete IADS;	2475 delete IADS;

2613 delete IAIT;	2476 delete IAIT;

2614 delete IARI;	2477 delete IARI;

2615 delete IARDW;	2478 delete IARDW;

2616 delete IARDH;	2479 delete IARDH;

	2480 delete IARDX;

	2481 delete IARDY;

	2482 delete IAID;

	2483 }

	2484 delete SBREG;

	2485 return NULL;

	2486 }

	2487 CJBig2_SymbolDict* CJBig2_SDDProc::decode_Arith(

	2488 CJBig2_ArithDecoder* pArithDecoder,

	2489 JBig2ArithCtx* gbContext,

	2490 JBig2ArithCtx* grContext) {

	2491 CJBig2_Image** SDNEWSYMS;

	2492 FX_DWORD HCHEIGHT, NSYMSDECODED;

	2493 FX_INT32 HCDH;

	2494 FX_DWORD SYMWIDTH, TOTWIDTH, HCFIRSTSYM;

	2495 FX_INT32 DW;

	2496 CJBig2_Image* BS;

	2497 FX_DWORD I, J, REFAGGNINST;

	2498 FX_BOOL* EXFLAGS;

	2499 FX_DWORD EXINDEX;

	2500 FX_BOOL CUREXFLAG;

	2501 FX_DWORD EXRUNLENGTH;

	2502 FX_INT32 nVal;

	2503 FX_DWORD nTmp;

	2504 FX_BOOL SBHUFF;

	2505 FX_DWORD SBNUMSYMS;

	2506 FX_BYTE SBSYMCODELEN;

	2507 FX_DWORD IDI;

	2508 FX_INT32 RDXI, RDYI;

	2509 CJBig2_Image** SBSYMS;

	2510 CJBig2_HuffmanTable* SBHUFFFS, SBHUFFDS, SBHUFFDT, SBHUFFRDW, SBHUFFRDH,

	2511 SBHUFFRDX, SBHUFFRDY, *SBHUFFRSIZE;

	2512 CJBig2_GRRDProc* pGRRD;

	2513 CJBig2_GRDProc* pGRD;

	2514 CJBig2_ArithIntDecoder* IADH, IADW, IAAI, IARDX, IARDY, IAEX, IADT,

	2515 IAFS, IADS, IAIT, IARI, IARDW, IARDH;

	2516 CJBig2_ArithIaidDecoder* IAID;

	2517 CJBig2_SymbolDict* pDict;

	2518 JBIG2_ALLOC(IADH, CJBig2_ArithIntDecoder());

	2519 JBIG2_ALLOC(IADW, CJBig2_ArithIntDecoder());

	2520 JBIG2_ALLOC(IAAI, CJBig2_ArithIntDecoder());

	2521 JBIG2_ALLOC(IARDX, CJBig2_ArithIntDecoder());

	2522 JBIG2_ALLOC(IARDY, CJBig2_ArithIntDecoder());

	2523 JBIG2_ALLOC(IAEX, CJBig2_ArithIntDecoder());

	2524 JBIG2_ALLOC(IADT, CJBig2_ArithIntDecoder());

	2525 JBIG2_ALLOC(IAFS, CJBig2_ArithIntDecoder());

	2526 JBIG2_ALLOC(IADS, CJBig2_ArithIntDecoder());

	2527 JBIG2_ALLOC(IAIT, CJBig2_ArithIntDecoder());

	2528 JBIG2_ALLOC(IARI, CJBig2_ArithIntDecoder());

	2529 JBIG2_ALLOC(IARDW, CJBig2_ArithIntDecoder());

	2530 JBIG2_ALLOC(IARDH, CJBig2_ArithIntDecoder());

	2531 nTmp = 0;

	2532 while ((FX_DWORD)(1 << nTmp) < (SDNUMINSYMS + SDNUMNEWSYMS)) {

	2533 nTmp++;

	2534 }

	2535 JBIG2_ALLOC(IAID, CJBig2_ArithIaidDecoder((FX_BYTE)nTmp));

	2536 SDNEWSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(SDNUMNEWSYMS,

	2537 sizeof(CJBig2_Image*));

	2538 FXSYS_memset32(SDNEWSYMS, 0, SDNUMNEWSYMS * sizeof(CJBig2_Image*));

	2539 HCHEIGHT = 0;

	2540 NSYMSDECODED = 0;

	2541 while (NSYMSDECODED < SDNUMNEWSYMS) {

	2542 BS = NULL;

	2543 if (IADH->decode(pArithDecoder, &HCDH) == -1) {

	2544 m_pModule->JBig2_Error(

	2545 "symbol dictionary decoding procedure (arith): too short.");

	2546 goto failed;

	2547 }

	2548 HCHEIGHT = HCHEIGHT + HCDH;

	2549 if ((int)HCHEIGHT < 0 \|\| (int)HCHEIGHT > JBIG2_MAX_IMAGE_SIZE) {

	2550 m_pModule->JBig2_Error(

	2551 "symbol dictionary decoding procedure (arith): invalid HCHEIGHT "

	2552 "value.");

	2553 goto failed;

	2554 }

	2555 SYMWIDTH = 0;

	2556 TOTWIDTH = 0;

	2557 HCFIRSTSYM = NSYMSDECODED;

	2558 for (;;) {

	2559 nVal = IADW->decode(pArithDecoder, &DW);

	2560 if (nVal == JBIG2_OOB) {

	2561 break;

	2562 } else if (nVal != 0) {

	2563 m_pModule->JBig2_Error(

	2564 "symbol dictionary decoding procedure (arith): too short.");

	2565 goto failed;

	2566 } else {

	2567 if (NSYMSDECODED >= SDNUMNEWSYMS) {

	2568 m_pModule->JBig2_Error(

	2569 "symbol dictionary decoding procedure (arith): NSYMSDECODED >= "

	2570 "SDNUMNEWSYMS.");

	2571 goto failed;

	2572 }

	2573 SYMWIDTH = SYMWIDTH + DW;

	2574 if ((int)SYMWIDTH < 0 \|\| (int)SYMWIDTH > JBIG2_MAX_IMAGE_SIZE) {

	2575 m_pModule->JBig2_Error(

	2576 "symbol dictionary decoding procedure (arith): invalid SYMWIDTH "

	2577 "value.");

	2578 goto failed;

	2579 } else if (HCHEIGHT == 0 \|\| SYMWIDTH == 0) {

	2580 TOTWIDTH = TOTWIDTH + SYMWIDTH;

	2581 SDNEWSYMS[NSYMSDECODED] = NULL;

	2582 NSYMSDECODED = NSYMSDECODED + 1;

	2583 continue;

	2584 }

	2585 TOTWIDTH = TOTWIDTH + SYMWIDTH;

	2586 }

	2587 if (SDREFAGG == 0) {

	2588 JBIG2_ALLOC(pGRD, CJBig2_GRDProc());

	2589 pGRD->MMR = 0;

	2590 pGRD->GBW = SYMWIDTH;

	2591 pGRD->GBH = HCHEIGHT;

	2592 pGRD->GBTEMPLATE = SDTEMPLATE;

	2593 pGRD->TPGDON = 0;

	2594 pGRD->USESKIP = 0;

	2595 pGRD->GBAT[0] = SDAT[0];

	2596 pGRD->GBAT[1] = SDAT[1];

	2597 pGRD->GBAT[2] = SDAT[2];

	2598 pGRD->GBAT[3] = SDAT[3];

	2599 pGRD->GBAT[4] = SDAT[4];

	2600 pGRD->GBAT[5] = SDAT[5];

	2601 pGRD->GBAT[6] = SDAT[6];

	2602 pGRD->GBAT[7] = SDAT[7];

	2603 BS = pGRD->decode_Arith(pArithDecoder, gbContext);

	2604 if (BS == NULL) {

	2605 delete pGRD;

	2606 goto failed;

	2607 }

	2608 delete pGRD;

	2609 } else {

	2610 if (IAAI->decode(pArithDecoder, (int*)&REFAGGNINST) == -1) {

	2611 m_pModule->JBig2_Error(

	2612 "symbol dictionary decoding procedure (arith): too short.");

	2613 goto failed;

	2614 }

	2615 if (REFAGGNINST > 1) {

	2616 CJBig2_TRDProc* pDecoder;

	2617 JBIG2_ALLOC(pDecoder, CJBig2_TRDProc());

	2618 pDecoder->SBHUFF = SDHUFF;

	2619 pDecoder->SBREFINE = 1;

	2620 pDecoder->SBW = SYMWIDTH;

	2621 pDecoder->SBH = HCHEIGHT;

	2622 pDecoder->SBNUMINSTANCES = REFAGGNINST;

	2623 pDecoder->SBSTRIPS = 1;

	2624 pDecoder->SBNUMSYMS = SDNUMINSYMS + NSYMSDECODED;

	2625 SBNUMSYMS = pDecoder->SBNUMSYMS;

	2626 nTmp = 0;

	2627 while ((FX_DWORD)(1 << nTmp) < SBNUMSYMS) {

	2628 nTmp++;

	2629 }

	2630 SBSYMCODELEN = (FX_BYTE)nTmp;

	2631 pDecoder->SBSYMCODELEN = SBSYMCODELEN;

	2632 SBSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(

	2633 SBNUMSYMS, sizeof(CJBig2_Image*));

	2634 JBIG2_memcpy(SBSYMS, SDINSYMS, SDNUMINSYMS * sizeof(CJBig2_Image*));

	2635 JBIG2_memcpy(SBSYMS + SDNUMINSYMS,

	2636 SDNEWSYMS,

	2637 NSYMSDECODED * sizeof(CJBig2_Image*));

	2638 pDecoder->SBSYMS = SBSYMS;

	2639 pDecoder->SBDEFPIXEL = 0;

	2640 pDecoder->SBCOMBOP = JBIG2_COMPOSE_OR;

	2641 pDecoder->TRANSPOSED = 0;

	2642 pDecoder->REFCORNER = JBIG2_CORNER_TOPLEFT;

	2643 pDecoder->SBDSOFFSET = 0;

	2644 JBIG2_ALLOC(SBHUFFFS,

	2645 CJBig2_HuffmanTable(

	2646 HuffmanTable_B6,

	2647 sizeof(HuffmanTable_B6) / sizeof(JBig2TableLine),

	2648 HuffmanTable_HTOOB_B6));

	2649 JBIG2_ALLOC(SBHUFFDS,

	2650 CJBig2_HuffmanTable(

	2651 HuffmanTable_B8,

	2652 sizeof(HuffmanTable_B8) / sizeof(JBig2TableLine),

	2653 HuffmanTable_HTOOB_B8));

	2654 JBIG2_ALLOC(SBHUFFDT,

	2655 CJBig2_HuffmanTable(

	2656 HuffmanTable_B11,

	2657 sizeof(HuffmanTable_B11) / sizeof(JBig2TableLine),

	2658 HuffmanTable_HTOOB_B11));

	2659 JBIG2_ALLOC(SBHUFFRDW,

	2660 CJBig2_HuffmanTable(

	2661 HuffmanTable_B15,

	2662 sizeof(HuffmanTable_B15) / sizeof(JBig2TableLine),

	2663 HuffmanTable_HTOOB_B15));

	2664 JBIG2_ALLOC(SBHUFFRDH,

	2665 CJBig2_HuffmanTable(

	2666 HuffmanTable_B15,

	2667 sizeof(HuffmanTable_B15) / sizeof(JBig2TableLine),

	2668 HuffmanTable_HTOOB_B15));

	2669 JBIG2_ALLOC(SBHUFFRDX,

	2670 CJBig2_HuffmanTable(

	2671 HuffmanTable_B15,

	2672 sizeof(HuffmanTable_B15) / sizeof(JBig2TableLine),

	2673 HuffmanTable_HTOOB_B15));

	2674 JBIG2_ALLOC(SBHUFFRDY,

	2675 CJBig2_HuffmanTable(

	2676 HuffmanTable_B15,

	2677 sizeof(HuffmanTable_B15) / sizeof(JBig2TableLine),

	2678 HuffmanTable_HTOOB_B15));

	2679 JBIG2_ALLOC(SBHUFFRSIZE,

	2680 CJBig2_HuffmanTable(

	2681 HuffmanTable_B1,

	2682 sizeof(HuffmanTable_B1) / sizeof(JBig2TableLine),

	2683 HuffmanTable_HTOOB_B1));

	2684 pDecoder->SBHUFFFS = SBHUFFFS;

	2685 pDecoder->SBHUFFDS = SBHUFFDS;

	2686 pDecoder->SBHUFFDT = SBHUFFDT;

	2687 pDecoder->SBHUFFRDW = SBHUFFRDW;

	2688 pDecoder->SBHUFFRDH = SBHUFFRDH;

	2689 pDecoder->SBHUFFRDX = SBHUFFRDX;

	2690 pDecoder->SBHUFFRDY = SBHUFFRDY;

	2691 pDecoder->SBHUFFRSIZE = SBHUFFRSIZE;

	2692 pDecoder->SBRTEMPLATE = SDRTEMPLATE;

	2693 pDecoder->SBRAT[0] = SDRAT[0];

	2694 pDecoder->SBRAT[1] = SDRAT[1];

	2695 pDecoder->SBRAT[2] = SDRAT[2];

	2696 pDecoder->SBRAT[3] = SDRAT[3];

	2697 JBig2IntDecoderState ids;

	2698 ids.IADT = IADT;

	2699 ids.IAFS = IAFS;

	2700 ids.IADS = IADS;

	2701 ids.IAIT = IAIT;

	2702 ids.IARI = IARI;

	2703 ids.IARDW = IARDW;

	2704 ids.IARDH = IARDH;

	2705 ids.IARDX = IARDX;

	2706 ids.IARDY = IARDY;

	2707 ids.IAID = IAID;

	2708 BS = pDecoder->decode_Arith(pArithDecoder, grContext, &ids);

	2709 if (BS == NULL) {

	2710 m_pModule->JBig2_Free(SBSYMS);

	2711 delete SBHUFFFS;

	2712 delete SBHUFFDS;

	2713 delete SBHUFFDT;

	2714 delete SBHUFFRDW;

	2715 delete SBHUFFRDH;

	2716 delete SBHUFFRDX;

	2717 delete SBHUFFRDY;

	2718 delete SBHUFFRSIZE;

	2719 delete pDecoder;

	2720 goto failed;

	2721 }

	2722 m_pModule->JBig2_Free(SBSYMS);

	2723 delete SBHUFFFS;

	2724 delete SBHUFFDS;

	2725 delete SBHUFFDT;

	2726 delete SBHUFFRDW;

	2727 delete SBHUFFRDH;

	2728 delete SBHUFFRDX;

	2729 delete SBHUFFRDY;

	2730 delete SBHUFFRSIZE;

	2731 delete pDecoder;

	2732 } else if (REFAGGNINST == 1) {

	2733 SBHUFF = SDHUFF;

	2734 SBNUMSYMS = SDNUMINSYMS + NSYMSDECODED;

	2735 if (IAID->decode(pArithDecoder, (int*)&IDI) == -1) {

	2736 m_pModule->JBig2_Error(

	2737 "symbol dictionary decoding procedure (arith): too short.");

	2738 goto failed;

	2739 }

	2740 if ((IARDX->decode(pArithDecoder, &RDXI) == -1) \|\|

	2741 (IARDY->decode(pArithDecoder, &RDYI) == -1)) {

	2742 m_pModule->JBig2_Error(

	2743 "symbol dictionary decoding procedure (arith): too short.");

	2744 goto failed;

	2745 }

	2746 if (IDI >= SBNUMSYMS) {

	2747 m_pModule->JBig2_Error(

	2748 "symbol dictionary decoding procedure (arith):"

	2749 " refinement references unknown symbol %d",

	2750 IDI);

	2751 goto failed;

	2752 }

	2753 SBSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(

	2754 SBNUMSYMS, sizeof(CJBig2_Image*));

	2755 JBIG2_memcpy(SBSYMS, SDINSYMS, SDNUMINSYMS * sizeof(CJBig2_Image*));

	2756 JBIG2_memcpy(SBSYMS + SDNUMINSYMS,

	2757 SDNEWSYMS,

	2758 NSYMSDECODED * sizeof(CJBig2_Image*));

	2759 if (!SBSYMS[IDI]) {

	2760 m_pModule->JBig2_Free(SBSYMS);

	2761 goto failed;

	2762 }

	2763 JBIG2_ALLOC(pGRRD, CJBig2_GRRDProc());

	2764 pGRRD->GRW = SYMWIDTH;

	2765 pGRRD->GRH = HCHEIGHT;

	2766 pGRRD->GRTEMPLATE = SDRTEMPLATE;

	2767 pGRRD->GRREFERENCE = SBSYMS[IDI];

	2768 pGRRD->GRREFERENCEDX = RDXI;

	2769 pGRRD->GRREFERENCEDY = RDYI;

	2770 pGRRD->TPGRON = 0;

	2771 pGRRD->GRAT[0] = SDRAT[0];

	2772 pGRRD->GRAT[1] = SDRAT[1];

	2773 pGRRD->GRAT[2] = SDRAT[2];

	2774 pGRRD->GRAT[3] = SDRAT[3];

	2775 BS = pGRRD->decode(pArithDecoder, grContext);

	2776 if (BS == NULL) {

	2777 m_pModule->JBig2_Free(SBSYMS);

	2778 delete pGRRD;

	2779 goto failed;

	2780 }

	2781 m_pModule->JBig2_Free(SBSYMS);

	2782 delete pGRRD;

	2783 }

	2784 }

	2785 SDNEWSYMS[NSYMSDECODED] = BS;

	2786 BS = NULL;

	2787 NSYMSDECODED = NSYMSDECODED + 1;

	2788 }

	2789 }

	2790 EXINDEX = 0;

	2791 CUREXFLAG = 0;

	2792 EXFLAGS = (FX_BOOL*)m_pModule->JBig2_Malloc2(sizeof(FX_BOOL),

	2793 (SDNUMINSYMS + SDNUMNEWSYMS));

	2794 while (EXINDEX < SDNUMINSYMS + SDNUMNEWSYMS) {

	2795 if (IAEX->decode(pArithDecoder, (int*)&EXRUNLENGTH) == -1) {

	2796 m_pModule->JBig2_Free(EXFLAGS);

	2797 m_pModule->JBig2_Error(

	2798 "symbol dictionary decoding procedure (arith): too short.");

	2799 goto failed;

	2800 }

	2801 if (EXINDEX + EXRUNLENGTH > SDNUMINSYMS + SDNUMNEWSYMS) {

	2802 m_pModule->JBig2_Free(EXFLAGS);

	2803 m_pModule->JBig2_Error(

	2804 "symbol dictionary decoding procedure (arith): Invalid EXRUNLENGTH "

	2805 "value.");

	2806 goto failed;

	2807 }

	2808 if (EXRUNLENGTH != 0) {

	2809 for (I = EXINDEX; I < EXINDEX + EXRUNLENGTH; I++) {

	2810 EXFLAGS[I] = CUREXFLAG;

	2811 }

	2812 }

	2813 EXINDEX = EXINDEX + EXRUNLENGTH;

	2814 CUREXFLAG = !CUREXFLAG;

	2815 }

	2816 JBIG2_ALLOC(pDict, CJBig2_SymbolDict());

	2817 pDict->SDNUMEXSYMS = SDNUMEXSYMS;

	2818 pDict->SDEXSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(

	2819 sizeof(CJBig2_Image*), SDNUMEXSYMS);

	2820 I = J = 0;

	2821 for (I = 0; I < SDNUMINSYMS + SDNUMNEWSYMS; I++) {

	2822 if (EXFLAGS[I] && J < SDNUMEXSYMS) {

	2823 if (I < SDNUMINSYMS) {

	2824 JBIG2_ALLOC(pDict->SDEXSYMS[J], CJBig2_Image(*SDINSYMS[I]));

	2825 } else {

	2826 pDict->SDEXSYMS[J] = SDNEWSYMS[I - SDNUMINSYMS];

	2827 }

	2828 J = J + 1;

	2829 } else if (!EXFLAGS[I] && I >= SDNUMINSYMS) {

	2830 delete SDNEWSYMS[I - SDNUMINSYMS];

	2831 }

	2832 }

	2833 if (J < SDNUMEXSYMS) {

	2834 pDict->SDNUMEXSYMS = J;

	2835 }

	2836 m_pModule->JBig2_Free(EXFLAGS);

	2837 m_pModule->JBig2_Free(SDNEWSYMS);

	2838 delete IADH;

	2839 delete IADW;

	2840 delete IAAI;

	2841 delete IARDX;

	2842 delete IARDY;

	2843 delete IAEX;

	2844 delete IAID;

	2845 delete IADT;

	2846 delete IAFS;

	2847 delete IADS;

	2848 delete IAIT;

	2849 delete IARI;

	2850 delete IARDW;

	2851 delete IARDH;

	2852 return pDict;

	2853 failed:

	2854 for (I = 0; I < NSYMSDECODED; I++) {

	2855 if (SDNEWSYMS[I]) {

	2856 delete SDNEWSYMS[I];

	2857 SDNEWSYMS[I] = NULL;

	2858 }

	2859 }

	2860 m_pModule->JBig2_Free(SDNEWSYMS);

	2861 delete IADH;

	2862 delete IADW;

	2863 delete IAAI;

	2864 delete IARDX;

	2865 delete IARDY;

	2866 delete IAEX;

	2867 delete IAID;

	2868 delete IADT;

	2869 delete IAFS;

	2870 delete IADS;

	2871 delete IAIT;

	2872 delete IARI;

	2873 delete IARDW;

	2874 delete IARDH;

	2875 return NULL;

	2876 }

	2877 CJBig2_SymbolDict* CJBig2_SDDProc::decode_Huffman(CJBig2_BitStream* pStream,

	2878 JBig2ArithCtx* gbContext,

	2879 JBig2ArithCtx* grContext,

	2880 IFX_Pause* pPause) {

	2881 CJBig2_Image** SDNEWSYMS;

	2882 FX_DWORD* SDNEWSYMWIDTHS;

	2883 FX_DWORD HCHEIGHT, NSYMSDECODED;

	2884 FX_INT32 HCDH;

	2885 FX_DWORD SYMWIDTH, TOTWIDTH, HCFIRSTSYM;

	2886 FX_INT32 DW;

	2887 CJBig2_Image* BS, *BHC;

	2888 FX_DWORD I, J, REFAGGNINST;

	2889 FX_BOOL* EXFLAGS;

	2890 FX_DWORD EXINDEX;

	2891 FX_BOOL CUREXFLAG;

	2892 FX_DWORD EXRUNLENGTH;

	2893 FX_INT32 nVal, nBits;

	2894 FX_DWORD nTmp;

	2895 FX_BOOL SBHUFF;

	2896 FX_DWORD SBNUMSYMS;

	2897 FX_BYTE SBSYMCODELEN;

	2898 JBig2HuffmanCode* SBSYMCODES;

	2899 FX_DWORD IDI;

	2900 FX_INT32 RDXI, RDYI;

	2901 FX_DWORD BMSIZE;

	2902 FX_DWORD stride;

	2903 CJBig2_Image** SBSYMS;

	2904 CJBig2_HuffmanTable* SBHUFFFS, SBHUFFDS, SBHUFFDT, SBHUFFRDW, SBHUFFRDH,

	2905 SBHUFFRDX, SBHUFFRDY, SBHUFFRSIZE, pTable;

	2906 CJBig2_HuffmanDecoder* pHuffmanDecoder;

	2907 CJBig2_GRRDProc* pGRRD;

	2908 CJBig2_ArithDecoder* pArithDecoder;

	2909 CJBig2_GRDProc* pGRD;

	2910 CJBig2_SymbolDict* pDict;

	2911 JBIG2_ALLOC(pHuffmanDecoder, CJBig2_HuffmanDecoder(pStream));

	2912 SDNEWSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(SDNUMNEWSYMS,

	2913 sizeof(CJBig2_Image*));

	2914 FXSYS_memset32(SDNEWSYMS, 0, SDNUMNEWSYMS * sizeof(CJBig2_Image*));

	2915 SDNEWSYMWIDTHS = NULL;

	2916 BHC = NULL;

	2917 if (SDREFAGG == 0) {

	2918 SDNEWSYMWIDTHS =

	2919 (FX_DWORD*)m_pModule->JBig2_Malloc2(SDNUMNEWSYMS, sizeof(FX_DWORD));

	2920 FXSYS_memset32(SDNEWSYMWIDTHS, 0, SDNUMNEWSYMS * sizeof(FX_DWORD));

	2921 }

	2922 HCHEIGHT = 0;

	2923 NSYMSDECODED = 0;

	2924 BS = NULL;

	2925 while (NSYMSDECODED < SDNUMNEWSYMS) {

	2926 if (pHuffmanDecoder->decodeAValue(SDHUFFDH, &HCDH) != 0) {

	2927 m_pModule->JBig2_Error(

	2928 "symbol dictionary decoding procedure (huffman): too short.");

	2929 goto failed;

	2930 }

	2931 HCHEIGHT = HCHEIGHT + HCDH;

	2932 if ((int)HCHEIGHT < 0 \|\| (int)HCHEIGHT > JBIG2_MAX_IMAGE_SIZE) {

	2933 m_pModule->JBig2_Error(

	2934 "symbol dictionary decoding procedure (huffman): invalid HCHEIGHT "

	2935 "value.");

	2936 goto failed;

	2937 }

	2938 SYMWIDTH = 0;

	2939 TOTWIDTH = 0;

	2940 HCFIRSTSYM = NSYMSDECODED;

	2941 for (;;) {

	2942 nVal = pHuffmanDecoder->decodeAValue(SDHUFFDW, &DW);

	2943 if (nVal == JBIG2_OOB) {

	2944 break;

	2945 } else if (nVal != 0) {

	2946 m_pModule->JBig2_Error(

	2947 "symbol dictionary decoding procedure (huffman): too short.");

	2948 goto failed;

	2949 } else {

	2950 if (NSYMSDECODED >= SDNUMNEWSYMS) {

	2951 m_pModule->JBig2_Error(

	2952 "symbol dictionary decoding procedure (huffman): NSYMSDECODED >= "

	2953 "SDNUMNEWSYMS.");

	2954 goto failed;

	2955 }

	2956 SYMWIDTH = SYMWIDTH + DW;

	2957 if ((int)SYMWIDTH < 0 \|\| (int)SYMWIDTH > JBIG2_MAX_IMAGE_SIZE) {

	2958 m_pModule->JBig2_Error(

	2959 "symbol dictionary decoding procedure (huffman): invalid "

	2960 "SYMWIDTH value.");

	2961 goto failed;

	2962 } else if (HCHEIGHT == 0 \|\| SYMWIDTH == 0) {

	2963 TOTWIDTH = TOTWIDTH + SYMWIDTH;

	2964 SDNEWSYMS[NSYMSDECODED] = NULL;

	2965 NSYMSDECODED = NSYMSDECODED + 1;

	2966 continue;

	2967 }

	2968 TOTWIDTH = TOTWIDTH + SYMWIDTH;

	2969 }

	2970 if (SDREFAGG == 1) {

	2971 if (pHuffmanDecoder->decodeAValue(SDHUFFAGGINST, (int*)&REFAGGNINST) !=

	2972 0) {

	2973 m_pModule->JBig2_Error(

	2974 "symbol dictionary decoding procedure (huffman): too short.");

	2975 goto failed;

	2976 }

	2977 BS = NULL;

	2978 if (REFAGGNINST > 1) {

	2979 CJBig2_TRDProc* pDecoder;

	2980 JBIG2_ALLOC(pDecoder, CJBig2_TRDProc());

	2981 pDecoder->SBHUFF = SDHUFF;

	2982 pDecoder->SBREFINE = 1;

	2983 pDecoder->SBW = SYMWIDTH;

	2984 pDecoder->SBH = HCHEIGHT;

	2985 pDecoder->SBNUMINSTANCES = REFAGGNINST;

	2986 pDecoder->SBSTRIPS = 1;

	2987 pDecoder->SBNUMSYMS = SDNUMINSYMS + NSYMSDECODED;

	2988 SBNUMSYMS = pDecoder->SBNUMSYMS;

	2989 SBSYMCODES = (JBig2HuffmanCode*)m_pModule->JBig2_Malloc2(

	2990 SBNUMSYMS, sizeof(JBig2HuffmanCode));

	2991 nTmp = 1;

	2992 while ((FX_DWORD)(1 << nTmp) < SBNUMSYMS) {

	2993 nTmp++;

	2994 }

	2995 for (I = 0; I < SBNUMSYMS; I++) {

	2996 SBSYMCODES[I].codelen = nTmp;

	2997 SBSYMCODES[I].code = I;

	2998 }

	2999 pDecoder->SBSYMCODES = SBSYMCODES;

	3000 SBSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(

	3001 SBNUMSYMS, sizeof(CJBig2_Image*));

	3002 JBIG2_memcpy(SBSYMS, SDINSYMS, SDNUMINSYMS * sizeof(CJBig2_Image*));

	3003 JBIG2_memcpy(SBSYMS + SDNUMINSYMS,

	3004 SDNEWSYMS,

	3005 NSYMSDECODED * sizeof(CJBig2_Image*));

	3006 pDecoder->SBSYMS = SBSYMS;

	3007 pDecoder->SBDEFPIXEL = 0;

	3008 pDecoder->SBCOMBOP = JBIG2_COMPOSE_OR;

	3009 pDecoder->TRANSPOSED = 0;

	3010 pDecoder->REFCORNER = JBIG2_CORNER_TOPLEFT;

	3011 pDecoder->SBDSOFFSET = 0;

	3012 JBIG2_ALLOC(SBHUFFFS,

	3013 CJBig2_HuffmanTable(

	3014 HuffmanTable_B6,

	3015 sizeof(HuffmanTable_B6) / sizeof(JBig2TableLine),

	3016 HuffmanTable_HTOOB_B6));

	3017 JBIG2_ALLOC(SBHUFFDS,

	3018 CJBig2_HuffmanTable(

	3019 HuffmanTable_B8,

	3020 sizeof(HuffmanTable_B8) / sizeof(JBig2TableLine),

	3021 HuffmanTable_HTOOB_B8));

	3022 JBIG2_ALLOC(SBHUFFDT,

	3023 CJBig2_HuffmanTable(

	3024 HuffmanTable_B11,

	3025 sizeof(HuffmanTable_B11) / sizeof(JBig2TableLine),

	3026 HuffmanTable_HTOOB_B11));

	3027 JBIG2_ALLOC(SBHUFFRDW,

	3028 CJBig2_HuffmanTable(

	3029 HuffmanTable_B15,

	3030 sizeof(HuffmanTable_B15) / sizeof(JBig2TableLine),

	3031 HuffmanTable_HTOOB_B15));

	3032 JBIG2_ALLOC(SBHUFFRDH,

	3033 CJBig2_HuffmanTable(

	3034 HuffmanTable_B15,

	3035 sizeof(HuffmanTable_B15) / sizeof(JBig2TableLine),

	3036 HuffmanTable_HTOOB_B15));

	3037 JBIG2_ALLOC(SBHUFFRDX,

	3038 CJBig2_HuffmanTable(

	3039 HuffmanTable_B15,

	3040 sizeof(HuffmanTable_B15) / sizeof(JBig2TableLine),

	3041 HuffmanTable_HTOOB_B15));

	3042 JBIG2_ALLOC(SBHUFFRDY,

	3043 CJBig2_HuffmanTable(

	3044 HuffmanTable_B15,

	3045 sizeof(HuffmanTable_B15) / sizeof(JBig2TableLine),

	3046 HuffmanTable_HTOOB_B15));

	3047 JBIG2_ALLOC(SBHUFFRSIZE,

	3048 CJBig2_HuffmanTable(

	3049 HuffmanTable_B1,

	3050 sizeof(HuffmanTable_B1) / sizeof(JBig2TableLine),

	3051 HuffmanTable_HTOOB_B1));

	3052 pDecoder->SBHUFFFS = SBHUFFFS;

	3053 pDecoder->SBHUFFDS = SBHUFFDS;

	3054 pDecoder->SBHUFFDT = SBHUFFDT;

	3055 pDecoder->SBHUFFRDW = SBHUFFRDW;

	3056 pDecoder->SBHUFFRDH = SBHUFFRDH;

	3057 pDecoder->SBHUFFRDX = SBHUFFRDX;

	3058 pDecoder->SBHUFFRDY = SBHUFFRDY;

	3059 pDecoder->SBHUFFRSIZE = SBHUFFRSIZE;

	3060 pDecoder->SBRTEMPLATE = SDRTEMPLATE;

	3061 pDecoder->SBRAT[0] = SDRAT[0];

	3062 pDecoder->SBRAT[1] = SDRAT[1];

	3063 pDecoder->SBRAT[2] = SDRAT[2];

	3064 pDecoder->SBRAT[3] = SDRAT[3];

	3065 BS = pDecoder->decode_Huffman(pStream, grContext);

	3066 if (BS == NULL) {

	3067 m_pModule->JBig2_Free(SBSYMCODES);

	3068 m_pModule->JBig2_Free(SBSYMS);

	3069 delete SBHUFFFS;

	3070 delete SBHUFFDS;

	3071 delete SBHUFFDT;

	3072 delete SBHUFFRDW;

	3073 delete SBHUFFRDH;

	3074 delete SBHUFFRDX;

	3075 delete SBHUFFRDY;

	3076 delete SBHUFFRSIZE;

	3077 delete pDecoder;

	3078 goto failed;

	3079 }

	3080 m_pModule->JBig2_Free(SBSYMCODES);

	3081 m_pModule->JBig2_Free(SBSYMS);

	3082 delete SBHUFFFS;

	3083 delete SBHUFFDS;

	3084 delete SBHUFFDT;

	3085 delete SBHUFFRDW;

	3086 delete SBHUFFRDH;

	3087 delete SBHUFFRDX;

	3088 delete SBHUFFRDY;

	3089 delete SBHUFFRSIZE;

	3090 delete pDecoder;

	3091 } else if (REFAGGNINST == 1) {

	3092 SBHUFF = SDHUFF;

	3093 SBNUMSYMS = SDNUMINSYMS + SDNUMNEWSYMS;

	3094 nTmp = 1;

	3095 while ((FX_DWORD)(1 << nTmp) < SBNUMSYMS) {

	3096 nTmp++;

	3097 }

	3098 SBSYMCODELEN = (FX_BYTE)nTmp;

	3099 SBSYMCODES = (JBig2HuffmanCode*)m_pModule->JBig2_Malloc2(

	3100 SBNUMSYMS, sizeof(JBig2HuffmanCode));

	3101 for (I = 0; I < SBNUMSYMS; I++) {

	3102 SBSYMCODES[I].codelen = SBSYMCODELEN;

	3103 SBSYMCODES[I].code = I;

	3104 }

	3105 nVal = 0;

	3106 nBits = 0;

	3107 for (;;) {

	3108 if (pStream->read1Bit(&nTmp) != 0) {

	3109 m_pModule->JBig2_Free(SBSYMCODES);

	3110 m_pModule->JBig2_Error(

	3111 "symbol dictionary decoding procedure (huffman): too short.");

	3112 goto failed;

	3113 }

	3114 nVal = (nVal << 1) \| nTmp;

	3115 for (IDI = 0; IDI < SBNUMSYMS; IDI++) {

	3116 if ((nVal == SBSYMCODES[IDI].code) &&

	3117 (nBits == SBSYMCODES[IDI].codelen)) {

	3118 break;

	3119 }

	3120 }

	3121 if (IDI < SBNUMSYMS) {

	3122 break;

	3123 }

	3124 }

	3125 m_pModule->JBig2_Free(SBSYMCODES);

	3126 JBIG2_ALLOC(SBHUFFRDX,

	3127 CJBig2_HuffmanTable(

	3128 HuffmanTable_B15,

	3129 sizeof(HuffmanTable_B15) / sizeof(JBig2TableLine),

	3130 HuffmanTable_HTOOB_B15));

	3131 JBIG2_ALLOC(SBHUFFRSIZE,

	3132 CJBig2_HuffmanTable(

	3133 HuffmanTable_B1,

	3134 sizeof(HuffmanTable_B1) / sizeof(JBig2TableLine),

	3135 HuffmanTable_HTOOB_B1));

	3136 if ((pHuffmanDecoder->decodeAValue(SBHUFFRDX, &RDXI) != 0) \|\|

	3137 (pHuffmanDecoder->decodeAValue(SBHUFFRDX, &RDYI) != 0) \|\|

	3138 (pHuffmanDecoder->decodeAValue(SBHUFFRSIZE, &nVal) != 0)) {

	3139 delete SBHUFFRDX;

	3140 delete SBHUFFRSIZE;

	3141 m_pModule->JBig2_Error(

	3142 "symbol dictionary decoding procedure (huffman): too short.");

	3143 goto failed;

	3144 }

	3145 delete SBHUFFRDX;

	3146 delete SBHUFFRSIZE;

	3147 pStream->alignByte();

	3148 nTmp = pStream->getOffset();

	3149 SBSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(

	3150 SBNUMSYMS, sizeof(CJBig2_Image*));

	3151 JBIG2_memcpy(SBSYMS, SDINSYMS, SDNUMINSYMS * sizeof(CJBig2_Image*));

	3152 JBIG2_memcpy(SBSYMS + SDNUMINSYMS,

	3153 SDNEWSYMS,

	3154 NSYMSDECODED * sizeof(CJBig2_Image*));

	3155 JBIG2_ALLOC(pGRRD, CJBig2_GRRDProc());

	3156 pGRRD->GRW = SYMWIDTH;

	3157 pGRRD->GRH = HCHEIGHT;

	3158 pGRRD->GRTEMPLATE = SDRTEMPLATE;

	3159 pGRRD->GRREFERENCE = SBSYMS[IDI];

	3160 pGRRD->GRREFERENCEDX = RDXI;

	3161 pGRRD->GRREFERENCEDY = RDYI;

	3162 pGRRD->TPGRON = 0;

	3163 pGRRD->GRAT[0] = SDRAT[0];

	3164 pGRRD->GRAT[1] = SDRAT[1];

	3165 pGRRD->GRAT[2] = SDRAT[2];

	3166 pGRRD->GRAT[3] = SDRAT[3];

	3167 JBIG2_ALLOC(pArithDecoder, CJBig2_ArithDecoder(pStream));

	3168 BS = pGRRD->decode(pArithDecoder, grContext);

	3169 if (BS == NULL) {

	3170 m_pModule->JBig2_Free(SBSYMS);

	3171 delete pGRRD;

	3172 delete pArithDecoder;

	3173 goto failed;

	3174 }

	3175 pStream->alignByte();

	3176 pStream->offset(2);

	3177 if ((FX_DWORD)nVal != (pStream->getOffset() - nTmp)) {

	3178 delete BS;

	3179 m_pModule->JBig2_Free(SBSYMS);

	3180 delete pGRRD;

	3181 delete pArithDecoder;

	3182 m_pModule->JBig2_Error(

	3183 "symbol dictionary decoding procedure (huffman):"

	3184 "bytes processed by generic refinement region decoding "

	3185 "procedure doesn't equal SBHUFFRSIZE.");

	3186 goto failed;

	3187 }

	3188 m_pModule->JBig2_Free(SBSYMS);

	3189 delete pGRRD;

	3190 delete pArithDecoder;

	3191 }

	3192 SDNEWSYMS[NSYMSDECODED] = BS;

	3193 }

	3194 if (SDREFAGG == 0) {

	3195 SDNEWSYMWIDTHS[NSYMSDECODED] = SYMWIDTH;

	3196 }

	3197 NSYMSDECODED = NSYMSDECODED + 1;

	3198 }

	3199 if (SDREFAGG == 0) {

	3200 if (pHuffmanDecoder->decodeAValue(SDHUFFBMSIZE, (FX_INT32*)&BMSIZE) !=

	3201 0) {

	3202 m_pModule->JBig2_Error(

	3203 "symbol dictionary decoding procedure (huffman): too short.");

	3204 goto failed;

	3205 }

	3206 pStream->alignByte();

	3207 if (BMSIZE == 0) {

	3208 stride = (TOTWIDTH + 7) >> 3;

	3209 if (pStream->getByteLeft() >= stride * HCHEIGHT) {

	3210 JBIG2_ALLOC(BHC, CJBig2_Image(TOTWIDTH, HCHEIGHT));

	3211 for (I = 0; I < HCHEIGHT; I++) {

	3212 JBIG2_memcpy(BHC->m_pData + I * BHC->m_nStride,

	3213 pStream->getPointer(),

	3214 stride);

	3215 pStream->offset(stride);

	3216 }

	3217 } else {

	3218 m_pModule->JBig2_Error(

	3219 "symbol dictionary decoding procedure (huffman): too short.");

	3220 goto failed;

	3221 }

	3222 } else {

	3223 JBIG2_ALLOC(pGRD, CJBig2_GRDProc());

	3224 pGRD->MMR = 1;

	3225 pGRD->GBW = TOTWIDTH;

	3226 pGRD->GBH = HCHEIGHT;

	3227 FXCODEC_STATUS status = pGRD->Start_decode_MMR(&BHC, pStream);

	3228 while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {

	3229 pGRD->Continue_decode(pPause);

	3230 }

	3231 delete pGRD;

	3232 pStream->alignByte();

	3233 }

	3234 nTmp = 0;

	3235 if (!BHC) {

	3236 continue;

	3237 }

	3238 for (I = HCFIRSTSYM; I < NSYMSDECODED; I++) {

	3239 SDNEWSYMS[I] = BHC->subImage(nTmp, 0, SDNEWSYMWIDTHS[I], HCHEIGHT);

	3240 nTmp += SDNEWSYMWIDTHS[I];

	3241 }

	3242 delete BHC;

	3243 BHC = NULL;

	3244 }

	3245 }

	3246 EXINDEX = 0;

	3247 CUREXFLAG = 0;

	3248 JBIG2_ALLOC(

	3249 pTable,

	3250 CJBig2_HuffmanTable(HuffmanTable_B1,

	3251 sizeof(HuffmanTable_B1) / sizeof(JBig2TableLine),

	3252 HuffmanTable_HTOOB_B1));

	3253 EXFLAGS = (FX_BOOL*)m_pModule->JBig2_Malloc2(sizeof(FX_BOOL),

	3254 (SDNUMINSYMS + SDNUMNEWSYMS));

	3255 while (EXINDEX < SDNUMINSYMS + SDNUMNEWSYMS) {

	3256 if (pHuffmanDecoder->decodeAValue(pTable, (int*)&EXRUNLENGTH) != 0) {

	3257 delete pTable;

	3258 m_pModule->JBig2_Free(EXFLAGS);

	3259 m_pModule->JBig2_Error(

	3260 "symbol dictionary decoding procedure (huffman): too short.");

	3261 goto failed;

	3262 }

	3263 if (EXINDEX + EXRUNLENGTH > SDNUMINSYMS + SDNUMNEWSYMS) {

	3264 delete pTable;

	3265 m_pModule->JBig2_Free(EXFLAGS);

	3266 m_pModule->JBig2_Error(

	3267 "symbol dictionary decoding procedure (arith): Invalid EXRUNLENGTH "

	3268 "value.");

	3269 goto failed;

	3270 }

	3271 if (EXRUNLENGTH != 0) {

	3272 for (I = EXINDEX; I < EXINDEX + EXRUNLENGTH; I++) {

	3273 EXFLAGS[I] = CUREXFLAG;

	3274 }

	3275 }

	3276 EXINDEX = EXINDEX + EXRUNLENGTH;

	3277 CUREXFLAG = !CUREXFLAG;

	3278 }

	3279 delete pTable;

	3280 JBIG2_ALLOC(pDict, CJBig2_SymbolDict());

	3281 pDict->SDNUMEXSYMS = SDNUMEXSYMS;

	3282 pDict->SDEXSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(

	3283 sizeof(CJBig2_Image*), SDNUMEXSYMS);

	3284 I = J = 0;

	3285 for (I = 0; I < SDNUMINSYMS + SDNUMNEWSYMS; I++) {

	3286 if (EXFLAGS[I] && J < SDNUMEXSYMS) {

	3287 if (I < SDNUMINSYMS) {

	3288 JBIG2_ALLOC(pDict->SDEXSYMS[J], CJBig2_Image(*SDINSYMS[I]));

	3289 } else {

	3290 pDict->SDEXSYMS[J] = SDNEWSYMS[I - SDNUMINSYMS];

	3291 }

	3292 J = J + 1;

	3293 } else if (!EXFLAGS[I] && I >= SDNUMINSYMS) {

	3294 delete SDNEWSYMS[I - SDNUMINSYMS];

	3295 }

	3296 }

	3297 if (J < SDNUMEXSYMS) {

	3298 pDict->SDNUMEXSYMS = J;

	3299 }

	3300 m_pModule->JBig2_Free(EXFLAGS);

	3301 m_pModule->JBig2_Free(SDNEWSYMS);

	3302 if (SDREFAGG == 0) {

	3303 m_pModule->JBig2_Free(SDNEWSYMWIDTHS);

	3304 }

	3305 delete pHuffmanDecoder;

	3306 return pDict;

	3307 failed:

	3308 for (I = 0; I < NSYMSDECODED; I++) {

	3309 if (SDNEWSYMS[I]) {

	3310 delete SDNEWSYMS[I];

	3311 }

	3312 }

	3313 m_pModule->JBig2_Free(SDNEWSYMS);

	3314 if (SDREFAGG == 0) {

	3315 m_pModule->JBig2_Free(SDNEWSYMWIDTHS);

	3316 }

	3317 delete pHuffmanDecoder;

	3318 return NULL;

	3319 }

	3320 CJBig2_Image* CJBig2_HTRDProc::decode_Arith(CJBig2_ArithDecoder* pArithDecoder,

	3321 JBig2ArithCtx* gbContext,

	3322 IFX_Pause* pPause) {

	3323 FX_DWORD ng, mg;

	3324 FX_INT32 x, y;

	3325 CJBig2_Image* HSKIP;

	3326 FX_DWORD HBPP;

	3327 FX_DWORD* GI;

	3328 CJBig2_Image* HTREG;

	3329 CJBig2_GSIDProc* pGID;

	3330 JBIG2_ALLOC(HTREG, CJBig2_Image(HBW, HBH));

	3331 HTREG->fill(HDEFPIXEL);

	3332 HSKIP = NULL;

	3333 if (HENABLESKIP == 1) {

	3334 JBIG2_ALLOC(HSKIP, CJBig2_Image(HGW, HGH));

	3335 for (mg = 0; mg < HGH; mg++) {

	3336 for (ng = 0; ng < HGW; ng++) {

	3337 x = (HGX + mg * HRY + ng * HRX) >> 8;

	3338 y = (HGY + mg * HRX - ng * HRY) >> 8;

	3339 if ((x + HPW <= 0) \| (x >= (FX_INT32)HBW) \| (y + HPH <= 0) \|

	3340 (y >= (FX_INT32)HPH)) {

	3341 HSKIP->setPixel(ng, mg, 1);

	3342 } else {

	3343 HSKIP->setPixel(ng, mg, 0);

	3344 }

	3345 }

	3346 }

	3347 }

	3348 HBPP = 1;

	3349 while ((FX_DWORD)(1 << HBPP) < HNUMPATS) {

	3350 HBPP++;

	3351 }

	3352 JBIG2_ALLOC(pGID, CJBig2_GSIDProc());

	3353 pGID->GSMMR = HMMR;

	3354 pGID->GSW = HGW;

	3355 pGID->GSH = HGH;

	3356 pGID->GSBPP = (FX_BYTE)HBPP;

	3357 pGID->GSUSESKIP = HENABLESKIP;

	3358 pGID->GSKIP = HSKIP;

	3359 pGID->GSTEMPLATE = HTEMPLATE;

	3360 GI = pGID->decode_Arith(pArithDecoder, gbContext, pPause);

	3361 if (GI == NULL) {

	3362 goto failed;

	3363 }

	3364 for (mg = 0; mg < HGH; mg++) {

	3365 for (ng = 0; ng < HGW; ng++) {

	3366 x = (HGX + mg * HRY + ng * HRX) >> 8;

	3367 y = (HGY + mg * HRX - ng * HRY) >> 8;

	3368 FX_DWORD pat_index = GI[mg * HGW + ng];

	3369 if (pat_index >= HNUMPATS) {

	3370 pat_index = HNUMPATS - 1;

	3371 }

	3372 HTREG->composeFrom(x, y, HPATS[pat_index], HCOMBOP);

	3373 }

	3374 }

	3375 m_pModule->JBig2_Free(GI);

	3376 if (HSKIP) {

	3377 delete HSKIP;

	3378 }

	3379 delete pGID;

	3380 return HTREG;

	3381 failed:

	3382 if (HSKIP) {

	3383 delete HSKIP;

	3384 }

	3385 delete pGID;

	3386 delete HTREG;

	3387 return NULL;

	3388 }

	3389 CJBig2_Image* CJBig2_HTRDProc::decode_MMR(CJBig2_BitStream* pStream,

	3390 IFX_Pause* pPause) {

	3391 FX_DWORD ng, mg;

	3392 FX_INT32 x, y;

	3393 FX_DWORD HBPP;

	3394 FX_DWORD* GI;

	3395 CJBig2_Image* HTREG;

	3396 CJBig2_GSIDProc* pGID;

	3397 JBIG2_ALLOC(HTREG, CJBig2_Image(HBW, HBH));

	3398 HTREG->fill(HDEFPIXEL);

	3399 HBPP = 1;

	3400 while ((FX_DWORD)(1 << HBPP) < HNUMPATS) {

	3401 HBPP++;

	3402 }

	3403 JBIG2_ALLOC(pGID, CJBig2_GSIDProc());

	3404 pGID->GSMMR = HMMR;

	3405 pGID->GSW = HGW;

	3406 pGID->GSH = HGH;

	3407 pGID->GSBPP = (FX_BYTE)HBPP;

	3408 pGID->GSUSESKIP = 0;

	3409 GI = pGID->decode_MMR(pStream, pPause);

	3410 if (GI == NULL) {

	3411 goto failed;

	3412 }

	3413 for (mg = 0; mg < HGH; mg++) {

	3414 for (ng = 0; ng < HGW; ng++) {

	3415 x = (HGX + mg * HRY + ng * HRX) >> 8;

	3416 y = (HGY + mg * HRX - ng * HRY) >> 8;

	3417 FX_DWORD pat_index = GI[mg * HGW + ng];

	3418 if (pat_index >= HNUMPATS) {

	3419 pat_index = HNUMPATS - 1;

	3420 }

	3421 HTREG->composeFrom(x, y, HPATS[pat_index], HCOMBOP);

	3422 }

	3423 }

	3424 m_pModule->JBig2_Free(GI);

	3425 delete pGID;

	3426 return HTREG;

	3427 failed:

	3428 delete pGID;

	3429 delete HTREG;

	3430 return NULL;

	3431 }

	3432 CJBig2_PatternDict* CJBig2_PDDProc::decode_Arith(

	3433 CJBig2_ArithDecoder* pArithDecoder,

	3434 JBig2ArithCtx* gbContext,

	3435 IFX_Pause* pPause) {

	3436 FX_DWORD GRAY;

	3437 CJBig2_Image* BHDC = NULL;

	3438 CJBig2_PatternDict* pDict;

	3439 CJBig2_GRDProc* pGRD;

	3440 JBIG2_ALLOC(pDict, CJBig2_PatternDict());

	3441 pDict->NUMPATS = GRAYMAX + 1;

	3442 pDict->HDPATS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(

	3443 sizeof(CJBig2_Image*), pDict->NUMPATS);

	3444 JBIG2_memset(pDict->HDPATS, 0, sizeof(CJBig2_Image) pDict->NUMPATS);

	3445 JBIG2_ALLOC(pGRD, CJBig2_GRDProc());

	3446 pGRD->MMR = HDMMR;

	3447 pGRD->GBW = (GRAYMAX + 1) * HDPW;

	3448 pGRD->GBH = HDPH;

	3449 pGRD->GBTEMPLATE = HDTEMPLATE;

	3450 pGRD->TPGDON = 0;

	3451 pGRD->USESKIP = 0;

	3452 pGRD->GBAT[0] = -(FX_INT32)HDPW;

	3453 pGRD->GBAT[1] = 0;

	3454 if (pGRD->GBTEMPLATE == 0) {

	3455 pGRD->GBAT[2] = -3;

	3456 pGRD->GBAT[3] = -1;

	3457 pGRD->GBAT[4] = 2;

	3458 pGRD->GBAT[5] = -2;

	3459 pGRD->GBAT[6] = -2;

	3460 pGRD->GBAT[7] = -2;

	3461 }

	3462 FXCODEC_STATUS status =

	3463 pGRD->Start_decode_Arith(&BHDC, pArithDecoder, gbContext);

	3464 while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {

	3465 pGRD->Continue_decode(pPause);

	3466 }

	3467 if (BHDC == NULL) {

	3468 delete pGRD;

	3469 goto failed;

	3470 }

	3471 delete pGRD;

	3472 GRAY = 0;

	3473 while (GRAY <= GRAYMAX) {

	3474 pDict->HDPATS[GRAY] = BHDC->subImage(HDPW * GRAY, 0, HDPW, HDPH);

	3475 GRAY = GRAY + 1;

	3476 }

	3477 delete BHDC;

	3478 return pDict;

	3479 failed:

	3480 delete pDict;

	3481 return NULL;

	3482 }

	3483

	3484 CJBig2_PatternDict* CJBig2_PDDProc::decode_MMR(CJBig2_BitStream* pStream,

	3485 IFX_Pause* pPause) {

	3486 FX_DWORD GRAY;

	3487 CJBig2_Image* BHDC = NULL;

	3488 CJBig2_PatternDict* pDict;

	3489 CJBig2_GRDProc* pGRD;

	3490 JBIG2_ALLOC(pDict, CJBig2_PatternDict());

	3491 pDict->NUMPATS = GRAYMAX + 1;

	3492 pDict->HDPATS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(

	3493 sizeof(CJBig2_Image*), pDict->NUMPATS);

	3494 JBIG2_memset(pDict->HDPATS, 0, sizeof(CJBig2_Image) pDict->NUMPATS);

	3495 JBIG2_ALLOC(pGRD, CJBig2_GRDProc());

	3496 pGRD->MMR = HDMMR;

	3497 pGRD->GBW = (GRAYMAX + 1) * HDPW;

	3498 pGRD->GBH = HDPH;

	3499 FXCODEC_STATUS status = pGRD->Start_decode_MMR(&BHDC, pStream);

	3500 while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {

	3501 pGRD->Continue_decode(pPause);

	3502 }

	3503 if (BHDC == NULL) {

	3504 delete pGRD;

	3505 goto failed;

	3506 }

	3507 delete pGRD;

	3508 GRAY = 0;

	3509 while (GRAY <= GRAYMAX) {

	3510 pDict->HDPATS[GRAY] = BHDC->subImage(HDPW * GRAY, 0, HDPW, HDPH);

	3511 GRAY = GRAY + 1;

	3512 }

	3513 delete BHDC;

	3514 return pDict;

	3515 failed:

	3516 delete pDict;

	3517 return NULL;

	3518 }

	3519 FX_DWORD* CJBig2_GSIDProc::decode_Arith(CJBig2_ArithDecoder* pArithDecoder,

	3520 JBig2ArithCtx* gbContext,

	3521 IFX_Pause* pPause) {

	3522 CJBig2_Image** GSPLANES;

	3523 FX_INT32 J, K;

	3524 FX_DWORD x, y;

	3525 FX_DWORD* GSVALS;

	3526 CJBig2_GRDProc* pGRD;

	3527 GSPLANES =

	3528 (CJBig2_Image*)m_pModule->JBig2_Malloc2(sizeof(CJBig2_Image), GSBPP);

	3529 if (!GSPLANES) {

2617 return NULL;	3530 return NULL;

2618 }	3531 }

2619 CJBig2_SymbolDict CJBig2_SDDProc::decode_Huffman(CJBig2_BitStream pStream,	3532 GSVALS = (FX_DWORD*)m_pModule->JBig2_Malloc3(sizeof(FX_DWORD), GSW, GSH);

2620 JBig2ArithCtx gbContext, JBig2ArithCtx grContext, IFX_Pause* pPause)	3533 if (!GSVALS) {

2621 {	3534 m_pModule->JBig2_Free(GSPLANES);

2622 CJBig2_Image **SDNEWSYMS;	3535 return NULL;

2623 FX_DWORD *SDNEWSYMWIDTHS;	3536 }

2624 FX_DWORD HCHEIGHT, NSYMSDECODED;	3537 JBIG2_memset(GSPLANES, 0, sizeof(CJBig2_Image) GSBPP);

2625 FX_INT32 HCDH;	3538 JBIG2_memset(GSVALS, 0, sizeof(FX_DWORD) * GSW * GSH);

2626 FX_DWORD SYMWIDTH, TOTWIDTH, HCFIRSTSYM;	3539 JBIG2_ALLOC(pGRD, CJBig2_GRDProc());

2627 FX_INT32 DW;	3540 pGRD->MMR = GSMMR;

2628 CJBig2_Image BS, BHC;	3541 pGRD->GBW = GSW;

2629 FX_DWORD I, J, REFAGGNINST;	3542 pGRD->GBH = GSH;

2630 FX_BOOL *EXFLAGS;	3543 pGRD->GBTEMPLATE = GSTEMPLATE;

2631 FX_DWORD EXINDEX;	3544 pGRD->TPGDON = 0;

2632 FX_BOOL CUREXFLAG;	3545 pGRD->USESKIP = GSUSESKIP;

2633 FX_DWORD EXRUNLENGTH;	3546 pGRD->SKIP = GSKIP;

2634 FX_INT32 nVal, nBits;	3547 if (GSTEMPLATE <= 1) {

2635 FX_DWORD nTmp;	3548 pGRD->GBAT[0] = 3;

2636 FX_BOOL SBHUFF;	3549 } else {

2637 FX_DWORD SBNUMSYMS;	3550 pGRD->GBAT[0] = 2;

2638 FX_BYTE SBSYMCODELEN;	3551 }

2639 JBig2HuffmanCode *SBSYMCODES;	3552 pGRD->GBAT[1] = -1;

2640 FX_DWORD IDI;	3553 if (pGRD->GBTEMPLATE == 0) {

2641 FX_INT32 RDXI, RDYI;	3554 pGRD->GBAT[2] = -3;

2642 FX_DWORD BMSIZE;	3555 pGRD->GBAT[3] = -1;

2643 FX_DWORD stride;	3556 pGRD->GBAT[4] = 2;

2644 CJBig2_Image **SBSYMS;	3557 pGRD->GBAT[5] = -2;

2645 CJBig2_HuffmanTable SBHUFFFS, SBHUFFDS, SBHUFFDT, SBHUFFRDW, SBHUFFRDH, SBHUFFRDX, *SBHUFFRDY,	3558 pGRD->GBAT[6] = -2;

2646 SBHUFFRSIZE, pTable;	3559 pGRD->GBAT[7] = -2;

2647 CJBig2_HuffmanDecoder *pHuffmanDecoder;	3560 }

2648 CJBig2_GRRDProc *pGRRD;	3561 FXCODEC_STATUS status =

2649 CJBig2_ArithDecoder *pArithDecoder;	3562 pGRD->Start_decode_Arith(&GSPLANES[GSBPP - 1], pArithDecoder, gbContext);

2650 CJBig2_GRDProc *pGRD;	3563 while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {

2651 CJBig2_SymbolDict *pDict;	3564 pGRD->Continue_decode(pPause);

2652 JBIG2_ALLOC(pHuffmanDecoder, CJBig2_HuffmanDecoder(pStream));	3565 }

2653 SDNEWSYMS = (CJBig2_Image*)m_pModule->JBig2_Malloc2(SDNUMNEWSYMS, sizeof(CJ Big2_Image));	3566 if (GSPLANES[GSBPP - 1] == NULL) {

2654 FXSYS_memset32(SDNEWSYMS, 0 , SDNUMNEWSYMS * sizeof(CJBig2_Image*));	3567 goto failed;

2655 SDNEWSYMWIDTHS = NULL;	3568 }

2656 BHC = NULL;	3569 J = GSBPP - 2;

2657 if(SDREFAGG == 0) {	3570 while (J >= 0) {

2658 SDNEWSYMWIDTHS = (FX_DWORD *)m_pModule->JBig2_Malloc2(SDNUMNEWSYMS, size of(FX_DWORD));	3571 FXCODEC_STATUS status =

2659 FXSYS_memset32(SDNEWSYMWIDTHS, 0 , SDNUMNEWSYMS * sizeof(FX_DWORD));	3572 pGRD->Start_decode_Arith(&GSPLANES[J], pArithDecoder, gbContext);

2660 }	3573 while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {

2661 HCHEIGHT = 0;	3574 pGRD->Continue_decode(pPause);

2662 NSYMSDECODED = 0;	3575 }

2663 BS = NULL;	3576 if (GSPLANES[J] == NULL) {

2664 while(NSYMSDECODED < SDNUMNEWSYMS) {	3577 for (K = GSBPP - 1; K > J; K--) {

2665 if(pHuffmanDecoder->decodeAValue(SDHUFFDH, &HCDH) != 0) {	3578 delete GSPLANES[K];

2666 m_pModule->JBig2_Error("symbol dictionary decoding procedure (huffma n): too short.");	3579 goto failed;

2667 goto failed;	3580 }

2668 }	3581 }

2669 HCHEIGHT = HCHEIGHT + HCDH;	3582 GSPLANES[J]->composeFrom(0, 0, GSPLANES[J + 1], JBIG2_COMPOSE_XOR);

2670 if ((int)HCHEIGHT < 0 \|\| (int)HCHEIGHT > JBIG2_MAX_IMAGE_SIZE) {	3583 J = J - 1;

2671 m_pModule->JBig2_Error("symbol dictionary decoding procedure (huffma n): invalid HCHEIGHT value.");	3584 }

2672 goto failed;	3585 for (y = 0; y < GSH; y++) {

2673 }	3586 for (x = 0; x < GSW; x++) {

2674 SYMWIDTH = 0;	3587 for (J = 0; J < GSBPP; J++) {

2675 TOTWIDTH = 0;	3588 GSVALS[y * GSW + x] \|= GSPLANES[J]->getPixel(x, y) << J;

2676 HCFIRSTSYM = NSYMSDECODED;	3589 }

2677 for(;;) {	3590 }

2678 nVal = pHuffmanDecoder->decodeAValue(SDHUFFDW, &DW);	3591 }

2679 if(nVal == JBIG2_OOB) {	3592 for (J = 0; J < GSBPP; J++) {

2680 break;	3593 delete GSPLANES[J];

2681 } else if(nVal != 0) {	3594 }

2682 m_pModule->JBig2_Error("symbol dictionary decoding procedure (hu ffman): too short.");	3595 m_pModule->JBig2_Free(GSPLANES);

2683 goto failed;	3596 delete pGRD;

2684 } else {	3597 return GSVALS;

2685 if (NSYMSDECODED >= SDNUMNEWSYMS) {

2686 m_pModule->JBig2_Error("symbol dictionary decoding procedure (huffman): NSYMSDECODED >= SDNUMNEWSYMS.");

2687 goto failed;

2688 }

2689 SYMWIDTH = SYMWIDTH + DW;

2690 if ((int)SYMWIDTH < 0 \|\| (int)SYMWIDTH > JBIG2_MAX_IMAGE_SIZE) {

2691 m_pModule->JBig2_Error("symbol dictionary decoding procedure (huffman): invalid SYMWIDTH value.");

2692 goto failed;

2693 } else if (HCHEIGHT == 0 \|\| SYMWIDTH == 0) {

2694 TOTWIDTH = TOTWIDTH + SYMWIDTH;

2695 SDNEWSYMS[NSYMSDECODED] = NULL;

2696 NSYMSDECODED = NSYMSDECODED + 1;

2697 continue;

2698 }

2699 TOTWIDTH = TOTWIDTH + SYMWIDTH;

2700 }

2701 if(SDREFAGG == 1) {

2702 if(pHuffmanDecoder->decodeAValue(SDHUFFAGGINST, (int*)&REFAGGNIN ST) != 0) {

2703 m_pModule->JBig2_Error("symbol dictionary decoding procedure (huffman): too short.");

2704 goto failed;

2705 }

2706 BS = NULL;

2707 if(REFAGGNINST > 1) {

2708 CJBig2_TRDProc *pDecoder;

2709 JBIG2_ALLOC(pDecoder, CJBig2_TRDProc());

2710 pDecoder->SBHUFF = SDHUFF;

2711 pDecoder->SBREFINE = 1;

2712 pDecoder->SBW = SYMWIDTH;

2713 pDecoder->SBH = HCHEIGHT;

2714 pDecoder->SBNUMINSTANCES = REFAGGNINST;

2715 pDecoder->SBSTRIPS = 1;

2716 pDecoder->SBNUMSYMS = SDNUMINSYMS + NSYMSDECODED;

2717 SBNUMSYMS = pDecoder->SBNUMSYMS;

2718 SBSYMCODES = (JBig2HuffmanCode*)m_pModule->JBig2_Malloc2(SBN UMSYMS, sizeof(JBig2HuffmanCode));

2719 nTmp = 1;

2720 while((FX_DWORD)(1 << nTmp) < SBNUMSYMS) {

2721 nTmp ++;

2722 }

2723 for(I = 0; I < SBNUMSYMS; I++) {

2724 SBSYMCODES[I].codelen = nTmp;

2725 SBSYMCODES[I].code = I;

2726 }

2727 pDecoder->SBSYMCODES = SBSYMCODES;

2728 SBSYMS = (CJBig2_Image*)m_pModule->JBig2_Malloc2(SBNUMSYMS, sizeof(CJBig2_Image));

2729 JBIG2_memcpy(SBSYMS, SDINSYMS, SDNUMINSYMS * sizeof(CJBig2_I mage*));

2730 JBIG2_memcpy(SBSYMS + SDNUMINSYMS, SDNEWSYMS, NSYMSDECODED * sizeof(CJBig2_Image*));

2731 pDecoder->SBSYMS = SBSYMS;

2732 pDecoder->SBDEFPIXEL = 0;

2733 pDecoder->SBCOMBOP = JBIG2_COMPOSE_OR;

2734 pDecoder->TRANSPOSED = 0;

2735 pDecoder->REFCORNER = JBIG2_CORNER_TOPLEFT;

2736 pDecoder->SBDSOFFSET = 0;

2737 JBIG2_ALLOC(SBHUFFFS, CJBig2_HuffmanTable(HuffmanTable_B6,

2738 sizeof(HuffmanTable_B6) / sizeof(JBig2TableLine) , HuffmanTable_HTOOB_B6));

2739 JBIG2_ALLOC(SBHUFFDS, CJBig2_HuffmanTable(HuffmanTable_B8,

2740 sizeof(HuffmanTable_B8) / sizeof(JBig2TableLine) , HuffmanTable_HTOOB_B8));

2741 JBIG2_ALLOC(SBHUFFDT, CJBig2_HuffmanTable(HuffmanTable_B11,

2742 sizeof(HuffmanTable_B11) / sizeof(JBig2TableLine ), HuffmanTable_HTOOB_B11));

2743 JBIG2_ALLOC(SBHUFFRDW, CJBig2_HuffmanTable(HuffmanTable_B15,

2744 sizeof(HuffmanTable_B15) / sizeof(JBig2TableLine ), HuffmanTable_HTOOB_B15));

2745 JBIG2_ALLOC(SBHUFFRDH, CJBig2_HuffmanTable(HuffmanTable_B15,

2746 sizeof(HuffmanTable_B15) / sizeof(JBig2TableLine ), HuffmanTable_HTOOB_B15));

2747 JBIG2_ALLOC(SBHUFFRDX, CJBig2_HuffmanTable(HuffmanTable_B15,

2748 sizeof(HuffmanTable_B15) / sizeof(JBig2TableLine ), HuffmanTable_HTOOB_B15));

2749 JBIG2_ALLOC(SBHUFFRDY, CJBig2_HuffmanTable(HuffmanTable_B15,

2750 sizeof(HuffmanTable_B15) / sizeof(JBig2TableLine ), HuffmanTable_HTOOB_B15));

2751 JBIG2_ALLOC(SBHUFFRSIZE, CJBig2_HuffmanTable(HuffmanTable_B1 ,

2752 sizeof(HuffmanTable_B1) / sizeof(JBig2TableLine) , HuffmanTable_HTOOB_B1));

2753 pDecoder->SBHUFFFS = SBHUFFFS;

2754 pDecoder->SBHUFFDS = SBHUFFDS;

2755 pDecoder->SBHUFFDT = SBHUFFDT;

2756 pDecoder->SBHUFFRDW = SBHUFFRDW;

2757 pDecoder->SBHUFFRDH = SBHUFFRDH;

2758 pDecoder->SBHUFFRDX = SBHUFFRDX;

2759 pDecoder->SBHUFFRDY = SBHUFFRDY;

2760 pDecoder->SBHUFFRSIZE = SBHUFFRSIZE;

2761 pDecoder->SBRTEMPLATE = SDRTEMPLATE;

2762 pDecoder->SBRAT[0] = SDRAT[0];

2763 pDecoder->SBRAT[1] = SDRAT[1];

2764 pDecoder->SBRAT[2] = SDRAT[2];

2765 pDecoder->SBRAT[3] = SDRAT[3];

2766 BS = pDecoder->decode_Huffman(pStream, grContext);

2767 if(BS == NULL) {

2768 m_pModule->JBig2_Free(SBSYMCODES);

2769 m_pModule->JBig2_Free(SBSYMS);

2770 delete SBHUFFFS;

2771 delete SBHUFFDS;

2772 delete SBHUFFDT;

2773 delete SBHUFFRDW;

2774 delete SBHUFFRDH;

2775 delete SBHUFFRDX;

2776 delete SBHUFFRDY;

2777 delete SBHUFFRSIZE;

2778 delete pDecoder;

2779 goto failed;

2780 }

2781 m_pModule->JBig2_Free(SBSYMCODES);

2782 m_pModule->JBig2_Free(SBSYMS);

2783 delete SBHUFFFS;

2784 delete SBHUFFDS;

2785 delete SBHUFFDT;

2786 delete SBHUFFRDW;

2787 delete SBHUFFRDH;

2788 delete SBHUFFRDX;

2789 delete SBHUFFRDY;

2790 delete SBHUFFRSIZE;

2791 delete pDecoder;

2792 } else if(REFAGGNINST == 1) {

2793 SBHUFF = SDHUFF;

2794 SBNUMSYMS = SDNUMINSYMS + SDNUMNEWSYMS;

2795 nTmp = 1;

2796 while((FX_DWORD)(1 << nTmp) < SBNUMSYMS) {

2797 nTmp ++;

2798 }

2799 SBSYMCODELEN = (FX_BYTE)nTmp;

2800 SBSYMCODES = (JBig2HuffmanCode*)m_pModule->JBig2_Malloc2(SBN UMSYMS, sizeof(JBig2HuffmanCode));

2801 for(I = 0; I < SBNUMSYMS; I++) {

2802 SBSYMCODES[I].codelen = SBSYMCODELEN;

2803 SBSYMCODES[I].code = I;

2804 }

2805 nVal = 0;

2806 nBits = 0;

2807 for(;;) {

2808 if(pStream->read1Bit(&nTmp) != 0) {

2809 m_pModule->JBig2_Free(SBSYMCODES);

2810 m_pModule->JBig2_Error("symbol dictionary decoding p rocedure (huffman): too short.");

2811 goto failed;

2812 }

2813 nVal = (nVal << 1) \| nTmp;

2814 for(IDI = 0; IDI < SBNUMSYMS; IDI++) {

2815 if((nVal == SBSYMCODES[IDI].code)

2816 && (nBits == SBSYMCODES[IDI].codelen)) {

2817 break;

2818 }

2819 }

2820 if(IDI < SBNUMSYMS) {

2821 break;

2822 }

2823 }

2824 m_pModule->JBig2_Free(SBSYMCODES);

2825 JBIG2_ALLOC(SBHUFFRDX, CJBig2_HuffmanTable(HuffmanTable_B15,

2826 sizeof(HuffmanTable_B15) / sizeof(JBig2TableLine ), HuffmanTable_HTOOB_B15));

2827 JBIG2_ALLOC(SBHUFFRSIZE, CJBig2_HuffmanTable(HuffmanTable_B1 ,

2828 sizeof(HuffmanTable_B1) / sizeof(JBig2TableLine) , HuffmanTable_HTOOB_B1));

2829 if((pHuffmanDecoder->decodeAValue(SBHUFFRDX, &RDXI) != 0)

2830 \|\| (pHuffmanDecoder->decodeAValue(SBHUFFRDX, &RDYI) != 0)

2831 \|\| (pHuffmanDecoder->decodeAValue(SBHUFFRSIZE, &nVal ) != 0)) {

2832 delete SBHUFFRDX;

2833 delete SBHUFFRSIZE;

2834 m_pModule->JBig2_Error("symbol dictionary decoding proce dure (huffman): too short.");

2835 goto failed;

2836 }

2837 delete SBHUFFRDX;

2838 delete SBHUFFRSIZE;

2839 pStream->alignByte();

2840 nTmp = pStream->getOffset();

2841 SBSYMS = (CJBig2_Image*)m_pModule->JBig2_Malloc2(SBNUMSYMS, sizeof(CJBig2_Image));

2842 JBIG2_memcpy(SBSYMS, SDINSYMS, SDNUMINSYMS * sizeof(CJBig2_I mage*));

2843 JBIG2_memcpy(SBSYMS + SDNUMINSYMS, SDNEWSYMS, NSYMSDECODED * sizeof(CJBig2_Image*));

2844 JBIG2_ALLOC(pGRRD, CJBig2_GRRDProc());

2845 pGRRD->GRW = SYMWIDTH;

2846 pGRRD->GRH = HCHEIGHT;

2847 pGRRD->GRTEMPLATE = SDRTEMPLATE;

2848 pGRRD->GRREFERENCE = SBSYMS[IDI];

2849 pGRRD->GRREFERENCEDX = RDXI;

2850 pGRRD->GRREFERENCEDY = RDYI;

2851 pGRRD->TPGRON = 0;

2852 pGRRD->GRAT[0] = SDRAT[0];

2853 pGRRD->GRAT[1] = SDRAT[1];

2854 pGRRD->GRAT[2] = SDRAT[2];

2855 pGRRD->GRAT[3] = SDRAT[3];

2856 JBIG2_ALLOC(pArithDecoder, CJBig2_ArithDecoder(pStream));

2857 BS = pGRRD->decode(pArithDecoder, grContext);

2858 if(BS == NULL) {

2859 m_pModule->JBig2_Free(SBSYMS);

2860 delete pGRRD;

2861 delete pArithDecoder;

2862 goto failed;

2863 }

2864 pStream->alignByte();

2865 pStream->offset(2);

2866 if((FX_DWORD)nVal != (pStream->getOffset() - nTmp)) {

2867 delete BS;

2868 m_pModule->JBig2_Free(SBSYMS);

2869 delete pGRRD;

2870 delete pArithDecoder;

2871 m_pModule->JBig2_Error("symbol dictionary decoding proce dure (huffman):"

2872 "bytes processed by generic refin ement region decoding procedure doesn't equal SBHUFFRSIZE.");

2873 goto failed;

2874 }

2875 m_pModule->JBig2_Free(SBSYMS);

2876 delete pGRRD;

2877 delete pArithDecoder;

2878 }

2879 SDNEWSYMS[NSYMSDECODED] = BS;

2880 }

2881 if(SDREFAGG == 0) {

2882 SDNEWSYMWIDTHS[NSYMSDECODED] = SYMWIDTH;

2883 }

2884 NSYMSDECODED = NSYMSDECODED + 1;

2885 }

2886 if(SDREFAGG == 0) {

2887 if(pHuffmanDecoder->decodeAValue(SDHUFFBMSIZE, (FX_INT32*)&BMSIZE) ! = 0) {

2888 m_pModule->JBig2_Error("symbol dictionary decoding procedure (hu ffman): too short.");

2889 goto failed;

2890 }

2891 pStream->alignByte();

2892 if(BMSIZE == 0) {

2893 stride = (TOTWIDTH + 7) >> 3;

2894 if(pStream->getByteLeft() >= stride * HCHEIGHT) {

2895 JBIG2_ALLOC(BHC, CJBig2_Image(TOTWIDTH, HCHEIGHT));

2896 for(I = 0; I < HCHEIGHT; I ++) {

2897 JBIG2_memcpy(BHC->m_pData + I * BHC->m_nStride, pStream- >getPointer(), stride);

2898 pStream->offset(stride);

2899 }

2900 } else {

2901 m_pModule->JBig2_Error("symbol dictionary decoding procedure (huffman): too short.");

2902 goto failed;

2903 }

2904 } else {

2905 JBIG2_ALLOC(pGRD, CJBig2_GRDProc());

2906 pGRD->MMR = 1;

2907 pGRD->GBW = TOTWIDTH;

2908 pGRD->GBH = HCHEIGHT;

2909 FXCODEC_STATUS status = pGRD->Start_decode_MMR(&BHC, pStream);

2910 while(status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {

2911 pGRD->Continue_decode(pPause);

2912 }

2913 delete pGRD;

2914 pStream->alignByte();

2915 }

2916 nTmp = 0;

2917 if (!BHC) {

2918 continue;

2919 }

2920 for(I = HCFIRSTSYM; I < NSYMSDECODED; I++) {

2921 SDNEWSYMS[I] = BHC->subImage(nTmp, 0, SDNEWSYMWIDTHS[I], HCHEIGH T);

2922 nTmp += SDNEWSYMWIDTHS[I];

2923 }

2924 delete BHC;

2925 BHC = NULL;

2926 }

2927 }

2928 EXINDEX = 0;

2929 CUREXFLAG = 0;

2930 JBIG2_ALLOC(pTable, CJBig2_HuffmanTable(HuffmanTable_B1,

2931 sizeof(HuffmanTable_B1) / sizeof(JBi g2TableLine), HuffmanTable_HTOOB_B1));

2932 EXFLAGS = (FX_BOOL*)m_pModule->JBig2_Malloc2(sizeof(FX_BOOL), (SDNUMINSYMS + SDNUMNEWSYMS));

2933 while(EXINDEX < SDNUMINSYMS + SDNUMNEWSYMS) {

2934 if(pHuffmanDecoder->decodeAValue(pTable, (int*)&EXRUNLENGTH) != 0) {

2935 delete pTable;

2936 m_pModule->JBig2_Free(EXFLAGS);

2937 m_pModule->JBig2_Error("symbol dictionary decoding procedure (huffma n): too short.");

2938 goto failed;

2939 }

2940 if (EXINDEX + EXRUNLENGTH > SDNUMINSYMS + SDNUMNEWSYMS) {

2941 delete pTable;

2942 m_pModule->JBig2_Free(EXFLAGS);

2943 m_pModule->JBig2_Error("symbol dictionary decoding procedure (arith) : Invalid EXRUNLENGTH value.");

2944 goto failed;

2945 }

2946 if(EXRUNLENGTH != 0) {

2947 for(I = EXINDEX; I < EXINDEX + EXRUNLENGTH; I++) {

2948 EXFLAGS[I] = CUREXFLAG;

2949 }

2950 }

2951 EXINDEX = EXINDEX + EXRUNLENGTH;

2952 CUREXFLAG = !CUREXFLAG;

2953 }

2954 delete pTable;

2955 JBIG2_ALLOC(pDict, CJBig2_SymbolDict());

2956 pDict->SDNUMEXSYMS = SDNUMEXSYMS;

2957 pDict->SDEXSYMS = (CJBig2_Image*)m_pModule->JBig2_Malloc2(sizeof(CJBig2_Ima ge), SDNUMEXSYMS);

2958 I = J = 0;

2959 for(I = 0; I < SDNUMINSYMS + SDNUMNEWSYMS; I++) {

2960 if(EXFLAGS[I] && J < SDNUMEXSYMS) {

2961 if(I < SDNUMINSYMS) {

2962 JBIG2_ALLOC(pDict->SDEXSYMS[J], CJBig2_Image(*SDINSYMS[I]));

2963 } else {

2964 pDict->SDEXSYMS[J] = SDNEWSYMS[I - SDNUMINSYMS];

2965 }

2966 J = J + 1;

2967 } else if (!EXFLAGS[I] && I >= SDNUMINSYMS) {

2968 delete SDNEWSYMS[I - SDNUMINSYMS];

2969 }

2970 }

2971 if (J < SDNUMEXSYMS) {

2972 pDict->SDNUMEXSYMS = J;

2973 }

2974 m_pModule->JBig2_Free(EXFLAGS);

2975 m_pModule->JBig2_Free(SDNEWSYMS);

2976 if(SDREFAGG == 0) {

2977 m_pModule->JBig2_Free(SDNEWSYMWIDTHS);

2978 }

2979 delete pHuffmanDecoder;

2980 return pDict;

2981 failed:	3598 failed:

2982 for(I = 0; I < NSYMSDECODED; I++) {	3599 m_pModule->JBig2_Free(GSPLANES);

2983 if (SDNEWSYMS[I]) {	3600 delete pGRD;

2984 delete SDNEWSYMS[I];	3601 m_pModule->JBig2_Free(GSVALS);

2985 }	3602 return NULL;

2986 }	3603 }

2987 m_pModule->JBig2_Free(SDNEWSYMS);	3604 FX_DWORD* CJBig2_GSIDProc::decode_MMR(CJBig2_BitStream* pStream,

2988 if(SDREFAGG == 0) {	3605 IFX_Pause* pPause) {

2989 m_pModule->JBig2_Free(SDNEWSYMWIDTHS);	3606 CJBig2_Image** GSPLANES;

2990 }	3607 FX_INT32 J, K;

2991 delete pHuffmanDecoder;	3608 FX_DWORD x, y;

	3609 FX_DWORD* GSVALS;

	3610 CJBig2_GRDProc* pGRD;

	3611 GSPLANES =

	3612 (CJBig2_Image*)m_pModule->JBig2_Malloc2(sizeof(CJBig2_Image), GSBPP);

	3613 if (!GSPLANES) {

2992 return NULL;	3614 return NULL;

2993 }	3615 }

2994 CJBig2_Image CJBig2_HTRDProc::decode_Arith(CJBig2_ArithDecoder pArithDecoder,	3616 GSVALS = (FX_DWORD*)m_pModule->JBig2_Malloc3(sizeof(FX_DWORD), GSW, GSH);

2995 JBig2ArithCtx gbContext, IFX_Pause pPause)	3617 if (!GSVALS) {

2996 {	3618 if (GSPLANES) {

2997 FX_DWORD ng, mg;	3619 m_pModule->JBig2_Free(GSPLANES);

2998 FX_INT32 x, y;	3620 }

2999 CJBig2_Image *HSKIP;	3621 return NULL;

3000 FX_DWORD HBPP;	3622 }

3001 FX_DWORD *GI;	3623 JBIG2_memset(GSPLANES, 0, sizeof(CJBig2_Image) GSBPP);

3002 CJBig2_Image *HTREG;	3624 JBIG2_memset(GSVALS, 0, sizeof(FX_DWORD) * GSW * GSH);

3003 CJBig2_GSIDProc *pGID;	3625 JBIG2_ALLOC(pGRD, CJBig2_GRDProc());

3004 JBIG2_ALLOC(HTREG, CJBig2_Image(HBW, HBH));	3626 pGRD->MMR = GSMMR;

3005 HTREG->fill(HDEFPIXEL);	3627 pGRD->GBW = GSW;

3006 HSKIP = NULL;	3628 pGRD->GBH = GSH;

3007 if(HENABLESKIP == 1) {	3629 FXCODEC_STATUS status = pGRD->Start_decode_MMR(&GSPLANES[GSBPP - 1], pStream);

3008 JBIG2_ALLOC(HSKIP, CJBig2_Image(HGW, HGH));	3630 while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {

3009 for(mg = 0; mg < HGH; mg++) {	3631 pGRD->Continue_decode(pPause);

3010 for(ng = 0; ng < HGW; ng++) {	3632 }

3011 x = (HGX + mg * HRY + ng * HRX) >> 8;	3633 if (GSPLANES[GSBPP - 1] == NULL) {

3012 y = (HGY + mg * HRX - ng * HRY) >> 8;	3634 goto failed;

3013 if((x + HPW <= 0) \| (x >= (FX_INT32)HBW)	3635 }

3014 \| (y + HPH <= 0) \| (y >= (FX_INT32)HPH)) {	3636 pStream->alignByte();

3015 HSKIP->setPixel(ng, mg, 1);	3637 pStream->offset(3);

3016 } else {	3638 J = GSBPP - 2;

3017 HSKIP->setPixel(ng, mg, 0);	3639 while (J >= 0) {

3018 }	3640 FXCODEC_STATUS status = pGRD->Start_decode_MMR(&GSPLANES[J], pStream);

3019 }	3641 while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {

3020 }	3642 pGRD->Continue_decode(pPause);

3021 }	3643 }

3022 HBPP = 1;	3644 if (GSPLANES[J] == NULL) {

3023 while((FX_DWORD)(1 << HBPP) < HNUMPATS) {	3645 for (K = GSBPP - 1; K > J; K--) {

3024 HBPP ++;	3646 delete GSPLANES[K];

3025 }

3026 JBIG2_ALLOC(pGID, CJBig2_GSIDProc());

3027 pGID->GSMMR = HMMR;

3028 pGID->GSW = HGW;

3029 pGID->GSH = HGH;

3030 pGID->GSBPP = (FX_BYTE)HBPP;

3031 pGID->GSUSESKIP = HENABLESKIP;

3032 pGID->GSKIP = HSKIP;

3033 pGID->GSTEMPLATE = HTEMPLATE;

3034 GI = pGID->decode_Arith(pArithDecoder, gbContext, pPause);

3035 if(GI == NULL) {

3036 goto failed;	3647 goto failed;

3037 }	3648 }

3038 for(mg = 0; mg < HGH; mg++) {

3039 for(ng = 0; ng < HGW; ng++) {

3040 x = (HGX + mg * HRY + ng * HRX) >> 8;

3041 y = (HGY + mg * HRX - ng * HRY) >> 8;

3042 FX_DWORD pat_index = GI[mg * HGW + ng];

3043 if (pat_index >= HNUMPATS) {

3044 pat_index = HNUMPATS - 1;

3045 }

3046 HTREG->composeFrom(x, y, HPATS[pat_index], HCOMBOP);

3047 }

3048 }

3049 m_pModule->JBig2_Free(GI);

3050 if(HSKIP) {

3051 delete HSKIP;

3052 }

3053 delete pGID;

3054 return HTREG;

3055 failed:

3056 if(HSKIP) {

3057 delete HSKIP;

3058 }

3059 delete pGID;

3060 delete HTREG;

3061 return NULL;

3062 }

3063 CJBig2_Image CJBig2_HTRDProc::decode_MMR(CJBig2_BitStream pStream, IFX_Pause* pPause)

3064 {

3065 FX_DWORD ng, mg;

3066 FX_INT32 x, y;

3067 FX_DWORD HBPP;

3068 FX_DWORD *GI;

3069 CJBig2_Image *HTREG;

3070 CJBig2_GSIDProc *pGID;

3071 JBIG2_ALLOC(HTREG, CJBig2_Image(HBW, HBH));

3072 HTREG->fill(HDEFPIXEL);

3073 HBPP = 1;

3074 while((FX_DWORD)(1 << HBPP) < HNUMPATS) {

3075 HBPP ++;

3076 }

3077 JBIG2_ALLOC(pGID, CJBig2_GSIDProc());

3078 pGID->GSMMR = HMMR;

3079 pGID->GSW = HGW;

3080 pGID->GSH = HGH;

3081 pGID->GSBPP = (FX_BYTE)HBPP;

3082 pGID->GSUSESKIP = 0;

3083 GI = pGID->decode_MMR(pStream, pPause);

3084 if(GI == NULL) {

3085 goto failed;

3086 }

3087 for(mg = 0; mg < HGH; mg++) {

3088 for(ng = 0; ng < HGW; ng++) {

3089 x = (HGX + mg * HRY + ng * HRX) >> 8;

3090 y = (HGY + mg * HRX - ng * HRY) >> 8;

3091 FX_DWORD pat_index = GI[mg * HGW + ng];

3092 if (pat_index >= HNUMPATS) {

3093 pat_index = HNUMPATS - 1;

3094 }

3095 HTREG->composeFrom(x, y, HPATS[pat_index], HCOMBOP);

3096 }

3097 }

3098 m_pModule->JBig2_Free(GI);

3099 delete pGID;

3100 return HTREG;

3101 failed:

3102 delete pGID;

3103 delete HTREG;

3104 return NULL;

3105 }

3106 CJBig2_PatternDict CJBig2_PDDProc::decode_Arith(CJBig2_ArithDecoder pArithDeco der,

3107 JBig2ArithCtx gbContext, IFX_Pause pPause)

3108 {

3109 FX_DWORD GRAY;

3110 CJBig2_Image *BHDC = NULL;

3111 CJBig2_PatternDict *pDict;

3112 CJBig2_GRDProc *pGRD;

3113 JBIG2_ALLOC(pDict, CJBig2_PatternDict());

3114 pDict->NUMPATS = GRAYMAX + 1;

3115 pDict->HDPATS = (CJBig2_Image*)m_pModule->JBig2_Malloc2(sizeof(CJBig2_Image ), pDict->NUMPATS);

3116 JBIG2_memset(pDict->HDPATS, 0, sizeof(CJBig2_Image)pDict->NUMPATS);

3117 JBIG2_ALLOC(pGRD, CJBig2_GRDProc());

3118 pGRD->MMR = HDMMR;

3119 pGRD->GBW = (GRAYMAX + 1) * HDPW;

3120 pGRD->GBH = HDPH;

3121 pGRD->GBTEMPLATE = HDTEMPLATE;

3122 pGRD->TPGDON = 0;

3123 pGRD->USESKIP = 0;

3124 pGRD->GBAT[0] = -(FX_INT32)HDPW;

3125 pGRD->GBAT[1] = 0;

3126 if(pGRD->GBTEMPLATE == 0) {

3127 pGRD->GBAT[2] = -3;

3128 pGRD->GBAT[3] = -1;

3129 pGRD->GBAT[4] = 2;

3130 pGRD->GBAT[5] = -2;

3131 pGRD->GBAT[6] = -2;

3132 pGRD->GBAT[7] = -2;

3133 }

3134 FXCODEC_STATUS status = pGRD->Start_decode_Arith(&BHDC, pArithDecoder, gbCon text);

3135 while(status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {

3136 pGRD->Continue_decode(pPause);

3137 }

3138 if(BHDC == NULL) {

3139 delete pGRD;

3140 goto failed;

3141 }

3142 delete pGRD;

3143 GRAY = 0;

3144 while(GRAY <= GRAYMAX) {

3145 pDict->HDPATS[GRAY] = BHDC->subImage(HDPW * GRAY, 0, HDPW, HDPH);

3146 GRAY = GRAY + 1;

3147 }

3148 delete BHDC;

3149 return pDict;

3150 failed:

3151 delete pDict;

3152 return NULL;

3153 }

3154

3155 CJBig2_PatternDict CJBig2_PDDProc::decode_MMR(CJBig2_BitStream pStream, IFX_Pa use* pPause)

3156 {

3157 FX_DWORD GRAY;

3158 CJBig2_Image *BHDC = NULL;

3159 CJBig2_PatternDict *pDict;

3160 CJBig2_GRDProc *pGRD;

3161 JBIG2_ALLOC(pDict, CJBig2_PatternDict());

3162 pDict->NUMPATS = GRAYMAX + 1;

3163 pDict->HDPATS = (CJBig2_Image*)m_pModule->JBig2_Malloc2(sizeof(CJBig2_Image ), pDict->NUMPATS);

3164 JBIG2_memset(pDict->HDPATS, 0, sizeof(CJBig2_Image)pDict->NUMPATS);

3165 JBIG2_ALLOC(pGRD, CJBig2_GRDProc());

3166 pGRD->MMR = HDMMR;

3167 pGRD->GBW = (GRAYMAX + 1) * HDPW;

3168 pGRD->GBH = HDPH;

3169 FXCODEC_STATUS status = pGRD->Start_decode_MMR(&BHDC, pStream);

3170 while(status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {

3171 pGRD->Continue_decode(pPause);

3172 }

3173 if(BHDC == NULL) {

3174 delete pGRD;

3175 goto failed;

3176 }

3177 delete pGRD;

3178 GRAY = 0;

3179 while(GRAY <= GRAYMAX) {

3180 pDict->HDPATS[GRAY] = BHDC->subImage(HDPW * GRAY, 0, HDPW, HDPH);

3181 GRAY = GRAY + 1;

3182 }

3183 delete BHDC;

3184 return pDict;

3185 failed:

3186 delete pDict;

3187 return NULL;

3188 }

3189 FX_DWORD CJBig2_GSIDProc::decode_Arith(CJBig2_ArithDecoder pArithDecoder,

3190 JBig2ArithCtx gbContext, IFX_Pause pPa use)

3191 {

3192 CJBig2_Image **GSPLANES;

3193 FX_INT32 J, K;

3194 FX_DWORD x, y;

3195 FX_DWORD *GSVALS;

3196 CJBig2_GRDProc *pGRD;

3197 GSPLANES = (CJBig2_Image *)m_pModule->JBig2_Malloc2(sizeof(CJBig2_Image), GSBPP);

3198 if (!GSPLANES) {

3199 return NULL;

3200 }

3201 GSVALS = (FX_DWORD*)m_pModule->JBig2_Malloc3(sizeof(FX_DWORD), GSW, GSH);

3202 if (!GSVALS) {

3203 m_pModule->JBig2_Free(GSPLANES);

3204 return NULL;

3205 }

3206 JBIG2_memset(GSPLANES, 0, sizeof(CJBig2_Image)GSBPP);

3207 JBIG2_memset(GSVALS, 0, sizeof(FX_DWORD)GSW GSH);

3208 JBIG2_ALLOC(pGRD, CJBig2_GRDProc());

3209 pGRD->MMR = GSMMR;

3210 pGRD->GBW = GSW;

3211 pGRD->GBH = GSH;

3212 pGRD->GBTEMPLATE = GSTEMPLATE;

3213 pGRD->TPGDON = 0;

3214 pGRD->USESKIP = GSUSESKIP;

3215 pGRD->SKIP = GSKIP;

3216 if(GSTEMPLATE <= 1) {

3217 pGRD->GBAT[0] = 3;

3218 } else {

3219 pGRD->GBAT[0] = 2;

3220 }

3221 pGRD->GBAT[1] = -1;

3222 if(pGRD->GBTEMPLATE == 0) {

3223 pGRD->GBAT[2] = -3;

3224 pGRD->GBAT[3] = -1;

3225 pGRD->GBAT[4] = 2;

3226 pGRD->GBAT[5] = -2;

3227 pGRD->GBAT[6] = -2;

3228 pGRD->GBAT[7] = -2;

3229 }

3230 FXCODEC_STATUS status = pGRD->Start_decode_Arith(&GSPLANES[GSBPP - 1], pArit hDecoder, gbContext);

3231 while(status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {

3232 pGRD->Continue_decode(pPause);

3233 }

3234 if(GSPLANES[GSBPP - 1] == NULL) {

3235 goto failed;

3236 }

3237 J = GSBPP - 2;

3238 while(J >= 0) {

3239 FXCODEC_STATUS status = pGRD->Start_decode_Arith(&GSPLANES[J], pArithDec oder, gbContext);

3240 while(status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {

3241 pGRD->Continue_decode(pPause);

3242 }

3243 if(GSPLANES[J] == NULL) {

3244 for(K = GSBPP - 1; K > J; K--) {

3245 delete GSPLANES[K];

3246 goto failed;

3247 }

3248 }

3249 GSPLANES[J]->composeFrom(0, 0, GSPLANES[J + 1], JBIG2_COMPOSE_XOR);

3250 J = J - 1;

3251 }

3252 for(y = 0; y < GSH; y++) {

3253 for(x = 0; x < GSW; x++) {

3254 for(J = 0; J < GSBPP; J++) {

3255 GSVALS[y * GSW + x] \|= GSPLANES[J]->getPixel(x, y) << J;

3256 }

3257 }

3258 }

3259 for(J = 0; J < GSBPP; J++) {

3260 delete GSPLANES[J];

3261 }

3262 m_pModule->JBig2_Free(GSPLANES);

3263 delete pGRD;

3264 return GSVALS;

3265 failed:

3266 m_pModule->JBig2_Free(GSPLANES);

3267 delete pGRD;

3268 m_pModule->JBig2_Free(GSVALS);

3269 return NULL;

3270 }

3271 FX_DWORD CJBig2_GSIDProc::decode_MMR(CJBig2_BitStream pStream, IFX_Pause* pPau se)

3272 {

3273 CJBig2_Image **GSPLANES;

3274 FX_INT32 J, K;

3275 FX_DWORD x, y;

3276 FX_DWORD *GSVALS;

3277 CJBig2_GRDProc *pGRD;

3278 GSPLANES = (CJBig2_Image *)m_pModule->JBig2_Malloc2(sizeof(CJBig2_Image), GSBPP);

3279 if (!GSPLANES) {

3280 return NULL;

3281 }

3282 GSVALS = (FX_DWORD*)m_pModule->JBig2_Malloc3(sizeof(FX_DWORD), GSW, GSH);

3283 if (!GSVALS) {

3284 if (GSPLANES) {

3285 m_pModule->JBig2_Free(GSPLANES);

3286 }

3287 return NULL;

3288 }

3289 JBIG2_memset(GSPLANES, 0, sizeof(CJBig2_Image)GSBPP);

3290 JBIG2_memset(GSVALS, 0, sizeof(FX_DWORD)GSW GSH);

3291 JBIG2_ALLOC(pGRD, CJBig2_GRDProc());

3292 pGRD->MMR = GSMMR;

3293 pGRD->GBW = GSW;

3294 pGRD->GBH = GSH;

3295 FXCODEC_STATUS status = pGRD->Start_decode_MMR(&GSPLANES[GSBPP - 1], pStream );

3296 while(status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {

3297 pGRD->Continue_decode(pPause);

3298 }

3299 if(GSPLANES[GSBPP - 1] == NULL) {

3300 goto failed;

3301 }	3649 }

3302 pStream->alignByte();	3650 pStream->alignByte();

3303 pStream->offset(3);	3651 pStream->offset(3);

3304 J = GSBPP - 2;	3652 GSPLANES[J]->composeFrom(0, 0, GSPLANES[J + 1], JBIG2_COMPOSE_XOR);

3305 while(J >= 0) {	3653 J = J - 1;

3306 FXCODEC_STATUS status = pGRD->Start_decode_MMR(&GSPLANES[J], pStream);	3654 }

3307 while(status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {	3655 for (y = 0; y < GSH; y++) {

3308 pGRD->Continue_decode(pPause);	3656 for (x = 0; x < GSW; x++) {

3309 }	3657 for (J = 0; J < GSBPP; J++) {

3310 if(GSPLANES[J] == NULL) {	3658 GSVALS[y * GSW + x] \|= GSPLANES[J]->getPixel(x, y) << J;

3311 for(K = GSBPP - 1; K > J; K--) {	3659 }

3312 delete GSPLANES[K];	3660 }

3313 goto failed;	3661 }

3314 }	3662 for (J = 0; J < GSBPP; J++) {

3315 }	3663 delete GSPLANES[J];

3316 pStream->alignByte();	3664 }

3317 pStream->offset(3);	3665 m_pModule->JBig2_Free(GSPLANES);

3318 GSPLANES[J]->composeFrom(0, 0, GSPLANES[J + 1], JBIG2_COMPOSE_XOR);	3666 delete pGRD;

3319 J = J - 1;	3667 return GSVALS;

3320 }

3321 for(y = 0; y < GSH; y++) {

3322 for(x = 0; x < GSW; x++) {

3323 for(J = 0; J < GSBPP; J++) {

3324 GSVALS[y * GSW + x] \|= GSPLANES[J]->getPixel(x, y) << J;

3325 }

3326 }

3327 }

3328 for(J = 0; J < GSBPP; J++) {

3329 delete GSPLANES[J];

3330 }

3331 m_pModule->JBig2_Free(GSPLANES);

3332 delete pGRD;

3333 return GSVALS;

3334 failed:	3668 failed:

3335 m_pModule->JBig2_Free(GSPLANES);	3669 m_pModule->JBig2_Free(GSPLANES);

3336 delete pGRD;	3670 delete pGRD;

3337 m_pModule->JBig2_Free(GSVALS);	3671 m_pModule->JBig2_Free(GSVALS);

3338 return NULL;	3672 return NULL;

3339 }	3673 }

3340 FXCODEC_STATUS CJBig2_GRDProc::Start_decode_Arith(CJBig2_Image** pImage, CJBig2_ ArithDecoder pArithDecoder, JBig2ArithCtx gbContext, IFX_Pause* pPause)	3674 FXCODEC_STATUS CJBig2_GRDProc::Start_decode_Arith(

3341 {	3675 CJBig2_Image** pImage,

3342 if (GBW == 0 \|\| GBH == 0) {	3676 CJBig2_ArithDecoder* pArithDecoder,

3343 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;	3677 JBig2ArithCtx* gbContext,

3344 return FXCODEC_STATUS_DECODE_FINISH;	3678 IFX_Pause* pPause) {

3345 }	3679 if (GBW == 0 \|\| GBH == 0) {

3346 m_ProssiveStatus = FXCODEC_STATUS_DECODE_READY;

3347 m_pPause = pPause;

3348 if(*pImage == NULL) {

3349 JBIG2_ALLOC((*pImage), CJBig2_Image(GBW, GBH));

3350 }

3351 if ((*pImage)->m_pData == NULL) {

3352 delete *pImage;

3353 *pImage = NULL;

3354 m_pModule->JBig2_Error("Generic region decoding procedure: Create Image Failed with width = %d, height = %d\n", GBW, GBH);

3355 m_ProssiveStatus = FXCODEC_STATUS_ERROR;

3356 return FXCODEC_STATUS_ERROR;

3357 }

3358 m_DecodeType = 1;

3359 m_pImage = pImage;

3360 (*m_pImage)->fill(0);

3361 m_pArithDecoder = pArithDecoder;

3362 m_gbContext = gbContext;

3363 LTP = 0;

3364 m_pLine = NULL;

3365 m_loopIndex = 0;

3366 return decode_Arith(pPause);

3367 }

3368 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith(IFX_Pause* pPause)

3369 {

3370 int iline = m_loopIndex;

3371 CJBig2_Image* pImage = *m_pImage;

3372 if(GBTEMPLATE == 0) {

3373 if((GBAT[0] == 3) && (GBAT[1] == (signed char) - 1)

3374 && (GBAT[2] == (signed char) - 3) && (GBAT[3] == (signed char) - 1)

3375 && (GBAT[4] == 2) && (GBAT[5] == (signed char) - 2)

3376 && (GBAT[6] == (signed char) - 2) && (GBAT[7] == (signed char) - 2)) {

3377 m_ProssiveStatus = decode_Arith_Template0_opt3(pImage, m_pArithDecod er, m_gbContext, pPause);

3378 } else {

3379 m_ProssiveStatus = decode_Arith_Template0_unopt(pImage, m_pArithDeco der, m_gbContext, pPause);

3380 }

3381 } else if(GBTEMPLATE == 1) {

3382 if((GBAT[0] == 3) && (GBAT[1] == (signed char) - 1)) {

3383 m_ProssiveStatus = decode_Arith_Template1_opt3(pImage, m_pArithDecod er, m_gbContext, pPause);

3384 } else {

3385 m_ProssiveStatus = decode_Arith_Template1_unopt(pImage, m_pArithDeco der, m_gbContext, pPause);

3386 }

3387 } else if(GBTEMPLATE == 2) {

3388 if((GBAT[0] == 2) && (GBAT[1] == (signed char) - 1)) {

3389 m_ProssiveStatus = decode_Arith_Template2_opt3(pImage, m_pArithDeco der, m_gbContext, pPause);

3390 } else {

3391 m_ProssiveStatus = decode_Arith_Template2_unopt(pImage, m_pArithDec oder, m_gbContext, pPause);

3392 }

3393 } else {

3394 if((GBAT[0] == 2) && (GBAT[1] == (signed char) - 1)) {

3395 m_ProssiveStatus = decode_Arith_Template3_opt3(pImage, m_pArithDecod er, m_gbContext, pPause);

3396 } else {

3397 m_ProssiveStatus = decode_Arith_Template3_unopt(pImage, m_pArithDeco der, m_gbContext, pPause);

3398 }

3399 }

3400 m_ReplaceRect.left = 0;

3401 m_ReplaceRect.right = pImage->m_nWidth;

3402 m_ReplaceRect.top = iline;

3403 m_ReplaceRect.bottom = m_loopIndex;

3404 if(m_ProssiveStatus == FXCODEC_STATUS_DECODE_FINISH) {

3405 m_loopIndex = 0;

3406 }

3407 return m_ProssiveStatus;

3408 }

3409 FXCODEC_STATUS CJBig2_GRDProc::Start_decode_Arith_V2(CJBig2_Image** pImage, CJBi g2_ArithDecoder pArithDecoder, JBig2ArithCtx gbContext, IFX_Pause* pPause)

3410 {

3411 if(GBW == 0 \|\| GBH == 0) {

3412 * pImage = NULL;

3413 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;

3414 return FXCODEC_STATUS_DECODE_FINISH;

3415 }

3416 if(*pImage == NULL) {

3417 JBIG2_ALLOC((*pImage), CJBig2_Image(GBW, GBH));

3418 }

3419 if ((*pImage)->m_pData == NULL) {

3420 delete *pImage;

3421 *pImage = NULL;

3422 m_pModule->JBig2_Error("Generic region decoding procedure: Create Image Failed with width = %d, height = %d\n", GBW, GBH);

3423 m_ProssiveStatus = FXCODEC_STATUS_ERROR;

3424 return FXCODEC_STATUS_ERROR;

3425 }

3426 m_ProssiveStatus = FXCODEC_STATUS_DECODE_READY;

3427 m_DecodeType = 2;

3428 m_pPause = pPause;

3429 m_pImage = pImage;

3430 (*m_pImage)->fill(0);

3431 LTP = 0;

3432 m_loopIndex = 0;

3433 m_pArithDecoder = pArithDecoder;

3434 m_gbContext = gbContext;

3435 return decode_Arith_V2(pPause);

3436 }

3437 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_V2(IFX_Pause* pPause)

3438 {

3439 FX_BOOL SLTP, bVal;

3440 FX_DWORD CONTEXT;

3441 CJBig2_Image GBREG = m_pImage;

3442 FX_DWORD line1, line2, line3;

3443 LTP = 0;

3444 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));

3445 GBREG->fill(0);

3446 for(; m_loopIndex < GBH; m_loopIndex++) {

3447 if(TPGDON) {

3448 switch(GBTEMPLATE) {

3449 case 0:

3450 CONTEXT = 0x9b25;

3451 break;

3452 case 1:

3453 CONTEXT = 0x0795;

3454 break;

3455 case 2:

3456 CONTEXT = 0x00e5;

3457 break;

3458 case 3:

3459 CONTEXT = 0x0195;

3460 break;

3461 }

3462 SLTP = m_pArithDecoder->DECODE(&m_gbContext[CONTEXT]);

3463 LTP = LTP ^ SLTP;

3464 }

3465 if(LTP == 1) {

3466 GBREG->copyLine(m_loopIndex, m_loopIndex - 1);

3467 } else {

3468 switch(GBTEMPLATE) {

3469 case 0: {

3470 line1 = GBREG->getPixel(1, m_loopIndex - 2);

3471 line1 \|= GBREG->getPixel(0, m_loopIndex - 2) << 1;

3472 line2 = GBREG->getPixel(2, m_loopIndex - 1);

3473 line2 \|= GBREG->getPixel(1, m_loopIndex - 1) << 1;

3474 line2 \|= GBREG->getPixel(0, m_loopIndex - 1) << 2;

3475 line3 = 0;

3476 for(FX_DWORD w = 0; w < GBW; w++) {

3477 if(USESKIP && SKIP->getPixel(w, m_loopIndex)) {

3478 bVal = 0;

3479 } else {

3480 CONTEXT = line3;

3481 CONTEXT \|= GBREG->getPixel(w + GBAT[0], m_loopIn dex + GBAT[1]) << 4;

3482 CONTEXT \|= line2 << 5;

3483 CONTEXT \|= GBREG->getPixel(w + GBAT[2], m_loopIn dex + GBAT[3]) << 10;

3484 CONTEXT \|= GBREG->getPixel(w + GBAT[4], m_loopIn dex + GBAT[5]) << 11;

3485 CONTEXT \|= line1 << 12;

3486 CONTEXT \|= GBREG->getPixel(w + GBAT[6], m_loopIn dex + GBAT[7]) << 15;

3487 bVal = m_pArithDecoder->DECODE(&m_gbContext[CONT EXT]);

3488 }

3489 if(bVal) {

3490 GBREG->setPixel(w, m_loopIndex, bVal);

3491 }

3492 line1 = ((line1 << 1) \| GBREG->getPixel(w + 2, m_loo pIndex - 2)) & 0x07;

3493 line2 = ((line2 << 1) \| GBREG->getPixel(w + 3, m_loo pIndex - 1)) & 0x1f;

3494 line3 = ((line3 << 1) \| bVal) & 0x0f;

3495 }

3496 }

3497 break;

3498 case 1: {

3499 line1 = GBREG->getPixel(2, m_loopIndex - 2);

3500 line1 \|= GBREG->getPixel(1, m_loopIndex - 2) << 1;

3501 line1 \|= GBREG->getPixel(0, m_loopIndex - 2) << 2;

3502 line2 = GBREG->getPixel(2, m_loopIndex - 1);

3503 line2 \|= GBREG->getPixel(1, m_loopIndex - 1) << 1;

3504 line2 \|= GBREG->getPixel(0, m_loopIndex - 1) << 2;

3505 line3 = 0;

3506 for(FX_DWORD w = 0; w < GBW; w++) {

3507 if(USESKIP && SKIP->getPixel(w, m_loopIndex)) {

3508 bVal = 0;

3509 } else {

3510 CONTEXT = line3;

3511 CONTEXT \|= GBREG->getPixel(w + GBAT[0], m_loopIn dex + GBAT[1]) << 3;

3512 CONTEXT \|= line2 << 4;

3513 CONTEXT \|= line1 << 9;

3514 bVal = m_pArithDecoder->DECODE(&m_gbContext[CONT EXT]);

3515 }

3516 if(bVal) {

3517 GBREG->setPixel(w, m_loopIndex, bVal);

3518 }

3519 line1 = ((line1 << 1) \| GBREG->getPixel(w + 3, m_loo pIndex - 2)) & 0x0f;

3520 line2 = ((line2 << 1) \| GBREG->getPixel(w + 3, m_loo pIndex - 1)) & 0x1f;

3521 line3 = ((line3 << 1) \| bVal) & 0x07;

3522 }

3523 }

3524 break;

3525 case 2: {

3526 line1 = GBREG->getPixel(1, m_loopIndex - 2);

3527 line1 \|= GBREG->getPixel(0, m_loopIndex - 2) << 1;

3528 line2 = GBREG->getPixel(1, m_loopIndex - 1);

3529 line2 \|= GBREG->getPixel(0, m_loopIndex - 1) << 1;

3530 line3 = 0;

3531 for(FX_DWORD w = 0; w < GBW; w++) {

3532 if(USESKIP && SKIP->getPixel(w, m_loopIndex)) {

3533 bVal = 0;

3534 } else {

3535 CONTEXT = line3;

3536 CONTEXT \|= GBREG->getPixel(w + GBAT[0], m_loopIn dex + GBAT[1]) << 2;

3537 CONTEXT \|= line2 << 3;

3538 CONTEXT \|= line1 << 7;

3539 bVal = m_pArithDecoder->DECODE(&m_gbContext[CONT EXT]);

3540 }

3541 if(bVal) {

3542 GBREG->setPixel(w, m_loopIndex, bVal);

3543 }

3544 line1 = ((line1 << 1) \| GBREG->getPixel(w + 2, m_loo pIndex - 2)) & 0x07;

3545 line2 = ((line2 << 1) \| GBREG->getPixel(w + 2, m_loo pIndex - 1)) & 0x0f;

3546 line3 = ((line3 << 1) \| bVal) & 0x03;

3547 }

3548 }

3549 break;

3550 case 3: {

3551 line1 = GBREG->getPixel(1, m_loopIndex - 1);

3552 line1 \|= GBREG->getPixel(0, m_loopIndex - 1) << 1;

3553 line2 = 0;

3554 for(FX_DWORD w = 0; w < GBW; w++) {

3555 if(USESKIP && SKIP->getPixel(w, m_loopIndex)) {

3556 bVal = 0;

3557 } else {

3558 CONTEXT = line2;

3559 CONTEXT \|= GBREG->getPixel(w + GBAT[0], m_loopIn dex + GBAT[1]) << 4;

3560 CONTEXT \|= line1 << 5;

3561 bVal = m_pArithDecoder->DECODE(&m_gbContext[CONT EXT]);

3562 }

3563 if(bVal) {

3564 GBREG->setPixel(w, m_loopIndex, bVal);

3565 }

3566 line1 = ((line1 << 1) \| GBREG->getPixel(w + 2, m_loo pIndex - 1)) & 0x1f;

3567 line2 = ((line2 << 1) \| bVal) & 0x0f;

3568 }

3569 }

3570 break;

3571 }

3572 }

3573 if(pPause && pPause->NeedToPauseNow()) {

3574 m_loopIndex ++;

3575 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;

3576 return FXCODEC_STATUS_DECODE_TOBECONTINUE;

3577 }

3578 }

3579 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;	3680 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;

3580 return FXCODEC_STATUS_DECODE_FINISH;	3681 return FXCODEC_STATUS_DECODE_FINISH;

3581 }	3682 }

3582 FXCODEC_STATUS CJBig2_GRDProc::Start_decode_Arith_V1(CJBig2_Image** pImage, CJBi g2_ArithDecoder pArithDecoder, JBig2ArithCtx gbContext, IFX_Pause* pPause)	3683 m_ProssiveStatus = FXCODEC_STATUS_DECODE_READY;

3583 {	3684 m_pPause = pPause;

3584 if(GBW == 0 \|\| GBH == 0) {	3685 if (*pImage == NULL) {

3585 * pImage = NULL;	3686 JBIG2_ALLOC((*pImage), CJBig2_Image(GBW, GBH));

3586 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;	3687 }

3587 return FXCODEC_STATUS_DECODE_FINISH;	3688 if ((*pImage)->m_pData == NULL) {

3588 }	3689 delete *pImage;

3589 if(*pImage == NULL) {	3690 *pImage = NULL;

3590 JBIG2_ALLOC((*pImage), CJBig2_Image(GBW, GBH));	3691 m_pModule->JBig2_Error(

3591 }	3692 "Generic region decoding procedure: Create Image Failed with width = "

3592 if ((*pImage)->m_pData == NULL) {	3693 "%d, height = %d\n",

3593 delete *pImage;	3694 GBW,

3594 *pImage = NULL;	3695 GBH);

3595 m_pModule->JBig2_Error("Generic region decoding procedure: Create Image Failed with width = %d, height = %d\n", GBW, GBH);	3696 m_ProssiveStatus = FXCODEC_STATUS_ERROR;

3596 m_ProssiveStatus = FXCODEC_STATUS_ERROR;	3697 return FXCODEC_STATUS_ERROR;

3597 return FXCODEC_STATUS_ERROR;	3698 }

3598 }	3699 m_DecodeType = 1;

3599 m_ProssiveStatus = FXCODEC_STATUS_DECODE_READY;	3700 m_pImage = pImage;

3600 m_pPause = pPause;	3701 (*m_pImage)->fill(0);

3601 m_pImage = pImage;	3702 m_pArithDecoder = pArithDecoder;

3602 m_DecodeType = 3;	3703 m_gbContext = gbContext;

3603 (*m_pImage)->fill(0);	3704 LTP = 0;

3604 LTP = 0;	3705 m_pLine = NULL;

	3706 m_loopIndex = 0;

	3707 return decode_Arith(pPause);

	3708 }

	3709 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith(IFX_Pause* pPause) {

	3710 int iline = m_loopIndex;

	3711 CJBig2_Image* pImage = *m_pImage;

	3712 if (GBTEMPLATE == 0) {

	3713 if ((GBAT[0] == 3) && (GBAT[1] == (signed char)-1) &&

	3714 (GBAT[2] == (signed char)-3) && (GBAT[3] == (signed char)-1) &&

	3715 (GBAT[4] == 2) && (GBAT[5] == (signed char)-2) &&

	3716 (GBAT[6] == (signed char)-2) && (GBAT[7] == (signed char)-2)) {

	3717 m_ProssiveStatus = decode_Arith_Template0_opt3(

	3718 pImage, m_pArithDecoder, m_gbContext, pPause);

	3719 } else {

	3720 m_ProssiveStatus = decode_Arith_Template0_unopt(

	3721 pImage, m_pArithDecoder, m_gbContext, pPause);

	3722 }

	3723 } else if (GBTEMPLATE == 1) {

	3724 if ((GBAT[0] == 3) && (GBAT[1] == (signed char)-1)) {

	3725 m_ProssiveStatus = decode_Arith_Template1_opt3(

	3726 pImage, m_pArithDecoder, m_gbContext, pPause);

	3727 } else {

	3728 m_ProssiveStatus = decode_Arith_Template1_unopt(

	3729 pImage, m_pArithDecoder, m_gbContext, pPause);

	3730 }

	3731 } else if (GBTEMPLATE == 2) {

	3732 if ((GBAT[0] == 2) && (GBAT[1] == (signed char)-1)) {

	3733 m_ProssiveStatus = decode_Arith_Template2_opt3(

	3734 pImage, m_pArithDecoder, m_gbContext, pPause);

	3735 } else {

	3736 m_ProssiveStatus = decode_Arith_Template2_unopt(

	3737 pImage, m_pArithDecoder, m_gbContext, pPause);

	3738 }

	3739 } else {

	3740 if ((GBAT[0] == 2) && (GBAT[1] == (signed char)-1)) {

	3741 m_ProssiveStatus = decode_Arith_Template3_opt3(

	3742 pImage, m_pArithDecoder, m_gbContext, pPause);

	3743 } else {

	3744 m_ProssiveStatus = decode_Arith_Template3_unopt(

	3745 pImage, m_pArithDecoder, m_gbContext, pPause);

	3746 }

	3747 }

	3748 m_ReplaceRect.left = 0;

	3749 m_ReplaceRect.right = pImage->m_nWidth;

	3750 m_ReplaceRect.top = iline;

	3751 m_ReplaceRect.bottom = m_loopIndex;

	3752 if (m_ProssiveStatus == FXCODEC_STATUS_DECODE_FINISH) {

3605 m_loopIndex = 0;	3753 m_loopIndex = 0;

3606 m_pArithDecoder = pArithDecoder;	3754 }

3607 m_gbContext = gbContext;	3755 return m_ProssiveStatus;

3608 return decode_Arith_V1(pPause);	3756 }

3609 }	3757 FXCODEC_STATUS CJBig2_GRDProc::Start_decode_Arith_V2(

3610 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_V1(IFX_Pause* pPause)	3758 CJBig2_Image** pImage,

3611 {	3759 CJBig2_ArithDecoder* pArithDecoder,

3612 FX_BOOL SLTP, bVal;	3760 JBig2ArithCtx* gbContext,

3613 FX_DWORD CONTEXT = 0;	3761 IFX_Pause* pPause) {

3614 CJBig2_Image GBREG = (m_pImage);	3762 if (GBW == 0 \|\| GBH == 0) {

3615 for(; m_loopIndex < GBH; m_loopIndex++) {	3763 *pImage = NULL;

3616 if(TPGDON) {

3617 switch(GBTEMPLATE) {

3618 case 0:

3619 CONTEXT = 0x9b25;

3620 break;

3621 case 1:

3622 CONTEXT = 0x0795;

3623 break;

3624 case 2:

3625 CONTEXT = 0x00e5;

3626 break;

3627 case 3:

3628 CONTEXT = 0x0195;

3629 break;

3630 }

3631 SLTP = m_pArithDecoder->DECODE(&m_gbContext[CONTEXT]);

3632 LTP = LTP ^ SLTP;

3633 }

3634 if(LTP == 1) {

3635 for(FX_DWORD w = 0; w < GBW; w++) {

3636 GBREG->setPixel(w, m_loopIndex, GBREG->getPixel(w, m_loopIndex - 1));

3637 }

3638 } else {

3639 for(FX_DWORD w = 0; w < GBW; w++) {

3640 if(USESKIP && SKIP->getPixel(w, m_loopIndex)) {

3641 GBREG->setPixel(w, m_loopIndex, 0);

3642 } else {

3643 CONTEXT = 0;

3644 switch(GBTEMPLATE) {

3645 case 0:

3646 CONTEXT \|= GBREG->getPixel(w - 1, m_loopIndex);

3647 CONTEXT \|= GBREG->getPixel(w - 2, m_loopIndex) << 1;

3648 CONTEXT \|= GBREG->getPixel(w - 3, m_loopIndex) << 2;

3649 CONTEXT \|= GBREG->getPixel(w - 4, m_loopIndex) << 3;

3650 CONTEXT \|= GBREG->getPixel(w + GBAT[0], m_loopIndex + GBAT[1]) << 4;

3651 CONTEXT \|= GBREG->getPixel(w + 2, m_loopIndex - 1) < < 5;

3652 CONTEXT \|= GBREG->getPixel(w + 1, m_loopIndex - 1) < < 6;

3653 CONTEXT \|= GBREG->getPixel(w, m_loopIndex - 1) << 7;

3654 CONTEXT \|= GBREG->getPixel(w - 1, m_loopIndex - 1) < < 8;

3655 CONTEXT \|= GBREG->getPixel(w - 2, m_loopIndex - 1) < < 9;

3656 CONTEXT \|= GBREG->getPixel(w + GBAT[2], m_loopIndex + GBAT[3]) << 10;

3657 CONTEXT \|= GBREG->getPixel(w + GBAT[4], m_loopIndex + GBAT[5]) << 11;

3658 CONTEXT \|= GBREG->getPixel(w + 1, m_loopIndex - 2) < < 12;

3659 CONTEXT \|= GBREG->getPixel(w, m_loopIndex - 2) << 13 ;

3660 CONTEXT \|= GBREG->getPixel(w - 1, m_loopIndex - 2) < < 14;

3661 CONTEXT \|= GBREG->getPixel(w + GBAT[6], m_loopIndex + GBAT[7]) << 15;

3662 break;

3663 case 1:

3664 CONTEXT \|= GBREG->getPixel(w - 1, m_loopIndex);

3665 CONTEXT \|= GBREG->getPixel(w - 2, m_loopIndex) << 1;

3666 CONTEXT \|= GBREG->getPixel(w - 3, m_loopIndex) << 2;

3667 CONTEXT \|= GBREG->getPixel(w + GBAT[0], m_loopIndex + GBAT[1]) << 3;

3668 CONTEXT \|= GBREG->getPixel(w + 2, m_loopIndex - 1) < < 4;

3669 CONTEXT \|= GBREG->getPixel(w + 1, m_loopIndex - 1) < < 5;

3670 CONTEXT \|= GBREG->getPixel(w, m_loopIndex - 1) << 6;

3671 CONTEXT \|= GBREG->getPixel(w - 1, m_loopIndex - 1) < < 7;

3672 CONTEXT \|= GBREG->getPixel(w - 2, m_loopIndex - 1) < < 8;

3673 CONTEXT \|= GBREG->getPixel(w + 2, m_loopIndex - 2) < < 9;

3674 CONTEXT \|= GBREG->getPixel(w + 1, m_loopIndex - 2) < < 10;

3675 CONTEXT \|= GBREG->getPixel(w, m_loopIndex - 2) << 11 ;

3676 CONTEXT \|= GBREG->getPixel(w - 1, m_loopIndex - 2) < < 12;

3677 break;

3678 case 2:

3679 CONTEXT \|= GBREG->getPixel(w - 1, m_loopIndex);

3680 CONTEXT \|= GBREG->getPixel(w - 2, m_loopIndex) << 1;

3681 CONTEXT \|= GBREG->getPixel(w + GBAT[0], m_loopIndex + GBAT[1]) << 2;

3682 CONTEXT \|= GBREG->getPixel(w + 1, m_loopIndex - 1) < < 3;

3683 CONTEXT \|= GBREG->getPixel(w, m_loopIndex - 1) << 4;

3684 CONTEXT \|= GBREG->getPixel(w - 1, m_loopIndex - 1) < < 5;

3685 CONTEXT \|= GBREG->getPixel(w - 2, m_loopIndex - 1) < < 6;

3686 CONTEXT \|= GBREG->getPixel(w + 1, m_loopIndex - 2) < < 7;

3687 CONTEXT \|= GBREG->getPixel(w, m_loopIndex - 2) << 8;

3688 CONTEXT \|= GBREG->getPixel(w - 1, m_loopIndex - 2) < < 9;

3689 break;

3690 case 3:

3691 CONTEXT \|= GBREG->getPixel(w - 1, m_loopIndex);

3692 CONTEXT \|= GBREG->getPixel(w - 2, m_loopIndex) << 1;

3693 CONTEXT \|= GBREG->getPixel(w - 3, m_loopIndex) << 2;

3694 CONTEXT \|= GBREG->getPixel(w - 4, m_loopIndex) << 3;

3695 CONTEXT \|= GBREG->getPixel(w + GBAT[0], m_loopIndex + GBAT[1]) << 4;

3696 CONTEXT \|= GBREG->getPixel(w + 1, m_loopIndex - 1) < < 5;

3697 CONTEXT \|= GBREG->getPixel(w, m_loopIndex - 1) << 6;

3698 CONTEXT \|= GBREG->getPixel(w - 1, m_loopIndex - 1) < < 7;

3699 CONTEXT \|= GBREG->getPixel(w - 2, m_loopIndex - 1) < < 8;

3700 CONTEXT \|= GBREG->getPixel(w - 3, m_loopIndex - 1) < < 9;

3701 break;

3702 }

3703 bVal = m_pArithDecoder->DECODE(&m_gbContext[CONTEXT]);

3704 GBREG->setPixel(w, m_loopIndex, bVal);

3705 }

3706 }

3707 }

3708 if(pPause && pPause->NeedToPauseNow()) {

3709 m_loopIndex ++;

3710 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;

3711 return FXCODEC_STATUS_DECODE_TOBECONTINUE;

3712 }

3713 }

3714 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;	3764 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;

3715 return FXCODEC_STATUS_DECODE_FINISH;	3765 return FXCODEC_STATUS_DECODE_FINISH;

3716 }	3766 }

3717 FXCODEC_STATUS CJBig2_GRDProc::Start_decode_MMR(CJBig2_Image** pImage, CJBig2_Bi tStream pStream, IFX_Pause pPause)	3767 if (*pImage == NULL) {

3718 {	3768 JBIG2_ALLOC((*pImage), CJBig2_Image(GBW, GBH));

3719 int bitpos, i;	3769 }

3720 JBIG2_ALLOC((* pImage), CJBig2_Image(GBW, GBH));	3770 if ((*pImage)->m_pData == NULL) {

3721 if ((* pImage)->m_pData == NULL) {	3771 delete *pImage;

3722 delete (* pImage);	3772 *pImage = NULL;

3723 (* pImage) = NULL;	3773 m_pModule->JBig2_Error(

3724 m_pModule->JBig2_Error("Generic region decoding procedure: Create Image Failed with width = %d, height = %d\n", GBW, GBH);	3774 "Generic region decoding procedure: Create Image Failed with width = "

3725 m_ProssiveStatus = FXCODEC_STATUS_ERROR;	3775 "%d, height = %d\n",

3726 return m_ProssiveStatus;	3776 GBW,

3727 }	3777 GBH);

3728 bitpos = (int)pStream->getBitPos();	3778 m_ProssiveStatus = FXCODEC_STATUS_ERROR;

3729 _FaxG4Decode(m_pModule, pStream->getBuf(), pStream->getLength(), &bitpos, (* pImage)->m_pData, GBW, GBH, (* pImage)->m_nStride);	3779 return FXCODEC_STATUS_ERROR;

3730 pStream->setBitPos(bitpos);	3780 }

3731 for(i = 0; (FX_DWORD)i < (* pImage)->m_nStride * GBH; i++) {	3781 m_ProssiveStatus = FXCODEC_STATUS_DECODE_READY;

3732 (* pImage)->m_pData[i] = ~(* pImage)->m_pData[i];	3782 m_DecodeType = 2;

3733 }	3783 m_pPause = pPause;

	3784 m_pImage = pImage;

	3785 (*m_pImage)->fill(0);

	3786 LTP = 0;

	3787 m_loopIndex = 0;

	3788 m_pArithDecoder = pArithDecoder;

	3789 m_gbContext = gbContext;

	3790 return decode_Arith_V2(pPause);

	3791 }

	3792 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_V2(IFX_Pause* pPause) {

	3793 FX_BOOL SLTP, bVal;

	3794 FX_DWORD CONTEXT;

	3795 CJBig2_Image* GBREG = *m_pImage;

	3796 FX_DWORD line1, line2, line3;

	3797 LTP = 0;

	3798 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));

	3799 GBREG->fill(0);

	3800 for (; m_loopIndex < GBH; m_loopIndex++) {

	3801 if (TPGDON) {

	3802 switch (GBTEMPLATE) {

	3803 case 0:

	3804 CONTEXT = 0x9b25;

	3805 break;

	3806 case 1:

	3807 CONTEXT = 0x0795;

	3808 break;

	3809 case 2:

	3810 CONTEXT = 0x00e5;

	3811 break;

	3812 case 3:

	3813 CONTEXT = 0x0195;

	3814 break;

	3815 }

	3816 SLTP = m_pArithDecoder->DECODE(&m_gbContext[CONTEXT]);

	3817 LTP = LTP ^ SLTP;

	3818 }

	3819 if (LTP == 1) {

	3820 GBREG->copyLine(m_loopIndex, m_loopIndex - 1);

	3821 } else {

	3822 switch (GBTEMPLATE) {

	3823 case 0: {

	3824 line1 = GBREG->getPixel(1, m_loopIndex - 2);

	3825 line1 \|= GBREG->getPixel(0, m_loopIndex - 2) << 1;

	3826 line2 = GBREG->getPixel(2, m_loopIndex - 1);

	3827 line2 \|= GBREG->getPixel(1, m_loopIndex - 1) << 1;

	3828 line2 \|= GBREG->getPixel(0, m_loopIndex - 1) << 2;

	3829 line3 = 0;

	3830 for (FX_DWORD w = 0; w < GBW; w++) {

	3831 if (USESKIP && SKIP->getPixel(w, m_loopIndex)) {

	3832 bVal = 0;

	3833 } else {

	3834 CONTEXT = line3;

	3835 CONTEXT \|= GBREG->getPixel(w + GBAT[0], m_loopIndex + GBAT[1])

	3836 << 4;

	3837 CONTEXT \|= line2 << 5;

	3838 CONTEXT \|= GBREG->getPixel(w + GBAT[2], m_loopIndex + GBAT[3])

	3839 << 10;

	3840 CONTEXT \|= GBREG->getPixel(w + GBAT[4], m_loopIndex + GBAT[5])

	3841 << 11;

	3842 CONTEXT \|= line1 << 12;

	3843 CONTEXT \|= GBREG->getPixel(w + GBAT[6], m_loopIndex + GBAT[7])

	3844 << 15;

	3845 bVal = m_pArithDecoder->DECODE(&m_gbContext[CONTEXT]);

	3846 }

	3847 if (bVal) {

	3848 GBREG->setPixel(w, m_loopIndex, bVal);

	3849 }

	3850 line1 =

	3851 ((line1 << 1) \| GBREG->getPixel(w + 2, m_loopIndex - 2)) & 0x07;

	3852 line2 =

	3853 ((line2 << 1) \| GBREG->getPixel(w + 3, m_loopIndex - 1)) & 0x1f;

	3854 line3 = ((line3 << 1) \| bVal) & 0x0f;

	3855 }

	3856 } break;

	3857 case 1: {

	3858 line1 = GBREG->getPixel(2, m_loopIndex - 2);

	3859 line1 \|= GBREG->getPixel(1, m_loopIndex - 2) << 1;

	3860 line1 \|= GBREG->getPixel(0, m_loopIndex - 2) << 2;

	3861 line2 = GBREG->getPixel(2, m_loopIndex - 1);

	3862 line2 \|= GBREG->getPixel(1, m_loopIndex - 1) << 1;

	3863 line2 \|= GBREG->getPixel(0, m_loopIndex - 1) << 2;

	3864 line3 = 0;

	3865 for (FX_DWORD w = 0; w < GBW; w++) {

	3866 if (USESKIP && SKIP->getPixel(w, m_loopIndex)) {

	3867 bVal = 0;

	3868 } else {

	3869 CONTEXT = line3;

	3870 CONTEXT \|= GBREG->getPixel(w + GBAT[0], m_loopIndex + GBAT[1])

	3871 << 3;

	3872 CONTEXT \|= line2 << 4;

	3873 CONTEXT \|= line1 << 9;

	3874 bVal = m_pArithDecoder->DECODE(&m_gbContext[CONTEXT]);

	3875 }

	3876 if (bVal) {

	3877 GBREG->setPixel(w, m_loopIndex, bVal);

	3878 }

	3879 line1 =

	3880 ((line1 << 1) \| GBREG->getPixel(w + 3, m_loopIndex - 2)) & 0x0f;

	3881 line2 =

	3882 ((line2 << 1) \| GBREG->getPixel(w + 3, m_loopIndex - 1)) & 0x1f;

	3883 line3 = ((line3 << 1) \| bVal) & 0x07;

	3884 }

	3885 } break;

	3886 case 2: {

	3887 line1 = GBREG->getPixel(1, m_loopIndex - 2);

	3888 line1 \|= GBREG->getPixel(0, m_loopIndex - 2) << 1;

	3889 line2 = GBREG->getPixel(1, m_loopIndex - 1);

	3890 line2 \|= GBREG->getPixel(0, m_loopIndex - 1) << 1;

	3891 line3 = 0;

	3892 for (FX_DWORD w = 0; w < GBW; w++) {

	3893 if (USESKIP && SKIP->getPixel(w, m_loopIndex)) {

	3894 bVal = 0;

	3895 } else {

	3896 CONTEXT = line3;

	3897 CONTEXT \|= GBREG->getPixel(w + GBAT[0], m_loopIndex + GBAT[1])

	3898 << 2;

	3899 CONTEXT \|= line2 << 3;

	3900 CONTEXT \|= line1 << 7;

	3901 bVal = m_pArithDecoder->DECODE(&m_gbContext[CONTEXT]);

	3902 }

	3903 if (bVal) {

	3904 GBREG->setPixel(w, m_loopIndex, bVal);

	3905 }

	3906 line1 =

	3907 ((line1 << 1) \| GBREG->getPixel(w + 2, m_loopIndex - 2)) & 0x07;

	3908 line2 =

	3909 ((line2 << 1) \| GBREG->getPixel(w + 2, m_loopIndex - 1)) & 0x0f;

	3910 line3 = ((line3 << 1) \| bVal) & 0x03;

	3911 }

	3912 } break;

	3913 case 3: {

	3914 line1 = GBREG->getPixel(1, m_loopIndex - 1);

	3915 line1 \|= GBREG->getPixel(0, m_loopIndex - 1) << 1;

	3916 line2 = 0;

	3917 for (FX_DWORD w = 0; w < GBW; w++) {

	3918 if (USESKIP && SKIP->getPixel(w, m_loopIndex)) {

	3919 bVal = 0;

	3920 } else {

	3921 CONTEXT = line2;

	3922 CONTEXT \|= GBREG->getPixel(w + GBAT[0], m_loopIndex + GBAT[1])

	3923 << 4;

	3924 CONTEXT \|= line1 << 5;

	3925 bVal = m_pArithDecoder->DECODE(&m_gbContext[CONTEXT]);

	3926 }

	3927 if (bVal) {

	3928 GBREG->setPixel(w, m_loopIndex, bVal);

	3929 }

	3930 line1 =

	3931 ((line1 << 1) \| GBREG->getPixel(w + 2, m_loopIndex - 1)) & 0x1f;

	3932 line2 = ((line2 << 1) \| bVal) & 0x0f;

	3933 }

	3934 } break;

	3935 }

	3936 }

	3937 if (pPause && pPause->NeedToPauseNow()) {

	3938 m_loopIndex++;

	3939 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;

	3940 return FXCODEC_STATUS_DECODE_TOBECONTINUE;

	3941 }

	3942 }

	3943 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;

	3944 return FXCODEC_STATUS_DECODE_FINISH;

	3945 }

	3946 FXCODEC_STATUS CJBig2_GRDProc::Start_decode_Arith_V1(

	3947 CJBig2_Image** pImage,

	3948 CJBig2_ArithDecoder* pArithDecoder,

	3949 JBig2ArithCtx* gbContext,

	3950 IFX_Pause* pPause) {

	3951 if (GBW == 0 \|\| GBH == 0) {

	3952 *pImage = NULL;

3734 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;	3953 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;

3735 return m_ProssiveStatus;	3954 return FXCODEC_STATUS_DECODE_FINISH;

3736 }	3955 }

3737 FXCODEC_STATUS CJBig2_GRDProc::decode_MMR()	3956 if (*pImage == NULL) {

3738 {	3957 JBIG2_ALLOC((*pImage), CJBig2_Image(GBW, GBH));

3739 return m_ProssiveStatus;	3958 }

3740 }	3959 if ((*pImage)->m_pData == NULL) {

3741 FXCODEC_STATUS CJBig2_GRDProc::Continue_decode(IFX_Pause* pPause)	3960 delete *pImage;

3742 {	3961 *pImage = NULL;

3743 if(m_ProssiveStatus != FXCODEC_STATUS_DECODE_TOBECONTINUE) {	3962 m_pModule->JBig2_Error(

3744 return m_ProssiveStatus;	3963 "Generic region decoding procedure: Create Image Failed with width = "

3745 }	3964 "%d, height = %d\n",

3746 switch (m_DecodeType) {	3965 GBW,

	3966 GBH);

	3967 m_ProssiveStatus = FXCODEC_STATUS_ERROR;

	3968 return FXCODEC_STATUS_ERROR;

	3969 }

	3970 m_ProssiveStatus = FXCODEC_STATUS_DECODE_READY;

	3971 m_pPause = pPause;

	3972 m_pImage = pImage;

	3973 m_DecodeType = 3;

	3974 (*m_pImage)->fill(0);

	3975 LTP = 0;

	3976 m_loopIndex = 0;

	3977 m_pArithDecoder = pArithDecoder;

	3978 m_gbContext = gbContext;

	3979 return decode_Arith_V1(pPause);

	3980 }

	3981 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_V1(IFX_Pause* pPause) {

	3982 FX_BOOL SLTP, bVal;

	3983 FX_DWORD CONTEXT = 0;

	3984 CJBig2_Image* GBREG = (*m_pImage);

	3985 for (; m_loopIndex < GBH; m_loopIndex++) {

	3986 if (TPGDON) {

	3987 switch (GBTEMPLATE) {

	3988 case 0:

	3989 CONTEXT = 0x9b25;

	3990 break;

3747 case 1:	3991 case 1:

3748 return decode_Arith(pPause);	3992 CONTEXT = 0x0795;

	3993 break;

3749 case 2:	3994 case 2:

3750 return decode_Arith_V2(pPause);	3995 CONTEXT = 0x00e5;

	3996 break;

3751 case 3:	3997 case 3:

3752 return decode_Arith_V1(pPause);	3998 CONTEXT = 0x0195;

3753 case 4:	3999 break;

3754 return decode_MMR();	4000 }

3755 }	4001 SLTP = m_pArithDecoder->DECODE(&m_gbContext[CONTEXT]);

	4002 LTP = LTP ^ SLTP;

	4003 }

	4004 if (LTP == 1) {

	4005 for (FX_DWORD w = 0; w < GBW; w++) {

	4006 GBREG->setPixel(w, m_loopIndex, GBREG->getPixel(w, m_loopIndex - 1));

	4007 }

	4008 } else {

	4009 for (FX_DWORD w = 0; w < GBW; w++) {

	4010 if (USESKIP && SKIP->getPixel(w, m_loopIndex)) {

	4011 GBREG->setPixel(w, m_loopIndex, 0);

	4012 } else {

	4013 CONTEXT = 0;

	4014 switch (GBTEMPLATE) {

	4015 case 0:

	4016 CONTEXT \|= GBREG->getPixel(w - 1, m_loopIndex);

	4017 CONTEXT \|= GBREG->getPixel(w - 2, m_loopIndex) << 1;

	4018 CONTEXT \|= GBREG->getPixel(w - 3, m_loopIndex) << 2;

	4019 CONTEXT \|= GBREG->getPixel(w - 4, m_loopIndex) << 3;

	4020 CONTEXT \|= GBREG->getPixel(w + GBAT[0], m_loopIndex + GBAT[1])

	4021 << 4;

	4022 CONTEXT \|= GBREG->getPixel(w + 2, m_loopIndex - 1) << 5;

	4023 CONTEXT \|= GBREG->getPixel(w + 1, m_loopIndex - 1) << 6;

	4024 CONTEXT \|= GBREG->getPixel(w, m_loopIndex - 1) << 7;

	4025 CONTEXT \|= GBREG->getPixel(w - 1, m_loopIndex - 1) << 8;

	4026 CONTEXT \|= GBREG->getPixel(w - 2, m_loopIndex - 1) << 9;

	4027 CONTEXT \|= GBREG->getPixel(w + GBAT[2], m_loopIndex + GBAT[3])

	4028 << 10;

	4029 CONTEXT \|= GBREG->getPixel(w + GBAT[4], m_loopIndex + GBAT[5])

	4030 << 11;

	4031 CONTEXT \|= GBREG->getPixel(w + 1, m_loopIndex - 2) << 12;

	4032 CONTEXT \|= GBREG->getPixel(w, m_loopIndex - 2) << 13;

	4033 CONTEXT \|= GBREG->getPixel(w - 1, m_loopIndex - 2) << 14;

	4034 CONTEXT \|= GBREG->getPixel(w + GBAT[6], m_loopIndex + GBAT[7])

	4035 << 15;

	4036 break;

	4037 case 1:

	4038 CONTEXT \|= GBREG->getPixel(w - 1, m_loopIndex);

	4039 CONTEXT \|= GBREG->getPixel(w - 2, m_loopIndex) << 1;

	4040 CONTEXT \|= GBREG->getPixel(w - 3, m_loopIndex) << 2;

	4041 CONTEXT \|= GBREG->getPixel(w + GBAT[0], m_loopIndex + GBAT[1])

	4042 << 3;

	4043 CONTEXT \|= GBREG->getPixel(w + 2, m_loopIndex - 1) << 4;

	4044 CONTEXT \|= GBREG->getPixel(w + 1, m_loopIndex - 1) << 5;

	4045 CONTEXT \|= GBREG->getPixel(w, m_loopIndex - 1) << 6;

	4046 CONTEXT \|= GBREG->getPixel(w - 1, m_loopIndex - 1) << 7;

	4047 CONTEXT \|= GBREG->getPixel(w - 2, m_loopIndex - 1) << 8;

	4048 CONTEXT \|= GBREG->getPixel(w + 2, m_loopIndex - 2) << 9;

	4049 CONTEXT \|= GBREG->getPixel(w + 1, m_loopIndex - 2) << 10;

	4050 CONTEXT \|= GBREG->getPixel(w, m_loopIndex - 2) << 11;

	4051 CONTEXT \|= GBREG->getPixel(w - 1, m_loopIndex - 2) << 12;

	4052 break;

	4053 case 2:

	4054 CONTEXT \|= GBREG->getPixel(w - 1, m_loopIndex);

	4055 CONTEXT \|= GBREG->getPixel(w - 2, m_loopIndex) << 1;

	4056 CONTEXT \|= GBREG->getPixel(w + GBAT[0], m_loopIndex + GBAT[1])

	4057 << 2;

	4058 CONTEXT \|= GBREG->getPixel(w + 1, m_loopIndex - 1) << 3;

	4059 CONTEXT \|= GBREG->getPixel(w, m_loopIndex - 1) << 4;

	4060 CONTEXT \|= GBREG->getPixel(w - 1, m_loopIndex - 1) << 5;

	4061 CONTEXT \|= GBREG->getPixel(w - 2, m_loopIndex - 1) << 6;

	4062 CONTEXT \|= GBREG->getPixel(w + 1, m_loopIndex - 2) << 7;

	4063 CONTEXT \|= GBREG->getPixel(w, m_loopIndex - 2) << 8;

	4064 CONTEXT \|= GBREG->getPixel(w - 1, m_loopIndex - 2) << 9;

	4065 break;

	4066 case 3:

	4067 CONTEXT \|= GBREG->getPixel(w - 1, m_loopIndex);

	4068 CONTEXT \|= GBREG->getPixel(w - 2, m_loopIndex) << 1;

	4069 CONTEXT \|= GBREG->getPixel(w - 3, m_loopIndex) << 2;

	4070 CONTEXT \|= GBREG->getPixel(w - 4, m_loopIndex) << 3;

	4071 CONTEXT \|= GBREG->getPixel(w + GBAT[0], m_loopIndex + GBAT[1])

	4072 << 4;

	4073 CONTEXT \|= GBREG->getPixel(w + 1, m_loopIndex - 1) << 5;

	4074 CONTEXT \|= GBREG->getPixel(w, m_loopIndex - 1) << 6;

	4075 CONTEXT \|= GBREG->getPixel(w - 1, m_loopIndex - 1) << 7;

	4076 CONTEXT \|= GBREG->getPixel(w - 2, m_loopIndex - 1) << 8;

	4077 CONTEXT \|= GBREG->getPixel(w - 3, m_loopIndex - 1) << 9;

	4078 break;

	4079 }

	4080 bVal = m_pArithDecoder->DECODE(&m_gbContext[CONTEXT]);

	4081 GBREG->setPixel(w, m_loopIndex, bVal);

	4082 }

	4083 }

	4084 }

	4085 if (pPause && pPause->NeedToPauseNow()) {

	4086 m_loopIndex++;

	4087 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;

	4088 return FXCODEC_STATUS_DECODE_TOBECONTINUE;

	4089 }

	4090 }

	4091 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;

	4092 return FXCODEC_STATUS_DECODE_FINISH;

	4093 }

	4094 FXCODEC_STATUS CJBig2_GRDProc::Start_decode_MMR(CJBig2_Image** pImage,

	4095 CJBig2_BitStream* pStream,

	4096 IFX_Pause* pPause) {

	4097 int bitpos, i;

	4098 JBIG2_ALLOC((*pImage), CJBig2_Image(GBW, GBH));

	4099 if ((*pImage)->m_pData == NULL) {

	4100 delete (*pImage);

	4101 (*pImage) = NULL;

	4102 m_pModule->JBig2_Error(

	4103 "Generic region decoding procedure: Create Image Failed with width = "

	4104 "%d, height = %d\n",

	4105 GBW,

	4106 GBH);

3756 m_ProssiveStatus = FXCODEC_STATUS_ERROR;	4107 m_ProssiveStatus = FXCODEC_STATUS_ERROR;

3757 return m_ProssiveStatus;	4108 return m_ProssiveStatus;

3758 }	4109 }

3759 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template0_opt3(CJBig2_Image pImage, CJBig2_ArithDecoder pArithDecoder, JBig2ArithCtx gbContext, IFX_Pause pPause )	4110 bitpos = (int)pStream->getBitPos();

3760 {	4111 _FaxG4Decode(m_pModule,

3761 FX_BOOL SLTP, bVal;	4112 pStream->getBuf(),

3762 FX_DWORD CONTEXT;	4113 pStream->getLength(),

3763 FX_DWORD line1, line2;	4114 &bitpos,

3764 FX_BYTE pLine1, pLine2, cVal;	4115 (*pImage)->m_pData,

3765 FX_INT32 nStride, nStride2, k;	4116 GBW,

3766 FX_INT32 nLineBytes, nBitsLeft, cc;	4117 GBH,

3767 if(m_pLine == NULL) {	4118 (*pImage)->m_nStride);

3768 m_pLine = pImage->m_pData;	4119 pStream->setBitPos(bitpos);

3769 }	4120 for (i = 0; (FX_DWORD)i < (pImage)->m_nStride GBH; i++) {

3770 nStride = pImage->m_nStride;	4121 (pImage)->m_pData[i] = ~(pImage)->m_pData[i];

3771 nStride2 = nStride << 1;	4122 }

3772 nLineBytes = ((GBW + 7) >> 3) - 1;	4123 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;

3773 nBitsLeft = GBW - (nLineBytes << 3);	4124 return m_ProssiveStatus;

3774 FX_DWORD height = GBH & 0x7fffffff;	4125 }

3775 for(; m_loopIndex < height; m_loopIndex++) {	4126 FXCODEC_STATUS CJBig2_GRDProc::decode_MMR() {

3776 if(TPGDON) {	4127 return m_ProssiveStatus;

3777 SLTP = pArithDecoder->DECODE(&gbContext[0x9b25]);	4128 }

3778 LTP = LTP ^ SLTP;	4129 FXCODEC_STATUS CJBig2_GRDProc::Continue_decode(IFX_Pause* pPause) {

3779 }	4130 if (m_ProssiveStatus != FXCODEC_STATUS_DECODE_TOBECONTINUE) {

3780 if(LTP == 1) {	4131 return m_ProssiveStatus;

3781 pImage->copyLine(m_loopIndex, m_loopIndex - 1);	4132 }

	4133 switch (m_DecodeType) {

	4134 case 1:

	4135 return decode_Arith(pPause);

	4136 case 2:

	4137 return decode_Arith_V2(pPause);

	4138 case 3:

	4139 return decode_Arith_V1(pPause);

	4140 case 4:

	4141 return decode_MMR();

	4142 }

	4143 m_ProssiveStatus = FXCODEC_STATUS_ERROR;

	4144 return m_ProssiveStatus;

	4145 }

	4146 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template0_opt3(

	4147 CJBig2_Image* pImage,

	4148 CJBig2_ArithDecoder* pArithDecoder,

	4149 JBig2ArithCtx* gbContext,

	4150 IFX_Pause* pPause) {

	4151 FX_BOOL SLTP, bVal;

	4152 FX_DWORD CONTEXT;

	4153 FX_DWORD line1, line2;

	4154 FX_BYTE* pLine1, *pLine2, cVal;

	4155 FX_INT32 nStride, nStride2, k;

	4156 FX_INT32 nLineBytes, nBitsLeft, cc;

	4157 if (m_pLine == NULL) {

	4158 m_pLine = pImage->m_pData;

	4159 }

	4160 nStride = pImage->m_nStride;

	4161 nStride2 = nStride << 1;

	4162 nLineBytes = ((GBW + 7) >> 3) - 1;

	4163 nBitsLeft = GBW - (nLineBytes << 3);

	4164 FX_DWORD height = GBH & 0x7fffffff;

	4165 for (; m_loopIndex < height; m_loopIndex++) {

	4166 if (TPGDON) {

	4167 SLTP = pArithDecoder->DECODE(&gbContext[0x9b25]);

	4168 LTP = LTP ^ SLTP;

	4169 }

	4170 if (LTP == 1) {

	4171 pImage->copyLine(m_loopIndex, m_loopIndex - 1);

	4172 } else {

	4173 if (m_loopIndex > 1) {

	4174 pLine1 = m_pLine - nStride2;

	4175 pLine2 = m_pLine - nStride;

	4176 line1 = (*pLine1++) << 6;

	4177 line2 = *pLine2++;

	4178 CONTEXT = ((line1 & 0xf800) \| (line2 & 0x07f0));

	4179 for (cc = 0; cc < nLineBytes; cc++) {

	4180 line1 = (line1 << 8) \| ((*pLine1++) << 6);

	4181 line2 = (line2 << 8) \| (*pLine2++);

	4182 cVal = 0;

	4183 for (k = 7; k >= 0; k--) {

	4184 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	4185 cVal \|= bVal << k;

	4186 CONTEXT = (((CONTEXT & 0x7bf7) << 1) \| bVal \|

	4187 ((line1 >> k) & 0x0800) \| ((line2 >> k) & 0x0010));

	4188 }

	4189 m_pLine[cc] = cVal;

	4190 }

	4191 line1 <<= 8;

	4192 line2 <<= 8;

	4193 cVal = 0;

	4194 for (k = 0; k < nBitsLeft; k++) {

	4195 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	4196 cVal \|= bVal << (7 - k);

	4197 CONTEXT =

	4198 (((CONTEXT & 0x7bf7) << 1) \| bVal \|

	4199 ((line1 >> (7 - k)) & 0x0800) \| ((line2 >> (7 - k)) & 0x0010));

	4200 }

	4201 m_pLine[nLineBytes] = cVal;

	4202 } else {

	4203 pLine2 = m_pLine - nStride;

	4204 line2 = (m_loopIndex & 1) ? (*pLine2++) : 0;

	4205 CONTEXT = (line2 & 0x07f0);

	4206 for (cc = 0; cc < nLineBytes; cc++) {

	4207 if (m_loopIndex & 1) {

	4208 line2 = (line2 << 8) \| (*pLine2++);

	4209 }

	4210 cVal = 0;

	4211 for (k = 7; k >= 0; k--) {

	4212 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	4213 cVal \|= bVal << k;

	4214 CONTEXT =

	4215 (((CONTEXT & 0x7bf7) << 1) \| bVal \| ((line2 >> k) & 0x0010));

	4216 }

	4217 m_pLine[cc] = cVal;

	4218 }

	4219 line2 <<= 8;

	4220 cVal = 0;

	4221 for (k = 0; k < nBitsLeft; k++) {

	4222 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	4223 cVal \|= bVal << (7 - k);

	4224 CONTEXT = (((CONTEXT & 0x7bf7) << 1) \| bVal \|

	4225 ((line2 >> (7 - k)) & 0x0010));

	4226 }

	4227 m_pLine[nLineBytes] = cVal;

	4228 }

	4229 }

	4230 m_pLine += nStride;

	4231 if (pPause && pPause->NeedToPauseNow()) {

	4232 m_loopIndex++;

	4233 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;

	4234 return FXCODEC_STATUS_DECODE_TOBECONTINUE;

	4235 }

	4236 }

	4237 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;

	4238 return FXCODEC_STATUS_DECODE_FINISH;

	4239 }

	4240 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template0_unopt(

	4241 CJBig2_Image* pImage,

	4242 CJBig2_ArithDecoder* pArithDecoder,

	4243 JBig2ArithCtx* gbContext,

	4244 IFX_Pause* pPause) {

	4245 FX_BOOL SLTP, bVal;

	4246 FX_DWORD CONTEXT;

	4247 FX_DWORD line1, line2, line3;

	4248 for (; m_loopIndex < GBH; m_loopIndex++) {

	4249 if (TPGDON) {

	4250 SLTP = pArithDecoder->DECODE(&gbContext[0x9b25]);

	4251 LTP = LTP ^ SLTP;

	4252 }

	4253 if (LTP == 1) {

	4254 pImage->copyLine(m_loopIndex, m_loopIndex - 1);

	4255 } else {

	4256 line1 = pImage->getPixel(1, m_loopIndex - 2);

	4257 line1 \|= pImage->getPixel(0, m_loopIndex - 2) << 1;

	4258 line2 = pImage->getPixel(2, m_loopIndex - 1);

	4259 line2 \|= pImage->getPixel(1, m_loopIndex - 1) << 1;

	4260 line2 \|= pImage->getPixel(0, m_loopIndex - 1) << 2;

	4261 line3 = 0;

	4262 for (FX_DWORD w = 0; w < GBW; w++) {

	4263 if (USESKIP && SKIP->getPixel(w, m_loopIndex)) {

	4264 bVal = 0;

3782 } else {	4265 } else {

3783 if(m_loopIndex > 1) {	4266 CONTEXT = line3;

3784 pLine1 = m_pLine - nStride2;	4267 CONTEXT \|= pImage->getPixel(w + GBAT[0], m_loopIndex + GBAT[1]) << 4;

3785 pLine2 = m_pLine - nStride;	4268 CONTEXT \|= line2 << 5;

3786 line1 = (*pLine1++) << 6;	4269 CONTEXT \|= pImage->getPixel(w + GBAT[2], m_loopIndex + GBAT[3]) << 10;

3787 line2 = *pLine2++;	4270 CONTEXT \|= pImage->getPixel(w + GBAT[4], m_loopIndex + GBAT[5]) << 11;

3788 CONTEXT = ((line1 & 0xf800) \| (line2 & 0x07f0));	4271 CONTEXT \|= line1 << 12;

3789 for(cc = 0; cc < nLineBytes; cc++) {	4272 CONTEXT \|= pImage->getPixel(w + GBAT[6], m_loopIndex + GBAT[7]) << 15;

3790 line1 = (line1 << 8) \| ((*pLine1++) << 6);	4273 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

3791 line2 = (line2 << 8) \| (*pLine2++);	4274 }

3792 cVal = 0;	4275 if (bVal) {

3793 for(k = 7; k >= 0; k--) {	4276 pImage->setPixel(w, m_loopIndex, bVal);

3794 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);	4277 }

3795 cVal \|= bVal << k;	4278 line1 =

3796 CONTEXT = (((CONTEXT & 0x7bf7) << 1) \| bVal	4279 ((line1 << 1) \| pImage->getPixel(w + 2, m_loopIndex - 2)) & 0x07;

3797 \| ((line1 >> k) & 0x0800)	4280 line2 =

3798 \| ((line2 >> k) & 0x0010));	4281 ((line2 << 1) \| pImage->getPixel(w + 3, m_loopIndex - 1)) & 0x1f;

3799 }	4282 line3 = ((line3 << 1) \| bVal) & 0x0f;

3800 m_pLine[cc] = cVal;	4283 }

3801 }	4284 }

3802 line1 <<= 8;	4285 if (pPause && pPause->NeedToPauseNow()) {

3803 line2 <<= 8;	4286 m_loopIndex++;

3804 cVal = 0;	4287 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;

3805 for(k = 0; k < nBitsLeft; k++) {	4288 return FXCODEC_STATUS_DECODE_TOBECONTINUE;

3806 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);	4289 }

3807 cVal \|= bVal << (7 - k);	4290 }

3808 CONTEXT = (((CONTEXT & 0x7bf7) << 1) \| bVal	4291 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;

3809 \| ((line1 >> (7 - k)) & 0x0800)	4292 return FXCODEC_STATUS_DECODE_FINISH;

3810 \| ((line2 >> (7 - k)) & 0x0010));	4293 }

3811 }	4294 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template1_opt3(

3812 m_pLine[nLineBytes] = cVal;	4295 CJBig2_Image* pImage,

3813 } else {	4296 CJBig2_ArithDecoder* pArithDecoder,

3814 pLine2 = m_pLine - nStride;	4297 JBig2ArithCtx* gbContext,

3815 line2 = (m_loopIndex & 1) ? (*pLine2++) : 0;	4298 IFX_Pause* pPause) {

3816 CONTEXT = (line2 & 0x07f0);	4299 FX_BOOL SLTP, bVal;

3817 for(cc = 0; cc < nLineBytes; cc++) {	4300 FX_DWORD CONTEXT;

3818 if(m_loopIndex & 1) {	4301 FX_DWORD line1, line2;

3819 line2 = (line2 << 8) \| (*pLine2++);	4302 FX_BYTE* pLine1, *pLine2, cVal;

3820 }	4303 FX_INT32 nStride, nStride2, k;

3821 cVal = 0;	4304 FX_INT32 nLineBytes, nBitsLeft, cc;

3822 for(k = 7; k >= 0; k--) {	4305 if (!m_pLine) {

3823 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);	4306 m_pLine = pImage->m_pData;

3824 cVal \|= bVal << k;	4307 }

3825 CONTEXT = (((CONTEXT & 0x7bf7) << 1) \| bVal	4308 nStride = pImage->m_nStride;

3826 \| ((line2 >> k) & 0x0010));	4309 nStride2 = nStride << 1;

3827 }	4310 nLineBytes = ((GBW + 7) >> 3) - 1;

3828 m_pLine[cc] = cVal;	4311 nBitsLeft = GBW - (nLineBytes << 3);

3829 }	4312 for (; m_loopIndex < GBH; m_loopIndex++) {

3830 line2 <<= 8;	4313 if (TPGDON) {

3831 cVal = 0;	4314 SLTP = pArithDecoder->DECODE(&gbContext[0x0795]);

3832 for(k = 0; k < nBitsLeft; k++) {	4315 LTP = LTP ^ SLTP;

3833 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);	4316 }

3834 cVal \|= bVal << (7 - k);	4317 if (LTP == 1) {

3835 CONTEXT = (((CONTEXT & 0x7bf7) << 1) \| bVal	4318 pImage->copyLine(m_loopIndex, m_loopIndex - 1);

3836 \| ((line2 >> (7 - k)) & 0x0010));	4319 } else {

3837 }	4320 if (m_loopIndex > 1) {

3838 m_pLine[nLineBytes] = cVal;	4321 pLine1 = m_pLine - nStride2;

3839 }	4322 pLine2 = m_pLine - nStride;

3840 }	4323 line1 = (*pLine1++) << 4;

3841 m_pLine += nStride;	4324 line2 = *pLine2++;

3842 if(pPause && pPause->NeedToPauseNow()) {	4325 CONTEXT = (line1 & 0x1e00) \| ((line2 >> 1) & 0x01f8);

3843 m_loopIndex++;	4326 for (cc = 0; cc < nLineBytes; cc++) {

3844 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;	4327 line1 = (line1 << 8) \| ((*pLine1++) << 4);

3845 return FXCODEC_STATUS_DECODE_TOBECONTINUE;	4328 line2 = (line2 << 8) \| (*pLine2++);

3846 }	4329 cVal = 0;

3847 }	4330 for (k = 7; k >= 0; k--) {

3848 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;	4331 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

3849 return FXCODEC_STATUS_DECODE_FINISH;	4332 cVal \|= bVal << k;

3850 }	4333 CONTEXT = ((CONTEXT & 0x0efb) << 1) \| bVal \|

3851 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template0_unopt(CJBig2_Image * pImag e, CJBig2_ArithDecoder pArithDecoder, JBig2ArithCtx gbContext, IFX_Pause* pPau se)	4334 ((line1 >> k) & 0x0200) \| ((line2 >> (k + 1)) & 0x0008);

3852 {	4335 }

3853 FX_BOOL SLTP, bVal;	4336 m_pLine[cc] = cVal;

3854 FX_DWORD CONTEXT;	4337 }

3855 FX_DWORD line1, line2, line3;	4338 line1 <<= 8;

3856 for(; m_loopIndex < GBH; m_loopIndex++) {	4339 line2 <<= 8;

3857 if(TPGDON) {	4340 cVal = 0;

3858 SLTP = pArithDecoder->DECODE(&gbContext[0x9b25]);	4341 for (k = 0; k < nBitsLeft; k++) {

3859 LTP = LTP ^ SLTP;	4342 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

3860 }	4343 cVal \|= bVal << (7 - k);

3861 if(LTP == 1) {	4344 CONTEXT = ((CONTEXT & 0x0efb) << 1) \| bVal \|

3862 pImage->copyLine(m_loopIndex, m_loopIndex - 1);	4345 ((line1 >> (7 - k)) & 0x0200) \|

	4346 ((line2 >> (8 - k)) & 0x0008);

	4347 }

	4348 m_pLine[nLineBytes] = cVal;

	4349 } else {

	4350 pLine2 = m_pLine - nStride;

	4351 line2 = (m_loopIndex & 1) ? (*pLine2++) : 0;

	4352 CONTEXT = (line2 >> 1) & 0x01f8;

	4353 for (cc = 0; cc < nLineBytes; cc++) {

	4354 if (m_loopIndex & 1) {

	4355 line2 = (line2 << 8) \| (*pLine2++);

	4356 }

	4357 cVal = 0;

	4358 for (k = 7; k >= 0; k--) {

	4359 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	4360 cVal \|= bVal << k;

	4361 CONTEXT = ((CONTEXT & 0x0efb) << 1) \| bVal \|

	4362 ((line2 >> (k + 1)) & 0x0008);

	4363 }

	4364 m_pLine[cc] = cVal;

	4365 }

	4366 line2 <<= 8;

	4367 cVal = 0;

	4368 for (k = 0; k < nBitsLeft; k++) {

	4369 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	4370 cVal \|= bVal << (7 - k);

	4371 CONTEXT =

	4372 ((CONTEXT & 0x0efb) << 1) \| bVal \| ((line2 >> (8 - k)) & 0x0008);

	4373 }

	4374 m_pLine[nLineBytes] = cVal;

	4375 }

	4376 }

	4377 m_pLine += nStride;

	4378 if (pPause && pPause->NeedToPauseNow()) {

	4379 m_loopIndex++;

	4380 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;

	4381 return FXCODEC_STATUS_DECODE_TOBECONTINUE;

	4382 }

	4383 }

	4384 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;

	4385 return FXCODEC_STATUS_DECODE_FINISH;

	4386 }

	4387 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template1_unopt(

	4388 CJBig2_Image* pImage,

	4389 CJBig2_ArithDecoder* pArithDecoder,

	4390 JBig2ArithCtx* gbContext,

	4391 IFX_Pause* pPause) {

	4392 FX_BOOL SLTP, bVal;

	4393 FX_DWORD CONTEXT;

	4394 FX_DWORD line1, line2, line3;

	4395 for (FX_DWORD h = 0; h < GBH; h++) {

	4396 if (TPGDON) {

	4397 SLTP = pArithDecoder->DECODE(&gbContext[0x0795]);

	4398 LTP = LTP ^ SLTP;

	4399 }

	4400 if (LTP == 1) {

	4401 pImage->copyLine(h, h - 1);

	4402 } else {

	4403 line1 = pImage->getPixel(2, h - 2);

	4404 line1 \|= pImage->getPixel(1, h - 2) << 1;

	4405 line1 \|= pImage->getPixel(0, h - 2) << 2;

	4406 line2 = pImage->getPixel(2, h - 1);

	4407 line2 \|= pImage->getPixel(1, h - 1) << 1;

	4408 line2 \|= pImage->getPixel(0, h - 1) << 2;

	4409 line3 = 0;

	4410 for (FX_DWORD w = 0; w < GBW; w++) {

	4411 if (USESKIP && SKIP->getPixel(w, h)) {

	4412 bVal = 0;

3863 } else {	4413 } else {

3864 line1 = pImage->getPixel(1, m_loopIndex - 2);	4414 CONTEXT = line3;

3865 line1 \|= pImage->getPixel(0, m_loopIndex - 2) << 1;	4415 CONTEXT \|= pImage->getPixel(w + GBAT[0], h + GBAT[1]) << 3;

3866 line2 = pImage->getPixel(2, m_loopIndex - 1);	4416 CONTEXT \|= line2 << 4;

3867 line2 \|= pImage->getPixel(1, m_loopIndex - 1) << 1;	4417 CONTEXT \|= line1 << 9;

3868 line2 \|= pImage->getPixel(0, m_loopIndex - 1) << 2;	4418 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

3869 line3 = 0;	4419 }

3870 for(FX_DWORD w = 0; w < GBW; w++) {	4420 if (bVal) {

3871 if(USESKIP && SKIP->getPixel(w, m_loopIndex)) {	4421 pImage->setPixel(w, h, bVal);

3872 bVal = 0;	4422 }

3873 } else {	4423 line1 = ((line1 << 1) \| pImage->getPixel(w + 3, h - 2)) & 0x0f;

3874 CONTEXT = line3;	4424 line2 = ((line2 << 1) \| pImage->getPixel(w + 3, h - 1)) & 0x1f;

3875 CONTEXT \|= pImage->getPixel(w + GBAT[0], m_loopIndex + GBAT[ 1]) << 4;	4425 line3 = ((line3 << 1) \| bVal) & 0x07;

3876 CONTEXT \|= line2 << 5;	4426 }

3877 CONTEXT \|= pImage->getPixel(w + GBAT[2], m_loopIndex + GBAT[ 3]) << 10;	4427 }

3878 CONTEXT \|= pImage->getPixel(w + GBAT[4], m_loopIndex + GBAT[ 5]) << 11;	4428 if (pPause && pPause->NeedToPauseNow()) {

3879 CONTEXT \|= line1 << 12;	4429 m_loopIndex++;

3880 CONTEXT \|= pImage->getPixel(w + GBAT[6], m_loopIndex + GBAT[ 7]) << 15;	4430 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;

3881 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);	4431 return FXCODEC_STATUS_DECODE_TOBECONTINUE;

3882 }	4432 }

3883 if(bVal) {	4433 }

3884 pImage->setPixel(w, m_loopIndex, bVal);	4434 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;

3885 }	4435 return FXCODEC_STATUS_DECODE_FINISH;

3886 line1 = ((line1 << 1) \| pImage->getPixel(w + 2, m_loopIndex - 2) ) & 0x07;	4436 }

3887 line2 = ((line2 << 1) \| pImage->getPixel(w + 3, m_loopIndex - 1) ) & 0x1f;	4437 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template2_opt3(

3888 line3 = ((line3 << 1) \| bVal) & 0x0f;	4438 CJBig2_Image* pImage,

3889 }	4439 CJBig2_ArithDecoder* pArithDecoder,

3890 }	4440 JBig2ArithCtx* gbContext,

3891 if(pPause && pPause->NeedToPauseNow()) {	4441 IFX_Pause* pPause) {

3892 m_loopIndex++;	4442 FX_BOOL SLTP, bVal;

3893 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;	4443 FX_DWORD CONTEXT;

3894 return FXCODEC_STATUS_DECODE_TOBECONTINUE;	4444 FX_DWORD line1, line2;

3895 }	4445 FX_BYTE* pLine1, *pLine2, cVal;

3896 }	4446 FX_INT32 nStride, nStride2, k;

3897 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;	4447 FX_INT32 nLineBytes, nBitsLeft, cc;

3898 return FXCODEC_STATUS_DECODE_FINISH;	4448 if (!m_pLine) {

3899 }	4449 m_pLine = pImage->m_pData;

3900 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template1_opt3(CJBig2_Image pImage, CJBig2_ArithDecoder pArithDecoder, JBig2ArithCtx gbContext, IFX_Pause pPause )	4450 }

3901 {	4451 nStride = pImage->m_nStride;

3902 FX_BOOL SLTP, bVal;	4452 nStride2 = nStride << 1;

3903 FX_DWORD CONTEXT;	4453 nLineBytes = ((GBW + 7) >> 3) - 1;

3904 FX_DWORD line1, line2;	4454 nBitsLeft = GBW - (nLineBytes << 3);

3905 FX_BYTE pLine1, pLine2, cVal;	4455 for (; m_loopIndex < GBH; m_loopIndex++) {

3906 FX_INT32 nStride, nStride2, k;	4456 if (TPGDON) {

3907 FX_INT32 nLineBytes, nBitsLeft, cc;	4457 SLTP = pArithDecoder->DECODE(&gbContext[0x00e5]);

3908 if (!m_pLine) {	4458 LTP = LTP ^ SLTP;

3909 m_pLine = pImage->m_pData;	4459 }

3910 }	4460 if (LTP == 1) {

3911 nStride = pImage->m_nStride;	4461 pImage->copyLine(m_loopIndex, m_loopIndex - 1);

3912 nStride2 = nStride << 1;	4462 } else {

3913 nLineBytes = ((GBW + 7) >> 3) - 1;	4463 if (m_loopIndex > 1) {

3914 nBitsLeft = GBW - (nLineBytes << 3);	4464 pLine1 = m_pLine - nStride2;

3915 for(; m_loopIndex < GBH; m_loopIndex++) {	4465 pLine2 = m_pLine - nStride;

3916 if(TPGDON) {	4466 line1 = (*pLine1++) << 1;

3917 SLTP = pArithDecoder->DECODE(&gbContext[0x0795]);	4467 line2 = *pLine2++;

3918 LTP = LTP ^ SLTP;	4468 CONTEXT = (line1 & 0x0380) \| ((line2 >> 3) & 0x007c);

3919 }	4469 for (cc = 0; cc < nLineBytes; cc++) {

3920 if(LTP == 1) {	4470 line1 = (line1 << 8) \| ((*pLine1++) << 1);

3921 pImage->copyLine(m_loopIndex, m_loopIndex - 1);	4471 line2 = (line2 << 8) \| (*pLine2++);

	4472 cVal = 0;

	4473 for (k = 7; k >= 0; k--) {

	4474 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	4475 cVal \|= bVal << k;

	4476 CONTEXT = ((CONTEXT & 0x01bd) << 1) \| bVal \|

	4477 ((line1 >> k) & 0x0080) \| ((line2 >> (k + 3)) & 0x0004);

	4478 }

	4479 m_pLine[cc] = cVal;

	4480 }

	4481 line1 <<= 8;

	4482 line2 <<= 8;

	4483 cVal = 0;

	4484 for (k = 0; k < nBitsLeft; k++) {

	4485 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	4486 cVal \|= bVal << (7 - k);

	4487 CONTEXT = ((CONTEXT & 0x01bd) << 1) \| bVal \|

	4488 ((line1 >> (7 - k)) & 0x0080) \|

	4489 ((line2 >> (10 - k)) & 0x0004);

	4490 }

	4491 m_pLine[nLineBytes] = cVal;

	4492 } else {

	4493 pLine2 = m_pLine - nStride;

	4494 line2 = (m_loopIndex & 1) ? (*pLine2++) : 0;

	4495 CONTEXT = (line2 >> 3) & 0x007c;

	4496 for (cc = 0; cc < nLineBytes; cc++) {

	4497 if (m_loopIndex & 1) {

	4498 line2 = (line2 << 8) \| (*pLine2++);

	4499 }

	4500 cVal = 0;

	4501 for (k = 7; k >= 0; k--) {

	4502 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	4503 cVal \|= bVal << k;

	4504 CONTEXT = ((CONTEXT & 0x01bd) << 1) \| bVal \|

	4505 ((line2 >> (k + 3)) & 0x0004);

	4506 }

	4507 m_pLine[cc] = cVal;

	4508 }

	4509 line2 <<= 8;

	4510 cVal = 0;

	4511 for (k = 0; k < nBitsLeft; k++) {

	4512 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	4513 cVal \|= bVal << (7 - k);

	4514 CONTEXT = ((CONTEXT & 0x01bd) << 1) \| bVal \|

	4515 (((line2 >> (10 - k))) & 0x0004);

	4516 }

	4517 m_pLine[nLineBytes] = cVal;

	4518 }

	4519 }

	4520 m_pLine += nStride;

	4521 if (pPause && m_loopIndex % 50 == 0 && pPause->NeedToPauseNow()) {

	4522 m_loopIndex++;

	4523 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;

	4524 return FXCODEC_STATUS_DECODE_TOBECONTINUE;

	4525 }

	4526 }

	4527 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;

	4528 return FXCODEC_STATUS_DECODE_FINISH;

	4529 }

	4530 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template2_unopt(

	4531 CJBig2_Image* pImage,

	4532 CJBig2_ArithDecoder* pArithDecoder,

	4533 JBig2ArithCtx* gbContext,

	4534 IFX_Pause* pPause) {

	4535 FX_BOOL SLTP, bVal;

	4536 FX_DWORD CONTEXT;

	4537 FX_DWORD line1, line2, line3;

	4538 for (; m_loopIndex < GBH; m_loopIndex++) {

	4539 if (TPGDON) {

	4540 SLTP = pArithDecoder->DECODE(&gbContext[0x00e5]);

	4541 LTP = LTP ^ SLTP;

	4542 }

	4543 if (LTP == 1) {

	4544 pImage->copyLine(m_loopIndex, m_loopIndex - 1);

	4545 } else {

	4546 line1 = pImage->getPixel(1, m_loopIndex - 2);

	4547 line1 \|= pImage->getPixel(0, m_loopIndex - 2) << 1;

	4548 line2 = pImage->getPixel(1, m_loopIndex - 1);

	4549 line2 \|= pImage->getPixel(0, m_loopIndex - 1) << 1;

	4550 line3 = 0;

	4551 for (FX_DWORD w = 0; w < GBW; w++) {

	4552 if (USESKIP && SKIP->getPixel(w, m_loopIndex)) {

	4553 bVal = 0;

3922 } else {	4554 } else {

3923 if(m_loopIndex > 1) {	4555 CONTEXT = line3;

3924 pLine1 = m_pLine - nStride2;	4556 CONTEXT \|= pImage->getPixel(w + GBAT[0], m_loopIndex + GBAT[1]) << 2;

3925 pLine2 = m_pLine - nStride;	4557 CONTEXT \|= line2 << 3;

3926 line1 = (*pLine1++) << 4;	4558 CONTEXT \|= line1 << 7;

3927 line2 = *pLine2++;	4559 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

3928 CONTEXT = (line1 & 0x1e00) \| ((line2 >> 1) & 0x01f8);	4560 }

3929 for(cc = 0; cc < nLineBytes; cc++) {	4561 if (bVal) {

3930 line1 = (line1 << 8) \| ((*pLine1++) << 4);	4562 pImage->setPixel(w, m_loopIndex, bVal);

3931 line2 = (line2 << 8) \| (*pLine2++);	4563 }

3932 cVal = 0;	4564 line1 =

3933 for(k = 7; k >= 0; k--) {	4565 ((line1 << 1) \| pImage->getPixel(w + 2, m_loopIndex - 2)) & 0x07;

3934 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);	4566 line2 =

3935 cVal \|= bVal << k;	4567 ((line2 << 1) \| pImage->getPixel(w + 2, m_loopIndex - 1)) & 0x0f;

3936 CONTEXT = ((CONTEXT & 0x0efb) << 1) \| bVal	4568 line3 = ((line3 << 1) \| bVal) & 0x03;

3937 \| ((line1 >> k) & 0x0200)	4569 }

3938 \| ((line2 >> (k + 1)) & 0x0008);	4570 }

3939 }	4571 if (pPause && pPause->NeedToPauseNow()) {

3940 m_pLine[cc] = cVal;	4572 m_loopIndex++;

3941 }	4573 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;

3942 line1 <<= 8;	4574 return FXCODEC_STATUS_DECODE_TOBECONTINUE;

3943 line2 <<= 8;	4575 }

3944 cVal = 0;	4576 }

3945 for(k = 0; k < nBitsLeft; k++) {	4577 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;

3946 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);	4578 return FXCODEC_STATUS_DECODE_FINISH;

3947 cVal \|= bVal << (7 - k);	4579 }

3948 CONTEXT = ((CONTEXT & 0x0efb) << 1) \| bVal	4580 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template3_opt3(

3949 \| ((line1 >> (7 - k)) & 0x0200)	4581 CJBig2_Image* pImage,

3950 \| ((line2 >> (8 - k)) & 0x0008);	4582 CJBig2_ArithDecoder* pArithDecoder,

3951 }	4583 JBig2ArithCtx* gbContext,

3952 m_pLine[nLineBytes] = cVal;	4584 IFX_Pause* pPause) {

3953 } else {	4585 FX_BOOL SLTP, bVal;

3954 pLine2 = m_pLine - nStride;	4586 FX_DWORD CONTEXT;

3955 line2 = (m_loopIndex & 1) ? (*pLine2++) : 0;	4587 FX_DWORD line1;

3956 CONTEXT = (line2 >> 1) & 0x01f8;	4588 FX_BYTE* pLine1, cVal;

3957 for(cc = 0; cc < nLineBytes; cc++) {	4589 FX_INT32 nStride, k;

3958 if(m_loopIndex & 1) {	4590 FX_INT32 nLineBytes, nBitsLeft, cc;

3959 line2 = (line2 << 8) \| (*pLine2++);	4591 if (!m_pLine) {

3960 }	4592 m_pLine = pImage->m_pData;

3961 cVal = 0;	4593 }

3962 for(k = 7; k >= 0; k--) {	4594 nStride = pImage->m_nStride;

3963 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);	4595 nLineBytes = ((GBW + 7) >> 3) - 1;

3964 cVal \|= bVal << k;	4596 nBitsLeft = GBW - (nLineBytes << 3);

3965 CONTEXT = ((CONTEXT & 0x0efb) << 1) \| bVal	4597 for (; m_loopIndex < GBH; m_loopIndex++) {

3966 \| ((line2 >> (k + 1)) & 0x0008);	4598 if (TPGDON) {

3967 }	4599 SLTP = pArithDecoder->DECODE(&gbContext[0x0195]);

3968 m_pLine[cc] = cVal;	4600 LTP = LTP ^ SLTP;

3969 }	4601 }

3970 line2 <<= 8;	4602 if (LTP == 1) {

3971 cVal = 0;	4603 pImage->copyLine(m_loopIndex, m_loopIndex - 1);

3972 for(k = 0; k < nBitsLeft; k++) {	4604 } else {

3973 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);	4605 if (m_loopIndex > 0) {

3974 cVal \|= bVal << (7 - k);	4606 pLine1 = m_pLine - nStride;

3975 CONTEXT = ((CONTEXT & 0x0efb) << 1) \| bVal	4607 line1 = *pLine1++;

3976 \| ((line2 >> (8 - k)) & 0x0008);	4608 CONTEXT = (line1 >> 1) & 0x03f0;

3977 }	4609 for (cc = 0; cc < nLineBytes; cc++) {

3978 m_pLine[nLineBytes] = cVal;	4610 line1 = (line1 << 8) \| (*pLine1++);

3979 }	4611 cVal = 0;

3980 }	4612 for (k = 7; k >= 0; k--) {

3981 m_pLine += nStride;	4613 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

3982 if(pPause && pPause->NeedToPauseNow()) {	4614 cVal \|= bVal << k;

3983 m_loopIndex++;	4615 CONTEXT = ((CONTEXT & 0x01f7) << 1) \| bVal \|

3984 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;	4616 ((line1 >> (k + 1)) & 0x0010);

3985 return FXCODEC_STATUS_DECODE_TOBECONTINUE;	4617 }

3986 }	4618 m_pLine[cc] = cVal;

3987 }	4619 }

3988 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;	4620 line1 <<= 8;

3989 return FXCODEC_STATUS_DECODE_FINISH;	4621 cVal = 0;

3990 }	4622 for (k = 0; k < nBitsLeft; k++) {

3991 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template1_unopt(CJBig2_Image * pImag e, CJBig2_ArithDecoder pArithDecoder, JBig2ArithCtx gbContext, IFX_Pause* pPau se)	4623 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

3992 {	4624 cVal \|= bVal << (7 - k);

3993 FX_BOOL SLTP, bVal;	4625 CONTEXT =

3994 FX_DWORD CONTEXT;	4626 ((CONTEXT & 0x01f7) << 1) \| bVal \| ((line1 >> (8 - k)) & 0x0010);

3995 FX_DWORD line1, line2, line3;	4627 }

3996 for(FX_DWORD h = 0; h < GBH; h++) {	4628 m_pLine[nLineBytes] = cVal;

3997 if(TPGDON) {	4629 } else {

3998 SLTP = pArithDecoder->DECODE(&gbContext[0x0795]);	4630 CONTEXT = 0;

3999 LTP = LTP ^ SLTP;	4631 for (cc = 0; cc < nLineBytes; cc++) {

4000 }	4632 cVal = 0;

4001 if(LTP == 1) {	4633 for (k = 7; k >= 0; k--) {

4002 pImage->copyLine(h, h - 1);	4634 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	4635 cVal \|= bVal << k;

	4636 CONTEXT = ((CONTEXT & 0x01f7) << 1) \| bVal;

	4637 }

	4638 m_pLine[cc] = cVal;

	4639 }

	4640 cVal = 0;

	4641 for (k = 0; k < nBitsLeft; k++) {

	4642 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

	4643 cVal \|= bVal << (7 - k);

	4644 CONTEXT = ((CONTEXT & 0x01f7) << 1) \| bVal;

	4645 }

	4646 m_pLine[nLineBytes] = cVal;

	4647 }

	4648 }

	4649 m_pLine += nStride;

	4650 if (pPause && pPause->NeedToPauseNow()) {

	4651 m_loopIndex++;

	4652 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;

	4653 return FXCODEC_STATUS_DECODE_TOBECONTINUE;

	4654 }

	4655 }

	4656 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;

	4657 return FXCODEC_STATUS_DECODE_FINISH;

	4658 }

	4659 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template3_unopt(

	4660 CJBig2_Image* pImage,

	4661 CJBig2_ArithDecoder* pArithDecoder,

	4662 JBig2ArithCtx* gbContext,

	4663 IFX_Pause* pPause) {

	4664 FX_BOOL SLTP, bVal;

	4665 FX_DWORD CONTEXT;

	4666 FX_DWORD line1, line2;

	4667 for (; m_loopIndex < GBH; m_loopIndex++) {

	4668 if (TPGDON) {

	4669 SLTP = pArithDecoder->DECODE(&gbContext[0x0195]);

	4670 LTP = LTP ^ SLTP;

	4671 }

	4672 if (LTP == 1) {

	4673 pImage->copyLine(m_loopIndex, m_loopIndex - 1);

	4674 } else {

	4675 line1 = pImage->getPixel(1, m_loopIndex - 1);

	4676 line1 \|= pImage->getPixel(0, m_loopIndex - 1) << 1;

	4677 line2 = 0;

	4678 for (FX_DWORD w = 0; w < GBW; w++) {

	4679 if (USESKIP && SKIP->getPixel(w, m_loopIndex)) {

	4680 bVal = 0;

4003 } else {	4681 } else {

4004 line1 = pImage->getPixel(2, h - 2);	4682 CONTEXT = line2;

4005 line1 \|= pImage->getPixel(1, h - 2) << 1;	4683 CONTEXT \|= pImage->getPixel(w + GBAT[0], m_loopIndex + GBAT[1]) << 4;

4006 line1 \|= pImage->getPixel(0, h - 2) << 2;	4684 CONTEXT \|= line1 << 5;

4007 line2 = pImage->getPixel(2, h - 1);	4685 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

4008 line2 \|= pImage->getPixel(1, h - 1) << 1;	4686 }

4009 line2 \|= pImage->getPixel(0, h - 1) << 2;	4687 if (bVal) {

4010 line3 = 0;	4688 pImage->setPixel(w, m_loopIndex, bVal);

4011 for(FX_DWORD w = 0; w < GBW; w++) {	4689 }

4012 if(USESKIP && SKIP->getPixel(w, h)) {	4690 line1 =

4013 bVal = 0;	4691 ((line1 << 1) \| pImage->getPixel(w + 2, m_loopIndex - 1)) & 0x1f;

4014 } else {	4692 line2 = ((line2 << 1) \| bVal) & 0x0f;

4015 CONTEXT = line3;	4693 }

4016 CONTEXT \|= pImage->getPixel(w + GBAT[0], h + GBAT[1]) << 3;	4694 }

4017 CONTEXT \|= line2 << 4;	4695 if (pPause && pPause->NeedToPauseNow()) {

4018 CONTEXT \|= line1 << 9;	4696 m_loopIndex++;

4019 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);	4697 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;

4020 }	4698 return FXCODEC_STATUS_DECODE_TOBECONTINUE;

4021 if(bVal) {	4699 }

4022 pImage->setPixel(w, h, bVal);	4700 }

4023 }	4701 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;

4024 line1 = ((line1 << 1) \| pImage->getPixel(w + 3, h - 2)) & 0x0f;	4702 return FXCODEC_STATUS_DECODE_FINISH;

4025 line2 = ((line2 << 1) \| pImage->getPixel(w + 3, h - 1)) & 0x1f;	4703 }

4026 line3 = ((line3 << 1) \| bVal) & 0x07;

4027 }

4028 }

4029 if(pPause && pPause->NeedToPauseNow()) {

4030 m_loopIndex++;

4031 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;

4032 return FXCODEC_STATUS_DECODE_TOBECONTINUE;

4033 }

4034 }

4035 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;

4036 return FXCODEC_STATUS_DECODE_FINISH;

4037 }

4038 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template2_opt3(CJBig2_Image pImage, CJBig2_ArithDecoder pArithDecoder, JBig2ArithCtx gbContext, IFX_Pause pPause )

4039 {

4040 FX_BOOL SLTP, bVal;

4041 FX_DWORD CONTEXT;

4042 FX_DWORD line1, line2;

4043 FX_BYTE pLine1, pLine2, cVal;

4044 FX_INT32 nStride, nStride2, k;

4045 FX_INT32 nLineBytes, nBitsLeft, cc;

4046 if(!m_pLine) {

4047 m_pLine = pImage->m_pData;

4048 }

4049 nStride = pImage->m_nStride;

4050 nStride2 = nStride << 1;

4051 nLineBytes = ((GBW + 7) >> 3) - 1;

4052 nBitsLeft = GBW - (nLineBytes << 3);

4053 for(; m_loopIndex < GBH; m_loopIndex++) {

4054 if(TPGDON) {

4055 SLTP = pArithDecoder->DECODE(&gbContext[0x00e5]);

4056 LTP = LTP ^ SLTP;

4057 }

4058 if(LTP == 1) {

4059 pImage->copyLine(m_loopIndex, m_loopIndex - 1);

4060 } else {

4061 if(m_loopIndex > 1) {

4062 pLine1 = m_pLine - nStride2;

4063 pLine2 = m_pLine - nStride;

4064 line1 = (*pLine1++) << 1;

4065 line2 = *pLine2++;

4066 CONTEXT = (line1 & 0x0380) \| ((line2 >> 3) & 0x007c);

4067 for(cc = 0; cc < nLineBytes; cc++) {

4068 line1 = (line1 << 8) \| ((*pLine1++) << 1);

4069 line2 = (line2 << 8) \| (*pLine2++);

4070 cVal = 0;

4071 for(k = 7; k >= 0; k--) {

4072 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

4073 cVal \|= bVal << k;

4074 CONTEXT = ((CONTEXT & 0x01bd) << 1) \| bVal

4075 \| ((line1 >> k) & 0x0080)

4076 \| ((line2 >> (k + 3)) & 0x0004);

4077 }

4078 m_pLine[cc] = cVal;

4079 }

4080 line1 <<= 8;

4081 line2 <<= 8;

4082 cVal = 0;

4083 for(k = 0; k < nBitsLeft; k++) {

4084 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

4085 cVal \|= bVal << (7 - k);

4086 CONTEXT = ((CONTEXT & 0x01bd) << 1) \| bVal

4087 \| ((line1 >> (7 - k)) & 0x0080)

4088 \| ((line2 >> (10 - k)) & 0x0004);

4089 }

4090 m_pLine[nLineBytes] = cVal;

4091 } else {

4092 pLine2 = m_pLine - nStride;

4093 line2 = (m_loopIndex & 1) ? (*pLine2++) : 0;

4094 CONTEXT = (line2 >> 3) & 0x007c;

4095 for(cc = 0; cc < nLineBytes; cc++) {

4096 if(m_loopIndex & 1) {

4097 line2 = (line2 << 8) \| (*pLine2++);

4098 }

4099 cVal = 0;

4100 for(k = 7; k >= 0; k--) {

4101 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

4102 cVal \|= bVal << k;

4103 CONTEXT = ((CONTEXT & 0x01bd) << 1) \| bVal

4104 \| ((line2 >> (k + 3)) & 0x0004);

4105 }

4106 m_pLine[cc] = cVal;

4107 }

4108 line2 <<= 8;

4109 cVal = 0;

4110 for(k = 0; k < nBitsLeft; k++) {

4111 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

4112 cVal \|= bVal << (7 - k);

4113 CONTEXT = ((CONTEXT & 0x01bd) << 1) \| bVal

4114 \| (((line2 >> (10 - k))) & 0x0004);

4115 }

4116 m_pLine[nLineBytes] = cVal;

4117 }

4118 }

4119 m_pLine += nStride;

4120 if(pPause && m_loopIndex % 50 == 0 && pPause->NeedToPauseNow()) {

4121 m_loopIndex++;

4122 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;

4123 return FXCODEC_STATUS_DECODE_TOBECONTINUE;

4124 }

4125 }

4126 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;

4127 return FXCODEC_STATUS_DECODE_FINISH;

4128 }

4129 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template2_unopt(CJBig2_Image * pImag e, CJBig2_ArithDecoder pArithDecoder, JBig2ArithCtx gbContext, IFX_Pause* pPau se)

4130 {

4131 FX_BOOL SLTP, bVal;

4132 FX_DWORD CONTEXT;

4133 FX_DWORD line1, line2, line3;

4134 for(; m_loopIndex < GBH; m_loopIndex++) {

4135 if(TPGDON) {

4136 SLTP = pArithDecoder->DECODE(&gbContext[0x00e5]);

4137 LTP = LTP ^ SLTP;

4138 }

4139 if(LTP == 1) {

4140 pImage->copyLine(m_loopIndex, m_loopIndex - 1);

4141 } else {

4142 line1 = pImage->getPixel(1, m_loopIndex - 2);

4143 line1 \|= pImage->getPixel(0, m_loopIndex - 2) << 1;

4144 line2 = pImage->getPixel(1, m_loopIndex - 1);

4145 line2 \|= pImage->getPixel(0, m_loopIndex - 1) << 1;

4146 line3 = 0;

4147 for(FX_DWORD w = 0; w < GBW; w++) {

4148 if(USESKIP && SKIP->getPixel(w, m_loopIndex)) {

4149 bVal = 0;

4150 } else {

4151 CONTEXT = line3;

4152 CONTEXT \|= pImage->getPixel(w + GBAT[0], m_loopIndex + GBAT[ 1]) << 2;

4153 CONTEXT \|= line2 << 3;

4154 CONTEXT \|= line1 << 7;

4155 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

4156 }

4157 if(bVal) {

4158 pImage->setPixel(w, m_loopIndex, bVal);

4159 }

4160 line1 = ((line1 << 1) \| pImage->getPixel(w + 2, m_loopIndex - 2) ) & 0x07;

4161 line2 = ((line2 << 1) \| pImage->getPixel(w + 2, m_loopIndex - 1) ) & 0x0f;

4162 line3 = ((line3 << 1) \| bVal) & 0x03;

4163 }

4164 }

4165 if(pPause && pPause->NeedToPauseNow()) {

4166 m_loopIndex++;

4167 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;

4168 return FXCODEC_STATUS_DECODE_TOBECONTINUE;

4169 }

4170 }

4171 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;

4172 return FXCODEC_STATUS_DECODE_FINISH;

4173 }

4174 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template3_opt3(CJBig2_Image pImage, CJBig2_ArithDecoder pArithDecoder, JBig2ArithCtx gbContext, IFX_Pause pPause )

4175 {

4176 FX_BOOL SLTP, bVal;

4177 FX_DWORD CONTEXT;

4178 FX_DWORD line1;

4179 FX_BYTE *pLine1, cVal;

4180 FX_INT32 nStride, k;

4181 FX_INT32 nLineBytes, nBitsLeft, cc;

4182 if (!m_pLine) {

4183 m_pLine = pImage->m_pData;

4184 }

4185 nStride = pImage->m_nStride;

4186 nLineBytes = ((GBW + 7) >> 3) - 1;

4187 nBitsLeft = GBW - (nLineBytes << 3);

4188 for(; m_loopIndex < GBH; m_loopIndex++) {

4189 if(TPGDON) {

4190 SLTP = pArithDecoder->DECODE(&gbContext[0x0195]);

4191 LTP = LTP ^ SLTP;

4192 }

4193 if(LTP == 1) {

4194 pImage->copyLine(m_loopIndex, m_loopIndex - 1);

4195 } else {

4196 if(m_loopIndex > 0) {

4197 pLine1 = m_pLine - nStride;

4198 line1 = *pLine1++;

4199 CONTEXT = (line1 >> 1) & 0x03f0;

4200 for(cc = 0; cc < nLineBytes; cc++) {

4201 line1 = (line1 << 8) \| (*pLine1++);

4202 cVal = 0;

4203 for(k = 7; k >= 0; k--) {

4204 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

4205 cVal \|= bVal << k;

4206 CONTEXT = ((CONTEXT & 0x01f7) << 1) \| bVal

4207 \| ((line1 >> (k + 1)) & 0x0010);

4208 }

4209 m_pLine[cc] = cVal;

4210 }

4211 line1 <<= 8;

4212 cVal = 0;

4213 for(k = 0; k < nBitsLeft; k++) {

4214 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

4215 cVal \|= bVal << (7 - k);

4216 CONTEXT = ((CONTEXT & 0x01f7) << 1) \| bVal

4217 \| ((line1 >> (8 - k)) & 0x0010);

4218 }

4219 m_pLine[nLineBytes] = cVal;

4220 } else {

4221 CONTEXT = 0;

4222 for(cc = 0; cc < nLineBytes; cc++) {

4223 cVal = 0;

4224 for(k = 7; k >= 0; k--) {

4225 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

4226 cVal \|= bVal << k;

4227 CONTEXT = ((CONTEXT & 0x01f7) << 1) \| bVal;

4228 }

4229 m_pLine[cc] = cVal;

4230 }

4231 cVal = 0;

4232 for(k = 0; k < nBitsLeft; k++) {

4233 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

4234 cVal \|= bVal << (7 - k);

4235 CONTEXT = ((CONTEXT & 0x01f7) << 1) \| bVal;

4236 }

4237 m_pLine[nLineBytes] = cVal;

4238 }

4239 }

4240 m_pLine += nStride;

4241 if(pPause && pPause->NeedToPauseNow()) {

4242 m_loopIndex++;

4243 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;

4244 return FXCODEC_STATUS_DECODE_TOBECONTINUE;

4245 }

4246 }

4247 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;

4248 return FXCODEC_STATUS_DECODE_FINISH;

4249 }

4250 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template3_unopt(CJBig2_Image * pImag e, CJBig2_ArithDecoder pArithDecoder, JBig2ArithCtx gbContext, IFX_Pause* pPau se)

4251 {

4252 FX_BOOL SLTP, bVal;

4253 FX_DWORD CONTEXT;

4254 FX_DWORD line1, line2;

4255 for(; m_loopIndex < GBH; m_loopIndex++) {

4256 if(TPGDON) {

4257 SLTP = pArithDecoder->DECODE(&gbContext[0x0195]);

4258 LTP = LTP ^ SLTP;

4259 }

4260 if(LTP == 1) {

4261 pImage->copyLine(m_loopIndex, m_loopIndex - 1);

4262 } else {

4263 line1 = pImage->getPixel(1, m_loopIndex - 1);

4264 line1 \|= pImage->getPixel(0, m_loopIndex - 1) << 1;

4265 line2 = 0;

4266 for(FX_DWORD w = 0; w < GBW; w++) {

4267 if(USESKIP && SKIP->getPixel(w, m_loopIndex)) {

4268 bVal = 0;

4269 } else {

4270 CONTEXT = line2;

4271 CONTEXT \|= pImage->getPixel(w + GBAT[0], m_loopIndex + GBAT[ 1]) << 4;

4272 CONTEXT \|= line1 << 5;

4273 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);

4274 }

4275 if(bVal) {

4276 pImage->setPixel(w, m_loopIndex, bVal);

4277 }

4278 line1 = ((line1 << 1) \| pImage->getPixel(w + 2, m_loopIndex - 1) ) & 0x1f;

4279 line2 = ((line2 << 1) \| bVal) & 0x0f;

4280 }

4281 }

4282 if(pPause && pPause->NeedToPauseNow()) {

4283 m_loopIndex++;

4284 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;

4285 return FXCODEC_STATUS_DECODE_TOBECONTINUE;

4286 }

4287 }

4288 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;

4289 return FXCODEC_STATUS_DECODE_FINISH;

4290 }

OLD	NEW

« core/src/fdrm/crypto/fx_crypt_aes.cpp ('K') | « core/src/fxcodec/jbig2/JBig2_GeneralDecoder.h ('k') | core/src/fxcodec/jbig2/JBig2_HuffmanDecoder.h » ('j') | no next file with comments »