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

Issues Search
    My Issues | Starred     Open | Closed | All

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

Issue 1265503005: clang-format all pdfium code. (Closed) Base URL: https://pdfium.googlesource.com/pdfium.git@master
Patch Set: sigh Created 5 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « core/src/fxcodec/jbig2/JBig2_GeneralDecoder.h ('k') | core/src/fxcodec/jbig2/JBig2_HuffmanDecoder.h » ('j') | fpdfsdk/src/javascript/Consts.cpp » ('J')
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright 2014 PDFium Authors. All rights reserved. 1 // Copyright 2014 PDFium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com 5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
6 6
7 #include "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 13
14 extern const JBig2ArithQe QeTable[] = { 14 extern const JBig2ArithQe QeTable[] = {
15 { 0x5601, 1, 1, 1 }, 15 {0x5601, 1, 1, 1}, {0x3401, 2, 6, 0}, {0x1801, 3, 9, 0},
16 { 0x3401, 2, 6, 0 }, 16 {0x0AC1, 4, 12, 0}, {0x0521, 5, 29, 0}, {0x0221, 38, 33, 0},
17 { 0x1801, 3, 9, 0 }, 17 {0x5601, 7, 6, 1}, {0x5401, 8, 14, 0}, {0x4801, 9, 14, 0},
18 { 0x0AC1, 4, 12, 0 }, 18 {0x3801, 10, 14, 0}, {0x3001, 11, 17, 0}, {0x2401, 12, 18, 0},
19 { 0x0521, 5, 29, 0 }, 19 {0x1C01, 13, 20, 0}, {0x1601, 29, 21, 0}, {0x5601, 15, 14, 1},
20 { 0x0221, 38, 33, 0 }, 20 {0x5401, 16, 14, 0}, {0x5101, 17, 15, 0}, {0x4801, 18, 16, 0},
21 { 0x5601, 7, 6, 1 }, 21 {0x3801, 19, 17, 0}, {0x3401, 20, 18, 0}, {0x3001, 21, 19, 0},
22 { 0x5401, 8, 14, 0 }, 22 {0x2801, 22, 19, 0}, {0x2401, 23, 20, 0}, {0x2201, 24, 21, 0},
23 { 0x4801, 9, 14, 0 }, 23 {0x1C01, 25, 22, 0}, {0x1801, 26, 23, 0}, {0x1601, 27, 24, 0},
24 { 0x3801, 10, 14, 0 }, 24 {0x1401, 28, 25, 0}, {0x1201, 29, 26, 0}, {0x1101, 30, 27, 0},
25 { 0x3001, 11, 17, 0 }, 25 {0x0AC1, 31, 28, 0}, {0x09C1, 32, 29, 0}, {0x08A1, 33, 30, 0},
26 { 0x2401, 12, 18, 0 }, 26 {0x0521, 34, 31, 0}, {0x0441, 35, 32, 0}, {0x02A1, 36, 33, 0},
27 { 0x1C01, 13, 20, 0 }, 27 {0x0221, 37, 34, 0}, {0x0141, 38, 35, 0}, {0x0111, 39, 36, 0},
28 { 0x1601, 29, 21, 0 }, 28 {0x0085, 40, 37, 0}, {0x0049, 41, 38, 0}, {0x0025, 42, 39, 0},
29 { 0x5601, 15, 14, 1 }, 29 {0x0015, 43, 40, 0}, {0x0009, 44, 41, 0}, {0x0005, 45, 42, 0},
30 { 0x5401, 16, 14, 0 }, 30 {0x0001, 45, 43, 0}, {0x5601, 46, 46, 0}};
31 { 0x5101, 17, 15, 0 },
32 { 0x4801, 18, 16, 0 },
33 { 0x3801, 19, 17, 0 },
34 { 0x3401, 20, 18, 0 },
35 { 0x3001, 21, 19, 0 },
36 { 0x2801, 22, 19, 0 },
37 { 0x2401, 23, 20, 0 },
38 { 0x2201, 24, 21, 0 },
39 { 0x1C01, 25, 22, 0 },
40 { 0x1801, 26, 23, 0 },
41 { 0x1601, 27, 24, 0 },
42 { 0x1401, 28, 25, 0 },
43 { 0x1201, 29, 26, 0 },
44 { 0x1101, 30, 27, 0 },
45 { 0x0AC1, 31, 28, 0 },
46 { 0x09C1, 32, 29, 0 },
47 { 0x08A1, 33, 30, 0 },
48 { 0x0521, 34, 31, 0 },
49 { 0x0441, 35, 32, 0 },
50 { 0x02A1, 36, 33, 0 },
51 { 0x0221, 37, 34, 0 },
52 { 0x0141, 38, 35, 0 },
53 { 0x0111, 39, 36, 0 },
54 { 0x0085, 40, 37, 0 },
55 { 0x0049, 41, 38, 0 },
56 { 0x0025, 42, 39, 0 },
57 { 0x0015, 43, 40, 0 },
58 { 0x0009, 44, 41, 0 },
59 { 0x0005, 45, 42, 0 },
60 { 0x0001, 45, 43, 0 },
61 { 0x5601, 46, 46, 0 }
62 };
63 31
64 extern const unsigned int JBIG2_QE_NUM = sizeof(QeTable) / sizeof(JBig2ArithQe); 32 extern const unsigned int JBIG2_QE_NUM = sizeof(QeTable) / sizeof(JBig2ArithQe);
65 33
66 CJBig2_Image *CJBig2_GRDProc::decode_Arith(CJBig2_ArithDecoder *pArithDecoder, J Big2ArithCtx *gbContext) 34 CJBig2_Image* CJBig2_GRDProc::decode_Arith(CJBig2_ArithDecoder* pArithDecoder,
67 { 35 JBig2ArithCtx* gbContext) {
68 if (GBW == 0 || GBH == 0) { 36 if (GBW == 0 || GBH == 0) {
69 CJBig2_Image* pImage; 37 CJBig2_Image* pImage;
70 JBIG2_ALLOC(pImage, CJBig2_Image(GBW, GBH)); 38 JBIG2_ALLOC(pImage, CJBig2_Image(GBW, GBH));
71 return pImage; 39 return pImage;
72 } 40 }
73 if(GBTEMPLATE == 0) { 41 if (GBTEMPLATE == 0) {
74 if((GBAT[0] == 3) && (GBAT[1] == (signed char) - 1) 42 if ((GBAT[0] == 3) && (GBAT[1] == (signed char)-1) &&
75 && (GBAT[2] == (signed char) - 3) && (GBAT[3] == (signed char) - 1) 43 (GBAT[2] == (signed char)-3) && (GBAT[3] == (signed char)-1) &&
76 && (GBAT[4] == 2) && (GBAT[5] == (signed char) - 2) 44 (GBAT[4] == 2) && (GBAT[5] == (signed char)-2) &&
77 && (GBAT[6] == (signed char) - 2) && (GBAT[7] == (signed char) - 2)) { 45 (GBAT[6] == (signed char)-2) && (GBAT[7] == (signed char)-2)) {
78 return decode_Arith_Template0_opt3(pArithDecoder, gbContext); 46 return decode_Arith_Template0_opt3(pArithDecoder, gbContext);
47 } else {
48 return decode_Arith_Template0_unopt(pArithDecoder, gbContext);
49 }
50 } else if (GBTEMPLATE == 1) {
51 if ((GBAT[0] == 3) && (GBAT[1] == (signed char)-1)) {
52 return decode_Arith_Template1_opt3(pArithDecoder, gbContext);
53 } else {
54 return decode_Arith_Template1_unopt(pArithDecoder, gbContext);
55 }
56 } else if (GBTEMPLATE == 2) {
57 if ((GBAT[0] == 2) && (GBAT[1] == (signed char)-1)) {
58 return decode_Arith_Template2_opt3(pArithDecoder, gbContext);
59 } else {
60 return decode_Arith_Template2_unopt(pArithDecoder, gbContext);
61 }
62 } else {
63 if ((GBAT[0] == 2) && (GBAT[1] == (signed char)-1)) {
64 return decode_Arith_Template3_opt3(pArithDecoder, gbContext);
65 } else {
66 return decode_Arith_Template3_unopt(pArithDecoder, gbContext);
67 }
68 }
69 }
70 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template0_opt(
71 CJBig2_ArithDecoder* pArithDecoder,
72 JBig2ArithCtx* gbContext) {
73 FX_BOOL LTP, SLTP, bVal;
74 FX_DWORD CONTEXT;
75 CJBig2_Image* GBREG;
76 FX_DWORD line1, line2, line3;
77 LTP = 0;
78 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
79 GBREG->fill(0);
80 for (FX_DWORD h = 0; h < GBH; h++) {
81 if (TPGDON) {
82 SLTP = pArithDecoder->DECODE(&gbContext[0x9b25]);
83 LTP = LTP ^ SLTP;
84 }
85 if (LTP == 1) {
86 GBREG->copyLine(h, h - 1);
87 } else {
88 line1 = GBREG->getPixel(2, h - 2);
89 line1 |= GBREG->getPixel(1, h - 2) << 1;
90 line1 |= GBREG->getPixel(0, h - 2) << 2;
91 line2 = GBREG->getPixel(3, h - 1);
92 line2 |= GBREG->getPixel(2, h - 1) << 1;
93 line2 |= GBREG->getPixel(1, h - 1) << 2;
94 line2 |= GBREG->getPixel(0, h - 1) << 3;
95 line3 = 0;
96 for (FX_DWORD w = 0; w < GBW; w++) {
97 if (USESKIP && SKIP->getPixel(w, h)) {
98 bVal = 0;
79 } else { 99 } else {
80 return decode_Arith_Template0_unopt(pArithDecoder, gbContext); 100 CONTEXT = line3;
81 } 101 CONTEXT |= line2 << 4;
82 } else if(GBTEMPLATE == 1) { 102 CONTEXT |= line1 << 11;
83 if((GBAT[0] == 3) && (GBAT[1] == (signed char) - 1)) { 103 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
84 return decode_Arith_Template1_opt3(pArithDecoder, gbContext); 104 }
105 if (bVal) {
106 GBREG->setPixel(w, h, bVal);
107 }
108 line1 = ((line1 << 1) | GBREG->getPixel(w + 3, h - 2)) & 0x1f;
109 line2 = ((line2 << 1) | GBREG->getPixel(w + 4, h - 1)) & 0x7f;
110 line3 = ((line3 << 1) | bVal) & 0x0f;
111 }
112 }
113 }
114 return GBREG;
115 }
116 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template0_opt2(
117 CJBig2_ArithDecoder* pArithDecoder,
118 JBig2ArithCtx* gbContext) {
119 FX_BOOL LTP, SLTP, bVal;
120 FX_DWORD CONTEXT;
121 CJBig2_Image* GBREG;
122 FX_DWORD line1, line2;
123 uint8_t *pLine, cVal;
124 intptr_t nStride, nStride2;
125 int32_t nBits, k;
126 LTP = 0;
127 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
128 if (GBREG->m_pData == NULL) {
129 delete GBREG;
130 m_pModule->JBig2_Error(
131 "Generic region decoding procedure: Create Image Failed with width = "
132 "%d, height = %d\n",
133 GBW, GBH);
134 return NULL;
135 }
136 pLine = GBREG->m_pData;
137 nStride = GBREG->m_nStride;
138 nStride2 = nStride << 1;
139 for (FX_DWORD h = 0; h < GBH; h++) {
140 if (TPGDON) {
141 SLTP = pArithDecoder->DECODE(&gbContext[0x9b25]);
142 LTP = LTP ^ SLTP;
143 }
144 if (LTP == 1) {
145 GBREG->copyLine(h, h - 1);
146 } else {
147 line1 = (h > 1) ? pLine[-nStride2] << 6 : 0;
148 line2 = (h > 0) ? pLine[-nStride] : 0;
149 CONTEXT = (line1 & 0xf800) | (line2 & 0x07f0);
150 for (FX_DWORD w = 0; w < GBW; w += 8) {
151 if (w + 8 < GBW) {
152 nBits = 8;
153 if (h > 1) {
154 line1 = (line1 << 8) | (pLine[-nStride2 + (w >> 3) + 1] << 6);
155 }
156 if (h > 0) {
157 line2 = (line2 << 8) | (pLine[-nStride + (w >> 3) + 1]);
158 }
85 } else { 159 } else {
86 return decode_Arith_Template1_unopt(pArithDecoder, gbContext); 160 nBits = GBW - w;
87 } 161 if (h > 1) {
88 } else if(GBTEMPLATE == 2) { 162 line1 <<= 8;
89 if((GBAT[0] == 2) && (GBAT[1] == (signed char) - 1)) { 163 }
90 return decode_Arith_Template2_opt3(pArithDecoder, gbContext); 164 if (h > 0) {
165 line2 <<= 8;
166 }
167 }
168 cVal = 0;
169 for (k = 0; k < nBits; k++) {
170 if (USESKIP && SKIP->getPixel(w, h)) {
171 bVal = 0;
172 } else {
173 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
174 }
175 cVal |= bVal << (7 - k);
176 CONTEXT = ((CONTEXT & 0x7bf7) << 1) | bVal |
177 ((line1 >> (7 - k)) & 0x0800) |
178 ((line2 >> (7 - k)) & 0x0010);
179 }
180 pLine[w >> 3] = cVal;
181 }
182 }
183 pLine += nStride;
184 }
185 return GBREG;
186 }
187 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template0_opt3(
188 CJBig2_ArithDecoder* pArithDecoder,
189 JBig2ArithCtx* gbContext) {
190 FX_BOOL LTP, SLTP, bVal;
191 FX_DWORD CONTEXT;
192 CJBig2_Image* GBREG;
193 FX_DWORD line1, line2;
194 uint8_t *pLine, *pLine1, *pLine2, cVal;
195 int32_t nStride, nStride2, k;
196 int32_t nLineBytes, nBitsLeft, cc;
197 LTP = 0;
198 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
199 if (GBREG->m_pData == NULL) {
200 delete GBREG;
201 m_pModule->JBig2_Error(
202 "Generic region decoding procedure: Create Image Failed with width = "
203 "%d, height = %d\n",
204 GBW, GBH);
205 return NULL;
206 }
207 pLine = GBREG->m_pData;
208 nStride = GBREG->m_nStride;
209 nStride2 = nStride << 1;
210 nLineBytes = ((GBW + 7) >> 3) - 1;
211 nBitsLeft = GBW - (nLineBytes << 3);
212 FX_DWORD height = GBH & 0x7fffffff;
213 for (FX_DWORD h = 0; h < height; h++) {
214 if (TPGDON) {
215 SLTP = pArithDecoder->DECODE(&gbContext[0x9b25]);
216 LTP = LTP ^ SLTP;
217 }
218 if (LTP == 1) {
219 GBREG->copyLine(h, h - 1);
220 } else {
221 if (h > 1) {
222 pLine1 = pLine - nStride2;
223 pLine2 = pLine - nStride;
224 line1 = (*pLine1++) << 6;
225 line2 = *pLine2++;
226 CONTEXT = ((line1 & 0xf800) | (line2 & 0x07f0));
227 for (cc = 0; cc < nLineBytes; cc++) {
228 line1 = (line1 << 8) | ((*pLine1++) << 6);
229 line2 = (line2 << 8) | (*pLine2++);
230 cVal = 0;
231 for (k = 7; k >= 0; k--) {
232 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
233 cVal |= bVal << k;
234 CONTEXT = (((CONTEXT & 0x7bf7) << 1) | bVal |
235 ((line1 >> k) & 0x0800) | ((line2 >> k) & 0x0010));
236 }
237 pLine[cc] = cVal;
238 }
239 line1 <<= 8;
240 line2 <<= 8;
241 cVal = 0;
242 for (k = 0; k < nBitsLeft; k++) {
243 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
244 cVal |= bVal << (7 - k);
245 CONTEXT =
246 (((CONTEXT & 0x7bf7) << 1) | bVal |
247 ((line1 >> (7 - k)) & 0x0800) | ((line2 >> (7 - k)) & 0x0010));
248 }
249 pLine[nLineBytes] = cVal;
250 } else {
251 pLine2 = pLine - nStride;
252 line2 = (h & 1) ? (*pLine2++) : 0;
253 CONTEXT = (line2 & 0x07f0);
254 for (cc = 0; cc < nLineBytes; cc++) {
255 if (h & 1) {
256 line2 = (line2 << 8) | (*pLine2++);
257 }
258 cVal = 0;
259 for (k = 7; k >= 0; k--) {
260 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
261 cVal |= bVal << k;
262 CONTEXT =
263 (((CONTEXT & 0x7bf7) << 1) | bVal | ((line2 >> k) & 0x0010));
264 }
265 pLine[cc] = cVal;
266 }
267 line2 <<= 8;
268 cVal = 0;
269 for (k = 0; k < nBitsLeft; k++) {
270 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
271 cVal |= bVal << (7 - k);
272 CONTEXT = (((CONTEXT & 0x7bf7) << 1) | bVal |
273 (((line2 >> (7 - k))) & 0x0010));
274 }
275 pLine[nLineBytes] = cVal;
276 }
277 }
278 pLine += nStride;
279 }
280 return GBREG;
281 }
282 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template0_unopt(
283 CJBig2_ArithDecoder* pArithDecoder,
284 JBig2ArithCtx* gbContext) {
285 FX_BOOL LTP, SLTP, bVal;
286 FX_DWORD CONTEXT;
287 CJBig2_Image* GBREG;
288 FX_DWORD line1, line2, line3;
289 LTP = 0;
290 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
291 GBREG->fill(0);
292 for (FX_DWORD h = 0; h < GBH; h++) {
293 if (TPGDON) {
294 SLTP = pArithDecoder->DECODE(&gbContext[0x9b25]);
295 LTP = LTP ^ SLTP;
296 }
297 if (LTP == 1) {
298 GBREG->copyLine(h, h - 1);
299 } else {
300 line1 = GBREG->getPixel(1, h - 2);
301 line1 |= GBREG->getPixel(0, h - 2) << 1;
302 line2 = GBREG->getPixel(2, h - 1);
303 line2 |= GBREG->getPixel(1, h - 1) << 1;
304 line2 |= GBREG->getPixel(0, h - 1) << 2;
305 line3 = 0;
306 for (FX_DWORD w = 0; w < GBW; w++) {
307 if (USESKIP && SKIP->getPixel(w, h)) {
308 bVal = 0;
91 } else { 309 } else {
92 return decode_Arith_Template2_unopt(pArithDecoder, gbContext); 310 CONTEXT = line3;
93 } 311 CONTEXT |= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 4;
94 } else { 312 CONTEXT |= line2 << 5;
95 if((GBAT[0] == 2) && (GBAT[1] == (signed char) - 1)) { 313 CONTEXT |= GBREG->getPixel(w + GBAT[2], h + GBAT[3]) << 10;
96 return decode_Arith_Template3_opt3(pArithDecoder, gbContext); 314 CONTEXT |= GBREG->getPixel(w + GBAT[4], h + GBAT[5]) << 11;
315 CONTEXT |= line1 << 12;
316 CONTEXT |= GBREG->getPixel(w + GBAT[6], h + GBAT[7]) << 15;
317 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
318 }
319 if (bVal) {
320 GBREG->setPixel(w, h, bVal);
321 }
322 line1 = ((line1 << 1) | GBREG->getPixel(w + 2, h - 2)) & 0x07;
323 line2 = ((line2 << 1) | GBREG->getPixel(w + 3, h - 1)) & 0x1f;
324 line3 = ((line3 << 1) | bVal) & 0x0f;
325 }
326 }
327 }
328 return GBREG;
329 }
330 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template1_opt(
331 CJBig2_ArithDecoder* pArithDecoder,
332 JBig2ArithCtx* gbContext) {
333 FX_BOOL LTP, SLTP, bVal;
334 FX_DWORD CONTEXT;
335 CJBig2_Image* GBREG;
336 FX_DWORD line1, line2, line3;
337 LTP = 0;
338 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
339 GBREG->fill(0);
340 for (FX_DWORD h = 0; h < GBH; h++) {
341 if (TPGDON) {
342 SLTP = pArithDecoder->DECODE(&gbContext[0x0795]);
343 LTP = LTP ^ SLTP;
344 }
345 if (LTP == 1) {
346 GBREG->copyLine(h, h - 1);
347 } else {
348 line1 = GBREG->getPixel(2, h - 2);
349 line1 |= GBREG->getPixel(1, h - 2) << 1;
350 line1 |= GBREG->getPixel(0, h - 2) << 2;
351 line2 = GBREG->getPixel(3, h - 1);
352 line2 |= GBREG->getPixel(2, h - 1) << 1;
353 line2 |= GBREG->getPixel(1, h - 1) << 2;
354 line2 |= GBREG->getPixel(0, h - 1) << 3;
355 line3 = 0;
356 for (FX_DWORD w = 0; w < GBW; w++) {
357 if (USESKIP && SKIP->getPixel(w, h)) {
358 bVal = 0;
97 } else { 359 } else {
98 return decode_Arith_Template3_unopt(pArithDecoder, gbContext); 360 CONTEXT = line3;
99 } 361 CONTEXT |= line2 << 3;
100 } 362 CONTEXT |= line1 << 9;
101 } 363 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
102 CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template0_opt(CJBig2_ArithDecoder *pA rithDecoder, JBig2ArithCtx *gbContext) 364 }
103 { 365 if (bVal) {
104 FX_BOOL LTP, SLTP, bVal; 366 GBREG->setPixel(w, h, bVal);
105 FX_DWORD CONTEXT; 367 }
106 CJBig2_Image *GBREG; 368 line1 = ((line1 << 1) | GBREG->getPixel(w + 3, h - 2)) & 0x0f;
107 FX_DWORD line1, line2, line3; 369 line2 = ((line2 << 1) | GBREG->getPixel(w + 4, h - 1)) & 0x3f;
108 LTP = 0; 370 line3 = ((line3 << 1) | bVal) & 0x07;
109 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH)); 371 }
110 GBREG->fill(0); 372 }
111 for(FX_DWORD h = 0; h < GBH; h++) { 373 }
112 if(TPGDON) { 374 return GBREG;
113 SLTP = pArithDecoder->DECODE(&gbContext[0x9b25]); 375 }
114 LTP = LTP ^ SLTP; 376 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template1_opt2(
115 } 377 CJBig2_ArithDecoder* pArithDecoder,
116 if(LTP == 1) { 378 JBig2ArithCtx* gbContext) {
117 GBREG->copyLine(h, h - 1); 379 FX_BOOL LTP, SLTP, bVal;
380 FX_DWORD CONTEXT;
381 CJBig2_Image* GBREG;
382 FX_DWORD line1, line2;
383 uint8_t *pLine, cVal;
384 intptr_t nStride, nStride2;
385 int32_t nBits, k;
386 LTP = 0;
387 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
388 if (GBREG->m_pData == NULL) {
389 delete GBREG;
390 m_pModule->JBig2_Error(
391 "Generic region decoding procedure: Create Image Failed with width = "
392 "%d, height = %d\n",
393 GBW, GBH);
394 return NULL;
395 }
396 pLine = GBREG->m_pData;
397 nStride = GBREG->m_nStride;
398 nStride2 = nStride << 1;
399 for (FX_DWORD h = 0; h < GBH; h++) {
400 if (TPGDON) {
401 SLTP = pArithDecoder->DECODE(&gbContext[0x0795]);
402 LTP = LTP ^ SLTP;
403 }
404 if (LTP == 1) {
405 GBREG->copyLine(h, h - 1);
406 } else {
407 line1 = (h > 1) ? pLine[-nStride2] << 4 : 0;
408 line2 = (h > 0) ? pLine[-nStride] : 0;
409 CONTEXT = (line1 & 0x1e00) | ((line2 >> 1) & 0x01f8);
410 for (FX_DWORD w = 0; w < GBW; w += 8) {
411 if (w + 8 < GBW) {
412 nBits = 8;
413 if (h > 1) {
414 line1 = (line1 << 8) | (pLine[-nStride2 + (w >> 3) + 1] << 4);
415 }
416 if (h > 0) {
417 line2 = (line2 << 8) | (pLine[-nStride + (w >> 3) + 1]);
418 }
118 } else { 419 } else {
119 line1 = GBREG->getPixel(2, h - 2); 420 nBits = GBW - w;
120 line1 |= GBREG->getPixel(1, h - 2) << 1; 421 if (h > 1) {
121 line1 |= GBREG->getPixel(0, h - 2) << 2; 422 line1 <<= 8;
122 line2 = GBREG->getPixel(3, h - 1); 423 }
123 line2 |= GBREG->getPixel(2, h - 1) << 1; 424 if (h > 0) {
124 line2 |= GBREG->getPixel(1, h - 1) << 2; 425 line2 <<= 8;
125 line2 |= GBREG->getPixel(0, h - 1) << 3; 426 }
126 line3 = 0; 427 }
127 for(FX_DWORD w = 0; w < GBW; w++) { 428 cVal = 0;
128 if(USESKIP && SKIP->getPixel(w, h)) { 429 for (k = 0; k < nBits; k++) {
129 bVal = 0; 430 if (USESKIP && SKIP->getPixel(w, h)) {
130 } else { 431 bVal = 0;
131 CONTEXT = line3; 432 } else {
132 CONTEXT |= line2 << 4; 433 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
133 CONTEXT |= line1 << 11; 434 }
134 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]); 435 cVal |= bVal << (7 - k);
135 } 436 CONTEXT = ((CONTEXT & 0x0efb) << 1) | bVal |
136 if(bVal) { 437 ((line1 >> (7 - k)) & 0x0200) |
137 GBREG->setPixel(w, h, bVal); 438 ((line2 >> (8 - k)) & 0x0008);
138 } 439 }
139 line1 = ((line1 << 1) | GBREG->getPixel(w + 3, h - 2)) & 0x1f; 440 pLine[w >> 3] = cVal;
140 line2 = ((line2 << 1) | GBREG->getPixel(w + 4, h - 1)) & 0x7f; 441 }
141 line3 = ((line3 << 1) | bVal) & 0x0f; 442 }
443 pLine += nStride;
444 }
445 return GBREG;
446 }
447 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template1_opt3(
448 CJBig2_ArithDecoder* pArithDecoder,
449 JBig2ArithCtx* gbContext) {
450 FX_BOOL LTP, SLTP, bVal;
451 FX_DWORD CONTEXT;
452 CJBig2_Image* GBREG;
453 FX_DWORD line1, line2;
454 uint8_t *pLine, *pLine1, *pLine2, cVal;
455 int32_t nStride, nStride2, k;
456 int32_t nLineBytes, nBitsLeft, cc;
457 LTP = 0;
458 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
459 if (GBREG->m_pData == NULL) {
460 delete GBREG;
461 m_pModule->JBig2_Error(
462 "Generic region decoding procedure: Create Image Failed with width = "
463 "%d, height = %d\n",
464 GBW, GBH);
465 return NULL;
466 }
467 pLine = GBREG->m_pData;
468 nStride = GBREG->m_nStride;
469 nStride2 = nStride << 1;
470 nLineBytes = ((GBW + 7) >> 3) - 1;
471 nBitsLeft = GBW - (nLineBytes << 3);
472 for (FX_DWORD h = 0; h < GBH; h++) {
473 if (TPGDON) {
474 SLTP = pArithDecoder->DECODE(&gbContext[0x0795]);
475 LTP = LTP ^ SLTP;
476 }
477 if (LTP == 1) {
478 GBREG->copyLine(h, h - 1);
479 } else {
480 if (h > 1) {
481 pLine1 = pLine - nStride2;
482 pLine2 = pLine - nStride;
483 line1 = (*pLine1++) << 4;
484 line2 = *pLine2++;
485 CONTEXT = (line1 & 0x1e00) | ((line2 >> 1) & 0x01f8);
486 for (cc = 0; cc < nLineBytes; cc++) {
487 line1 = (line1 << 8) | ((*pLine1++) << 4);
488 line2 = (line2 << 8) | (*pLine2++);
489 cVal = 0;
490 for (k = 7; k >= 0; k--) {
491 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
492 cVal |= bVal << k;
493 CONTEXT = ((CONTEXT & 0x0efb) << 1) | bVal |
494 ((line1 >> k) & 0x0200) | ((line2 >> (k + 1)) & 0x0008);
495 }
496 pLine[cc] = cVal;
497 }
498 line1 <<= 8;
499 line2 <<= 8;
500 cVal = 0;
501 for (k = 0; k < nBitsLeft; k++) {
502 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
503 cVal |= bVal << (7 - k);
504 CONTEXT = ((CONTEXT & 0x0efb) << 1) | bVal |
505 ((line1 >> (7 - k)) & 0x0200) |
506 ((line2 >> (8 - k)) & 0x0008);
507 }
508 pLine[nLineBytes] = cVal;
509 } else {
510 pLine2 = pLine - nStride;
511 line2 = (h & 1) ? (*pLine2++) : 0;
512 CONTEXT = (line2 >> 1) & 0x01f8;
513 for (cc = 0; cc < nLineBytes; cc++) {
514 if (h & 1) {
515 line2 = (line2 << 8) | (*pLine2++);
516 }
517 cVal = 0;
518 for (k = 7; k >= 0; k--) {
519 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
520 cVal |= bVal << k;
521 CONTEXT = ((CONTEXT & 0x0efb) << 1) | bVal |
522 ((line2 >> (k + 1)) & 0x0008);
523 }
524 pLine[cc] = cVal;
525 }
526 line2 <<= 8;
527 cVal = 0;
528 for (k = 0; k < nBitsLeft; k++) {
529 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
530 cVal |= bVal << (7 - k);
531 CONTEXT =
532 ((CONTEXT & 0x0efb) << 1) | bVal | ((line2 >> (8 - k)) & 0x0008);
533 }
534 pLine[nLineBytes] = cVal;
535 }
536 }
537 pLine += nStride;
538 }
539 return GBREG;
540 }
541 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template1_unopt(
542 CJBig2_ArithDecoder* pArithDecoder,
543 JBig2ArithCtx* gbContext) {
544 FX_BOOL LTP, SLTP, bVal;
545 FX_DWORD CONTEXT;
546 CJBig2_Image* GBREG;
547 FX_DWORD line1, line2, line3;
548 LTP = 0;
549 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
550 GBREG->fill(0);
551 for (FX_DWORD h = 0; h < GBH; h++) {
552 if (TPGDON) {
553 SLTP = pArithDecoder->DECODE(&gbContext[0x0795]);
554 LTP = LTP ^ SLTP;
555 }
556 if (LTP == 1) {
557 GBREG->copyLine(h, h - 1);
558 } else {
559 line1 = GBREG->getPixel(2, h - 2);
560 line1 |= GBREG->getPixel(1, h - 2) << 1;
561 line1 |= GBREG->getPixel(0, h - 2) << 2;
562 line2 = GBREG->getPixel(2, h - 1);
563 line2 |= GBREG->getPixel(1, h - 1) << 1;
564 line2 |= GBREG->getPixel(0, h - 1) << 2;
565 line3 = 0;
566 for (FX_DWORD w = 0; w < GBW; w++) {
567 if (USESKIP && SKIP->getPixel(w, h)) {
568 bVal = 0;
569 } else {
570 CONTEXT = line3;
571 CONTEXT |= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 3;
572 CONTEXT |= line2 << 4;
573 CONTEXT |= line1 << 9;
574 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
575 }
576 if (bVal) {
577 GBREG->setPixel(w, h, bVal);
578 }
579 line1 = ((line1 << 1) | GBREG->getPixel(w + 3, h - 2)) & 0x0f;
580 line2 = ((line2 << 1) | GBREG->getPixel(w + 3, h - 1)) & 0x1f;
581 line3 = ((line3 << 1) | bVal) & 0x07;
582 }
583 }
584 }
585 return GBREG;
586 }
587 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template2_opt(
588 CJBig2_ArithDecoder* pArithDecoder,
589 JBig2ArithCtx* gbContext) {
590 FX_BOOL LTP, SLTP, bVal;
591 FX_DWORD CONTEXT;
592 CJBig2_Image* GBREG;
593 FX_DWORD line1, line2, line3;
594 LTP = 0;
595 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
596 GBREG->fill(0);
597 for (FX_DWORD h = 0; h < GBH; h++) {
598 if (TPGDON) {
599 SLTP = pArithDecoder->DECODE(&gbContext[0x00e5]);
600 LTP = LTP ^ SLTP;
601 }
602 if (LTP == 1) {
603 GBREG->copyLine(h, h - 1);
604 } else {
605 line1 = GBREG->getPixel(1, h - 2);
606 line1 |= GBREG->getPixel(0, h - 2) << 1;
607 line2 = GBREG->getPixel(2, h - 1);
608 line2 |= GBREG->getPixel(1, h - 1) << 1;
609 line2 |= GBREG->getPixel(0, h - 1) << 2;
610 line3 = 0;
611 for (FX_DWORD w = 0; w < GBW; w++) {
612 if (USESKIP && SKIP->getPixel(w, h)) {
613 bVal = 0;
614 } else {
615 CONTEXT = line3;
616 CONTEXT |= line2 << 2;
617 CONTEXT |= line1 << 7;
618 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
619 }
620 if (bVal) {
621 GBREG->setPixel(w, h, bVal);
622 }
623 line1 = ((line1 << 1) | GBREG->getPixel(w + 2, h - 2)) & 0x07;
624 line2 = ((line2 << 1) | GBREG->getPixel(w + 3, h - 1)) & 0x1f;
625 line3 = ((line3 << 1) | bVal) & 0x03;
626 }
627 }
628 }
629 return GBREG;
630 }
631 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template2_opt2(
632 CJBig2_ArithDecoder* pArithDecoder,
633 JBig2ArithCtx* gbContext) {
634 FX_BOOL LTP, SLTP, bVal;
635 FX_DWORD CONTEXT;
636 CJBig2_Image* GBREG;
637 FX_DWORD line1, line2;
638 uint8_t *pLine, cVal;
639 intptr_t nStride, nStride2;
640 int32_t nBits, k;
641 LTP = 0;
642 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
643 if (GBREG->m_pData == NULL) {
644 delete GBREG;
645 m_pModule->JBig2_Error(
646 "Generic region decoding procedure: Create Image Failed with width = "
647 "%d, height = %d\n",
648 GBW, GBH);
649 return NULL;
650 }
651 pLine = GBREG->m_pData;
652 nStride = GBREG->m_nStride;
653 nStride2 = nStride << 1;
654 for (FX_DWORD h = 0; h < GBH; h++) {
655 if (TPGDON) {
656 SLTP = pArithDecoder->DECODE(&gbContext[0x00e5]);
657 LTP = LTP ^ SLTP;
658 }
659 if (LTP == 1) {
660 GBREG->copyLine(h, h - 1);
661 } else {
662 line1 = (h > 1) ? pLine[-nStride2] << 1 : 0;
663 line2 = (h > 0) ? pLine[-nStride] : 0;
664 CONTEXT = (line1 & 0x0380) | ((line2 >> 3) & 0x007c);
665 for (FX_DWORD w = 0; w < GBW; w += 8) {
666 if (w + 8 < GBW) {
667 nBits = 8;
668 if (h > 1) {
669 line1 = (line1 << 8) | (pLine[-nStride2 + (w >> 3) + 1] << 1);
670 }
671 if (h > 0) {
672 line2 = (line2 << 8) | (pLine[-nStride + (w >> 3) + 1]);
673 }
674 } else {
675 nBits = GBW - w;
676 if (h > 1) {
677 line1 <<= 8;
678 }
679 if (h > 0) {
680 line2 <<= 8;
681 }
682 }
683 cVal = 0;
684 for (k = 0; k < nBits; k++) {
685 if (USESKIP && SKIP->getPixel(w, h)) {
686 bVal = 0;
687 } else {
688 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
689 }
690 cVal |= bVal << (7 - k);
691 CONTEXT = ((CONTEXT & 0x01bd) << 1) | bVal |
692 ((line1 >> (7 - k)) & 0x0080) |
693 ((line2 >> (10 - k)) & 0x0004);
694 }
695 pLine[w >> 3] = cVal;
696 }
697 }
698 pLine += nStride;
699 }
700 return GBREG;
701 }
702 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template2_opt3(
703 CJBig2_ArithDecoder* pArithDecoder,
704 JBig2ArithCtx* gbContext) {
705 FX_BOOL LTP, SLTP, bVal;
706 FX_DWORD CONTEXT;
707 CJBig2_Image* GBREG;
708 FX_DWORD line1, line2;
709 uint8_t *pLine, *pLine1, *pLine2, cVal;
710 int32_t nStride, nStride2, k;
711 int32_t nLineBytes, nBitsLeft, cc;
712 LTP = 0;
713 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
714 if (GBREG->m_pData == NULL) {
715 delete GBREG;
716 m_pModule->JBig2_Error(
717 "Generic region decoding procedure: Create Image Failed with width = "
718 "%d, height = %d\n",
719 GBW, GBH);
720 return NULL;
721 }
722 pLine = GBREG->m_pData;
723 nStride = GBREG->m_nStride;
724 nStride2 = nStride << 1;
725 nLineBytes = ((GBW + 7) >> 3) - 1;
726 nBitsLeft = GBW - (nLineBytes << 3);
727 for (FX_DWORD h = 0; h < GBH; h++) {
728 if (TPGDON) {
729 SLTP = pArithDecoder->DECODE(&gbContext[0x00e5]);
730 LTP = LTP ^ SLTP;
731 }
732 if (LTP == 1) {
733 GBREG->copyLine(h, h - 1);
734 } else {
735 if (h > 1) {
736 pLine1 = pLine - nStride2;
737 pLine2 = pLine - nStride;
738 line1 = (*pLine1++) << 1;
739 line2 = *pLine2++;
740 CONTEXT = (line1 & 0x0380) | ((line2 >> 3) & 0x007c);
741 for (cc = 0; cc < nLineBytes; cc++) {
742 line1 = (line1 << 8) | ((*pLine1++) << 1);
743 line2 = (line2 << 8) | (*pLine2++);
744 cVal = 0;
745 for (k = 7; k >= 0; k--) {
746 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
747 cVal |= bVal << k;
748 CONTEXT = ((CONTEXT & 0x01bd) << 1) | bVal |
749 ((line1 >> k) & 0x0080) | ((line2 >> (k + 3)) & 0x0004);
750 }
751 pLine[cc] = cVal;
752 }
753 line1 <<= 8;
754 line2 <<= 8;
755 cVal = 0;
756 for (k = 0; k < nBitsLeft; k++) {
757 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
758 cVal |= bVal << (7 - k);
759 CONTEXT = ((CONTEXT & 0x01bd) << 1) | bVal |
760 ((line1 >> (7 - k)) & 0x0080) |
761 ((line2 >> (10 - k)) & 0x0004);
762 }
763 pLine[nLineBytes] = cVal;
764 } else {
765 pLine2 = pLine - nStride;
766 line2 = (h & 1) ? (*pLine2++) : 0;
767 CONTEXT = (line2 >> 3) & 0x007c;
768 for (cc = 0; cc < nLineBytes; cc++) {
769 if (h & 1) {
770 line2 = (line2 << 8) | (*pLine2++);
771 }
772 cVal = 0;
773 for (k = 7; k >= 0; k--) {
774 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
775 cVal |= bVal << k;
776 CONTEXT = ((CONTEXT & 0x01bd) << 1) | bVal |
777 ((line2 >> (k + 3)) & 0x0004);
778 }
779 pLine[cc] = cVal;
780 }
781 line2 <<= 8;
782 cVal = 0;
783 for (k = 0; k < nBitsLeft; k++) {
784 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
785 cVal |= bVal << (7 - k);
786 CONTEXT = ((CONTEXT & 0x01bd) << 1) | bVal |
787 (((line2 >> (10 - k))) & 0x0004);
788 }
789 pLine[nLineBytes] = cVal;
790 }
791 }
792 pLine += nStride;
793 }
794 return GBREG;
795 }
796 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template2_unopt(
797 CJBig2_ArithDecoder* pArithDecoder,
798 JBig2ArithCtx* gbContext) {
799 FX_BOOL LTP, SLTP, bVal;
800 FX_DWORD CONTEXT;
801 CJBig2_Image* GBREG;
802 FX_DWORD line1, line2, line3;
803 LTP = 0;
804 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
805 GBREG->fill(0);
806 for (FX_DWORD h = 0; h < GBH; h++) {
807 if (TPGDON) {
808 SLTP = pArithDecoder->DECODE(&gbContext[0x00e5]);
809 LTP = LTP ^ SLTP;
810 }
811 if (LTP == 1) {
812 GBREG->copyLine(h, h - 1);
813 } else {
814 line1 = GBREG->getPixel(1, h - 2);
815 line1 |= GBREG->getPixel(0, h - 2) << 1;
816 line2 = GBREG->getPixel(1, h - 1);
817 line2 |= GBREG->getPixel(0, h - 1) << 1;
818 line3 = 0;
819 for (FX_DWORD w = 0; w < GBW; w++) {
820 if (USESKIP && SKIP->getPixel(w, h)) {
821 bVal = 0;
822 } else {
823 CONTEXT = line3;
824 CONTEXT |= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 2;
825 CONTEXT |= line2 << 3;
826 CONTEXT |= line1 << 7;
827 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
828 }
829 if (bVal) {
830 GBREG->setPixel(w, h, bVal);
831 }
832 line1 = ((line1 << 1) | GBREG->getPixel(w + 2, h - 2)) & 0x07;
833 line2 = ((line2 << 1) | GBREG->getPixel(w + 2, h - 1)) & 0x0f;
834 line3 = ((line3 << 1) | bVal) & 0x03;
835 }
836 }
837 }
838 return GBREG;
839 }
840 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template3_opt(
841 CJBig2_ArithDecoder* pArithDecoder,
842 JBig2ArithCtx* gbContext) {
843 FX_BOOL LTP, SLTP, bVal;
844 FX_DWORD CONTEXT;
845 CJBig2_Image* GBREG;
846 FX_DWORD line1, line2;
847 LTP = 0;
848 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
849 GBREG->fill(0);
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 = GBREG->getPixel(2, h - 1);
859 line1 |= GBREG->getPixel(1, h - 1) << 1;
860 line1 |= GBREG->getPixel(0, h - 1) << 2;
861 line2 = 0;
862 for (FX_DWORD w = 0; w < GBW; w++) {
863 if (USESKIP && SKIP->getPixel(w, h)) {
864 bVal = 0;
865 } else {
866 CONTEXT = line2;
867 CONTEXT |= line1 << 4;
868 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
869 }
870 if (bVal) {
871 GBREG->setPixel(w, h, bVal);
872 }
873 line1 = ((line1 << 1) | GBREG->getPixel(w + 3, h - 1)) & 0x3f;
874 line2 = ((line2 << 1) | bVal) & 0x0f;
875 }
876 }
877 }
878 return GBREG;
879 }
880 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template3_opt2(
881 CJBig2_ArithDecoder* pArithDecoder,
882 JBig2ArithCtx* gbContext) {
883 FX_BOOL LTP, SLTP, bVal;
884 FX_DWORD CONTEXT;
885 CJBig2_Image* GBREG;
886 FX_DWORD line1;
887 uint8_t *pLine, cVal;
888 intptr_t nStride;
889 int32_t nBits, k;
890 LTP = 0;
891 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
892 if (GBREG->m_pData == NULL) {
893 delete GBREG;
894 m_pModule->JBig2_Error(
895 "Generic region decoding procedure: Create Image Failed with width = "
896 "%d, height = %d\n",
897 GBW, GBH);
898 return NULL;
899 }
900 pLine = GBREG->m_pData;
901 nStride = GBREG->m_nStride;
902 for (FX_DWORD h = 0; h < GBH; h++) {
903 if (TPGDON) {
904 SLTP = pArithDecoder->DECODE(&gbContext[0x0195]);
905 LTP = LTP ^ SLTP;
906 }
907 if (LTP == 1) {
908 GBREG->copyLine(h, h - 1);
909 } else {
910 line1 = (h > 0) ? pLine[-nStride] : 0;
911 CONTEXT = (line1 >> 1) & 0x03f0;
912 for (FX_DWORD w = 0; w < GBW; w += 8) {
913 if (w + 8 < GBW) {
914 nBits = 8;
915 if (h > 0) {
916 line1 = (line1 << 8) | (pLine[-nStride + (w >> 3) + 1]);
917 }
918 } else {
919 nBits = GBW - w;
920 if (h > 0) {
921 line1 <<= 8;
922 }
923 }
924 cVal = 0;
925 for (k = 0; k < nBits; k++) {
926 if (USESKIP && SKIP->getPixel(w, h)) {
927 bVal = 0;
928 } else {
929 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
930 }
931 cVal |= bVal << (7 - k);
932 CONTEXT =
933 ((CONTEXT & 0x01f7) << 1) | bVal | ((line1 >> (8 - k)) & 0x0010);
934 }
935 pLine[w >> 3] = cVal;
936 }
937 }
938 pLine += nStride;
939 }
940 return GBREG;
941 }
942 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template3_opt3(
943 CJBig2_ArithDecoder* pArithDecoder,
944 JBig2ArithCtx* gbContext) {
945 FX_BOOL LTP, SLTP, bVal;
946 FX_DWORD CONTEXT;
947 CJBig2_Image* GBREG;
948 FX_DWORD line1;
949 uint8_t *pLine, *pLine1, cVal;
950 int32_t nStride, k;
951 int32_t nLineBytes, nBitsLeft, cc;
952 LTP = 0;
953 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
954 if (GBREG->m_pData == NULL) {
955 delete GBREG;
956 m_pModule->JBig2_Error(
957 "Generic region decoding procedure: Create Image Failed with width = "
958 "%d, height = %d\n",
959 GBW, GBH);
960 return NULL;
961 }
962 pLine = GBREG->m_pData;
963 nStride = GBREG->m_nStride;
964 nLineBytes = ((GBW + 7) >> 3) - 1;
965 nBitsLeft = GBW - (nLineBytes << 3);
966 for (FX_DWORD h = 0; h < GBH; h++) {
967 if (TPGDON) {
968 SLTP = pArithDecoder->DECODE(&gbContext[0x0195]);
969 LTP = LTP ^ SLTP;
970 }
971 if (LTP == 1) {
972 GBREG->copyLine(h, h - 1);
973 } else {
974 if (h > 0) {
975 pLine1 = pLine - nStride;
976 line1 = *pLine1++;
977 CONTEXT = (line1 >> 1) & 0x03f0;
978 for (cc = 0; cc < nLineBytes; cc++) {
979 line1 = (line1 << 8) | (*pLine1++);
980 cVal = 0;
981 for (k = 7; k >= 0; k--) {
982 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
983 cVal |= bVal << k;
984 CONTEXT = ((CONTEXT & 0x01f7) << 1) | bVal |
985 ((line1 >> (k + 1)) & 0x0010);
986 }
987 pLine[cc] = cVal;
988 }
989 line1 <<= 8;
990 cVal = 0;
991 for (k = 0; k < nBitsLeft; k++) {
992 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
993 cVal |= bVal << (7 - k);
994 CONTEXT =
995 ((CONTEXT & 0x01f7) << 1) | bVal | ((line1 >> (8 - k)) & 0x0010);
996 }
997 pLine[nLineBytes] = cVal;
998 } else {
999 CONTEXT = 0;
1000 for (cc = 0; cc < nLineBytes; cc++) {
1001 cVal = 0;
1002 for (k = 7; k >= 0; k--) {
1003 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
1004 cVal |= bVal << k;
1005 CONTEXT = ((CONTEXT & 0x01f7) << 1) | bVal;
1006 }
1007 pLine[cc] = cVal;
1008 }
1009 cVal = 0;
1010 for (k = 0; k < nBitsLeft; k++) {
1011 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
1012 cVal |= bVal << (7 - k);
1013 CONTEXT = ((CONTEXT & 0x01f7) << 1) | bVal;
1014 }
1015 pLine[nLineBytes] = cVal;
1016 }
1017 }
1018 pLine += nStride;
1019 }
1020 return GBREG;
1021 }
1022 CJBig2_Image* CJBig2_GRDProc::decode_Arith_Template3_unopt(
1023 CJBig2_ArithDecoder* pArithDecoder,
1024 JBig2ArithCtx* gbContext) {
1025 FX_BOOL LTP, SLTP, bVal;
1026 FX_DWORD CONTEXT;
1027 CJBig2_Image* GBREG;
1028 FX_DWORD line1, line2;
1029 LTP = 0;
1030 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
1031 GBREG->fill(0);
1032 for (FX_DWORD h = 0; h < GBH; h++) {
1033 if (TPGDON) {
1034 SLTP = pArithDecoder->DECODE(&gbContext[0x0195]);
1035 LTP = LTP ^ SLTP;
1036 }
1037 if (LTP == 1) {
1038 GBREG->copyLine(h, h - 1);
1039 } else {
1040 line1 = GBREG->getPixel(1, h - 1);
1041 line1 |= GBREG->getPixel(0, h - 1) << 1;
1042 line2 = 0;
1043 for (FX_DWORD w = 0; w < GBW; w++) {
1044 if (USESKIP && SKIP->getPixel(w, h)) {
1045 bVal = 0;
1046 } else {
1047 CONTEXT = line2;
1048 CONTEXT |= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 4;
1049 CONTEXT |= line1 << 5;
1050 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
1051 }
1052 if (bVal) {
1053 GBREG->setPixel(w, h, bVal);
1054 }
1055 line1 = ((line1 << 1) | GBREG->getPixel(w + 2, h - 1)) & 0x1f;
1056 line2 = ((line2 << 1) | bVal) & 0x0f;
1057 }
1058 }
1059 }
1060 return GBREG;
1061 }
1062 CJBig2_Image* CJBig2_GRDProc::decode_Arith_V2(
1063 CJBig2_ArithDecoder* pArithDecoder,
1064 JBig2ArithCtx* gbContext) {
1065 FX_BOOL LTP, SLTP, bVal;
1066 FX_DWORD CONTEXT;
1067 CJBig2_Image* GBREG;
1068 FX_DWORD line1, line2, line3;
1069 LTP = 0;
1070 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
1071 GBREG->fill(0);
1072 for (FX_DWORD h = 0; h < GBH; h++) {
1073 if (TPGDON) {
1074 switch (GBTEMPLATE) {
1075 case 0:
1076 CONTEXT = 0x9b25;
1077 break;
1078 case 1:
1079 CONTEXT = 0x0795;
1080 break;
1081 case 2:
1082 CONTEXT = 0x00e5;
1083 break;
1084 case 3:
1085 CONTEXT = 0x0195;
1086 break;
1087 }
1088 SLTP = pArithDecoder->DECODE(&gbContext[CONTEXT]);
1089 LTP = LTP ^ SLTP;
1090 }
1091 if (LTP == 1) {
1092 GBREG->copyLine(h, h - 1);
1093 } else {
1094 switch (GBTEMPLATE) {
1095 case 0: {
1096 line1 = GBREG->getPixel(1, h - 2);
1097 line1 |= GBREG->getPixel(0, h - 2) << 1;
1098 line2 = GBREG->getPixel(2, h - 1);
1099 line2 |= GBREG->getPixel(1, h - 1) << 1;
1100 line2 |= GBREG->getPixel(0, h - 1) << 2;
1101 line3 = 0;
1102 for (FX_DWORD w = 0; w < GBW; w++) {
1103 if (USESKIP && SKIP->getPixel(w, h)) {
1104 bVal = 0;
1105 } else {
1106 CONTEXT = line3;
1107 CONTEXT |= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 4;
1108 CONTEXT |= line2 << 5;
1109 CONTEXT |= GBREG->getPixel(w + GBAT[2], h + GBAT[3]) << 10;
1110 CONTEXT |= GBREG->getPixel(w + GBAT[4], h + GBAT[5]) << 11;
1111 CONTEXT |= line1 << 12;
1112 CONTEXT |= GBREG->getPixel(w + GBAT[6], h + GBAT[7]) << 15;
1113 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
142 } 1114 }
143 } 1115 if (bVal) {
144 } 1116 GBREG->setPixel(w, h, bVal);
145 return GBREG; 1117 }
146 } 1118 line1 = ((line1 << 1) | GBREG->getPixel(w + 2, h - 2)) & 0x07;
147 CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template0_opt2(CJBig2_ArithDecoder *p ArithDecoder, JBig2ArithCtx *gbContext) 1119 line2 = ((line2 << 1) | GBREG->getPixel(w + 3, h - 1)) & 0x1f;
148 { 1120 line3 = ((line3 << 1) | bVal) & 0x0f;
149 FX_BOOL LTP, SLTP, bVal; 1121 }
150 FX_DWORD CONTEXT; 1122 } break;
151 CJBig2_Image *GBREG; 1123 case 1: {
152 FX_DWORD line1, line2; 1124 line1 = GBREG->getPixel(2, h - 2);
153 uint8_t *pLine, cVal; 1125 line1 |= GBREG->getPixel(1, h - 2) << 1;
154 intptr_t nStride, nStride2; 1126 line1 |= GBREG->getPixel(0, h - 2) << 2;
155 int32_t nBits, k; 1127 line2 = GBREG->getPixel(2, h - 1);
156 LTP = 0; 1128 line2 |= GBREG->getPixel(1, h - 1) << 1;
157 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH)); 1129 line2 |= GBREG->getPixel(0, h - 1) << 2;
158 if (GBREG->m_pData == NULL) { 1130 line3 = 0;
159 delete GBREG; 1131 for (FX_DWORD w = 0; w < GBW; w++) {
160 m_pModule->JBig2_Error("Generic region decoding procedure: Create Image Failed with width = %d, height = %d\n", GBW, GBH); 1132 if (USESKIP && SKIP->getPixel(w, h)) {
161 return NULL; 1133 bVal = 0;
162 } 1134 } else {
163 pLine = GBREG->m_pData; 1135 CONTEXT = line3;
164 nStride = GBREG->m_nStride; 1136 CONTEXT |= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 3;
165 nStride2 = nStride << 1; 1137 CONTEXT |= line2 << 4;
166 for(FX_DWORD h = 0; h < GBH; h++) { 1138 CONTEXT |= line1 << 9;
167 if(TPGDON) { 1139 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
168 SLTP = pArithDecoder->DECODE(&gbContext[0x9b25]); 1140 }
169 LTP = LTP ^ SLTP; 1141 if (bVal) {
170 } 1142 GBREG->setPixel(w, h, bVal);
171 if(LTP == 1) { 1143 }
172 GBREG->copyLine(h, h - 1); 1144 line1 = ((line1 << 1) | GBREG->getPixel(w + 3, h - 2)) & 0x0f;
1145 line2 = ((line2 << 1) | GBREG->getPixel(w + 3, h - 1)) & 0x1f;
1146 line3 = ((line3 << 1) | bVal) & 0x07;
1147 }
1148 } break;
1149 case 2: {
1150 line1 = GBREG->getPixel(1, h - 2);
1151 line1 |= GBREG->getPixel(0, h - 2) << 1;
1152 line2 = GBREG->getPixel(1, h - 1);
1153 line2 |= GBREG->getPixel(0, h - 1) << 1;
1154 line3 = 0;
1155 for (FX_DWORD w = 0; w < GBW; w++) {
1156 if (USESKIP && SKIP->getPixel(w, h)) {
1157 bVal = 0;
1158 } else {
1159 CONTEXT = line3;
1160 CONTEXT |= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 2;
1161 CONTEXT |= line2 << 3;
1162 CONTEXT |= line1 << 7;
1163 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
1164 }
1165 if (bVal) {
1166 GBREG->setPixel(w, h, bVal);
1167 }
1168 line1 = ((line1 << 1) | GBREG->getPixel(w + 2, h - 2)) & 0x07;
1169 line2 = ((line2 << 1) | GBREG->getPixel(w + 2, h - 1)) & 0x0f;
1170 line3 = ((line3 << 1) | bVal) & 0x03;
1171 }
1172 } break;
1173 case 3: {
1174 line1 = GBREG->getPixel(1, h - 1);
1175 line1 |= GBREG->getPixel(0, h - 1) << 1;
1176 line2 = 0;
1177 for (FX_DWORD w = 0; w < GBW; w++) {
1178 if (USESKIP && SKIP->getPixel(w, h)) {
1179 bVal = 0;
1180 } else {
1181 CONTEXT = line2;
1182 CONTEXT |= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 4;
1183 CONTEXT |= line1 << 5;
1184 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
1185 }
1186 if (bVal) {
1187 GBREG->setPixel(w, h, bVal);
1188 }
1189 line1 = ((line1 << 1) | GBREG->getPixel(w + 2, h - 1)) & 0x1f;
1190 line2 = ((line2 << 1) | bVal) & 0x0f;
1191 }
1192 } break;
1193 }
1194 }
1195 }
1196 return GBREG;
1197 }
1198 CJBig2_Image* CJBig2_GRDProc::decode_Arith_V1(
1199 CJBig2_ArithDecoder* pArithDecoder,
1200 JBig2ArithCtx* gbContext) {
1201 FX_BOOL LTP, SLTP, bVal;
1202 FX_DWORD CONTEXT = 0;
1203 CJBig2_Image* GBREG;
1204 LTP = 0;
1205 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
1206 GBREG->fill(0);
1207 for (FX_DWORD h = 0; h < GBH; h++) {
1208 if (TPGDON) {
1209 switch (GBTEMPLATE) {
1210 case 0:
1211 CONTEXT = 0x9b25;
1212 break;
1213 case 1:
1214 CONTEXT = 0x0795;
1215 break;
1216 case 2:
1217 CONTEXT = 0x00e5;
1218 break;
1219 case 3:
1220 CONTEXT = 0x0195;
1221 break;
1222 }
1223 SLTP = pArithDecoder->DECODE(&gbContext[CONTEXT]);
1224 LTP = LTP ^ SLTP;
1225 }
1226 if (LTP == 1) {
1227 for (FX_DWORD w = 0; w < GBW; w++) {
1228 GBREG->setPixel(w, h, GBREG->getPixel(w, h - 1));
1229 }
1230 } else {
1231 for (FX_DWORD w = 0; w < GBW; w++) {
1232 if (USESKIP && SKIP->getPixel(w, h)) {
1233 GBREG->setPixel(w, h, 0);
173 } else { 1234 } else {
174 line1 = (h > 1) ? pLine[-nStride2] << 6 : 0; 1235 CONTEXT = 0;
175 line2 = (h > 0) ? pLine[-nStride] : 0; 1236 switch (GBTEMPLATE) {
176 CONTEXT = (line1 & 0xf800) | (line2 & 0x07f0); 1237 case 0:
177 for(FX_DWORD w = 0; w < GBW; w += 8) { 1238 CONTEXT |= GBREG->getPixel(w - 1, h);
178 if(w + 8 < GBW) { 1239 CONTEXT |= GBREG->getPixel(w - 2, h) << 1;
179 nBits = 8; 1240 CONTEXT |= GBREG->getPixel(w - 3, h) << 2;
180 if(h > 1) { 1241 CONTEXT |= GBREG->getPixel(w - 4, h) << 3;
181 line1 = (line1 << 8) | (pLine[-nStride2 + (w >> 3) + 1] << 6); 1242 CONTEXT |= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 4;
182 } 1243 CONTEXT |= GBREG->getPixel(w + 2, h - 1) << 5;
183 if(h > 0) { 1244 CONTEXT |= GBREG->getPixel(w + 1, h - 1) << 6;
184 line2 = (line2 << 8) | (pLine[-nStride + (w >> 3) + 1]); 1245 CONTEXT |= GBREG->getPixel(w, h - 1) << 7;
185 } 1246 CONTEXT |= GBREG->getPixel(w - 1, h - 1) << 8;
186 } else { 1247 CONTEXT |= GBREG->getPixel(w - 2, h - 1) << 9;
187 nBits = GBW - w; 1248 CONTEXT |= GBREG->getPixel(w + GBAT[2], h + GBAT[3]) << 10;
188 if(h > 1) { 1249 CONTEXT |= GBREG->getPixel(w + GBAT[4], h + GBAT[5]) << 11;
189 line1 <<= 8; 1250 CONTEXT |= GBREG->getPixel(w + 1, h - 2) << 12;
190 } 1251 CONTEXT |= GBREG->getPixel(w, h - 2) << 13;
191 if(h > 0) { 1252 CONTEXT |= GBREG->getPixel(w - 1, h - 2) << 14;
192 line2 <<= 8; 1253 CONTEXT |= GBREG->getPixel(w + GBAT[6], h + GBAT[7]) << 15;
193 } 1254 break;
194 } 1255 case 1:
195 cVal = 0; 1256 CONTEXT |= GBREG->getPixel(w - 1, h);
196 for(k = 0; k < nBits; k++) { 1257 CONTEXT |= GBREG->getPixel(w - 2, h) << 1;
197 if(USESKIP && SKIP->getPixel(w, h)) { 1258 CONTEXT |= GBREG->getPixel(w - 3, h) << 2;
198 bVal = 0; 1259 CONTEXT |= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 3;
199 } else { 1260 CONTEXT |= GBREG->getPixel(w + 2, h - 1) << 4;
200 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]); 1261 CONTEXT |= GBREG->getPixel(w + 1, h - 1) << 5;
201 } 1262 CONTEXT |= GBREG->getPixel(w, h - 1) << 6;
202 cVal |= bVal << (7 - k); 1263 CONTEXT |= GBREG->getPixel(w - 1, h - 1) << 7;
203 CONTEXT = ((CONTEXT & 0x7bf7) << 1) | bVal 1264 CONTEXT |= GBREG->getPixel(w - 2, h - 1) << 8;
204 | ((line1 >> (7 - k)) & 0x0800) 1265 CONTEXT |= GBREG->getPixel(w + 2, h - 2) << 9;
205 | ((line2 >> (7 - k)) & 0x0010); 1266 CONTEXT |= GBREG->getPixel(w + 1, h - 2) << 10;
206 } 1267 CONTEXT |= GBREG->getPixel(w, h - 2) << 11;
207 pLine[w >> 3] = cVal; 1268 CONTEXT |= GBREG->getPixel(w - 1, h - 2) << 12;
208 } 1269 break;
209 } 1270 case 2:
210 pLine += nStride; 1271 CONTEXT |= GBREG->getPixel(w - 1, h);
211 } 1272 CONTEXT |= GBREG->getPixel(w - 2, h) << 1;
212 return GBREG; 1273 CONTEXT |= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 2;
213 } 1274 CONTEXT |= GBREG->getPixel(w + 1, h - 1) << 3;
214 CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template0_opt3(CJBig2_ArithDecoder *p ArithDecoder, JBig2ArithCtx *gbContext) 1275 CONTEXT |= GBREG->getPixel(w, h - 1) << 4;
215 { 1276 CONTEXT |= GBREG->getPixel(w - 1, h - 1) << 5;
216 FX_BOOL LTP, SLTP, bVal; 1277 CONTEXT |= GBREG->getPixel(w - 2, h - 1) << 6;
217 FX_DWORD CONTEXT; 1278 CONTEXT |= GBREG->getPixel(w + 1, h - 2) << 7;
218 CJBig2_Image *GBREG; 1279 CONTEXT |= GBREG->getPixel(w, h - 2) << 8;
219 FX_DWORD line1, line2; 1280 CONTEXT |= GBREG->getPixel(w - 1, h - 2) << 9;
220 uint8_t *pLine, *pLine1, *pLine2, cVal; 1281 break;
221 int32_t nStride, nStride2, k; 1282 case 3:
222 int32_t nLineBytes, nBitsLeft, cc; 1283 CONTEXT |= GBREG->getPixel(w - 1, h);
223 LTP = 0; 1284 CONTEXT |= GBREG->getPixel(w - 2, h) << 1;
224 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH)); 1285 CONTEXT |= GBREG->getPixel(w - 3, h) << 2;
225 if (GBREG->m_pData == NULL) { 1286 CONTEXT |= GBREG->getPixel(w - 4, h) << 3;
226 delete GBREG; 1287 CONTEXT |= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 4;
227 m_pModule->JBig2_Error("Generic region decoding procedure: Create Image Failed with width = %d, height = %d\n", GBW, GBH); 1288 CONTEXT |= GBREG->getPixel(w + 1, h - 1) << 5;
228 return NULL; 1289 CONTEXT |= GBREG->getPixel(w, h - 1) << 6;
229 } 1290 CONTEXT |= GBREG->getPixel(w - 1, h - 1) << 7;
230 pLine = GBREG->m_pData; 1291 CONTEXT |= GBREG->getPixel(w - 2, h - 1) << 8;
231 nStride = GBREG->m_nStride; 1292 CONTEXT |= GBREG->getPixel(w - 3, h - 1) << 9;
232 nStride2 = nStride << 1; 1293 break;
233 nLineBytes = ((GBW + 7) >> 3) - 1; 1294 }
234 nBitsLeft = GBW - (nLineBytes << 3); 1295 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
235 FX_DWORD height = GBH & 0x7fffffff; 1296 GBREG->setPixel(w, h, bVal);
236 for(FX_DWORD h = 0; h < height; h++) { 1297 }
237 if(TPGDON) { 1298 }
238 SLTP = pArithDecoder->DECODE(&gbContext[0x9b25]); 1299 }
239 LTP = LTP ^ SLTP; 1300 }
240 } 1301 return GBREG;
241 if(LTP == 1) { 1302 }
242 GBREG->copyLine(h, h - 1); 1303 CJBig2_Image* CJBig2_GRDProc::decode_MMR(CJBig2_BitStream* pStream) {
1304 int bitpos, i;
1305 CJBig2_Image* pImage;
1306 JBIG2_ALLOC(pImage, CJBig2_Image(GBW, GBH));
1307 if (pImage->m_pData == NULL) {
1308 delete pImage;
1309 m_pModule->JBig2_Error(
1310 "Generic region decoding procedure: Create Image Failed with width = "
1311 "%d, height = %d\n",
1312 GBW, GBH);
1313 return NULL;
1314 }
1315 bitpos = (int)pStream->getBitPos();
1316 _FaxG4Decode(m_pModule, pStream->getBuf(), pStream->getLength(), &bitpos,
1317 pImage->m_pData, GBW, GBH, pImage->m_nStride);
1318 pStream->setBitPos(bitpos);
1319 for (i = 0; (FX_DWORD)i < pImage->m_nStride * GBH; i++) {
1320 pImage->m_pData[i] = ~pImage->m_pData[i];
1321 }
1322 return pImage;
1323 }
1324 CJBig2_Image* CJBig2_GRRDProc::decode(CJBig2_ArithDecoder* pArithDecoder,
1325 JBig2ArithCtx* grContext) {
1326 if (GRW == 0 || GRH == 0) {
1327 CJBig2_Image* pImage;
1328 JBIG2_ALLOC(pImage, CJBig2_Image(GRW, GRH));
1329 return pImage;
1330 }
1331 if (GRTEMPLATE == 0) {
1332 if ((GRAT[0] == (signed char)-1) && (GRAT[1] == (signed char)-1) &&
1333 (GRAT[2] == (signed char)-1) && (GRAT[3] == (signed char)-1) &&
1334 (GRREFERENCEDX == 0) && (GRW == (FX_DWORD)GRREFERENCE->m_nWidth)) {
1335 return decode_Template0_opt(pArithDecoder, grContext);
1336 } else {
1337 return decode_Template0_unopt(pArithDecoder, grContext);
1338 }
1339 } else {
1340 if ((GRREFERENCEDX == 0) && (GRW == (FX_DWORD)GRREFERENCE->m_nWidth)) {
1341 return decode_Template1_opt(pArithDecoder, grContext);
1342 } else {
1343 return decode_Template1_unopt(pArithDecoder, grContext);
1344 }
1345 }
1346 }
1347 CJBig2_Image* CJBig2_GRRDProc::decode_Template0_unopt(
1348 CJBig2_ArithDecoder* pArithDecoder,
1349 JBig2ArithCtx* grContext) {
1350 FX_BOOL LTP, SLTP, bVal;
1351 FX_DWORD CONTEXT;
1352 CJBig2_Image* GRREG;
1353 FX_DWORD line1, line2, line3, line4, line5;
1354 LTP = 0;
1355 JBIG2_ALLOC(GRREG, CJBig2_Image(GRW, GRH));
1356 GRREG->fill(0);
1357 for (FX_DWORD h = 0; h < GRH; h++) {
1358 if (TPGRON) {
1359 SLTP = pArithDecoder->DECODE(&grContext[0x0010]);
1360 LTP = LTP ^ SLTP;
1361 }
1362 if (LTP == 0) {
1363 line1 = GRREG->getPixel(1, h - 1);
1364 line1 |= GRREG->getPixel(0, h - 1) << 1;
1365 line2 = 0;
1366 line3 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY - 1);
1367 line3 |= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY - 1)
1368 << 1;
1369 line4 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY);
1370 line4 |= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY) << 1;
1371 line4 |= GRREFERENCE->getPixel(-GRREFERENCEDX - 1, h - GRREFERENCEDY)
1372 << 2;
1373 line5 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY + 1);
1374 line5 |= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY + 1)
1375 << 1;
1376 line5 |= GRREFERENCE->getPixel(-GRREFERENCEDX - 1, h - GRREFERENCEDY + 1)
1377 << 2;
1378 for (FX_DWORD w = 0; w < GRW; w++) {
1379 CONTEXT = line5;
1380 CONTEXT |= line4 << 3;
1381 CONTEXT |= line3 << 6;
1382 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX + GRAT[2],
1383 h - GRREFERENCEDY + GRAT[3])
1384 << 8;
1385 CONTEXT |= line2 << 9;
1386 CONTEXT |= line1 << 10;
1387 CONTEXT |= GRREG->getPixel(w + GRAT[0], h + GRAT[1]) << 12;
1388 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);
1389 GRREG->setPixel(w, h, bVal);
1390 line1 = ((line1 << 1) | GRREG->getPixel(w + 2, h - 1)) & 0x03;
1391 line2 = ((line2 << 1) | bVal) & 0x01;
1392 line3 = ((line3 << 1) |
1393 GRREFERENCE->getPixel(w - GRREFERENCEDX + 2,
1394 h - GRREFERENCEDY - 1)) &
1395 0x03;
1396 line4 =
1397 ((line4 << 1) |
1398 GRREFERENCE->getPixel(w - GRREFERENCEDX + 2, h - GRREFERENCEDY)) &
1399 0x07;
1400 line5 = ((line5 << 1) |
1401 GRREFERENCE->getPixel(w - GRREFERENCEDX + 2,
1402 h - GRREFERENCEDY + 1)) &
1403 0x07;
1404 }
1405 } else {
1406 line1 = GRREG->getPixel(1, h - 1);
1407 line1 |= GRREG->getPixel(0, h - 1) << 1;
1408 line2 = 0;
1409 line3 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY - 1);
1410 line3 |= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY - 1)
1411 << 1;
1412 line4 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY);
1413 line4 |= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY) << 1;
1414 line4 |= GRREFERENCE->getPixel(-GRREFERENCEDX - 1, h - GRREFERENCEDY)
1415 << 2;
1416 line5 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY + 1);
1417 line5 |= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY + 1)
1418 << 1;
1419 line5 |= GRREFERENCE->getPixel(-GRREFERENCEDX - 1, h - GRREFERENCEDY + 1)
1420 << 2;
1421 for (FX_DWORD w = 0; w < GRW; w++) {
1422 bVal = GRREFERENCE->getPixel(w, h);
1423 if (!(TPGRON && (bVal == GRREFERENCE->getPixel(w - 1, h - 1)) &&
1424 (bVal == GRREFERENCE->getPixel(w, h - 1)) &&
1425 (bVal == GRREFERENCE->getPixel(w + 1, h - 1)) &&
1426 (bVal == GRREFERENCE->getPixel(w - 1, h)) &&
1427 (bVal == GRREFERENCE->getPixel(w + 1, h)) &&
1428 (bVal == GRREFERENCE->getPixel(w - 1, h + 1)) &&
1429 (bVal == GRREFERENCE->getPixel(w, h + 1)) &&
1430 (bVal == GRREFERENCE->getPixel(w + 1, h + 1)))) {
1431 CONTEXT = line5;
1432 CONTEXT |= line4 << 3;
1433 CONTEXT |= line3 << 6;
1434 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX + GRAT[2],
1435 h - GRREFERENCEDY + GRAT[3])
1436 << 8;
1437 CONTEXT |= line2 << 9;
1438 CONTEXT |= line1 << 10;
1439 CONTEXT |= GRREG->getPixel(w + GRAT[0], h + GRAT[1]) << 12;
1440 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);
1441 }
1442 GRREG->setPixel(w, h, bVal);
1443 line1 = ((line1 << 1) | GRREG->getPixel(w + 2, h - 1)) & 0x03;
1444 line2 = ((line2 << 1) | bVal) & 0x01;
1445 line3 = ((line3 << 1) |
1446 GRREFERENCE->getPixel(w - GRREFERENCEDX + 2,
1447 h - GRREFERENCEDY - 1)) &
1448 0x03;
1449 line4 =
1450 ((line4 << 1) |
1451 GRREFERENCE->getPixel(w - GRREFERENCEDX + 2, h - GRREFERENCEDY)) &
1452 0x07;
1453 line5 = ((line5 << 1) |
1454 GRREFERENCE->getPixel(w - GRREFERENCEDX + 2,
1455 h - GRREFERENCEDY + 1)) &
1456 0x07;
1457 }
1458 }
1459 }
1460 return GRREG;
1461 }
1462 CJBig2_Image* CJBig2_GRRDProc::decode_Template0_opt(
1463 CJBig2_ArithDecoder* pArithDecoder,
1464 JBig2ArithCtx* grContext) {
1465 FX_BOOL LTP, SLTP, bVal;
1466 FX_DWORD CONTEXT;
1467 CJBig2_Image* GRREG;
1468 FX_DWORD line1, line1_r, line2_r, line3_r;
1469 uint8_t *pLine, *pLineR, cVal;
1470 intptr_t nStride, nStrideR, nOffset;
1471 int32_t k, nBits;
1472 int32_t GRWR, GRHR;
1473 int32_t GRW, GRH;
1474 GRW = (int32_t)CJBig2_GRRDProc::GRW;
1475 GRH = (int32_t)CJBig2_GRRDProc::GRH;
1476 LTP = 0;
1477 JBIG2_ALLOC(GRREG, CJBig2_Image(GRW, GRH));
1478 if (GRREG->m_pData == NULL) {
1479 delete GRREG;
1480 m_pModule->JBig2_Error(
1481 "Generic refinement region decoding procedure: Create Image Failed "
1482 "with width = %d, height = %d\n",
1483 GRW, GRH);
1484 return NULL;
1485 }
1486 pLine = GRREG->m_pData;
1487 pLineR = GRREFERENCE->m_pData;
1488 nStride = GRREG->m_nStride;
1489 nStrideR = GRREFERENCE->m_nStride;
1490 GRWR = (int32_t)GRREFERENCE->m_nWidth;
1491 GRHR = (int32_t)GRREFERENCE->m_nHeight;
1492 if (GRREFERENCEDY < -GRHR + 1 || GRREFERENCEDY > GRHR - 1) {
1493 GRREFERENCEDY = 0;
1494 }
1495 nOffset = -GRREFERENCEDY * nStrideR;
1496 for (int32_t h = 0; h < GRH; h++) {
1497 if (TPGRON) {
1498 SLTP = pArithDecoder->DECODE(&grContext[0x0010]);
1499 LTP = LTP ^ SLTP;
1500 }
1501 line1 = (h > 0) ? pLine[-nStride] << 4 : 0;
1502 int32_t reference_h = h - GRREFERENCEDY;
1503 FX_BOOL line1_r_ok = (reference_h > 0 && reference_h < GRHR + 1);
1504 FX_BOOL line2_r_ok = (reference_h > -1 && reference_h < GRHR);
1505 FX_BOOL line3_r_ok = (reference_h > -2 && reference_h < GRHR - 1);
1506 line1_r = line1_r_ok ? pLineR[nOffset - nStrideR] : 0;
1507 line2_r = line2_r_ok ? pLineR[nOffset] : 0;
1508 line3_r = line3_r_ok ? pLineR[nOffset + nStrideR] : 0;
1509 if (LTP == 0) {
1510 CONTEXT = (line1 & 0x1c00) | (line1_r & 0x01c0) |
1511 ((line2_r >> 3) & 0x0038) | ((line3_r >> 6) & 0x0007);
1512 for (int32_t w = 0; w < GRW; w += 8) {
1513 nBits = GRW - w > 8 ? 8 : GRW - w;
1514 if (h > 0)
1515 line1 = (line1 << 8) |
1516 (w + 8 < GRW ? pLine[-nStride + (w >> 3) + 1] << 4 : 0);
1517 if (h > GRHR + GRREFERENCEDY + 1) {
1518 line1_r = 0;
1519 line2_r = 0;
1520 line3_r = 0;
243 } else { 1521 } else {
244 if(h > 1) { 1522 if (line1_r_ok)
245 pLine1 = pLine - nStride2; 1523 line1_r =
246 pLine2 = pLine - nStride; 1524 (line1_r << 8) |
247 line1 = (*pLine1++) << 6; 1525 (w + 8 < GRWR ? pLineR[nOffset - nStrideR + (w >> 3) + 1] : 0);
248 line2 = *pLine2++; 1526 if (line2_r_ok)
249 CONTEXT = ((line1 & 0xf800) | (line2 & 0x07f0)); 1527 line2_r = (line2_r << 8) |
250 for(cc = 0; cc < nLineBytes; cc++) { 1528 (w + 8 < GRWR ? pLineR[nOffset + (w >> 3) + 1] : 0);
251 line1 = (line1 << 8) | ((*pLine1++) << 6); 1529 if (line3_r_ok)
252 line2 = (line2 << 8) | (*pLine2++); 1530 line3_r =
253 cVal = 0; 1531 (line3_r << 8) |
254 for(k = 7; k >= 0; k--) { 1532 (w + 8 < GRWR ? pLineR[nOffset + nStrideR + (w >> 3) + 1] : 0);
255 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]); 1533 else {
256 cVal |= bVal << k; 1534 line3_r = 0;
257 CONTEXT = (((CONTEXT & 0x7bf7) << 1) | bVal 1535 }
258 | ((line1 >> k) & 0x0800) 1536 }
259 | ((line2 >> k) & 0x0010)); 1537 cVal = 0;
260 } 1538 for (k = 0; k < nBits; k++) {
261 pLine[cc] = cVal; 1539 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);
262 } 1540 cVal |= bVal << (7 - k);
263 line1 <<= 8; 1541 CONTEXT = ((CONTEXT & 0x0cdb) << 1) | (bVal << 9) |
264 line2 <<= 8; 1542 ((line1 >> (7 - k)) & 0x0400) |
265 cVal = 0; 1543 ((line1_r >> (7 - k)) & 0x0040) |
266 for(k = 0; k < nBitsLeft; k++) { 1544 ((line2_r >> (10 - k)) & 0x0008) |
267 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]); 1545 ((line3_r >> (13 - k)) & 0x0001);
268 cVal |= bVal << (7 - k); 1546 }
269 CONTEXT = (((CONTEXT & 0x7bf7) << 1) | bVal 1547 pLine[w >> 3] = cVal;
270 | ((line1 >> (7 - k)) & 0x0800) 1548 }
271 | ((line2 >> (7 - k)) & 0x0010)); 1549 } else {
272 } 1550 CONTEXT = (line1 & 0x1c00) | (line1_r & 0x01c0) |
273 pLine[nLineBytes] = cVal; 1551 ((line2_r >> 3) & 0x0038) | ((line3_r >> 6) & 0x0007);
274 } else { 1552 for (int32_t w = 0; w < GRW; w += 8) {
275 pLine2 = pLine - nStride; 1553 nBits = GRW - w > 8 ? 8 : GRW - w;
276 line2 = (h & 1) ? (*pLine2++) : 0; 1554 if (h > 0)
277 CONTEXT = (line2 & 0x07f0); 1555 line1 = (line1 << 8) |
278 for(cc = 0; cc < nLineBytes; cc++) { 1556 (w + 8 < GRW ? pLine[-nStride + (w >> 3) + 1] << 4 : 0);
279 if(h & 1) { 1557 if (line1_r_ok)
280 line2 = (line2 << 8) | (*pLine2++); 1558 line1_r =
281 } 1559 (line1_r << 8) |
282 cVal = 0; 1560 (w + 8 < GRWR ? pLineR[nOffset - nStrideR + (w >> 3) + 1] : 0);
283 for(k = 7; k >= 0; k--) { 1561 if (line2_r_ok)
284 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]); 1562 line2_r = (line2_r << 8) |
285 cVal |= bVal << k; 1563 (w + 8 < GRWR ? pLineR[nOffset + (w >> 3) + 1] : 0);
286 CONTEXT = (((CONTEXT & 0x7bf7) << 1) | bVal 1564 if (line3_r_ok)
287 | ((line2 >> k) & 0x0010)); 1565 line3_r =
288 } 1566 (line3_r << 8) |
289 pLine[cc] = cVal; 1567 (w + 8 < GRWR ? pLineR[nOffset + nStrideR + (w >> 3) + 1] : 0);
290 } 1568 else {
291 line2 <<= 8; 1569 line3_r = 0;
292 cVal = 0; 1570 }
293 for(k = 0; k < nBitsLeft; k++) { 1571 cVal = 0;
294 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]); 1572 for (k = 0; k < nBits; k++) {
295 cVal |= bVal << (7 - k); 1573 bVal = GRREFERENCE->getPixel(w + k, h);
296 CONTEXT = (((CONTEXT & 0x7bf7) << 1) | bVal 1574 if (!(TPGRON && (bVal == GRREFERENCE->getPixel(w + k - 1, h - 1)) &&
297 | (((line2 >> (7 - k))) & 0x0010)); 1575 (bVal == GRREFERENCE->getPixel(w + k, h - 1)) &&
298 } 1576 (bVal == GRREFERENCE->getPixel(w + k + 1, h - 1)) &&
299 pLine[nLineBytes] = cVal; 1577 (bVal == GRREFERENCE->getPixel(w + k - 1, h)) &&
300 } 1578 (bVal == GRREFERENCE->getPixel(w + k + 1, h)) &&
301 } 1579 (bVal == GRREFERENCE->getPixel(w + k - 1, h + 1)) &&
302 pLine += nStride; 1580 (bVal == GRREFERENCE->getPixel(w + k, h + 1)) &&
303 } 1581 (bVal == GRREFERENCE->getPixel(w + k + 1, h + 1)))) {
304 return GBREG; 1582 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);
305 } 1583 }
306 CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template0_unopt(CJBig2_ArithDecoder * pArithDecoder, JBig2ArithCtx *gbContext) 1584 cVal |= bVal << (7 - k);
307 { 1585 CONTEXT = ((CONTEXT & 0x0cdb) << 1) | (bVal << 9) |
308 FX_BOOL LTP, SLTP, bVal; 1586 ((line1 >> (7 - k)) & 0x0400) |
309 FX_DWORD CONTEXT; 1587 ((line1_r >> (7 - k)) & 0x0040) |
310 CJBig2_Image *GBREG; 1588 ((line2_r >> (10 - k)) & 0x0008) |
311 FX_DWORD line1, line2, line3; 1589 ((line3_r >> (13 - k)) & 0x0001);
312 LTP = 0; 1590 }
313 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH)); 1591 pLine[w >> 3] = cVal;
314 GBREG->fill(0); 1592 }
315 for(FX_DWORD h = 0; h < GBH; h++) { 1593 }
316 if(TPGDON) { 1594 pLine += nStride;
317 SLTP = pArithDecoder->DECODE(&gbContext[0x9b25]); 1595 if (h < GRHR + GRREFERENCEDY) {
318 LTP = LTP ^ SLTP; 1596 pLineR += nStrideR;
319 } 1597 }
320 if(LTP == 1) { 1598 }
321 GBREG->copyLine(h, h - 1); 1599 return GRREG;
1600 }
1601 CJBig2_Image* CJBig2_GRRDProc::decode_Template1_unopt(
1602 CJBig2_ArithDecoder* pArithDecoder,
1603 JBig2ArithCtx* grContext) {
1604 FX_BOOL LTP, SLTP, bVal;
1605 FX_DWORD CONTEXT;
1606 CJBig2_Image* GRREG;
1607 FX_DWORD line1, line2, line3, line4, line5;
1608 LTP = 0;
1609 JBIG2_ALLOC(GRREG, CJBig2_Image(GRW, GRH));
1610 GRREG->fill(0);
1611 for (FX_DWORD h = 0; h < GRH; h++) {
1612 if (TPGRON) {
1613 SLTP = pArithDecoder->DECODE(&grContext[0x0008]);
1614 LTP = LTP ^ SLTP;
1615 }
1616 if (LTP == 0) {
1617 line1 = GRREG->getPixel(1, h - 1);
1618 line1 |= GRREG->getPixel(0, h - 1) << 1;
1619 line1 |= GRREG->getPixel(-1, h - 1) << 2;
1620 line2 = 0;
1621 line3 = GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY - 1);
1622 line4 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY);
1623 line4 |= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY) << 1;
1624 line4 |= GRREFERENCE->getPixel(-GRREFERENCEDX - 1, h - GRREFERENCEDY)
1625 << 2;
1626 line5 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY + 1);
1627 line5 |= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY + 1)
1628 << 1;
1629 for (FX_DWORD w = 0; w < GRW; w++) {
1630 CONTEXT = line5;
1631 CONTEXT |= line4 << 2;
1632 CONTEXT |= line3 << 5;
1633 CONTEXT |= line2 << 6;
1634 CONTEXT |= line1 << 7;
1635 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);
1636 GRREG->setPixel(w, h, bVal);
1637 line1 = ((line1 << 1) | GRREG->getPixel(w + 2, h - 1)) & 0x07;
1638 line2 = ((line2 << 1) | bVal) & 0x01;
1639 line3 = ((line3 << 1) |
1640 GRREFERENCE->getPixel(w - GRREFERENCEDX + 1,
1641 h - GRREFERENCEDY - 1)) &
1642 0x01;
1643 line4 =
1644 ((line4 << 1) |
1645 GRREFERENCE->getPixel(w - GRREFERENCEDX + 2, h - GRREFERENCEDY)) &
1646 0x07;
1647 line5 = ((line5 << 1) |
1648 GRREFERENCE->getPixel(w - GRREFERENCEDX + 2,
1649 h - GRREFERENCEDY + 1)) &
1650 0x03;
1651 }
1652 } else {
1653 line1 = GRREG->getPixel(1, h - 1);
1654 line1 |= GRREG->getPixel(0, h - 1) << 1;
1655 line1 |= GRREG->getPixel(-1, h - 1) << 2;
1656 line2 = 0;
1657 line3 = GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY - 1);
1658 line4 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY);
1659 line4 |= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY) << 1;
1660 line4 |= GRREFERENCE->getPixel(-GRREFERENCEDX - 1, h - GRREFERENCEDY)
1661 << 2;
1662 line5 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY + 1);
1663 line5 |= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY + 1)
1664 << 1;
1665 for (FX_DWORD w = 0; w < GRW; w++) {
1666 bVal = GRREFERENCE->getPixel(w, h);
1667 if (!(TPGRON && (bVal == GRREFERENCE->getPixel(w - 1, h - 1)) &&
1668 (bVal == GRREFERENCE->getPixel(w, h - 1)) &&
1669 (bVal == GRREFERENCE->getPixel(w + 1, h - 1)) &&
1670 (bVal == GRREFERENCE->getPixel(w - 1, h)) &&
1671 (bVal == GRREFERENCE->getPixel(w + 1, h)) &&
1672 (bVal == GRREFERENCE->getPixel(w - 1, h + 1)) &&
1673 (bVal == GRREFERENCE->getPixel(w, h + 1)) &&
1674 (bVal == GRREFERENCE->getPixel(w + 1, h + 1)))) {
1675 CONTEXT = line5;
1676 CONTEXT |= line4 << 2;
1677 CONTEXT |= line3 << 5;
1678 CONTEXT |= line2 << 6;
1679 CONTEXT |= line1 << 7;
1680 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);
1681 }
1682 GRREG->setPixel(w, h, bVal);
1683 line1 = ((line1 << 1) | GRREG->getPixel(w + 2, h - 1)) & 0x07;
1684 line2 = ((line2 << 1) | bVal) & 0x01;
1685 line3 = ((line3 << 1) |
1686 GRREFERENCE->getPixel(w - GRREFERENCEDX + 1,
1687 h - GRREFERENCEDY - 1)) &
1688 0x01;
1689 line4 =
1690 ((line4 << 1) |
1691 GRREFERENCE->getPixel(w - GRREFERENCEDX + 2, h - GRREFERENCEDY)) &
1692 0x07;
1693 line5 = ((line5 << 1) |
1694 GRREFERENCE->getPixel(w - GRREFERENCEDX + 2,
1695 h - GRREFERENCEDY + 1)) &
1696 0x03;
1697 }
1698 }
1699 }
1700 return GRREG;
1701 }
1702 CJBig2_Image* CJBig2_GRRDProc::decode_Template1_opt(
1703 CJBig2_ArithDecoder* pArithDecoder,
1704 JBig2ArithCtx* grContext) {
1705 FX_BOOL LTP, SLTP, bVal;
1706 FX_DWORD CONTEXT;
1707 CJBig2_Image* GRREG;
1708 FX_DWORD line1, line1_r, line2_r, line3_r;
1709 uint8_t *pLine, *pLineR, cVal;
1710 intptr_t nStride, nStrideR, nOffset;
1711 int32_t k, nBits;
1712 int32_t GRWR, GRHR;
1713 int32_t GRW, GRH;
1714 GRW = (int32_t)CJBig2_GRRDProc::GRW;
1715 GRH = (int32_t)CJBig2_GRRDProc::GRH;
1716 LTP = 0;
1717 JBIG2_ALLOC(GRREG, CJBig2_Image(GRW, GRH));
1718 if (GRREG->m_pData == NULL) {
1719 delete GRREG;
1720 m_pModule->JBig2_Error(
1721 "Generic refinement region decoding procedure: Create Image Failed "
1722 "with width = %d, height = %d\n",
1723 GRW, GRH);
1724 return NULL;
1725 }
1726 pLine = GRREG->m_pData;
1727 pLineR = GRREFERENCE->m_pData;
1728 nStride = GRREG->m_nStride;
1729 nStrideR = GRREFERENCE->m_nStride;
1730 GRWR = (int32_t)GRREFERENCE->m_nWidth;
1731 GRHR = (int32_t)GRREFERENCE->m_nHeight;
1732 if (GRREFERENCEDY < -GRHR + 1 || GRREFERENCEDY > GRHR - 1) {
1733 GRREFERENCEDY = 0;
1734 }
1735 nOffset = -GRREFERENCEDY * nStrideR;
1736 for (int32_t h = 0; h < GRH; h++) {
1737 if (TPGRON) {
1738 SLTP = pArithDecoder->DECODE(&grContext[0x0008]);
1739 LTP = LTP ^ SLTP;
1740 }
1741 line1 = (h > 0) ? pLine[-nStride] << 1 : 0;
1742 int32_t reference_h = h - GRREFERENCEDY;
1743 FX_BOOL line1_r_ok = (reference_h > 0 && reference_h < GRHR + 1);
1744 FX_BOOL line2_r_ok = (reference_h > -1 && reference_h < GRHR);
1745 FX_BOOL line3_r_ok = (reference_h > -2 && reference_h < GRHR - 1);
1746 line1_r = line1_r_ok ? pLineR[nOffset - nStrideR] : 0;
1747 line2_r = line2_r_ok ? pLineR[nOffset] : 0;
1748 line3_r = line3_r_ok ? pLineR[nOffset + nStrideR] : 0;
1749 if (LTP == 0) {
1750 CONTEXT = (line1 & 0x0380) | ((line1_r >> 2) & 0x0020) |
1751 ((line2_r >> 4) & 0x001c) | ((line3_r >> 6) & 0x0003);
1752 for (int32_t w = 0; w < GRW; w += 8) {
1753 nBits = GRW - w > 8 ? 8 : GRW - w;
1754 if (h > 0)
1755 line1 = (line1 << 8) |
1756 (w + 8 < GRW ? pLine[-nStride + (w >> 3) + 1] << 1 : 0);
1757 if (line1_r_ok)
1758 line1_r =
1759 (line1_r << 8) |
1760 (w + 8 < GRWR ? pLineR[nOffset - nStrideR + (w >> 3) + 1] : 0);
1761 if (line2_r_ok)
1762 line2_r = (line2_r << 8) |
1763 (w + 8 < GRWR ? pLineR[nOffset + (w >> 3) + 1] : 0);
1764 if (line3_r_ok)
1765 line3_r =
1766 (line3_r << 8) |
1767 (w + 8 < GRWR ? pLineR[nOffset + nStrideR + (w >> 3) + 1] : 0);
1768 else {
1769 line3_r = 0;
1770 }
1771 cVal = 0;
1772 for (k = 0; k < nBits; k++) {
1773 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);
1774 cVal |= bVal << (7 - k);
1775 CONTEXT = ((CONTEXT & 0x018d) << 1) | (bVal << 6) |
1776 ((line1 >> (7 - k)) & 0x0080) |
1777 ((line1_r >> (9 - k)) & 0x0020) |
1778 ((line2_r >> (11 - k)) & 0x0004) |
1779 ((line3_r >> (13 - k)) & 0x0001);
1780 }
1781 pLine[w >> 3] = cVal;
1782 }
1783 } else {
1784 CONTEXT = (line1 & 0x0380) | ((line1_r >> 2) & 0x0020) |
1785 ((line2_r >> 4) & 0x001c) | ((line3_r >> 6) & 0x0003);
1786 for (int32_t w = 0; w < GRW; w += 8) {
1787 nBits = GRW - w > 8 ? 8 : GRW - w;
1788 if (h > 0)
1789 line1 = (line1 << 8) |
1790 (w + 8 < GRW ? pLine[-nStride + (w >> 3) + 1] << 1 : 0);
1791 if (line1_r_ok)
1792 line1_r =
1793 (line1_r << 8) |
1794 (w + 8 < GRWR ? pLineR[nOffset - nStrideR + (w >> 3) + 1] : 0);
1795 if (line2_r_ok)
1796 line2_r = (line2_r << 8) |
1797 (w + 8 < GRWR ? pLineR[nOffset + (w >> 3) + 1] : 0);
1798 if (line3_r_ok)
1799 line3_r =
1800 (line3_r << 8) |
1801 (w + 8 < GRWR ? pLineR[nOffset + nStrideR + (w >> 3) + 1] : 0);
1802 else {
1803 line3_r = 0;
1804 }
1805 cVal = 0;
1806 for (k = 0; k < nBits; k++) {
1807 bVal = GRREFERENCE->getPixel(w + k, h);
1808 if (!(TPGRON && (bVal == GRREFERENCE->getPixel(w + k - 1, h - 1)) &&
1809 (bVal == GRREFERENCE->getPixel(w + k, h - 1)) &&
1810 (bVal == GRREFERENCE->getPixel(w + k + 1, h - 1)) &&
1811 (bVal == GRREFERENCE->getPixel(w + k - 1, h)) &&
1812 (bVal == GRREFERENCE->getPixel(w + k + 1, h)) &&
1813 (bVal == GRREFERENCE->getPixel(w + k - 1, h + 1)) &&
1814 (bVal == GRREFERENCE->getPixel(w + k, h + 1)) &&
1815 (bVal == GRREFERENCE->getPixel(w + k + 1, h + 1)))) {
1816 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);
1817 }
1818 cVal |= bVal << (7 - k);
1819 CONTEXT = ((CONTEXT & 0x018d) << 1) | (bVal << 6) |
1820 ((line1 >> (7 - k)) & 0x0080) |
1821 ((line1_r >> (9 - k)) & 0x0020) |
1822 ((line2_r >> (11 - k)) & 0x0004) |
1823 ((line3_r >> (13 - k)) & 0x0001);
1824 }
1825 pLine[w >> 3] = cVal;
1826 }
1827 }
1828 pLine += nStride;
1829 if (h < GRHR + GRREFERENCEDY) {
1830 pLineR += nStrideR;
1831 }
1832 }
1833 return GRREG;
1834 }
1835 CJBig2_Image* CJBig2_GRRDProc::decode_V1(CJBig2_ArithDecoder* pArithDecoder,
1836 JBig2ArithCtx* grContext) {
1837 FX_BOOL LTP, SLTP, bVal;
1838 FX_BOOL TPGRPIX, TPGRVAL;
1839 FX_DWORD CONTEXT;
1840 CJBig2_Image* GRREG;
1841 LTP = 0;
1842 JBIG2_ALLOC(GRREG, CJBig2_Image(GRW, GRH));
1843 GRREG->fill(0);
1844 for (FX_DWORD h = 0; h < GRH; h++) {
1845 if (TPGRON) {
1846 switch (GRTEMPLATE) {
1847 case 0:
1848 CONTEXT = 0x0010;
1849 break;
1850 case 1:
1851 CONTEXT = 0x0008;
1852 break;
1853 }
1854 SLTP = pArithDecoder->DECODE(&grContext[CONTEXT]);
1855 LTP = LTP ^ SLTP;
1856 }
1857 if (LTP == 0) {
1858 for (FX_DWORD w = 0; w < GRW; w++) {
1859 CONTEXT = 0;
1860 switch (GRTEMPLATE) {
1861 case 0:
1862 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX + 1,
1863 h - GRREFERENCEDY + 1);
1864 CONTEXT |=
1865 GRREFERENCE->getPixel(w - GRREFERENCEDX, h - GRREFERENCEDY + 1)
1866 << 1;
1867 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX - 1,
1868 h - GRREFERENCEDY + 1)
1869 << 2;
1870 CONTEXT |=
1871 GRREFERENCE->getPixel(w - GRREFERENCEDX + 1, h - GRREFERENCEDY)
1872 << 3;
1873 CONTEXT |=
1874 GRREFERENCE->getPixel(w - GRREFERENCEDX, h - GRREFERENCEDY)
1875 << 4;
1876 CONTEXT |=
1877 GRREFERENCE->getPixel(w - GRREFERENCEDX - 1, h - GRREFERENCEDY)
1878 << 5;
1879 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX + 1,
1880 h - GRREFERENCEDY - 1)
1881 << 6;
1882 CONTEXT |=
1883 GRREFERENCE->getPixel(w - GRREFERENCEDX, h - GRREFERENCEDY - 1)
1884 << 7;
1885 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX + GRAT[2],
1886 h - GRREFERENCEDY + GRAT[3])
1887 << 8;
1888 CONTEXT |= GRREG->getPixel(w - 1, h) << 9;
1889 CONTEXT |= GRREG->getPixel(w + 1, h - 1) << 10;
1890 CONTEXT |= GRREG->getPixel(w, h - 1) << 11;
1891 CONTEXT |= GRREG->getPixel(w + GRAT[0], h + GRAT[1]) << 12;
1892 break;
1893 case 1:
1894 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX + 1,
1895 h - GRREFERENCEDY + 1);
1896 CONTEXT |=
1897 GRREFERENCE->getPixel(w - GRREFERENCEDX, h - GRREFERENCEDY + 1)
1898 << 1;
1899 CONTEXT |=
1900 GRREFERENCE->getPixel(w - GRREFERENCEDX + 1, h - GRREFERENCEDY)
1901 << 2;
1902 CONTEXT |=
1903 GRREFERENCE->getPixel(w - GRREFERENCEDX, h - GRREFERENCEDY)
1904 << 3;
1905 CONTEXT |=
1906 GRREFERENCE->getPixel(w - GRREFERENCEDX - 1, h - GRREFERENCEDY)
1907 << 4;
1908 CONTEXT |=
1909 GRREFERENCE->getPixel(w - GRREFERENCEDX, h - GRREFERENCEDY - 1)
1910 << 5;
1911 CONTEXT |= GRREG->getPixel(w - 1, h) << 6;
1912 CONTEXT |= GRREG->getPixel(w + 1, h - 1) << 7;
1913 CONTEXT |= GRREG->getPixel(w, h - 1) << 8;
1914 CONTEXT |= GRREG->getPixel(w - 1, h - 1) << 9;
1915 break;
1916 }
1917 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);
1918 GRREG->setPixel(w, h, bVal);
1919 }
1920 } else {
1921 for (FX_DWORD w = 0; w < GRW; w++) {
1922 bVal = GRREFERENCE->getPixel(w, h);
1923 if (TPGRON && (bVal == GRREFERENCE->getPixel(w - 1, h - 1)) &&
1924 (bVal == GRREFERENCE->getPixel(w, h - 1)) &&
1925 (bVal == GRREFERENCE->getPixel(w + 1, h - 1)) &&
1926 (bVal == GRREFERENCE->getPixel(w - 1, h)) &&
1927 (bVal == GRREFERENCE->getPixel(w + 1, h)) &&
1928 (bVal == GRREFERENCE->getPixel(w - 1, h + 1)) &&
1929 (bVal == GRREFERENCE->getPixel(w, h + 1)) &&
1930 (bVal == GRREFERENCE->getPixel(w + 1, h + 1))) {
1931 TPGRPIX = 1;
1932 TPGRVAL = bVal;
322 } else { 1933 } else {
323 line1 = GBREG->getPixel(1, h - 2); 1934 TPGRPIX = 0;
324 line1 |= GBREG->getPixel(0, h - 2) << 1; 1935 }
325 line2 = GBREG->getPixel(2, h - 1); 1936 if (TPGRPIX) {
326 line2 |= GBREG->getPixel(1, h - 1) << 1; 1937 GRREG->setPixel(w, h, TPGRVAL);
327 line2 |= GBREG->getPixel(0, h - 1) << 2;
328 line3 = 0;
329 for(FX_DWORD w = 0; w < GBW; w++) {
330 if(USESKIP && SKIP->getPixel(w, h)) {
331 bVal = 0;
332 } else {
333 CONTEXT = line3;
334 CONTEXT |= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 4;
335 CONTEXT |= line2 << 5;
336 CONTEXT |= GBREG->getPixel(w + GBAT[2], h + GBAT[3]) << 10;
337 CONTEXT |= GBREG->getPixel(w + GBAT[4], h + GBAT[5]) << 11;
338 CONTEXT |= line1 << 12;
339 CONTEXT |= GBREG->getPixel(w + GBAT[6], h + GBAT[7]) << 15;
340 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
341 }
342 if(bVal) {
343 GBREG->setPixel(w, h, bVal);
344 }
345 line1 = ((line1 << 1) | GBREG->getPixel(w + 2, h - 2)) & 0x07;
346 line2 = ((line2 << 1) | GBREG->getPixel(w + 3, h - 1)) & 0x1f;
347 line3 = ((line3 << 1) | bVal) & 0x0f;
348 }
349 }
350 }
351 return GBREG;
352 }
353 CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template1_opt(CJBig2_ArithDecoder *pA rithDecoder, JBig2ArithCtx *gbContext)
354 {
355 FX_BOOL LTP, SLTP, bVal;
356 FX_DWORD CONTEXT;
357 CJBig2_Image *GBREG;
358 FX_DWORD line1, line2, line3;
359 LTP = 0;
360 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
361 GBREG->fill(0);
362 for(FX_DWORD h = 0; h < GBH; h++) {
363 if(TPGDON) {
364 SLTP = pArithDecoder->DECODE(&gbContext[0x0795]);
365 LTP = LTP ^ SLTP;
366 }
367 if(LTP == 1) {
368 GBREG->copyLine(h, h - 1);
369 } else { 1938 } else {
370 line1 = GBREG->getPixel(2, h - 2); 1939 CONTEXT = 0;
371 line1 |= GBREG->getPixel(1, h - 2) << 1; 1940 switch (GRTEMPLATE) {
372 line1 |= GBREG->getPixel(0, h - 2) << 2; 1941 case 0:
373 line2 = GBREG->getPixel(3, h - 1); 1942 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX + 1,
374 line2 |= GBREG->getPixel(2, h - 1) << 1; 1943 h - GRREFERENCEDY + 1);
375 line2 |= GBREG->getPixel(1, h - 1) << 2; 1944 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX,
376 line2 |= GBREG->getPixel(0, h - 1) << 3; 1945 h - GRREFERENCEDY + 1)
377 line3 = 0; 1946 << 1;
378 for(FX_DWORD w = 0; w < GBW; w++) { 1947 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX - 1,
379 if(USESKIP && SKIP->getPixel(w, h)) { 1948 h - GRREFERENCEDY + 1)
380 bVal = 0; 1949 << 2;
381 } else { 1950 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX + 1,
382 CONTEXT = line3; 1951 h - GRREFERENCEDY)
383 CONTEXT |= line2 << 3; 1952 << 3;
384 CONTEXT |= line1 << 9; 1953 CONTEXT |=
385 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]); 1954 GRREFERENCE->getPixel(w - GRREFERENCEDX, h - GRREFERENCEDY)
386 } 1955 << 4;
387 if(bVal) { 1956 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX - 1,
388 GBREG->setPixel(w, h, bVal); 1957 h - GRREFERENCEDY)
389 } 1958 << 5;
390 line1 = ((line1 << 1) | GBREG->getPixel(w + 3, h - 2)) & 0x0f; 1959 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX + 1,
391 line2 = ((line2 << 1) | GBREG->getPixel(w + 4, h - 1)) & 0x3f; 1960 h - GRREFERENCEDY - 1)
392 line3 = ((line3 << 1) | bVal) & 0x07; 1961 << 6;
393 } 1962 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX,
394 } 1963 h - GRREFERENCEDY - 1)
395 } 1964 << 7;
396 return GBREG; 1965 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX + GRAT[2],
397 } 1966 h - GRREFERENCEDY + GRAT[3])
398 CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template1_opt2(CJBig2_ArithDecoder *p ArithDecoder, JBig2ArithCtx *gbContext) 1967 << 8;
399 { 1968 CONTEXT |= GRREG->getPixel(w - 1, h) << 9;
400 FX_BOOL LTP, SLTP, bVal; 1969 CONTEXT |= GRREG->getPixel(w + 1, h - 1) << 10;
401 FX_DWORD CONTEXT; 1970 CONTEXT |= GRREG->getPixel(w, h - 1) << 11;
402 CJBig2_Image *GBREG; 1971 CONTEXT |= GRREG->getPixel(w + GRAT[0], h + GRAT[1]) << 12;
403 FX_DWORD line1, line2; 1972 break;
404 uint8_t *pLine, cVal; 1973 case 1:
405 intptr_t nStride, nStride2; 1974 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX + 1,
406 int32_t nBits, k; 1975 h - GRREFERENCEDY + 1);
407 LTP = 0; 1976 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX,
408 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH)); 1977 h - GRREFERENCEDY + 1)
409 if (GBREG->m_pData == NULL) { 1978 << 1;
410 delete GBREG; 1979 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX + 1,
411 m_pModule->JBig2_Error("Generic region decoding procedure: Create Image Failed with width = %d, height = %d\n", GBW, GBH); 1980 h - GRREFERENCEDY)
412 return NULL; 1981 << 2;
413 } 1982 CONTEXT |=
414 pLine = GBREG->m_pData; 1983 GRREFERENCE->getPixel(w - GRREFERENCEDX, h - GRREFERENCEDY)
415 nStride = GBREG->m_nStride; 1984 << 3;
416 nStride2 = nStride << 1; 1985 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX - 1,
417 for(FX_DWORD h = 0; h < GBH; h++) { 1986 h - GRREFERENCEDY)
418 if(TPGDON) { 1987 << 4;
419 SLTP = pArithDecoder->DECODE(&gbContext[0x0795]); 1988 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX,
420 LTP = LTP ^ SLTP; 1989 h - GRREFERENCEDY - 1)
421 } 1990 << 5;
422 if(LTP == 1) { 1991 CONTEXT |= GRREG->getPixel(w - 1, h) << 6;
423 GBREG->copyLine(h, h - 1); 1992 CONTEXT |= GRREG->getPixel(w + 1, h - 1) << 7;
1993 CONTEXT |= GRREG->getPixel(w, h - 1) << 8;
1994 CONTEXT |= GRREG->getPixel(w - 1, h - 1) << 9;
1995 break;
1996 }
1997 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);
1998 GRREG->setPixel(w, h, bVal);
1999 }
2000 }
2001 }
2002 }
2003 return GRREG;
2004 }
2005 CJBig2_Image* CJBig2_TRDProc::decode_Huffman(CJBig2_BitStream* pStream,
2006 JBig2ArithCtx* grContext) {
2007 int32_t STRIPT, FIRSTS;
2008 FX_DWORD NINSTANCES;
2009 int32_t DT, DFS, CURS;
2010 uint8_t CURT;
2011 int32_t SI, TI;
2012 FX_DWORD IDI;
2013 CJBig2_Image* IBI;
2014 FX_DWORD WI, HI;
2015 int32_t IDS;
2016 FX_BOOL RI;
2017 int32_t RDWI, RDHI, RDXI, RDYI;
2018 CJBig2_Image* IBOI;
2019 FX_DWORD WOI, HOI;
2020 CJBig2_Image* SBREG;
2021 FX_BOOL bFirst;
2022 FX_DWORD nTmp;
2023 int32_t nVal, nBits;
2024 CJBig2_HuffmanDecoder* pHuffmanDecoder;
2025 CJBig2_GRRDProc* pGRRD;
2026 CJBig2_ArithDecoder* pArithDecoder;
2027 JBIG2_ALLOC(pHuffmanDecoder, CJBig2_HuffmanDecoder(pStream));
2028 JBIG2_ALLOC(SBREG, CJBig2_Image(SBW, SBH));
2029 SBREG->fill(SBDEFPIXEL);
2030 if (pHuffmanDecoder->decodeAValue(SBHUFFDT, &STRIPT) != 0) {
2031 m_pModule->JBig2_Error(
2032 "text region decoding procedure (huffman): too short.");
2033 goto failed;
2034 }
2035 STRIPT *= SBSTRIPS;
2036 STRIPT = -STRIPT;
2037 FIRSTS = 0;
2038 NINSTANCES = 0;
2039 while (NINSTANCES < SBNUMINSTANCES) {
2040 if (pHuffmanDecoder->decodeAValue(SBHUFFDT, &DT) != 0) {
2041 m_pModule->JBig2_Error(
2042 "text region decoding procedure (huffman): too short.");
2043 goto failed;
2044 }
2045 DT *= SBSTRIPS;
2046 STRIPT = STRIPT + DT;
2047 bFirst = TRUE;
2048 for (;;) {
2049 if (bFirst) {
2050 if (pHuffmanDecoder->decodeAValue(SBHUFFFS, &DFS) != 0) {
2051 m_pModule->JBig2_Error(
2052 "text region decoding procedure (huffman): too short.");
2053 goto failed;
2054 }
2055 FIRSTS = FIRSTS + DFS;
2056 CURS = FIRSTS;
2057 bFirst = FALSE;
2058 } else {
2059 nVal = pHuffmanDecoder->decodeAValue(SBHUFFDS, &IDS);
2060 if (nVal == JBIG2_OOB) {
2061 break;
2062 } else if (nVal != 0) {
2063 m_pModule->JBig2_Error(
2064 "text region decoding procedure (huffman): too short.");
2065 goto failed;
424 } else { 2066 } else {
425 line1 = (h > 1) ? pLine[-nStride2] << 4 : 0; 2067 CURS = CURS + IDS + SBDSOFFSET;
426 line2 = (h > 0) ? pLine[-nStride] : 0; 2068 }
427 CONTEXT = (line1 & 0x1e00) | ((line2 >> 1) & 0x01f8); 2069 }
428 for(FX_DWORD w = 0; w < GBW; w += 8) { 2070 if (SBSTRIPS == 1) {
429 if(w + 8 < GBW) { 2071 CURT = 0;
430 nBits = 8; 2072 } else {
431 if(h > 1) { 2073 nTmp = 1;
432 line1 = (line1 << 8) | (pLine[-nStride2 + (w >> 3) + 1] << 4); 2074 while ((FX_DWORD)(1 << nTmp) < SBSTRIPS) {
433 } 2075 nTmp++;
434 if(h > 0) { 2076 }
435 line2 = (line2 << 8) | (pLine[-nStride + (w >> 3) + 1]); 2077 if (pStream->readNBits(nTmp, &nVal) != 0) {
436 } 2078 m_pModule->JBig2_Error(
437 } else { 2079 "text region decoding procedure (huffman): too short.");
438 nBits = GBW - w; 2080 goto failed;
439 if(h > 1) { 2081 }
440 line1 <<= 8; 2082 CURT = nVal;
441 } 2083 }
442 if(h > 0) { 2084 TI = STRIPT + CURT;
443 line2 <<= 8; 2085 nVal = 0;
444 } 2086 nBits = 0;
445 } 2087 for (;;) {
446 cVal = 0; 2088 if (pStream->read1Bit(&nTmp) != 0) {
447 for(k = 0; k < nBits; k++) { 2089 m_pModule->JBig2_Error(
448 if(USESKIP && SKIP->getPixel(w, h)) { 2090 "text region decoding procedure (huffman): too short.");
449 bVal = 0; 2091 goto failed;
450 } else { 2092 }
451 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]); 2093 nVal = (nVal << 1) | nTmp;
452 } 2094 nBits++;
453 cVal |= bVal << (7 - k); 2095 for (IDI = 0; IDI < SBNUMSYMS; IDI++) {
454 CONTEXT = ((CONTEXT & 0x0efb) << 1) | bVal 2096 if ((nBits == SBSYMCODES[IDI].codelen) &&
455 | ((line1 >> (7 - k)) & 0x0200) 2097 (nVal == SBSYMCODES[IDI].code)) {
456 | ((line2 >> (8 - k)) & 0x0008); 2098 break;
457 } 2099 }
458 pLine[w >> 3] = cVal; 2100 }
459 } 2101 if (IDI < SBNUMSYMS) {
460 } 2102 break;
461 pLine += nStride; 2103 }
462 } 2104 }
463 return GBREG; 2105 if (SBREFINE == 0) {
464 } 2106 RI = 0;
465 CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template1_opt3(CJBig2_ArithDecoder *p ArithDecoder, JBig2ArithCtx *gbContext) 2107 } else {
466 { 2108 if (pStream->read1Bit(&RI) != 0) {
467 FX_BOOL LTP, SLTP, bVal; 2109 m_pModule->JBig2_Error(
468 FX_DWORD CONTEXT; 2110 "text region decoding procedure (huffman): too short.");
469 CJBig2_Image *GBREG; 2111 goto failed;
470 FX_DWORD line1, line2; 2112 }
471 uint8_t *pLine, *pLine1, *pLine2, cVal; 2113 }
472 int32_t nStride, nStride2, k; 2114 if (RI == 0) {
473 int32_t nLineBytes, nBitsLeft, cc; 2115 IBI = SBSYMS[IDI];
474 LTP = 0; 2116 } else {
475 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH)); 2117 if ((pHuffmanDecoder->decodeAValue(SBHUFFRDW, &RDWI) != 0) ||
476 if (GBREG->m_pData == NULL) { 2118 (pHuffmanDecoder->decodeAValue(SBHUFFRDH, &RDHI) != 0) ||
477 delete GBREG; 2119 (pHuffmanDecoder->decodeAValue(SBHUFFRDX, &RDXI) != 0) ||
478 m_pModule->JBig2_Error("Generic region decoding procedure: Create Image Failed with width = %d, height = %d\n", GBW, GBH); 2120 (pHuffmanDecoder->decodeAValue(SBHUFFRDY, &RDYI) != 0) ||
479 return NULL; 2121 (pHuffmanDecoder->decodeAValue(SBHUFFRSIZE, &nVal) != 0)) {
480 } 2122 m_pModule->JBig2_Error(
481 pLine = GBREG->m_pData; 2123 "text region decoding procedure (huffman): too short.");
482 nStride = GBREG->m_nStride; 2124 goto failed;
483 nStride2 = nStride << 1; 2125 }
484 nLineBytes = ((GBW + 7) >> 3) - 1; 2126 pStream->alignByte();
485 nBitsLeft = GBW - (nLineBytes << 3); 2127 nTmp = pStream->getOffset();
486 for(FX_DWORD h = 0; h < GBH; h++) { 2128 IBOI = SBSYMS[IDI];
487 if(TPGDON) { 2129 if (!IBOI) {
488 SLTP = pArithDecoder->DECODE(&gbContext[0x0795]); 2130 goto failed;
489 LTP = LTP ^ SLTP; 2131 }
490 } 2132 WOI = IBOI->m_nWidth;
491 if(LTP == 1) { 2133 HOI = IBOI->m_nHeight;
492 GBREG->copyLine(h, h - 1); 2134 if ((int)(WOI + RDWI) < 0 || (int)(HOI + RDHI) < 0) {
493 } else { 2135 m_pModule->JBig2_Error(
494 if(h > 1) { 2136 "text region decoding procedure (huffman): Invalid RDWI or RDHI "
495 pLine1 = pLine - nStride2; 2137 "value.");
496 pLine2 = pLine - nStride; 2138 goto failed;
497 line1 = (*pLine1++) << 4; 2139 }
498 line2 = *pLine2++; 2140 JBIG2_ALLOC(pGRRD, CJBig2_GRRDProc());
499 CONTEXT = (line1 & 0x1e00) | ((line2 >> 1) & 0x01f8); 2141 pGRRD->GRW = WOI + RDWI;
500 for(cc = 0; cc < nLineBytes; cc++) { 2142 pGRRD->GRH = HOI + RDHI;
501 line1 = (line1 << 8) | ((*pLine1++) << 4); 2143 pGRRD->GRTEMPLATE = SBRTEMPLATE;
502 line2 = (line2 << 8) | (*pLine2++); 2144 pGRRD->GRREFERENCE = IBOI;
503 cVal = 0; 2145 pGRRD->GRREFERENCEDX = (RDWI >> 2) + RDXI;
504 for(k = 7; k >= 0; k--) { 2146 pGRRD->GRREFERENCEDY = (RDHI >> 2) + RDYI;
505 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]); 2147 pGRRD->TPGRON = 0;
506 cVal |= bVal << k; 2148 pGRRD->GRAT[0] = SBRAT[0];
507 CONTEXT = ((CONTEXT & 0x0efb) << 1) | bVal 2149 pGRRD->GRAT[1] = SBRAT[1];
508 | ((line1 >> k) & 0x0200) 2150 pGRRD->GRAT[2] = SBRAT[2];
509 | ((line2 >> (k + 1)) & 0x0008); 2151 pGRRD->GRAT[3] = SBRAT[3];
510 } 2152 JBIG2_ALLOC(pArithDecoder, CJBig2_ArithDecoder(pStream));
511 pLine[cc] = cVal; 2153 IBI = pGRRD->decode(pArithDecoder, grContext);
512 } 2154 if (IBI == NULL) {
513 line1 <<= 8; 2155 delete pGRRD;
514 line2 <<= 8; 2156 delete pArithDecoder;
515 cVal = 0; 2157 goto failed;
516 for(k = 0; k < nBitsLeft; k++) { 2158 }
517 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]); 2159 delete pArithDecoder;
518 cVal |= bVal << (7 - k); 2160 pStream->alignByte();
519 CONTEXT = ((CONTEXT & 0x0efb) << 1) | bVal 2161 pStream->offset(2);
520 | ((line1 >> (7 - k)) & 0x0200) 2162 if ((FX_DWORD)nVal != (pStream->getOffset() - nTmp)) {
521 | ((line2 >> (8 - k)) & 0x0008); 2163 delete IBI;
522 } 2164 delete pGRRD;
523 pLine[nLineBytes] = cVal; 2165 m_pModule->JBig2_Error(
524 } else { 2166 "text region decoding procedure (huffman):"
525 pLine2 = pLine - nStride; 2167 "bytes processed by generic refinement region decoding procedure "
526 line2 = (h & 1) ? (*pLine2++) : 0; 2168 "doesn't equal SBHUFFRSIZE.");
527 CONTEXT = (line2 >> 1) & 0x01f8; 2169 goto failed;
528 for(cc = 0; cc < nLineBytes; cc++) { 2170 }
529 if(h & 1) { 2171 delete pGRRD;
530 line2 = (line2 << 8) | (*pLine2++); 2172 }
531 } 2173 if (!IBI) {
532 cVal = 0; 2174 continue;
533 for(k = 7; k >= 0; k--) { 2175 }
534 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]); 2176 WI = IBI->m_nWidth;
535 cVal |= bVal << k; 2177 HI = IBI->m_nHeight;
536 CONTEXT = ((CONTEXT & 0x0efb) << 1) | bVal 2178 if (TRANSPOSED == 0 && ((REFCORNER == JBIG2_CORNER_TOPRIGHT) ||
537 | ((line2 >> (k + 1)) & 0x0008); 2179 (REFCORNER == JBIG2_CORNER_BOTTOMRIGHT))) {
538 } 2180 CURS = CURS + WI - 1;
539 pLine[cc] = cVal; 2181 } else if (TRANSPOSED == 1 && ((REFCORNER == JBIG2_CORNER_BOTTOMLEFT) ||
540 } 2182 (REFCORNER == JBIG2_CORNER_BOTTOMRIGHT))) {
541 line2 <<= 8; 2183 CURS = CURS + HI - 1;
542 cVal = 0; 2184 }
543 for(k = 0; k < nBitsLeft; k++) { 2185 SI = CURS;
544 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]); 2186 if (TRANSPOSED == 0) {
545 cVal |= bVal << (7 - k); 2187 switch (REFCORNER) {
546 CONTEXT = ((CONTEXT & 0x0efb) << 1) | bVal 2188 case JBIG2_CORNER_TOPLEFT:
547 | ((line2 >> (8 - k)) & 0x0008); 2189 SBREG->composeFrom(SI, TI, IBI, SBCOMBOP);
548 } 2190 break;
549 pLine[nLineBytes] = cVal; 2191 case JBIG2_CORNER_TOPRIGHT:
550 } 2192 SBREG->composeFrom(SI - WI + 1, TI, IBI, SBCOMBOP);
551 } 2193 break;
552 pLine += nStride; 2194 case JBIG2_CORNER_BOTTOMLEFT:
553 } 2195 SBREG->composeFrom(SI, TI - HI + 1, IBI, SBCOMBOP);
554 return GBREG; 2196 break;
555 } 2197 case JBIG2_CORNER_BOTTOMRIGHT:
556 CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template1_unopt(CJBig2_ArithDecoder * pArithDecoder, JBig2ArithCtx *gbContext) 2198 SBREG->composeFrom(SI - WI + 1, TI - HI + 1, IBI, SBCOMBOP);
557 { 2199 break;
558 FX_BOOL LTP, SLTP, bVal; 2200 }
559 FX_DWORD CONTEXT; 2201 } else {
560 CJBig2_Image *GBREG; 2202 switch (REFCORNER) {
561 FX_DWORD line1, line2, line3; 2203 case JBIG2_CORNER_TOPLEFT:
562 LTP = 0; 2204 SBREG->composeFrom(TI, SI, IBI, SBCOMBOP);
563 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH)); 2205 break;
564 GBREG->fill(0); 2206 case JBIG2_CORNER_TOPRIGHT:
565 for(FX_DWORD h = 0; h < GBH; h++) { 2207 SBREG->composeFrom(TI - WI + 1, SI, IBI, SBCOMBOP);
566 if(TPGDON) { 2208 break;
567 SLTP = pArithDecoder->DECODE(&gbContext[0x0795]); 2209 case JBIG2_CORNER_BOTTOMLEFT:
568 LTP = LTP ^ SLTP; 2210 SBREG->composeFrom(TI, SI - HI + 1, IBI, SBCOMBOP);
569 } 2211 break;
570 if(LTP == 1) { 2212 case JBIG2_CORNER_BOTTOMRIGHT:
571 GBREG->copyLine(h, h - 1); 2213 SBREG->composeFrom(TI - WI + 1, SI - HI + 1, IBI, SBCOMBOP);
572 } else { 2214 break;
573 line1 = GBREG->getPixel(2, h - 2); 2215 }
574 line1 |= GBREG->getPixel(1, h - 2) << 1; 2216 }
575 line1 |= GBREG->getPixel(0, h - 2) << 2; 2217 if (RI != 0) {
576 line2 = GBREG->getPixel(2, h - 1); 2218 delete IBI;
577 line2 |= GBREG->getPixel(1, h - 1) << 1; 2219 }
578 line2 |= GBREG->getPixel(0, h - 1) << 2; 2220 if (TRANSPOSED == 0 && ((REFCORNER == JBIG2_CORNER_TOPLEFT) ||
579 line3 = 0; 2221 (REFCORNER == JBIG2_CORNER_BOTTOMLEFT))) {
580 for(FX_DWORD w = 0; w < GBW; w++) { 2222 CURS = CURS + WI - 1;
581 if(USESKIP && SKIP->getPixel(w, h)) { 2223 } else if (TRANSPOSED == 1 && ((REFCORNER == JBIG2_CORNER_TOPLEFT) ||
582 bVal = 0; 2224 (REFCORNER == JBIG2_CORNER_TOPRIGHT))) {
583 } else { 2225 CURS = CURS + HI - 1;
584 CONTEXT = line3; 2226 }
585 CONTEXT |= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 3; 2227 NINSTANCES = NINSTANCES + 1;
586 CONTEXT |= line2 << 4; 2228 }
587 CONTEXT |= line1 << 9; 2229 }
588 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]); 2230 delete pHuffmanDecoder;
589 } 2231 return SBREG;
590 if(bVal) {
591 GBREG->setPixel(w, h, bVal);
592 }
593 line1 = ((line1 << 1) | GBREG->getPixel(w + 3, h - 2)) & 0x0f;
594 line2 = ((line2 << 1) | GBREG->getPixel(w + 3, h - 1)) & 0x1f;
595 line3 = ((line3 << 1) | bVal) & 0x07;
596 }
597 }
598 }
599 return GBREG;
600 }
601 CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template2_opt(CJBig2_ArithDecoder *pA rithDecoder, JBig2ArithCtx *gbContext)
602 {
603 FX_BOOL LTP, SLTP, bVal;
604 FX_DWORD CONTEXT;
605 CJBig2_Image *GBREG;
606 FX_DWORD line1, line2, line3;
607 LTP = 0;
608 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
609 GBREG->fill(0);
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 = GBREG->getPixel(1, h - 2);
619 line1 |= GBREG->getPixel(0, h - 2) << 1;
620 line2 = GBREG->getPixel(2, h - 1);
621 line2 |= GBREG->getPixel(1, h - 1) << 1;
622 line2 |= GBREG->getPixel(0, h - 1) << 2;
623 line3 = 0;
624 for(FX_DWORD w = 0; w < GBW; w++) {
625 if(USESKIP && SKIP->getPixel(w, h)) {
626 bVal = 0;
627 } else {
628 CONTEXT = line3;
629 CONTEXT |= line2 << 2;
630 CONTEXT |= line1 << 7;
631 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
632 }
633 if(bVal) {
634 GBREG->setPixel(w, h, bVal);
635 }
636 line1 = ((line1 << 1) | GBREG->getPixel(w + 2, h - 2)) & 0x07;
637 line2 = ((line2 << 1) | GBREG->getPixel(w + 3, h - 1)) & 0x1f;
638 line3 = ((line3 << 1) | bVal) & 0x03;
639 }
640 }
641 }
642 return GBREG;
643 }
644 CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template2_opt2(CJBig2_ArithDecoder *p ArithDecoder, JBig2ArithCtx *gbContext)
645 {
646 FX_BOOL LTP, SLTP, bVal;
647 FX_DWORD CONTEXT;
648 CJBig2_Image *GBREG;
649 FX_DWORD line1, line2;
650 uint8_t *pLine, cVal;
651 intptr_t nStride, nStride2;
652 int32_t nBits, k;
653 LTP = 0;
654 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
655 if (GBREG->m_pData == NULL) {
656 delete GBREG;
657 m_pModule->JBig2_Error("Generic region decoding procedure: Create Image Failed with width = %d, height = %d\n", GBW, GBH);
658 return NULL;
659 }
660 pLine = GBREG->m_pData;
661 nStride = GBREG->m_nStride;
662 nStride2 = nStride << 1;
663 for(FX_DWORD h = 0; h < GBH; h++) {
664 if(TPGDON) {
665 SLTP = pArithDecoder->DECODE(&gbContext[0x00e5]);
666 LTP = LTP ^ SLTP;
667 }
668 if(LTP == 1) {
669 GBREG->copyLine(h, h - 1);
670 } else {
671 line1 = (h > 1) ? pLine[-nStride2] << 1 : 0;
672 line2 = (h > 0) ? pLine[-nStride] : 0;
673 CONTEXT = (line1 & 0x0380) | ((line2 >> 3) & 0x007c);
674 for(FX_DWORD w = 0; w < GBW; w += 8) {
675 if(w + 8 < GBW) {
676 nBits = 8;
677 if(h > 1) {
678 line1 = (line1 << 8) | (pLine[-nStride2 + (w >> 3) + 1] << 1);
679 }
680 if(h > 0) {
681 line2 = (line2 << 8) | (pLine[-nStride + (w >> 3) + 1]);
682 }
683 } else {
684 nBits = GBW - w;
685 if(h > 1) {
686 line1 <<= 8;
687 }
688 if(h > 0) {
689 line2 <<= 8;
690 }
691 }
692 cVal = 0;
693 for(k = 0; k < nBits; k++) {
694 if(USESKIP && SKIP->getPixel(w, h)) {
695 bVal = 0;
696 } else {
697 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
698 }
699 cVal |= bVal << (7 - k);
700 CONTEXT = ((CONTEXT & 0x01bd) << 1) | bVal
701 | ((line1 >> (7 - k)) & 0x0080)
702 | ((line2 >> (10 - k)) & 0x0004);
703 }
704 pLine[w >> 3] = cVal;
705 }
706 }
707 pLine += nStride;
708 }
709 return GBREG;
710 }
711 CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template2_opt3(CJBig2_ArithDecoder *p ArithDecoder, JBig2ArithCtx *gbContext)
712 {
713 FX_BOOL LTP, SLTP, bVal;
714 FX_DWORD CONTEXT;
715 CJBig2_Image *GBREG;
716 FX_DWORD line1, line2;
717 uint8_t *pLine, *pLine1, *pLine2, cVal;
718 int32_t nStride, nStride2, k;
719 int32_t nLineBytes, nBitsLeft, cc;
720 LTP = 0;
721 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
722 if (GBREG->m_pData == NULL) {
723 delete GBREG;
724 m_pModule->JBig2_Error("Generic region decoding procedure: Create Image Failed with width = %d, height = %d\n", GBW, GBH);
725 return NULL;
726 }
727 pLine = GBREG->m_pData;
728 nStride = GBREG->m_nStride;
729 nStride2 = nStride << 1;
730 nLineBytes = ((GBW + 7) >> 3) - 1;
731 nBitsLeft = GBW - (nLineBytes << 3);
732 for(FX_DWORD h = 0; h < GBH; h++) {
733 if(TPGDON) {
734 SLTP = pArithDecoder->DECODE(&gbContext[0x00e5]);
735 LTP = LTP ^ SLTP;
736 }
737 if(LTP == 1) {
738 GBREG->copyLine(h, h - 1);
739 } else {
740 if(h > 1) {
741 pLine1 = pLine - nStride2;
742 pLine2 = pLine - nStride;
743 line1 = (*pLine1++) << 1;
744 line2 = *pLine2++;
745 CONTEXT = (line1 & 0x0380) | ((line2 >> 3) & 0x007c);
746 for(cc = 0; cc < nLineBytes; cc++) {
747 line1 = (line1 << 8) | ((*pLine1++) << 1);
748 line2 = (line2 << 8) | (*pLine2++);
749 cVal = 0;
750 for(k = 7; k >= 0; k--) {
751 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
752 cVal |= bVal << k;
753 CONTEXT = ((CONTEXT & 0x01bd) << 1) | bVal
754 | ((line1 >> k) & 0x0080)
755 | ((line2 >> (k + 3)) & 0x0004);
756 }
757 pLine[cc] = cVal;
758 }
759 line1 <<= 8;
760 line2 <<= 8;
761 cVal = 0;
762 for(k = 0; k < nBitsLeft; k++) {
763 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
764 cVal |= bVal << (7 - k);
765 CONTEXT = ((CONTEXT & 0x01bd) << 1) | bVal
766 | ((line1 >> (7 - k)) & 0x0080)
767 | ((line2 >> (10 - k)) & 0x0004);
768 }
769 pLine[nLineBytes] = cVal;
770 } else {
771 pLine2 = pLine - nStride;
772 line2 = (h & 1) ? (*pLine2++) : 0;
773 CONTEXT = (line2 >> 3) & 0x007c;
774 for(cc = 0; cc < nLineBytes; cc++) {
775 if(h & 1) {
776 line2 = (line2 << 8) | (*pLine2++);
777 }
778 cVal = 0;
779 for(k = 7; k >= 0; k--) {
780 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
781 cVal |= bVal << k;
782 CONTEXT = ((CONTEXT & 0x01bd) << 1) | bVal
783 | ((line2 >> (k + 3)) & 0x0004);
784 }
785 pLine[cc] = cVal;
786 }
787 line2 <<= 8;
788 cVal = 0;
789 for(k = 0; k < nBitsLeft; k++) {
790 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
791 cVal |= bVal << (7 - k);
792 CONTEXT = ((CONTEXT & 0x01bd) << 1) | bVal
793 | (((line2 >> (10 - k))) & 0x0004);
794 }
795 pLine[nLineBytes] = cVal;
796 }
797 }
798 pLine += nStride;
799 }
800 return GBREG;
801 }
802 CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template2_unopt(CJBig2_ArithDecoder * pArithDecoder, JBig2ArithCtx *gbContext)
803 {
804 FX_BOOL LTP, SLTP, bVal;
805 FX_DWORD CONTEXT;
806 CJBig2_Image *GBREG;
807 FX_DWORD line1, line2, line3;
808 LTP = 0;
809 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
810 GBREG->fill(0);
811 for(FX_DWORD h = 0; h < GBH; h++) {
812 if(TPGDON) {
813 SLTP = pArithDecoder->DECODE(&gbContext[0x00e5]);
814 LTP = LTP ^ SLTP;
815 }
816 if(LTP == 1) {
817 GBREG->copyLine(h, h - 1);
818 } else {
819 line1 = GBREG->getPixel(1, h - 2);
820 line1 |= GBREG->getPixel(0, h - 2) << 1;
821 line2 = GBREG->getPixel(1, h - 1);
822 line2 |= GBREG->getPixel(0, h - 1) << 1;
823 line3 = 0;
824 for(FX_DWORD w = 0; w < GBW; w++) {
825 if(USESKIP && SKIP->getPixel(w, h)) {
826 bVal = 0;
827 } else {
828 CONTEXT = line3;
829 CONTEXT |= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 2;
830 CONTEXT |= line2 << 3;
831 CONTEXT |= line1 << 7;
832 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
833 }
834 if(bVal) {
835 GBREG->setPixel(w, h, bVal);
836 }
837 line1 = ((line1 << 1) | GBREG->getPixel(w + 2, h - 2)) & 0x07;
838 line2 = ((line2 << 1) | GBREG->getPixel(w + 2, h - 1)) & 0x0f;
839 line3 = ((line3 << 1) | bVal) & 0x03;
840 }
841 }
842 }
843 return GBREG;
844 }
845 CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template3_opt(CJBig2_ArithDecoder *pA rithDecoder, JBig2ArithCtx *gbContext)
846 {
847 FX_BOOL LTP, SLTP, bVal;
848 FX_DWORD CONTEXT;
849 CJBig2_Image *GBREG;
850 FX_DWORD line1, line2;
851 LTP = 0;
852 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
853 GBREG->fill(0);
854 for(FX_DWORD h = 0; h < GBH; h++) {
855 if(TPGDON) {
856 SLTP = pArithDecoder->DECODE(&gbContext[0x0195]);
857 LTP = LTP ^ SLTP;
858 }
859 if(LTP == 1) {
860 GBREG->copyLine(h, h - 1);
861 } else {
862 line1 = GBREG->getPixel(2, h - 1);
863 line1 |= GBREG->getPixel(1, h - 1) << 1;
864 line1 |= GBREG->getPixel(0, h - 1) << 2;
865 line2 = 0;
866 for(FX_DWORD w = 0; w < GBW; w++) {
867 if(USESKIP && SKIP->getPixel(w, h)) {
868 bVal = 0;
869 } else {
870 CONTEXT = line2;
871 CONTEXT |= line1 << 4;
872 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
873 }
874 if(bVal) {
875 GBREG->setPixel(w, h, bVal);
876 }
877 line1 = ((line1 << 1) | GBREG->getPixel(w + 3, h - 1)) & 0x3f;
878 line2 = ((line2 << 1) | bVal) & 0x0f;
879 }
880 }
881 }
882 return GBREG;
883 }
884 CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template3_opt2(CJBig2_ArithDecoder *p ArithDecoder, JBig2ArithCtx *gbContext)
885 {
886 FX_BOOL LTP, SLTP, bVal;
887 FX_DWORD CONTEXT;
888 CJBig2_Image *GBREG;
889 FX_DWORD line1;
890 uint8_t *pLine, cVal;
891 intptr_t nStride;
892 int32_t nBits, k;
893 LTP = 0;
894 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
895 if (GBREG->m_pData == NULL) {
896 delete GBREG;
897 m_pModule->JBig2_Error("Generic region decoding procedure: Create Image Failed with width = %d, height = %d\n", GBW, GBH);
898 return NULL;
899 }
900 pLine = GBREG->m_pData;
901 nStride = GBREG->m_nStride;
902 for(FX_DWORD h = 0; h < GBH; h++) {
903 if(TPGDON) {
904 SLTP = pArithDecoder->DECODE(&gbContext[0x0195]);
905 LTP = LTP ^ SLTP;
906 }
907 if(LTP == 1) {
908 GBREG->copyLine(h, h - 1);
909 } else {
910 line1 = (h > 0) ? pLine[-nStride] : 0;
911 CONTEXT = (line1 >> 1) & 0x03f0;
912 for(FX_DWORD w = 0; w < GBW; w += 8) {
913 if(w + 8 < GBW) {
914 nBits = 8;
915 if(h > 0) {
916 line1 = (line1 << 8) | (pLine[-nStride + (w >> 3) + 1]);
917 }
918 } else {
919 nBits = GBW - w;
920 if(h > 0) {
921 line1 <<= 8;
922 }
923 }
924 cVal = 0;
925 for(k = 0; k < nBits; k++) {
926 if(USESKIP && SKIP->getPixel(w, h)) {
927 bVal = 0;
928 } else {
929 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
930 }
931 cVal |= bVal << (7 - k);
932 CONTEXT = ((CONTEXT & 0x01f7) << 1) | bVal
933 | ((line1 >> (8 - k)) & 0x0010);
934 }
935 pLine[w >> 3] = cVal;
936 }
937 }
938 pLine += nStride;
939 }
940 return GBREG;
941 }
942 CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template3_opt3(CJBig2_ArithDecoder *p ArithDecoder, JBig2ArithCtx *gbContext)
943 {
944 FX_BOOL LTP, SLTP, bVal;
945 FX_DWORD CONTEXT;
946 CJBig2_Image *GBREG;
947 FX_DWORD line1;
948 uint8_t *pLine, *pLine1, cVal;
949 int32_t nStride, k;
950 int32_t nLineBytes, nBitsLeft, cc;
951 LTP = 0;
952 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
953 if (GBREG->m_pData == NULL) {
954 delete GBREG;
955 m_pModule->JBig2_Error("Generic region decoding procedure: Create Image Failed with width = %d, height = %d\n", GBW, GBH);
956 return NULL;
957 }
958 pLine = GBREG->m_pData;
959 nStride = GBREG->m_nStride;
960 nLineBytes = ((GBW + 7) >> 3) - 1;
961 nBitsLeft = GBW - (nLineBytes << 3);
962 for(FX_DWORD h = 0; h < GBH; h++) {
963 if(TPGDON) {
964 SLTP = pArithDecoder->DECODE(&gbContext[0x0195]);
965 LTP = LTP ^ SLTP;
966 }
967 if(LTP == 1) {
968 GBREG->copyLine(h, h - 1);
969 } else {
970 if(h > 0) {
971 pLine1 = pLine - nStride;
972 line1 = *pLine1++;
973 CONTEXT = (line1 >> 1) & 0x03f0;
974 for(cc = 0; cc < nLineBytes; cc++) {
975 line1 = (line1 << 8) | (*pLine1++);
976 cVal = 0;
977 for(k = 7; k >= 0; k--) {
978 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
979 cVal |= bVal << k;
980 CONTEXT = ((CONTEXT & 0x01f7) << 1) | bVal
981 | ((line1 >> (k + 1)) & 0x0010);
982 }
983 pLine[cc] = cVal;
984 }
985 line1 <<= 8;
986 cVal = 0;
987 for(k = 0; k < nBitsLeft; k++) {
988 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
989 cVal |= bVal << (7 - k);
990 CONTEXT = ((CONTEXT & 0x01f7) << 1) | bVal
991 | ((line1 >> (8 - k)) & 0x0010);
992 }
993 pLine[nLineBytes] = cVal;
994 } else {
995 CONTEXT = 0;
996 for(cc = 0; cc < nLineBytes; cc++) {
997 cVal = 0;
998 for(k = 7; k >= 0; k--) {
999 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
1000 cVal |= bVal << k;
1001 CONTEXT = ((CONTEXT & 0x01f7) << 1) | bVal;
1002 }
1003 pLine[cc] = cVal;
1004 }
1005 cVal = 0;
1006 for(k = 0; k < nBitsLeft; k++) {
1007 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
1008 cVal |= bVal << (7 - k);
1009 CONTEXT = ((CONTEXT & 0x01f7) << 1) | bVal;
1010 }
1011 pLine[nLineBytes] = cVal;
1012 }
1013 }
1014 pLine += nStride;
1015 }
1016 return GBREG;
1017 }
1018 CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template3_unopt(CJBig2_ArithDecoder * pArithDecoder, JBig2ArithCtx *gbContext)
1019 {
1020 FX_BOOL LTP, SLTP, bVal;
1021 FX_DWORD CONTEXT;
1022 CJBig2_Image *GBREG;
1023 FX_DWORD line1, line2;
1024 LTP = 0;
1025 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
1026 GBREG->fill(0);
1027 for(FX_DWORD h = 0; h < GBH; h++) {
1028 if(TPGDON) {
1029 SLTP = pArithDecoder->DECODE(&gbContext[0x0195]);
1030 LTP = LTP ^ SLTP;
1031 }
1032 if(LTP == 1) {
1033 GBREG->copyLine(h, h - 1);
1034 } else {
1035 line1 = GBREG->getPixel(1, h - 1);
1036 line1 |= GBREG->getPixel(0, h - 1) << 1;
1037 line2 = 0;
1038 for(FX_DWORD w = 0; w < GBW; w++) {
1039 if(USESKIP && SKIP->getPixel(w, h)) {
1040 bVal = 0;
1041 } else {
1042 CONTEXT = line2;
1043 CONTEXT |= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 4;
1044 CONTEXT |= line1 << 5;
1045 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
1046 }
1047 if(bVal) {
1048 GBREG->setPixel(w, h, bVal);
1049 }
1050 line1 = ((line1 << 1) | GBREG->getPixel(w + 2, h - 1)) & 0x1f;
1051 line2 = ((line2 << 1) | bVal) & 0x0f;
1052 }
1053 }
1054 }
1055 return GBREG;
1056 }
1057 CJBig2_Image *CJBig2_GRDProc::decode_Arith_V2(CJBig2_ArithDecoder *pArithDecoder , JBig2ArithCtx *gbContext)
1058 {
1059 FX_BOOL LTP, SLTP, bVal;
1060 FX_DWORD CONTEXT;
1061 CJBig2_Image *GBREG;
1062 FX_DWORD line1, line2, line3;
1063 LTP = 0;
1064 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
1065 GBREG->fill(0);
1066 for(FX_DWORD h = 0; h < GBH; h++) {
1067 if(TPGDON) {
1068 switch(GBTEMPLATE) {
1069 case 0:
1070 CONTEXT = 0x9b25;
1071 break;
1072 case 1:
1073 CONTEXT = 0x0795;
1074 break;
1075 case 2:
1076 CONTEXT = 0x00e5;
1077 break;
1078 case 3:
1079 CONTEXT = 0x0195;
1080 break;
1081 }
1082 SLTP = pArithDecoder->DECODE(&gbContext[CONTEXT]);
1083 LTP = LTP ^ SLTP;
1084 }
1085 if(LTP == 1) {
1086 GBREG->copyLine(h, h - 1);
1087 } else {
1088 switch(GBTEMPLATE) {
1089 case 0: {
1090 line1 = GBREG->getPixel(1, h - 2);
1091 line1 |= GBREG->getPixel(0, h - 2) << 1;
1092 line2 = GBREG->getPixel(2, h - 1);
1093 line2 |= GBREG->getPixel(1, h - 1) << 1;
1094 line2 |= GBREG->getPixel(0, h - 1) << 2;
1095 line3 = 0;
1096 for(FX_DWORD w = 0; w < GBW; w++) {
1097 if(USESKIP && SKIP->getPixel(w, h)) {
1098 bVal = 0;
1099 } else {
1100 CONTEXT = line3;
1101 CONTEXT |= GBREG->getPixel(w + GBAT[0], h + GBAT [1]) << 4;
1102 CONTEXT |= line2 << 5;
1103 CONTEXT |= GBREG->getPixel(w + GBAT[2], h + GBAT [3]) << 10;
1104 CONTEXT |= GBREG->getPixel(w + GBAT[4], h + GBAT [5]) << 11;
1105 CONTEXT |= line1 << 12;
1106 CONTEXT |= GBREG->getPixel(w + GBAT[6], h + GBAT [7]) << 15;
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 + 3, h - 1 )) & 0x1f;
1114 line3 = ((line3 << 1) | bVal) & 0x0f;
1115 }
1116 }
1117 break;
1118 case 1: {
1119 line1 = GBREG->getPixel(2, h - 2);
1120 line1 |= GBREG->getPixel(1, h - 2) << 1;
1121 line1 |= GBREG->getPixel(0, h - 2) << 2;
1122 line2 = GBREG->getPixel(2, h - 1);
1123 line2 |= GBREG->getPixel(1, h - 1) << 1;
1124 line2 |= GBREG->getPixel(0, h - 1) << 2;
1125 line3 = 0;
1126 for(FX_DWORD w = 0; w < GBW; w++) {
1127 if(USESKIP && SKIP->getPixel(w, h)) {
1128 bVal = 0;
1129 } else {
1130 CONTEXT = line3;
1131 CONTEXT |= GBREG->getPixel(w + GBAT[0], h + GBAT [1]) << 3;
1132 CONTEXT |= line2 << 4;
1133 CONTEXT |= line1 << 9;
1134 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT] );
1135 }
1136 if(bVal) {
1137 GBREG->setPixel(w, h, bVal);
1138 }
1139 line1 = ((line1 << 1) | GBREG->getPixel(w + 3, h - 2 )) & 0x0f;
1140 line2 = ((line2 << 1) | GBREG->getPixel(w + 3, h - 1 )) & 0x1f;
1141 line3 = ((line3 << 1) | bVal) & 0x07;
1142 }
1143 }
1144 break;
1145 case 2: {
1146 line1 = GBREG->getPixel(1, h - 2);
1147 line1 |= GBREG->getPixel(0, h - 2) << 1;
1148 line2 = GBREG->getPixel(1, h - 1);
1149 line2 |= GBREG->getPixel(0, h - 1) << 1;
1150 line3 = 0;
1151 for(FX_DWORD w = 0; w < GBW; w++) {
1152 if(USESKIP && SKIP->getPixel(w, h)) {
1153 bVal = 0;
1154 } else {
1155 CONTEXT = line3;
1156 CONTEXT |= GBREG->getPixel(w + GBAT[0], h + GBAT [1]) << 2;
1157 CONTEXT |= line2 << 3;
1158 CONTEXT |= line1 << 7;
1159 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT] );
1160 }
1161 if(bVal) {
1162 GBREG->setPixel(w, h, bVal);
1163 }
1164 line1 = ((line1 << 1) | GBREG->getPixel(w + 2, h - 2 )) & 0x07;
1165 line2 = ((line2 << 1) | GBREG->getPixel(w + 2, h - 1 )) & 0x0f;
1166 line3 = ((line3 << 1) | bVal) & 0x03;
1167 }
1168 }
1169 break;
1170 case 3: {
1171 line1 = GBREG->getPixel(1, h - 1);
1172 line1 |= GBREG->getPixel(0, h - 1) << 1;
1173 line2 = 0;
1174 for(FX_DWORD w = 0; w < GBW; w++) {
1175 if(USESKIP && SKIP->getPixel(w, h)) {
1176 bVal = 0;
1177 } else {
1178 CONTEXT = line2;
1179 CONTEXT |= GBREG->getPixel(w + GBAT[0], h + GBAT [1]) << 4;
1180 CONTEXT |= line1 << 5;
1181 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT] );
1182 }
1183 if(bVal) {
1184 GBREG->setPixel(w, h, bVal);
1185 }
1186 line1 = ((line1 << 1) | GBREG->getPixel(w + 2, h - 1 )) & 0x1f;
1187 line2 = ((line2 << 1) | bVal) & 0x0f;
1188 }
1189 }
1190 break;
1191 }
1192 }
1193 }
1194 return GBREG;
1195 }
1196 CJBig2_Image *CJBig2_GRDProc::decode_Arith_V1(CJBig2_ArithDecoder *pArithDecoder , JBig2ArithCtx *gbContext)
1197 {
1198 FX_BOOL LTP, SLTP, bVal;
1199 FX_DWORD CONTEXT = 0;
1200 CJBig2_Image *GBREG;
1201 LTP = 0;
1202 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
1203 GBREG->fill(0);
1204 for(FX_DWORD h = 0; h < GBH; h++) {
1205 if(TPGDON) {
1206 switch(GBTEMPLATE) {
1207 case 0:
1208 CONTEXT = 0x9b25;
1209 break;
1210 case 1:
1211 CONTEXT = 0x0795;
1212 break;
1213 case 2:
1214 CONTEXT = 0x00e5;
1215 break;
1216 case 3:
1217 CONTEXT = 0x0195;
1218 break;
1219 }
1220 SLTP = pArithDecoder->DECODE(&gbContext[CONTEXT]);
1221 LTP = LTP ^ SLTP;
1222 }
1223 if(LTP == 1) {
1224 for(FX_DWORD w = 0; w < GBW; w++) {
1225 GBREG->setPixel(w, h, GBREG->getPixel(w, h - 1));
1226 }
1227 } else {
1228 for(FX_DWORD w = 0; w < GBW; w++) {
1229 if(USESKIP && SKIP->getPixel(w, h)) {
1230 GBREG->setPixel(w, h, 0);
1231 } else {
1232 CONTEXT = 0;
1233 switch(GBTEMPLATE) {
1234 case 0:
1235 CONTEXT |= GBREG->getPixel(w - 1, h);
1236 CONTEXT |= GBREG->getPixel(w - 2, h) << 1;
1237 CONTEXT |= GBREG->getPixel(w - 3, h) << 2;
1238 CONTEXT |= GBREG->getPixel(w - 4, h) << 3;
1239 CONTEXT |= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 4;
1240 CONTEXT |= GBREG->getPixel(w + 2, h - 1) << 5;
1241 CONTEXT |= GBREG->getPixel(w + 1, h - 1) << 6;
1242 CONTEXT |= GBREG->getPixel(w, h - 1) << 7;
1243 CONTEXT |= GBREG->getPixel(w - 1, h - 1) << 8;
1244 CONTEXT |= GBREG->getPixel(w - 2, h - 1) << 9;
1245 CONTEXT |= GBREG->getPixel(w + GBAT[2], h + GBAT[3]) << 10;
1246 CONTEXT |= GBREG->getPixel(w + GBAT[4], h + GBAT[5]) << 11;
1247 CONTEXT |= GBREG->getPixel(w + 1, h - 2) << 12;
1248 CONTEXT |= GBREG->getPixel(w, h - 2) << 13;
1249 CONTEXT |= GBREG->getPixel(w - 1, h - 2) << 14;
1250 CONTEXT |= GBREG->getPixel(w + GBAT[6], h + GBAT[7]) << 15;
1251 break;
1252 case 1:
1253 CONTEXT |= GBREG->getPixel(w - 1, h);
1254 CONTEXT |= GBREG->getPixel(w - 2, h) << 1;
1255 CONTEXT |= GBREG->getPixel(w - 3, h) << 2;
1256 CONTEXT |= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 3;
1257 CONTEXT |= GBREG->getPixel(w + 2, h - 1) << 4;
1258 CONTEXT |= GBREG->getPixel(w + 1, h - 1) << 5;
1259 CONTEXT |= GBREG->getPixel(w, h - 1) << 6;
1260 CONTEXT |= GBREG->getPixel(w - 1, h - 1) << 7;
1261 CONTEXT |= GBREG->getPixel(w - 2, h - 1) << 8;
1262 CONTEXT |= GBREG->getPixel(w + 2, h - 2) << 9;
1263 CONTEXT |= GBREG->getPixel(w + 1, h - 2) << 10;
1264 CONTEXT |= GBREG->getPixel(w, h - 2) << 11;
1265 CONTEXT |= GBREG->getPixel(w - 1, h - 2) << 12;
1266 break;
1267 case 2:
1268 CONTEXT |= GBREG->getPixel(w - 1, h);
1269 CONTEXT |= GBREG->getPixel(w - 2, h) << 1;
1270 CONTEXT |= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 2;
1271 CONTEXT |= GBREG->getPixel(w + 1, h - 1) << 3;
1272 CONTEXT |= GBREG->getPixel(w, h - 1) << 4;
1273 CONTEXT |= GBREG->getPixel(w - 1, h - 1) << 5;
1274 CONTEXT |= GBREG->getPixel(w - 2, h - 1) << 6;
1275 CONTEXT |= GBREG->getPixel(w + 1, h - 2) << 7;
1276 CONTEXT |= GBREG->getPixel(w, h - 2) << 8;
1277 CONTEXT |= GBREG->getPixel(w - 1, h - 2) << 9;
1278 break;
1279 case 3:
1280 CONTEXT |= GBREG->getPixel(w - 1, h);
1281 CONTEXT |= GBREG->getPixel(w - 2, h) << 1;
1282 CONTEXT |= GBREG->getPixel(w - 3, h) << 2;
1283 CONTEXT |= GBREG->getPixel(w - 4, h) << 3;
1284 CONTEXT |= GBREG->getPixel(w + GBAT[0], h + GBAT[1]) << 4;
1285 CONTEXT |= GBREG->getPixel(w + 1, h - 1) << 5;
1286 CONTEXT |= GBREG->getPixel(w, h - 1) << 6;
1287 CONTEXT |= GBREG->getPixel(w - 1, h - 1) << 7;
1288 CONTEXT |= GBREG->getPixel(w - 2, h - 1) << 8;
1289 CONTEXT |= GBREG->getPixel(w - 3, h - 1) << 9;
1290 break;
1291 }
1292 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
1293 GBREG->setPixel(w, h, bVal);
1294 }
1295 }
1296 }
1297 }
1298 return GBREG;
1299 }
1300 CJBig2_Image *CJBig2_GRDProc::decode_MMR(CJBig2_BitStream *pStream)
1301 {
1302 int bitpos, i;
1303 CJBig2_Image *pImage;
1304 JBIG2_ALLOC(pImage, CJBig2_Image(GBW, GBH));
1305 if (pImage->m_pData == NULL) {
1306 delete pImage;
1307 m_pModule->JBig2_Error("Generic region decoding procedure: Create Image Failed with width = %d, height = %d\n", GBW, GBH);
1308 return NULL;
1309 }
1310 bitpos = (int)pStream->getBitPos();
1311 _FaxG4Decode(m_pModule, pStream->getBuf(), pStream->getLength(), &bitpos, pI mage->m_pData, GBW, GBH, pImage->m_nStride);
1312 pStream->setBitPos(bitpos);
1313 for(i = 0; (FX_DWORD)i < pImage->m_nStride * GBH; i++) {
1314 pImage->m_pData[i] = ~pImage->m_pData[i];
1315 }
1316 return pImage;
1317 }
1318 CJBig2_Image *CJBig2_GRRDProc::decode(CJBig2_ArithDecoder *pArithDecoder, JBig2A rithCtx *grContext)
1319 {
1320 if (GRW == 0 || GRH == 0) {
1321 CJBig2_Image* pImage;
1322 JBIG2_ALLOC(pImage, CJBig2_Image(GRW, GRH));
1323 return pImage;
1324 }
1325 if(GRTEMPLATE == 0) {
1326 if((GRAT[0] == (signed char) - 1) && (GRAT[1] == (signed char) - 1)
1327 && (GRAT[2] == (signed char) - 1) && (GRAT[3] == (signed char) - 1)
1328 && (GRREFERENCEDX == 0) && (GRW == (FX_DWORD)GRREFERENCE->m_nWid th)) {
1329 return decode_Template0_opt(pArithDecoder, grContext);
1330 } else {
1331 return decode_Template0_unopt(pArithDecoder, grContext);
1332 }
1333 } else {
1334 if((GRREFERENCEDX == 0) && (GRW == (FX_DWORD)GRREFERENCE->m_nWidth)) {
1335 return decode_Template1_opt(pArithDecoder, grContext);
1336 } else {
1337 return decode_Template1_unopt(pArithDecoder, grContext);
1338 }
1339 }
1340 }
1341 CJBig2_Image *CJBig2_GRRDProc::decode_Template0_unopt(CJBig2_ArithDecoder *pArit hDecoder, JBig2ArithCtx *grContext)
1342 {
1343 FX_BOOL LTP, SLTP, bVal;
1344 FX_DWORD CONTEXT;
1345 CJBig2_Image *GRREG;
1346 FX_DWORD line1, line2, line3, line4, line5;
1347 LTP = 0;
1348 JBIG2_ALLOC(GRREG, CJBig2_Image(GRW, GRH));
1349 GRREG->fill(0);
1350 for(FX_DWORD h = 0; h < GRH; h++) {
1351 if(TPGRON) {
1352 SLTP = pArithDecoder->DECODE(&grContext[0x0010]);
1353 LTP = LTP ^ SLTP;
1354 }
1355 if(LTP == 0) {
1356 line1 = GRREG->getPixel(1, h - 1);
1357 line1 |= GRREG->getPixel(0, h - 1) << 1;
1358 line2 = 0;
1359 line3 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY - 1);
1360 line3 |= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY - 1 ) << 1;
1361 line4 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY) ;
1362 line4 |= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY) << 1;
1363 line4 |= GRREFERENCE->getPixel(-GRREFERENCEDX - 1, h - GRREFERENCEDY ) << 2;
1364 line5 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY + 1);
1365 line5 |= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY + 1 ) << 1;
1366 line5 |= GRREFERENCE->getPixel(-GRREFERENCEDX - 1, h - GRREFERENCEDY + 1) << 2;
1367 for(FX_DWORD w = 0; w < GRW; w++) {
1368 CONTEXT = line5;
1369 CONTEXT |= line4 << 3;
1370 CONTEXT |= line3 << 6;
1371 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX + GRAT[2], h - GRREFERENCEDY + GRAT[3]) << 8;
1372 CONTEXT |= line2 << 9;
1373 CONTEXT |= line1 << 10;
1374 CONTEXT |= GRREG->getPixel(w + GRAT[0], h + GRAT[1]) << 12;
1375 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);
1376 GRREG->setPixel(w, h, bVal);
1377 line1 = ((line1 << 1) | GRREG->getPixel(w + 2, h - 1)) & 0x03;
1378 line2 = ((line2 << 1) | bVal) & 0x01;
1379 line3 = ((line3 << 1) | GRREFERENCE->getPixel(w - GRREFERENCEDX + 2, h - GRREFERENCEDY - 1)) & 0x03;
1380 line4 = ((line4 << 1) | GRREFERENCE->getPixel(w - GRREFERENCEDX + 2, h - GRREFERENCEDY)) & 0x07;
1381 line5 = ((line5 << 1) | GRREFERENCE->getPixel(w - GRREFERENCEDX + 2, h - GRREFERENCEDY + 1)) & 0x07;
1382 }
1383 } else {
1384 line1 = GRREG->getPixel(1, h - 1);
1385 line1 |= GRREG->getPixel(0, h - 1) << 1;
1386 line2 = 0;
1387 line3 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY - 1);
1388 line3 |= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY - 1 ) << 1;
1389 line4 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY) ;
1390 line4 |= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY) << 1;
1391 line4 |= GRREFERENCE->getPixel(-GRREFERENCEDX - 1, h - GRREFERENCEDY ) << 2;
1392 line5 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY + 1);
1393 line5 |= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY + 1 ) << 1;
1394 line5 |= GRREFERENCE->getPixel(-GRREFERENCEDX - 1, h - GRREFERENCEDY + 1) << 2;
1395 for(FX_DWORD w = 0; w < GRW; w++) {
1396 bVal = GRREFERENCE->getPixel(w, h);
1397 if(!(TPGRON && (bVal == GRREFERENCE->getPixel(w - 1, h - 1))
1398 && (bVal == GRREFERENCE->getPixel(w, h - 1))
1399 && (bVal == GRREFERENCE->getPixel(w + 1, h - 1))
1400 && (bVal == GRREFERENCE->getPixel(w - 1, h))
1401 && (bVal == GRREFERENCE->getPixel(w + 1, h))
1402 && (bVal == GRREFERENCE->getPixel(w - 1, h + 1))
1403 && (bVal == GRREFERENCE->getPixel(w, h + 1))
1404 && (bVal == GRREFERENCE->getPixel(w + 1, h + 1)))) {
1405 CONTEXT = line5;
1406 CONTEXT |= line4 << 3;
1407 CONTEXT |= line3 << 6;
1408 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX + GRAT[2] , h - GRREFERENCEDY + GRAT[3]) << 8;
1409 CONTEXT |= line2 << 9;
1410 CONTEXT |= line1 << 10;
1411 CONTEXT |= GRREG->getPixel(w + GRAT[0], h + GRAT[1]) << 12;
1412 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);
1413 }
1414 GRREG->setPixel(w, h, bVal);
1415 line1 = ((line1 << 1) | GRREG->getPixel(w + 2, h - 1)) & 0x03;
1416 line2 = ((line2 << 1) | bVal) & 0x01;
1417 line3 = ((line3 << 1) | GRREFERENCE->getPixel(w - GRREFERENCEDX + 2, h - GRREFERENCEDY - 1)) & 0x03;
1418 line4 = ((line4 << 1) | GRREFERENCE->getPixel(w - GRREFERENCEDX + 2, h - GRREFERENCEDY)) & 0x07;
1419 line5 = ((line5 << 1) | GRREFERENCE->getPixel(w - GRREFERENCEDX + 2, h - GRREFERENCEDY + 1)) & 0x07;
1420 }
1421 }
1422 }
1423 return GRREG;
1424 }
1425 CJBig2_Image *CJBig2_GRRDProc::decode_Template0_opt(CJBig2_ArithDecoder *pArithD ecoder, JBig2ArithCtx *grContext)
1426 {
1427 FX_BOOL LTP, SLTP, bVal;
1428 FX_DWORD CONTEXT;
1429 CJBig2_Image *GRREG;
1430 FX_DWORD line1, line1_r, line2_r, line3_r;
1431 uint8_t *pLine, *pLineR, cVal;
1432 intptr_t nStride, nStrideR, nOffset;
1433 int32_t k, nBits;
1434 int32_t GRWR, GRHR;
1435 int32_t GRW, GRH;
1436 GRW = (int32_t)CJBig2_GRRDProc::GRW;
1437 GRH = (int32_t)CJBig2_GRRDProc::GRH;
1438 LTP = 0;
1439 JBIG2_ALLOC(GRREG, CJBig2_Image(GRW, GRH));
1440 if (GRREG->m_pData == NULL) {
1441 delete GRREG;
1442 m_pModule->JBig2_Error("Generic refinement region decoding procedure: Cr eate Image Failed with width = %d, height = %d\n", GRW, GRH);
1443 return NULL;
1444 }
1445 pLine = GRREG->m_pData;
1446 pLineR = GRREFERENCE->m_pData;
1447 nStride = GRREG->m_nStride;
1448 nStrideR = GRREFERENCE->m_nStride;
1449 GRWR = (int32_t)GRREFERENCE->m_nWidth;
1450 GRHR = (int32_t)GRREFERENCE->m_nHeight;
1451 if (GRREFERENCEDY < -GRHR + 1 || GRREFERENCEDY > GRHR - 1) {
1452 GRREFERENCEDY = 0;
1453 }
1454 nOffset = -GRREFERENCEDY * nStrideR;
1455 for (int32_t h = 0; h < GRH; h++) {
1456 if(TPGRON) {
1457 SLTP = pArithDecoder->DECODE(&grContext[0x0010]);
1458 LTP = LTP ^ SLTP;
1459 }
1460 line1 = (h > 0) ? pLine[-nStride] << 4 : 0;
1461 int32_t reference_h = h - GRREFERENCEDY;
1462 FX_BOOL line1_r_ok = (reference_h > 0 && reference_h < GRHR + 1);
1463 FX_BOOL line2_r_ok = (reference_h > -1 && reference_h < GRHR);
1464 FX_BOOL line3_r_ok = (reference_h > -2 && reference_h < GRHR - 1);
1465 line1_r = line1_r_ok ? pLineR[nOffset - nStrideR] : 0;
1466 line2_r = line2_r_ok ? pLineR[nOffset] : 0;
1467 line3_r = line3_r_ok ? pLineR[nOffset + nStrideR] : 0;
1468 if(LTP == 0) {
1469 CONTEXT = (line1 & 0x1c00) | (line1_r & 0x01c0)
1470 | ((line2_r >> 3) & 0x0038) | ((line3_r >> 6) & 0x0007);
1471 for (int32_t w = 0; w < GRW; w += 8) {
1472 nBits = GRW - w > 8 ? 8 : GRW - w;
1473 if (h > 0)
1474 line1 = (line1 << 8) |
1475 (w + 8 < GRW ? pLine[-nStride + (w >> 3) + 1] << 4 : 0);
1476 if (h > GRHR + GRREFERENCEDY + 1) {
1477 line1_r = 0;
1478 line2_r = 0;
1479 line3_r = 0;
1480 } else {
1481 if(line1_r_ok)
1482 line1_r = (line1_r << 8) |
1483 (w + 8 < GRWR ? pLineR[nOffset - nStrideR + (w >> 3) + 1] : 0);
1484 if(line2_r_ok)
1485 line2_r = (line2_r << 8) |
1486 (w + 8 < GRWR ? pLineR[nOffset + (w >> 3) + 1] : 0);
1487 if(line3_r_ok)
1488 line3_r = (line3_r << 8) |
1489 (w + 8 < GRWR ? pLineR[nOffset + nStrideR + (w >> 3) + 1] : 0);
1490 else {
1491 line3_r = 0;
1492 }
1493 }
1494 cVal = 0;
1495 for (k = 0; k < nBits; k++) {
1496 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);
1497 cVal |= bVal << (7 - k);
1498 CONTEXT = ((CONTEXT & 0x0cdb) << 1) | (bVal << 9) |
1499 ((line1 >> (7 - k)) & 0x0400) |
1500 ((line1_r >> (7 - k)) & 0x0040) |
1501 ((line2_r >> (10 - k)) & 0x0008) |
1502 ((line3_r >> (13 - k)) & 0x0001);
1503 }
1504 pLine[w >> 3] = cVal;
1505 }
1506 } else {
1507 CONTEXT = (line1 & 0x1c00) | (line1_r & 0x01c0)
1508 | ((line2_r >> 3) & 0x0038) | ((line3_r >> 6) & 0x0007);
1509 for (int32_t w = 0; w < GRW; w += 8) {
1510 nBits = GRW - w > 8 ? 8 : GRW - w;
1511 if (h > 0)
1512 line1 = (line1 << 8) |
1513 (w + 8 < GRW ? pLine[-nStride + (w >> 3) + 1] << 4 : 0);
1514 if(line1_r_ok)
1515 line1_r = (line1_r << 8) |
1516 (w + 8 < GRWR ? pLineR[nOffset - nStrideR + (w >> 3) + 1] : 0);
1517 if(line2_r_ok)
1518 line2_r = (line2_r << 8) |
1519 (w + 8 < GRWR ? pLineR[nOffset + (w >> 3) + 1] : 0 );
1520 if(line3_r_ok)
1521 line3_r = (line3_r << 8) |
1522 (w + 8 < GRWR ? pLineR[nOffset + nStrideR + (w >> 3) + 1] : 0);
1523 else {
1524 line3_r = 0;
1525 }
1526 cVal = 0;
1527 for (k = 0; k < nBits; k++) {
1528 bVal = GRREFERENCE->getPixel(w + k, h);
1529 if(!(TPGRON && (bVal == GRREFERENCE->getPixel(w + k - 1, h - 1))
1530 && (bVal == GRREFERENCE->getPixel(w + k, h - 1))
1531 && (bVal == GRREFERENCE->getPixel(w + k + 1, h - 1))
1532 && (bVal == GRREFERENCE->getPixel(w + k - 1, h))
1533 && (bVal == GRREFERENCE->getPixel(w + k + 1, h))
1534 && (bVal == GRREFERENCE->getPixel(w + k - 1, h + 1))
1535 && (bVal == GRREFERENCE->getPixel(w + k, h + 1))
1536 && (bVal == GRREFERENCE->getPixel(w + k + 1, h + 1)) )) {
1537 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);
1538 }
1539 cVal |= bVal << (7 - k);
1540 CONTEXT = ((CONTEXT & 0x0cdb) << 1) | (bVal << 9) |
1541 ((line1 >> (7 - k)) & 0x0400) |
1542 ((line1_r >> (7 - k)) & 0x0040) |
1543 ((line2_r >> (10 - k)) & 0x0008) |
1544 ((line3_r >> (13 - k)) & 0x0001);
1545 }
1546 pLine[w >> 3] = cVal;
1547 }
1548 }
1549 pLine += nStride;
1550 if (h < GRHR + GRREFERENCEDY) {
1551 pLineR += nStrideR;
1552 }
1553 }
1554 return GRREG;
1555 }
1556 CJBig2_Image *CJBig2_GRRDProc::decode_Template1_unopt(CJBig2_ArithDecoder *pArit hDecoder, JBig2ArithCtx *grContext)
1557 {
1558 FX_BOOL LTP, SLTP, bVal;
1559 FX_DWORD CONTEXT;
1560 CJBig2_Image *GRREG;
1561 FX_DWORD line1, line2, line3, line4, line5;
1562 LTP = 0;
1563 JBIG2_ALLOC(GRREG, CJBig2_Image(GRW, GRH));
1564 GRREG->fill(0);
1565 for(FX_DWORD h = 0; h < GRH; h++) {
1566 if(TPGRON) {
1567 SLTP = pArithDecoder->DECODE(&grContext[0x0008]);
1568 LTP = LTP ^ SLTP;
1569 }
1570 if(LTP == 0) {
1571 line1 = GRREG->getPixel(1, h - 1);
1572 line1 |= GRREG->getPixel(0, h - 1) << 1;
1573 line1 |= GRREG->getPixel(-1, h - 1) << 2;
1574 line2 = 0;
1575 line3 = GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY - 1) ;
1576 line4 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY) ;
1577 line4 |= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY) << 1;
1578 line4 |= GRREFERENCE->getPixel(-GRREFERENCEDX - 1, h - GRREFERENCEDY ) << 2;
1579 line5 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY + 1);
1580 line5 |= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY + 1 ) << 1;
1581 for(FX_DWORD w = 0; w < GRW; w++) {
1582 CONTEXT = line5;
1583 CONTEXT |= line4 << 2;
1584 CONTEXT |= line3 << 5;
1585 CONTEXT |= line2 << 6;
1586 CONTEXT |= line1 << 7;
1587 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);
1588 GRREG->setPixel(w, h, bVal);
1589 line1 = ((line1 << 1) | GRREG->getPixel(w + 2, h - 1)) & 0x07;
1590 line2 = ((line2 << 1) | bVal) & 0x01;
1591 line3 = ((line3 << 1) | GRREFERENCE->getPixel(w - GRREFERENCEDX + 1, h - GRREFERENCEDY - 1)) & 0x01;
1592 line4 = ((line4 << 1) | GRREFERENCE->getPixel(w - GRREFERENCEDX + 2, h - GRREFERENCEDY)) & 0x07;
1593 line5 = ((line5 << 1) | GRREFERENCE->getPixel(w - GRREFERENCEDX + 2, h - GRREFERENCEDY + 1)) & 0x03;
1594 }
1595 } else {
1596 line1 = GRREG->getPixel(1, h - 1);
1597 line1 |= GRREG->getPixel(0, h - 1) << 1;
1598 line1 |= GRREG->getPixel(-1, h - 1) << 2;
1599 line2 = 0;
1600 line3 = GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY - 1) ;
1601 line4 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY) ;
1602 line4 |= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY) << 1;
1603 line4 |= GRREFERENCE->getPixel(-GRREFERENCEDX - 1, h - GRREFERENCEDY ) << 2;
1604 line5 = GRREFERENCE->getPixel(-GRREFERENCEDX + 1, h - GRREFERENCEDY + 1);
1605 line5 |= GRREFERENCE->getPixel(-GRREFERENCEDX, h - GRREFERENCEDY + 1 ) << 1;
1606 for(FX_DWORD w = 0; w < GRW; w++) {
1607 bVal = GRREFERENCE->getPixel(w, h);
1608 if(!(TPGRON && (bVal == GRREFERENCE->getPixel(w - 1, h - 1))
1609 && (bVal == GRREFERENCE->getPixel(w, h - 1))
1610 && (bVal == GRREFERENCE->getPixel(w + 1, h - 1))
1611 && (bVal == GRREFERENCE->getPixel(w - 1, h))
1612 && (bVal == GRREFERENCE->getPixel(w + 1, h))
1613 && (bVal == GRREFERENCE->getPixel(w - 1, h + 1))
1614 && (bVal == GRREFERENCE->getPixel(w, h + 1))
1615 && (bVal == GRREFERENCE->getPixel(w + 1, h + 1)))) {
1616 CONTEXT = line5;
1617 CONTEXT |= line4 << 2;
1618 CONTEXT |= line3 << 5;
1619 CONTEXT |= line2 << 6;
1620 CONTEXT |= line1 << 7;
1621 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);
1622 }
1623 GRREG->setPixel(w, h, bVal);
1624 line1 = ((line1 << 1) | GRREG->getPixel(w + 2, h - 1)) & 0x07;
1625 line2 = ((line2 << 1) | bVal) & 0x01;
1626 line3 = ((line3 << 1) | GRREFERENCE->getPixel(w - GRREFERENCEDX + 1, h - GRREFERENCEDY - 1)) & 0x01;
1627 line4 = ((line4 << 1) | GRREFERENCE->getPixel(w - GRREFERENCEDX + 2, h - GRREFERENCEDY)) & 0x07;
1628 line5 = ((line5 << 1) | GRREFERENCE->getPixel(w - GRREFERENCEDX + 2, h - GRREFERENCEDY + 1)) & 0x03;
1629 }
1630 }
1631 }
1632 return GRREG;
1633 }
1634 CJBig2_Image *CJBig2_GRRDProc::decode_Template1_opt(CJBig2_ArithDecoder *pArithD ecoder, JBig2ArithCtx *grContext)
1635 {
1636 FX_BOOL LTP, SLTP, bVal;
1637 FX_DWORD CONTEXT;
1638 CJBig2_Image *GRREG;
1639 FX_DWORD line1, line1_r, line2_r, line3_r;
1640 uint8_t *pLine, *pLineR, cVal;
1641 intptr_t nStride, nStrideR, nOffset;
1642 int32_t k, nBits;
1643 int32_t GRWR, GRHR;
1644 int32_t GRW, GRH;
1645 GRW = (int32_t)CJBig2_GRRDProc::GRW;
1646 GRH = (int32_t)CJBig2_GRRDProc::GRH;
1647 LTP = 0;
1648 JBIG2_ALLOC(GRREG, CJBig2_Image(GRW, GRH));
1649 if (GRREG->m_pData == NULL) {
1650 delete GRREG;
1651 m_pModule->JBig2_Error("Generic refinement region decoding procedure: Cr eate Image Failed with width = %d, height = %d\n", GRW, GRH);
1652 return NULL;
1653 }
1654 pLine = GRREG->m_pData;
1655 pLineR = GRREFERENCE->m_pData;
1656 nStride = GRREG->m_nStride;
1657 nStrideR = GRREFERENCE->m_nStride;
1658 GRWR = (int32_t)GRREFERENCE->m_nWidth;
1659 GRHR = (int32_t)GRREFERENCE->m_nHeight;
1660 if (GRREFERENCEDY < -GRHR + 1 || GRREFERENCEDY > GRHR - 1) {
1661 GRREFERENCEDY = 0;
1662 }
1663 nOffset = -GRREFERENCEDY * nStrideR;
1664 for (int32_t h = 0; h < GRH; h++) {
1665 if(TPGRON) {
1666 SLTP = pArithDecoder->DECODE(&grContext[0x0008]);
1667 LTP = LTP ^ SLTP;
1668 }
1669 line1 = (h > 0) ? pLine[-nStride] << 1 : 0;
1670 int32_t reference_h = h - GRREFERENCEDY;
1671 FX_BOOL line1_r_ok = (reference_h > 0 && reference_h < GRHR + 1);
1672 FX_BOOL line2_r_ok = (reference_h > -1 && reference_h < GRHR);
1673 FX_BOOL line3_r_ok = (reference_h > -2 && reference_h < GRHR - 1);
1674 line1_r = line1_r_ok ? pLineR[nOffset - nStrideR] : 0;
1675 line2_r = line2_r_ok ? pLineR[nOffset] : 0;
1676 line3_r = line3_r_ok ? pLineR[nOffset + nStrideR] : 0;
1677 if(LTP == 0) {
1678 CONTEXT = (line1 & 0x0380) | ((line1_r >> 2) & 0x0020)
1679 | ((line2_r >> 4) & 0x001c) | ((line3_r >> 6) & 0x0003);
1680 for (int32_t w = 0; w < GRW; w += 8) {
1681 nBits = GRW - w > 8 ? 8 : GRW - w;
1682 if (h > 0)
1683 line1 = (line1 << 8) |
1684 (w + 8 < GRW ? pLine[-nStride + (w >> 3) + 1] << 1 : 0);
1685 if(line1_r_ok)
1686 line1_r = (line1_r << 8) |
1687 (w + 8 < GRWR ? pLineR[nOffset - nStrideR + (w >> 3) + 1] : 0);
1688 if(line2_r_ok)
1689 line2_r = (line2_r << 8) |
1690 (w + 8 < GRWR ? pLineR[nOffset + (w >> 3) + 1] : 0 );
1691 if(line3_r_ok)
1692 line3_r = (line3_r << 8) |
1693 (w + 8 < GRWR ? pLineR[nOffset + nStrideR + (w >> 3) + 1] : 0);
1694 else {
1695 line3_r = 0;
1696 }
1697 cVal = 0;
1698 for (k = 0; k < nBits; k++) {
1699 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);
1700 cVal |= bVal << (7 - k);
1701 CONTEXT = ((CONTEXT & 0x018d) << 1) | (bVal << 6) |
1702 ((line1 >> (7 - k)) & 0x0080) |
1703 ((line1_r >> (9 - k)) & 0x0020) |
1704 ((line2_r >> (11 - k)) & 0x0004) |
1705 ((line3_r >> (13 - k)) & 0x0001);
1706 }
1707 pLine[w >> 3] = cVal;
1708 }
1709 } else {
1710 CONTEXT = (line1 & 0x0380) | ((line1_r >> 2) & 0x0020)
1711 | ((line2_r >> 4) & 0x001c) | ((line3_r >> 6) & 0x0003);
1712 for (int32_t w = 0; w < GRW; w += 8) {
1713 nBits = GRW - w > 8 ? 8 : GRW - w;
1714 if (h > 0)
1715 line1 = (line1 << 8) |
1716 (w + 8 < GRW ? pLine[-nStride + (w >> 3) + 1] << 1 : 0);
1717 if(line1_r_ok)
1718 line1_r = (line1_r << 8) |
1719 (w + 8 < GRWR ? pLineR[nOffset - nStrideR + (w >> 3) + 1] : 0);
1720 if(line2_r_ok)
1721 line2_r = (line2_r << 8) |
1722 (w + 8 < GRWR ? pLineR[nOffset + (w >> 3) + 1] : 0 );
1723 if(line3_r_ok)
1724 line3_r = (line3_r << 8) |
1725 (w + 8 < GRWR ? pLineR[nOffset + nStrideR + (w >> 3) + 1] : 0);
1726 else {
1727 line3_r = 0;
1728 }
1729 cVal = 0;
1730 for (k = 0; k < nBits; k++) {
1731 bVal = GRREFERENCE->getPixel(w + k, h);
1732 if(!(TPGRON && (bVal == GRREFERENCE->getPixel(w + k - 1, h - 1))
1733 && (bVal == GRREFERENCE->getPixel(w + k, h - 1))
1734 && (bVal == GRREFERENCE->getPixel(w + k + 1, h - 1))
1735 && (bVal == GRREFERENCE->getPixel(w + k - 1, h))
1736 && (bVal == GRREFERENCE->getPixel(w + k + 1, h))
1737 && (bVal == GRREFERENCE->getPixel(w + k - 1, h + 1))
1738 && (bVal == GRREFERENCE->getPixel(w + k, h + 1))
1739 && (bVal == GRREFERENCE->getPixel(w + k + 1, h + 1)) )) {
1740 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);
1741 }
1742 cVal |= bVal << (7 - k);
1743 CONTEXT = ((CONTEXT & 0x018d) << 1) | (bVal << 6) |
1744 ((line1 >> (7 - k)) & 0x0080) |
1745 ((line1_r >> (9 - k)) & 0x0020) |
1746 ((line2_r >> (11 - k)) & 0x0004) |
1747 ((line3_r >> (13 - k)) & 0x0001);
1748 }
1749 pLine[w >> 3] = cVal;
1750 }
1751 }
1752 pLine += nStride;
1753 if (h < GRHR + GRREFERENCEDY) {
1754 pLineR += nStrideR;
1755 }
1756 }
1757 return GRREG;
1758 }
1759 CJBig2_Image *CJBig2_GRRDProc::decode_V1(CJBig2_ArithDecoder *pArithDecoder, JBi g2ArithCtx *grContext)
1760 {
1761 FX_BOOL LTP, SLTP, bVal;
1762 FX_BOOL TPGRPIX, TPGRVAL;
1763 FX_DWORD CONTEXT;
1764 CJBig2_Image *GRREG;
1765 LTP = 0;
1766 JBIG2_ALLOC(GRREG, CJBig2_Image(GRW, GRH));
1767 GRREG->fill(0);
1768 for(FX_DWORD h = 0; h < GRH; h++) {
1769 if(TPGRON) {
1770 switch(GRTEMPLATE) {
1771 case 0:
1772 CONTEXT = 0x0010;
1773 break;
1774 case 1:
1775 CONTEXT = 0x0008;
1776 break;
1777 }
1778 SLTP = pArithDecoder->DECODE(&grContext[CONTEXT]);
1779 LTP = LTP ^ SLTP;
1780 }
1781 if(LTP == 0) {
1782 for(FX_DWORD w = 0; w < GRW; w++) {
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 + GRA T[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 } else {
1817 for(FX_DWORD w = 0; w < GRW; w++) {
1818 bVal = GRREFERENCE->getPixel(w, h);
1819 if(TPGRON && (bVal == GRREFERENCE->getPixel(w - 1, h - 1))
1820 && (bVal == GRREFERENCE->getPixel(w, h - 1))
1821 && (bVal == GRREFERENCE->getPixel(w + 1, h - 1))
1822 && (bVal == GRREFERENCE->getPixel(w - 1, h))
1823 && (bVal == GRREFERENCE->getPixel(w + 1, h))
1824 && (bVal == GRREFERENCE->getPixel(w - 1, h + 1))
1825 && (bVal == GRREFERENCE->getPixel(w, h + 1))
1826 && (bVal == GRREFERENCE->getPixel(w + 1, h + 1))) {
1827 TPGRPIX = 1;
1828 TPGRVAL = bVal;
1829 } else {
1830 TPGRPIX = 0;
1831 }
1832 if(TPGRPIX) {
1833 GRREG->setPixel(w, h, TPGRVAL);
1834 } else {
1835 CONTEXT = 0;
1836 switch(GRTEMPLATE) {
1837 case 0:
1838 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX + 1, h - GRREFERENCEDY + 1);
1839 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX, h - GRREFERENCEDY + 1) << 1;
1840 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX - 1, h - GRREFERENCEDY + 1) << 2;
1841 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX + 1, h - GRREFERENCEDY) << 3;
1842 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX, h - GRREFERENCEDY) << 4;
1843 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX - 1, h - GRREFERENCEDY) << 5;
1844 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX + 1, h - GRREFERENCEDY - 1) << 6;
1845 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX, h - GRREFERENCEDY - 1) << 7;
1846 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX + GRAT[2], h - GRREFERENCEDY + GRAT[3]) << 8;
1847 CONTEXT |= GRREG->getPixel(w - 1, h) << 9;
1848 CONTEXT |= GRREG->getPixel(w + 1, h - 1) << 10;
1849 CONTEXT |= GRREG->getPixel(w, h - 1) << 11;
1850 CONTEXT |= GRREG->getPixel(w + GRAT[0], h + GRAT[1]) << 12;
1851 break;
1852 case 1:
1853 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX + 1, h - GRREFERENCEDY + 1);
1854 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX, h - GRREFERENCEDY + 1) << 1;
1855 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX + 1, h - GRREFERENCEDY) << 2;
1856 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX, h - GRREFERENCEDY) << 3;
1857 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX - 1, h - GRREFERENCEDY) << 4;
1858 CONTEXT |= GRREFERENCE->getPixel(w - GRREFERENCEDX, h - GRREFERENCEDY - 1) << 5;
1859 CONTEXT |= GRREG->getPixel(w - 1, h) << 6;
1860 CONTEXT |= GRREG->getPixel(w + 1, h - 1) << 7;
1861 CONTEXT |= GRREG->getPixel(w, h - 1) << 8;
1862 CONTEXT |= GRREG->getPixel(w - 1, h - 1) << 9;
1863 break;
1864 }
1865 bVal = pArithDecoder->DECODE(&grContext[CONTEXT]);
1866 GRREG->setPixel(w, h, bVal);
1867 }
1868 }
1869 }
1870 }
1871 return GRREG;
1872 }
1873 CJBig2_Image *CJBig2_TRDProc::decode_Huffman(CJBig2_BitStream *pStream, JBig2Ari thCtx *grContext)
1874 {
1875 int32_t STRIPT, FIRSTS;
1876 FX_DWORD NINSTANCES;
1877 int32_t DT, DFS, CURS;
1878 uint8_t CURT;
1879 int32_t SI, TI;
1880 FX_DWORD IDI;
1881 CJBig2_Image *IBI;
1882 FX_DWORD WI, HI;
1883 int32_t IDS;
1884 FX_BOOL RI;
1885 int32_t RDWI, RDHI, RDXI, RDYI;
1886 CJBig2_Image *IBOI;
1887 FX_DWORD WOI, HOI;
1888 CJBig2_Image *SBREG;
1889 FX_BOOL bFirst;
1890 FX_DWORD nTmp;
1891 int32_t nVal, nBits;
1892 CJBig2_HuffmanDecoder *pHuffmanDecoder;
1893 CJBig2_GRRDProc *pGRRD;
1894 CJBig2_ArithDecoder *pArithDecoder;
1895 JBIG2_ALLOC(pHuffmanDecoder, CJBig2_HuffmanDecoder(pStream));
1896 JBIG2_ALLOC(SBREG, CJBig2_Image(SBW, SBH));
1897 SBREG->fill(SBDEFPIXEL);
1898 if(pHuffmanDecoder->decodeAValue(SBHUFFDT, &STRIPT) != 0) {
1899 m_pModule->JBig2_Error("text region decoding procedure (huffman): too sh ort.");
1900 goto failed;
1901 }
1902 STRIPT *= SBSTRIPS;
1903 STRIPT = -STRIPT;
1904 FIRSTS = 0;
1905 NINSTANCES = 0;
1906 while(NINSTANCES < SBNUMINSTANCES) {
1907 if(pHuffmanDecoder->decodeAValue(SBHUFFDT, &DT) != 0) {
1908 m_pModule->JBig2_Error("text region decoding procedure (huffman): to o short.");
1909 goto failed;
1910 }
1911 DT *= SBSTRIPS;
1912 STRIPT = STRIPT + DT;
1913 bFirst = TRUE;
1914 for(;;) {
1915 if(bFirst) {
1916 if(pHuffmanDecoder->decodeAValue(SBHUFFFS, &DFS) != 0) {
1917 m_pModule->JBig2_Error("text region decoding procedure (huff man): too short.");
1918 goto failed;
1919 }
1920 FIRSTS = FIRSTS + DFS;
1921 CURS = FIRSTS;
1922 bFirst = FALSE;
1923 } else {
1924 nVal = pHuffmanDecoder->decodeAValue(SBHUFFDS, &IDS);
1925 if(nVal == JBIG2_OOB) {
1926 break;
1927 } else if(nVal != 0) {
1928 m_pModule->JBig2_Error("text region decoding procedure (huff man): too short.");
1929 goto failed;
1930 } else {
1931 CURS = CURS + IDS + SBDSOFFSET;
1932 }
1933 }
1934 if(SBSTRIPS == 1) {
1935 CURT = 0;
1936 } else {
1937 nTmp = 1;
1938 while((FX_DWORD)(1 << nTmp) < SBSTRIPS) {
1939 nTmp ++;
1940 }
1941 if(pStream->readNBits(nTmp, &nVal) != 0) {
1942 m_pModule->JBig2_Error("text region decoding procedure (huff man): too short.");
1943 goto failed;
1944 }
1945 CURT = nVal;
1946 }
1947 TI = STRIPT + CURT;
1948 nVal = 0;
1949 nBits = 0;
1950 for(;;) {
1951 if(pStream->read1Bit(&nTmp) != 0) {
1952 m_pModule->JBig2_Error("text region decoding procedure (huff man): too short.");
1953 goto failed;
1954 }
1955 nVal = (nVal << 1) | nTmp;
1956 nBits ++;
1957 for(IDI = 0; IDI < SBNUMSYMS; IDI++) {
1958 if((nBits == SBSYMCODES[IDI].codelen) && (nVal == SBSYMCODES [IDI].code)) {
1959 break;
1960 }
1961 }
1962 if(IDI < SBNUMSYMS) {
1963 break;
1964 }
1965 }
1966 if(SBREFINE == 0) {
1967 RI = 0;
1968 } else {
1969 if(pStream->read1Bit(&RI) != 0) {
1970 m_pModule->JBig2_Error("text region decoding procedure (huff man): too short.");
1971 goto failed;
1972 }
1973 }
1974 if(RI == 0) {
1975 IBI = SBSYMS[IDI];
1976 } else {
1977 if((pHuffmanDecoder->decodeAValue(SBHUFFRDW, &RDWI) != 0)
1978 || (pHuffmanDecoder->decodeAValue(SBHUFFRDH, &RDHI) != 0 )
1979 || (pHuffmanDecoder->decodeAValue(SBHUFFRDX, &RDXI) != 0 )
1980 || (pHuffmanDecoder->decodeAValue(SBHUFFRDY, &RDYI) != 0 )
1981 || (pHuffmanDecoder->decodeAValue(SBHUFFRSIZE, &nVal) != 0)) {
1982 m_pModule->JBig2_Error("text region decoding procedure (huff man): too short.");
1983 goto failed;
1984 }
1985 pStream->alignByte();
1986 nTmp = pStream->getOffset();
1987 IBOI = SBSYMS[IDI];
1988 if (!IBOI) {
1989 goto failed;
1990 }
1991 WOI = IBOI->m_nWidth;
1992 HOI = IBOI->m_nHeight;
1993 if ((int)(WOI + RDWI) < 0 || (int)(HOI + RDHI) < 0) {
1994 m_pModule->JBig2_Error("text region decoding procedure (huff man): Invalid RDWI or RDHI value.");
1995 goto failed;
1996 }
1997 JBIG2_ALLOC(pGRRD, CJBig2_GRRDProc());
1998 pGRRD->GRW = WOI + RDWI;
1999 pGRRD->GRH = HOI + RDHI;
2000 pGRRD->GRTEMPLATE = SBRTEMPLATE;
2001 pGRRD->GRREFERENCE = IBOI;
2002 pGRRD->GRREFERENCEDX = (RDWI >> 2) + RDXI;
2003 pGRRD->GRREFERENCEDY = (RDHI >> 2) + RDYI;
2004 pGRRD->TPGRON = 0;
2005 pGRRD->GRAT[0] = SBRAT[0];
2006 pGRRD->GRAT[1] = SBRAT[1];
2007 pGRRD->GRAT[2] = SBRAT[2];
2008 pGRRD->GRAT[3] = SBRAT[3];
2009 JBIG2_ALLOC(pArithDecoder, CJBig2_ArithDecoder(pStream));
2010 IBI = pGRRD->decode(pArithDecoder, grContext);
2011 if(IBI == NULL) {
2012 delete pGRRD;
2013 delete pArithDecoder;
2014 goto failed;
2015 }
2016 delete pArithDecoder;
2017 pStream->alignByte();
2018 pStream->offset(2);
2019 if((FX_DWORD)nVal != (pStream->getOffset() - nTmp)) {
2020 delete IBI;
2021 delete pGRRD;
2022 m_pModule->JBig2_Error("text region decoding procedure (huff man):"
2023 "bytes processed by generic refinemen t region decoding procedure doesn't equal SBHUFFRSIZE.");
2024 goto failed;
2025 }
2026 delete pGRRD;
2027 }
2028 if (!IBI) {
2029 continue;
2030 }
2031 WI = IBI->m_nWidth;
2032 HI = IBI->m_nHeight;
2033 if(TRANSPOSED == 0 && ((REFCORNER == JBIG2_CORNER_TOPRIGHT)
2034 || (REFCORNER == JBIG2_CORNER_BOTTOMRIGHT))) {
2035 CURS = CURS + WI - 1;
2036 } else if(TRANSPOSED == 1 && ((REFCORNER == JBIG2_CORNER_BOTTOMLEFT)
2037 || (REFCORNER == JBIG2_CORNER_BOTTOMRI GHT))) {
2038 CURS = CURS + HI - 1;
2039 }
2040 SI = CURS;
2041 if(TRANSPOSED == 0) {
2042 switch(REFCORNER) {
2043 case JBIG2_CORNER_TOPLEFT:
2044 SBREG->composeFrom(SI, TI, IBI, SBCOMBOP);
2045 break;
2046 case JBIG2_CORNER_TOPRIGHT:
2047 SBREG->composeFrom(SI - WI + 1, TI, IBI, SBCOMBOP);
2048 break;
2049 case JBIG2_CORNER_BOTTOMLEFT:
2050 SBREG->composeFrom(SI, TI - HI + 1, IBI, SBCOMBOP);
2051 break;
2052 case JBIG2_CORNER_BOTTOMRIGHT:
2053 SBREG->composeFrom(SI - WI + 1, TI - HI + 1, IBI, SBCOMB OP);
2054 break;
2055 }
2056 } else {
2057 switch(REFCORNER) {
2058 case JBIG2_CORNER_TOPLEFT:
2059 SBREG->composeFrom(TI, SI, IBI, SBCOMBOP);
2060 break;
2061 case JBIG2_CORNER_TOPRIGHT:
2062 SBREG->composeFrom(TI - WI + 1, SI, IBI, SBCOMBOP);
2063 break;
2064 case JBIG2_CORNER_BOTTOMLEFT:
2065 SBREG->composeFrom(TI, SI - HI + 1, IBI, SBCOMBOP);
2066 break;
2067 case JBIG2_CORNER_BOTTOMRIGHT:
2068 SBREG->composeFrom(TI - WI + 1, SI - HI + 1, IBI, SBCOMB OP);
2069 break;
2070 }
2071 }
2072 if(RI != 0) {
2073 delete IBI;
2074 }
2075 if(TRANSPOSED == 0 && ((REFCORNER == JBIG2_CORNER_TOPLEFT)
2076 || (REFCORNER == JBIG2_CORNER_BOTTOMLEFT))) {
2077 CURS = CURS + WI - 1;
2078 } else if(TRANSPOSED == 1 && ((REFCORNER == JBIG2_CORNER_TOPLEFT)
2079 || (REFCORNER == JBIG2_CORNER_TOPRIGHT ))) {
2080 CURS = CURS + HI - 1;
2081 }
2082 NINSTANCES = NINSTANCES + 1;
2083 }
2084 }
2085 delete pHuffmanDecoder;
2086 return SBREG;
2087 failed: 2232 failed:
2088 delete pHuffmanDecoder; 2233 delete pHuffmanDecoder;
2089 delete SBREG; 2234 delete SBREG;
2090 return NULL; 2235 return NULL;
2091 } 2236 }
2092 CJBig2_Image *CJBig2_TRDProc::decode_Arith(CJBig2_ArithDecoder *pArithDecoder, J Big2ArithCtx *grContext, 2237 CJBig2_Image* CJBig2_TRDProc::decode_Arith(CJBig2_ArithDecoder* pArithDecoder,
2093 JBig2IntDecoderState *pIDS) 2238 JBig2ArithCtx* grContext,
2094 { 2239 JBig2IntDecoderState* pIDS) {
2095 int32_t STRIPT, FIRSTS; 2240 int32_t STRIPT, FIRSTS;
2096 FX_DWORD NINSTANCES; 2241 FX_DWORD NINSTANCES;
2097 int32_t DT, DFS, CURS; 2242 int32_t DT, DFS, CURS;
2098 int32_t CURT; 2243 int32_t CURT;
2099 int32_t SI, TI; 2244 int32_t SI, TI;
2100 FX_DWORD IDI; 2245 FX_DWORD IDI;
2101 CJBig2_Image *IBI; 2246 CJBig2_Image* IBI;
2102 FX_DWORD WI, HI; 2247 FX_DWORD WI, HI;
2103 int32_t IDS; 2248 int32_t IDS;
2104 int RI; 2249 int RI;
2105 int32_t RDWI, RDHI, RDXI, RDYI; 2250 int32_t RDWI, RDHI, RDXI, RDYI;
2106 CJBig2_Image *IBOI; 2251 CJBig2_Image* IBOI;
2107 FX_DWORD WOI, HOI; 2252 FX_DWORD WOI, HOI;
2108 CJBig2_Image *SBREG; 2253 CJBig2_Image* SBREG;
2109 FX_BOOL bFirst; 2254 FX_BOOL bFirst;
2110 int32_t nRet, nVal; 2255 int32_t nRet, nVal;
2111 int32_t bRetained; 2256 int32_t bRetained;
2112 CJBig2_ArithIntDecoder *IADT, *IAFS, *IADS, *IAIT, *IARI, *IARDW, *IARDH, *I ARDX, *IARDY; 2257 CJBig2_ArithIntDecoder *IADT, *IAFS, *IADS, *IAIT, *IARI, *IARDW, *IARDH,
2113 CJBig2_ArithIaidDecoder *IAID; 2258 *IARDX, *IARDY;
2114 CJBig2_GRRDProc *pGRRD; 2259 CJBig2_ArithIaidDecoder* IAID;
2115 if(pIDS) { 2260 CJBig2_GRRDProc* pGRRD;
2116 IADT = pIDS->IADT; 2261 if (pIDS) {
2117 IAFS = pIDS->IAFS; 2262 IADT = pIDS->IADT;
2118 IADS = pIDS->IADS; 2263 IAFS = pIDS->IAFS;
2119 IAIT = pIDS->IAIT; 2264 IADS = pIDS->IADS;
2120 IARI = pIDS->IARI; 2265 IAIT = pIDS->IAIT;
2121 IARDW = pIDS->IARDW; 2266 IARI = pIDS->IARI;
2122 IARDH = pIDS->IARDH; 2267 IARDW = pIDS->IARDW;
2123 IARDX = pIDS->IARDX; 2268 IARDH = pIDS->IARDH;
2124 IARDY = pIDS->IARDY; 2269 IARDX = pIDS->IARDX;
2125 IAID = pIDS->IAID; 2270 IARDY = pIDS->IARDY;
2126 bRetained = TRUE; 2271 IAID = pIDS->IAID;
2127 } else { 2272 bRetained = TRUE;
2128 JBIG2_ALLOC(IADT, CJBig2_ArithIntDecoder()); 2273 } else {
2129 JBIG2_ALLOC(IAFS, CJBig2_ArithIntDecoder());
2130 JBIG2_ALLOC(IADS, CJBig2_ArithIntDecoder());
2131 JBIG2_ALLOC(IAIT, CJBig2_ArithIntDecoder());
2132 JBIG2_ALLOC(IARI, CJBig2_ArithIntDecoder());
2133 JBIG2_ALLOC(IARDW, CJBig2_ArithIntDecoder());
2134 JBIG2_ALLOC(IARDH, CJBig2_ArithIntDecoder());
2135 JBIG2_ALLOC(IARDX, CJBig2_ArithIntDecoder());
2136 JBIG2_ALLOC(IARDY, CJBig2_ArithIntDecoder());
2137 JBIG2_ALLOC(IAID , CJBig2_ArithIaidDecoder(SBSYMCODELEN));
2138 bRetained = FALSE;
2139 }
2140 JBIG2_ALLOC(SBREG, CJBig2_Image(SBW, SBH));
2141 SBREG->fill(SBDEFPIXEL);
2142 if(IADT->decode(pArithDecoder, &STRIPT) == -1) {
2143 m_pModule->JBig2_Error("text region decoding procedure (arith): too shor t.");
2144 goto failed;
2145 }
2146 STRIPT *= SBSTRIPS;
2147 STRIPT = -STRIPT;
2148 FIRSTS = 0;
2149 NINSTANCES = 0;
2150 while(NINSTANCES < SBNUMINSTANCES) {
2151 if(IADT->decode(pArithDecoder, &DT) == -1) {
2152 m_pModule->JBig2_Error("text region decoding procedure (arith): too short.");
2153 goto failed;
2154 }
2155 DT *= SBSTRIPS;
2156 STRIPT = STRIPT + DT;
2157 bFirst = TRUE;
2158 for(;;) {
2159 if(bFirst) {
2160 if(IAFS->decode(pArithDecoder, &DFS) == -1) {
2161 m_pModule->JBig2_Error("text region decoding procedure (arit h): too short.");
2162 goto failed;
2163 }
2164 FIRSTS = FIRSTS + DFS;
2165 CURS = FIRSTS;
2166 bFirst = FALSE;
2167 } else {
2168 nRet = IADS->decode(pArithDecoder, &IDS);
2169 if(nRet == JBIG2_OOB) {
2170 break;
2171 } else if(nRet != 0) {
2172 m_pModule->JBig2_Error("text region decoding procedure (arit h): too short.");
2173 goto failed;
2174 } else {
2175 CURS = CURS + IDS + SBDSOFFSET;
2176 }
2177 }
2178 if (NINSTANCES >= SBNUMINSTANCES) {
2179 break;
2180 }
2181 if(SBSTRIPS == 1) {
2182 CURT = 0;
2183 } else {
2184 if(IAIT->decode(pArithDecoder, &nVal) == -1) {
2185 m_pModule->JBig2_Error("text region decoding procedure (arit h): too short.");
2186 goto failed;
2187 }
2188 CURT = nVal;
2189 }
2190 TI = STRIPT + CURT;
2191 if(IAID->decode(pArithDecoder, &nVal) == -1) {
2192 m_pModule->JBig2_Error("text region decoding procedure (arith): too short.");
2193 goto failed;
2194 }
2195 IDI = nVal;
2196 if(IDI >= SBNUMSYMS) {
2197 m_pModule->JBig2_Error("text region decoding procedure (arith): symbol id out of range.(%d/%d)",
2198 IDI, SBNUMSYMS);
2199 goto failed;
2200 }
2201 if(SBREFINE == 0) {
2202 RI = 0;
2203 } else {
2204 if(IARI->decode(pArithDecoder, &RI) == -1) {
2205 m_pModule->JBig2_Error("text region decoding procedure (arit h): too short.");
2206 goto failed;
2207 }
2208 }
2209 if (!SBSYMS[IDI]) {
2210 goto failed;
2211 }
2212 if(RI == 0) {
2213 IBI = SBSYMS[IDI];
2214 } else {
2215 if((IARDW->decode(pArithDecoder, &RDWI) == -1)
2216 || (IARDH->decode(pArithDecoder, &RDHI) == -1)
2217 || (IARDX->decode(pArithDecoder, &RDXI) == -1)
2218 || (IARDY->decode(pArithDecoder, &RDYI) == -1)) {
2219 m_pModule->JBig2_Error("text region decoding procedure (arit h): too short.");
2220 goto failed;
2221 }
2222 IBOI = SBSYMS[IDI];
2223 WOI = IBOI->m_nWidth;
2224 HOI = IBOI->m_nHeight;
2225 if ((int)(WOI + RDWI) < 0 || (int)(HOI + RDHI) < 0) {
2226 m_pModule->JBig2_Error("text region decoding procedure (arit h): Invalid RDWI or RDHI value.");
2227 goto failed;
2228 }
2229 JBIG2_ALLOC(pGRRD, CJBig2_GRRDProc());
2230 pGRRD->GRW = WOI + RDWI;
2231 pGRRD->GRH = HOI + RDHI;
2232 pGRRD->GRTEMPLATE = SBRTEMPLATE;
2233 pGRRD->GRREFERENCE = IBOI;
2234 pGRRD->GRREFERENCEDX = (RDWI >> 1) + RDXI;
2235 pGRRD->GRREFERENCEDY = (RDHI >> 1) + RDYI;
2236 pGRRD->TPGRON = 0;
2237 pGRRD->GRAT[0] = SBRAT[0];
2238 pGRRD->GRAT[1] = SBRAT[1];
2239 pGRRD->GRAT[2] = SBRAT[2];
2240 pGRRD->GRAT[3] = SBRAT[3];
2241 IBI = pGRRD->decode(pArithDecoder, grContext);
2242 if(IBI == NULL) {
2243 delete pGRRD;
2244 goto failed;
2245 }
2246 delete pGRRD;
2247 }
2248 WI = IBI->m_nWidth;
2249 HI = IBI->m_nHeight;
2250 if(TRANSPOSED == 0 && ((REFCORNER == JBIG2_CORNER_TOPRIGHT)
2251 || (REFCORNER == JBIG2_CORNER_BOTTOMRIGHT))) {
2252 CURS = CURS + WI - 1;
2253 } else if(TRANSPOSED == 1 && ((REFCORNER == JBIG2_CORNER_BOTTOMLEFT)
2254 || (REFCORNER == JBIG2_CORNER_BOTTOMRI GHT))) {
2255 CURS = CURS + HI - 1;
2256 }
2257 SI = CURS;
2258 if(TRANSPOSED == 0) {
2259 switch(REFCORNER) {
2260 case JBIG2_CORNER_TOPLEFT:
2261 SBREG->composeFrom(SI, TI, IBI, SBCOMBOP);
2262 break;
2263 case JBIG2_CORNER_TOPRIGHT:
2264 SBREG->composeFrom(SI - WI + 1, TI, IBI, SBCOMBOP);
2265 break;
2266 case JBIG2_CORNER_BOTTOMLEFT:
2267 SBREG->composeFrom(SI, TI - HI + 1, IBI, SBCOMBOP);
2268 break;
2269 case JBIG2_CORNER_BOTTOMRIGHT:
2270 SBREG->composeFrom(SI - WI + 1, TI - HI + 1, IBI, SBCOMB OP);
2271 break;
2272 }
2273 } else {
2274 switch(REFCORNER) {
2275 case JBIG2_CORNER_TOPLEFT:
2276 SBREG->composeFrom(TI, SI, IBI, SBCOMBOP);
2277 break;
2278 case JBIG2_CORNER_TOPRIGHT:
2279 SBREG->composeFrom(TI - WI + 1, SI, IBI, SBCOMBOP);
2280 break;
2281 case JBIG2_CORNER_BOTTOMLEFT:
2282 SBREG->composeFrom(TI, SI - HI + 1, IBI, SBCOMBOP);
2283 break;
2284 case JBIG2_CORNER_BOTTOMRIGHT:
2285 SBREG->composeFrom(TI - WI + 1, SI - HI + 1, IBI, SBCOMB OP);
2286 break;
2287 }
2288 }
2289 if(RI != 0) {
2290 delete IBI;
2291 }
2292 if(TRANSPOSED == 0 && ((REFCORNER == JBIG2_CORNER_TOPLEFT)
2293 || (REFCORNER == JBIG2_CORNER_BOTTOMLEFT))) {
2294 CURS = CURS + WI - 1;
2295 } else if(TRANSPOSED == 1 && ((REFCORNER == JBIG2_CORNER_TOPLEFT)
2296 || (REFCORNER == JBIG2_CORNER_TOPRIGHT ))) {
2297 CURS = CURS + HI - 1;
2298 }
2299 NINSTANCES = NINSTANCES + 1;
2300 }
2301 }
2302 if(bRetained == FALSE) {
2303 delete IADT;
2304 delete IAFS;
2305 delete IADS;
2306 delete IAIT;
2307 delete IARI;
2308 delete IARDW;
2309 delete IARDH;
2310 delete IARDX;
2311 delete IARDY;
2312 delete IAID;
2313 }
2314 return SBREG;
2315 failed:
2316 if(bRetained == FALSE) {
2317 delete IADT;
2318 delete IAFS;
2319 delete IADS;
2320 delete IAIT;
2321 delete IARI;
2322 delete IARDW;
2323 delete IARDH;
2324 delete IARDX;
2325 delete IARDY;
2326 delete IAID;
2327 }
2328 delete SBREG;
2329 return NULL;
2330 }
2331 CJBig2_SymbolDict *CJBig2_SDDProc::decode_Arith(CJBig2_ArithDecoder *pArithDecod er,
2332 JBig2ArithCtx *gbContext, JBig2ArithCtx *grContext)
2333 {
2334 CJBig2_Image **SDNEWSYMS;
2335 FX_DWORD HCHEIGHT, NSYMSDECODED;
2336 int32_t HCDH;
2337 FX_DWORD SYMWIDTH, TOTWIDTH;
2338 int32_t DW;
2339 CJBig2_Image *BS;
2340 FX_DWORD I, J, REFAGGNINST;
2341 FX_BOOL *EXFLAGS;
2342 FX_DWORD EXINDEX;
2343 FX_BOOL CUREXFLAG;
2344 FX_DWORD EXRUNLENGTH;
2345 int32_t nVal;
2346 FX_DWORD nTmp;
2347 FX_DWORD SBNUMSYMS;
2348 uint8_t SBSYMCODELEN;
2349 FX_DWORD IDI;
2350 int32_t RDXI, RDYI;
2351 CJBig2_Image **SBSYMS;
2352 CJBig2_HuffmanTable *SBHUFFFS, *SBHUFFDS, *SBHUFFDT, *SBHUFFRDW, *SBHUFFRDH, *SBHUFFRDX, *SBHUFFRDY,
2353 *SBHUFFRSIZE;
2354 CJBig2_GRRDProc *pGRRD;
2355 CJBig2_GRDProc *pGRD;
2356 CJBig2_ArithIntDecoder *IADH, *IADW, *IAAI, *IARDX, *IARDY, *IAEX,
2357 *IADT, *IAFS, *IADS, *IAIT, *IARI, *IARDW, *IARDH;
2358 CJBig2_ArithIaidDecoder *IAID;
2359 CJBig2_SymbolDict *pDict;
2360 JBIG2_ALLOC(IADH, CJBig2_ArithIntDecoder());
2361 JBIG2_ALLOC(IADW, CJBig2_ArithIntDecoder());
2362 JBIG2_ALLOC(IAAI, CJBig2_ArithIntDecoder());
2363 JBIG2_ALLOC(IARDX, CJBig2_ArithIntDecoder());
2364 JBIG2_ALLOC(IARDY, CJBig2_ArithIntDecoder());
2365 JBIG2_ALLOC(IAEX, CJBig2_ArithIntDecoder());
2366 JBIG2_ALLOC(IADT, CJBig2_ArithIntDecoder()); 2274 JBIG2_ALLOC(IADT, CJBig2_ArithIntDecoder());
2367 JBIG2_ALLOC(IAFS, CJBig2_ArithIntDecoder()); 2275 JBIG2_ALLOC(IAFS, CJBig2_ArithIntDecoder());
2368 JBIG2_ALLOC(IADS, CJBig2_ArithIntDecoder()); 2276 JBIG2_ALLOC(IADS, CJBig2_ArithIntDecoder());
2369 JBIG2_ALLOC(IAIT, CJBig2_ArithIntDecoder()); 2277 JBIG2_ALLOC(IAIT, CJBig2_ArithIntDecoder());
2370 JBIG2_ALLOC(IARI, CJBig2_ArithIntDecoder()); 2278 JBIG2_ALLOC(IARI, CJBig2_ArithIntDecoder());
2371 JBIG2_ALLOC(IARDW, CJBig2_ArithIntDecoder()); 2279 JBIG2_ALLOC(IARDW, CJBig2_ArithIntDecoder());
2372 JBIG2_ALLOC(IARDH, CJBig2_ArithIntDecoder()); 2280 JBIG2_ALLOC(IARDH, CJBig2_ArithIntDecoder());
2373 nTmp = 0; 2281 JBIG2_ALLOC(IARDX, CJBig2_ArithIntDecoder());
2374 while((FX_DWORD)(1 << nTmp) < (SDNUMINSYMS + SDNUMNEWSYMS)) { 2282 JBIG2_ALLOC(IARDY, CJBig2_ArithIntDecoder());
2375 nTmp ++; 2283 JBIG2_ALLOC(IAID, CJBig2_ArithIaidDecoder(SBSYMCODELEN));
2284 bRetained = FALSE;
2285 }
2286 JBIG2_ALLOC(SBREG, CJBig2_Image(SBW, SBH));
2287 SBREG->fill(SBDEFPIXEL);
2288 if (IADT->decode(pArithDecoder, &STRIPT) == -1) {
2289 m_pModule->JBig2_Error(
2290 "text region decoding procedure (arith): too short.");
2291 goto failed;
2292 }
2293 STRIPT *= SBSTRIPS;
2294 STRIPT = -STRIPT;
2295 FIRSTS = 0;
2296 NINSTANCES = 0;
2297 while (NINSTANCES < SBNUMINSTANCES) {
2298 if (IADT->decode(pArithDecoder, &DT) == -1) {
2299 m_pModule->JBig2_Error(
2300 "text region decoding procedure (arith): too short.");
2301 goto failed;
2376 } 2302 }
2377 JBIG2_ALLOC(IAID, CJBig2_ArithIaidDecoder((uint8_t)nTmp)); 2303 DT *= SBSTRIPS;
2378 SDNEWSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(SDNUMNEWSYMS, sizeof(CJ Big2_Image*)); 2304 STRIPT = STRIPT + DT;
2379 FXSYS_memset(SDNEWSYMS, 0 , SDNUMNEWSYMS * sizeof(CJBig2_Image*)); 2305 bFirst = TRUE;
2380 HCHEIGHT = 0; 2306 for (;;) {
2381 NSYMSDECODED = 0; 2307 if (bFirst) {
2382 while(NSYMSDECODED < SDNUMNEWSYMS) { 2308 if (IAFS->decode(pArithDecoder, &DFS) == -1) {
2383 BS = NULL; 2309 m_pModule->JBig2_Error(
2384 if(IADH->decode(pArithDecoder, &HCDH) == -1) { 2310 "text region decoding procedure (arith): too short.");
2385 m_pModule->JBig2_Error("symbol dictionary decoding procedure (arith) : too short."); 2311 goto failed;
2386 goto failed;
2387 } 2312 }
2388 HCHEIGHT = HCHEIGHT + HCDH; 2313 FIRSTS = FIRSTS + DFS;
2389 if ((int)HCHEIGHT < 0 || (int)HCHEIGHT > JBIG2_MAX_IMAGE_SIZE) { 2314 CURS = FIRSTS;
2390 m_pModule->JBig2_Error("symbol dictionary decoding procedure (arith) : invalid HCHEIGHT value."); 2315 bFirst = FALSE;
2391 goto failed; 2316 } else {
2317 nRet = IADS->decode(pArithDecoder, &IDS);
2318 if (nRet == JBIG2_OOB) {
2319 break;
2320 } else if (nRet != 0) {
2321 m_pModule->JBig2_Error(
2322 "text region decoding procedure (arith): too short.");
2323 goto failed;
2324 } else {
2325 CURS = CURS + IDS + SBDSOFFSET;
2392 } 2326 }
2393 SYMWIDTH = 0; 2327 }
2394 TOTWIDTH = 0; 2328 if (NINSTANCES >= SBNUMINSTANCES) {
2395 for(;;) { 2329 break;
2396 nVal = IADW->decode(pArithDecoder, &DW); 2330 }
2397 if(nVal == JBIG2_OOB) { 2331 if (SBSTRIPS == 1) {
2398 break; 2332 CURT = 0;
2399 } else if(nVal != 0) { 2333 } else {
2400 m_pModule->JBig2_Error("symbol dictionary decoding procedure (ar ith): too short."); 2334 if (IAIT->decode(pArithDecoder, &nVal) == -1) {
2401 goto failed; 2335 m_pModule->JBig2_Error(
2402 } else { 2336 "text region decoding procedure (arith): too short.");
2403 if (NSYMSDECODED >= SDNUMNEWSYMS) { 2337 goto failed;
2404 m_pModule->JBig2_Error("symbol dictionary decoding procedure (arith): NSYMSDECODED >= SDNUMNEWSYMS.");
2405 goto failed;
2406 }
2407 SYMWIDTH = SYMWIDTH + DW;
2408 if ((int)SYMWIDTH < 0 || (int)SYMWIDTH > JBIG2_MAX_IMAGE_SIZE) {
2409 m_pModule->JBig2_Error("symbol dictionary decoding procedure (arith): invalid SYMWIDTH value.");
2410 goto failed;
2411 } else if (HCHEIGHT == 0 || SYMWIDTH == 0) {
2412 TOTWIDTH = TOTWIDTH + SYMWIDTH;
2413 SDNEWSYMS[NSYMSDECODED] = NULL;
2414 NSYMSDECODED = NSYMSDECODED + 1;
2415 continue;
2416 }
2417 TOTWIDTH = TOTWIDTH + SYMWIDTH;
2418 }
2419 if(SDREFAGG == 0) {
2420 JBIG2_ALLOC(pGRD, CJBig2_GRDProc());
2421 pGRD->MMR = 0;
2422 pGRD->GBW = SYMWIDTH;
2423 pGRD->GBH = HCHEIGHT;
2424 pGRD->GBTEMPLATE = SDTEMPLATE;
2425 pGRD->TPGDON = 0;
2426 pGRD->USESKIP = 0;
2427 pGRD->GBAT[0] = SDAT[0];
2428 pGRD->GBAT[1] = SDAT[1];
2429 pGRD->GBAT[2] = SDAT[2];
2430 pGRD->GBAT[3] = SDAT[3];
2431 pGRD->GBAT[4] = SDAT[4];
2432 pGRD->GBAT[5] = SDAT[5];
2433 pGRD->GBAT[6] = SDAT[6];
2434 pGRD->GBAT[7] = SDAT[7];
2435 BS = pGRD->decode_Arith(pArithDecoder, gbContext);
2436 if(BS == NULL) {
2437 delete pGRD;
2438 goto failed;
2439 }
2440 delete pGRD;
2441 } else {
2442 if(IAAI->decode(pArithDecoder, (int*)&REFAGGNINST) == -1) {
2443 m_pModule->JBig2_Error("symbol dictionary decoding procedure (arith): too short.");
2444 goto failed;
2445 }
2446 if(REFAGGNINST > 1) {
2447 CJBig2_TRDProc *pDecoder;
2448 JBIG2_ALLOC(pDecoder, CJBig2_TRDProc());
2449 pDecoder->SBHUFF = SDHUFF;
2450 pDecoder->SBREFINE = 1;
2451 pDecoder->SBW = SYMWIDTH;
2452 pDecoder->SBH = HCHEIGHT;
2453 pDecoder->SBNUMINSTANCES = REFAGGNINST;
2454 pDecoder->SBSTRIPS = 1;
2455 pDecoder->SBNUMSYMS = SDNUMINSYMS + NSYMSDECODED;
2456 SBNUMSYMS = pDecoder->SBNUMSYMS;
2457 nTmp = 0;
2458 while((FX_DWORD)(1 << nTmp) < SBNUMSYMS) {
2459 nTmp ++;
2460 }
2461 SBSYMCODELEN = (uint8_t)nTmp;
2462 pDecoder->SBSYMCODELEN = SBSYMCODELEN;
2463 SBSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(SBNUMSYMS, sizeof(CJBig2_Image*));
2464 JBIG2_memcpy(SBSYMS, SDINSYMS, SDNUMINSYMS * sizeof(CJBig2_I mage*));
2465 JBIG2_memcpy(SBSYMS + SDNUMINSYMS, SDNEWSYMS, NSYMSDECODED * sizeof(CJBig2_Image*));
2466 pDecoder->SBSYMS = SBSYMS;
2467 pDecoder->SBDEFPIXEL = 0;
2468 pDecoder->SBCOMBOP = JBIG2_COMPOSE_OR;
2469 pDecoder->TRANSPOSED = 0;
2470 pDecoder->REFCORNER = JBIG2_CORNER_TOPLEFT;
2471 pDecoder->SBDSOFFSET = 0;
2472 JBIG2_ALLOC(SBHUFFFS, CJBig2_HuffmanTable(HuffmanTable_B6,
2473 sizeof(HuffmanTable_B6) / sizeof(JBig2TableLine) , HuffmanTable_HTOOB_B6));
2474 JBIG2_ALLOC(SBHUFFDS, CJBig2_HuffmanTable(HuffmanTable_B8,
2475 sizeof(HuffmanTable_B8) / sizeof(JBig2TableLine) , HuffmanTable_HTOOB_B8));
2476 JBIG2_ALLOC(SBHUFFDT, CJBig2_HuffmanTable(HuffmanTable_B11,
2477 sizeof(HuffmanTable_B11) / sizeof(JBig2TableLine ), HuffmanTable_HTOOB_B11));
2478 JBIG2_ALLOC(SBHUFFRDW, CJBig2_HuffmanTable(HuffmanTable_B15,
2479 sizeof(HuffmanTable_B15) / sizeof(JBig2TableLine ), HuffmanTable_HTOOB_B15));
2480 JBIG2_ALLOC(SBHUFFRDH, CJBig2_HuffmanTable(HuffmanTable_B15,
2481 sizeof(HuffmanTable_B15) / sizeof(JBig2TableLine ), HuffmanTable_HTOOB_B15));
2482 JBIG2_ALLOC(SBHUFFRDX, CJBig2_HuffmanTable(HuffmanTable_B15,
2483 sizeof(HuffmanTable_B15) / sizeof(JBig2TableLine ), HuffmanTable_HTOOB_B15));
2484 JBIG2_ALLOC(SBHUFFRDY, CJBig2_HuffmanTable(HuffmanTable_B15,
2485 sizeof(HuffmanTable_B15) / sizeof(JBig2TableLine ), HuffmanTable_HTOOB_B15));
2486 JBIG2_ALLOC(SBHUFFRSIZE, CJBig2_HuffmanTable(HuffmanTable_B1 ,
2487 sizeof(HuffmanTable_B1) / sizeof(JBig2TableLine) , HuffmanTable_HTOOB_B1));
2488 pDecoder->SBHUFFFS = SBHUFFFS;
2489 pDecoder->SBHUFFDS = SBHUFFDS;
2490 pDecoder->SBHUFFDT = SBHUFFDT;
2491 pDecoder->SBHUFFRDW = SBHUFFRDW;
2492 pDecoder->SBHUFFRDH = SBHUFFRDH;
2493 pDecoder->SBHUFFRDX = SBHUFFRDX;
2494 pDecoder->SBHUFFRDY = SBHUFFRDY;
2495 pDecoder->SBHUFFRSIZE = SBHUFFRSIZE;
2496 pDecoder->SBRTEMPLATE = SDRTEMPLATE;
2497 pDecoder->SBRAT[0] = SDRAT[0];
2498 pDecoder->SBRAT[1] = SDRAT[1];
2499 pDecoder->SBRAT[2] = SDRAT[2];
2500 pDecoder->SBRAT[3] = SDRAT[3];
2501 JBig2IntDecoderState ids;
2502 ids.IADT = IADT;
2503 ids.IAFS = IAFS;
2504 ids.IADS = IADS;
2505 ids.IAIT = IAIT;
2506 ids.IARI = IARI;
2507 ids.IARDW = IARDW;
2508 ids.IARDH = IARDH;
2509 ids.IARDX = IARDX;
2510 ids.IARDY = IARDY;
2511 ids.IAID = IAID;
2512 BS = pDecoder->decode_Arith(pArithDecoder, grContext, &ids);
2513 if(BS == NULL) {
2514 m_pModule->JBig2_Free(SBSYMS);
2515 delete SBHUFFFS;
2516 delete SBHUFFDS;
2517 delete SBHUFFDT;
2518 delete SBHUFFRDW;
2519 delete SBHUFFRDH;
2520 delete SBHUFFRDX;
2521 delete SBHUFFRDY;
2522 delete SBHUFFRSIZE;
2523 delete pDecoder;
2524 goto failed;
2525 }
2526 m_pModule->JBig2_Free(SBSYMS);
2527 delete SBHUFFFS;
2528 delete SBHUFFDS;
2529 delete SBHUFFDT;
2530 delete SBHUFFRDW;
2531 delete SBHUFFRDH;
2532 delete SBHUFFRDX;
2533 delete SBHUFFRDY;
2534 delete SBHUFFRSIZE;
2535 delete pDecoder;
2536 } else if(REFAGGNINST == 1) {
2537 SBNUMSYMS = SDNUMINSYMS + NSYMSDECODED;
2538 if(IAID->decode(pArithDecoder, (int*)&IDI) == -1) {
2539 m_pModule->JBig2_Error("symbol dictionary decoding proce dure (arith): too short.");
2540 goto failed;
2541 }
2542 if((IARDX->decode(pArithDecoder, &RDXI) == -1)
2543 || (IARDY->decode(pArithDecoder, &RDYI) == -1)) {
2544 m_pModule->JBig2_Error("symbol dictionary decoding proce dure (arith): too short.");
2545 goto failed;
2546 }
2547 if (IDI >= SBNUMSYMS) {
2548 m_pModule->JBig2_Error("symbol dictionary decoding proce dure (arith):"
2549 " refinement references unknown s ymbol %d", IDI);
2550 goto failed;
2551 }
2552 SBSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(SBNUMSYMS, sizeof(CJBig2_Image*));
2553 JBIG2_memcpy(SBSYMS, SDINSYMS, SDNUMINSYMS * sizeof(CJBig2_I mage*));
2554 JBIG2_memcpy(SBSYMS + SDNUMINSYMS, SDNEWSYMS, NSYMSDECODED * sizeof(CJBig2_Image*));
2555 if (!SBSYMS[IDI]) {
2556 m_pModule->JBig2_Free(SBSYMS);
2557 goto failed;
2558 }
2559 JBIG2_ALLOC(pGRRD, CJBig2_GRRDProc());
2560 pGRRD->GRW = SYMWIDTH;
2561 pGRRD->GRH = HCHEIGHT;
2562 pGRRD->GRTEMPLATE = SDRTEMPLATE;
2563 pGRRD->GRREFERENCE = SBSYMS[IDI];
2564 pGRRD->GRREFERENCEDX = RDXI;
2565 pGRRD->GRREFERENCEDY = RDYI;
2566 pGRRD->TPGRON = 0;
2567 pGRRD->GRAT[0] = SDRAT[0];
2568 pGRRD->GRAT[1] = SDRAT[1];
2569 pGRRD->GRAT[2] = SDRAT[2];
2570 pGRRD->GRAT[3] = SDRAT[3];
2571 BS = pGRRD->decode(pArithDecoder, grContext);
2572 if(BS == NULL) {
2573 m_pModule->JBig2_Free(SBSYMS);
2574 delete pGRRD;
2575 goto failed;
2576 }
2577 m_pModule->JBig2_Free(SBSYMS);
2578 delete pGRRD;
2579 }
2580 }
2581 SDNEWSYMS[NSYMSDECODED] = BS;
2582 BS = NULL;
2583 NSYMSDECODED = NSYMSDECODED + 1;
2584 } 2338 }
2339 CURT = nVal;
2340 }
2341 TI = STRIPT + CURT;
2342 if (IAID->decode(pArithDecoder, &nVal) == -1) {
2343 m_pModule->JBig2_Error(
2344 "text region decoding procedure (arith): too short.");
2345 goto failed;
2346 }
2347 IDI = nVal;
2348 if (IDI >= SBNUMSYMS) {
2349 m_pModule->JBig2_Error(
2350 "text region decoding procedure (arith): symbol id out of "
2351 "range.(%d/%d)",
2352 IDI, SBNUMSYMS);
2353 goto failed;
2354 }
2355 if (SBREFINE == 0) {
2356 RI = 0;
2357 } else {
2358 if (IARI->decode(pArithDecoder, &RI) == -1) {
2359 m_pModule->JBig2_Error(
2360 "text region decoding procedure (arith): too short.");
2361 goto failed;
2362 }
2363 }
2364 if (!SBSYMS[IDI]) {
2365 goto failed;
2366 }
2367 if (RI == 0) {
2368 IBI = SBSYMS[IDI];
2369 } else {
2370 if ((IARDW->decode(pArithDecoder, &RDWI) == -1) ||
2371 (IARDH->decode(pArithDecoder, &RDHI) == -1) ||
2372 (IARDX->decode(pArithDecoder, &RDXI) == -1) ||
2373 (IARDY->decode(pArithDecoder, &RDYI) == -1)) {
2374 m_pModule->JBig2_Error(
2375 "text region decoding procedure (arith): too short.");
2376 goto failed;
2377 }
2378 IBOI = SBSYMS[IDI];
2379 WOI = IBOI->m_nWidth;
2380 HOI = IBOI->m_nHeight;
2381 if ((int)(WOI + RDWI) < 0 || (int)(HOI + RDHI) < 0) {
2382 m_pModule->JBig2_Error(
2383 "text region decoding procedure (arith): Invalid RDWI or RDHI "
2384 "value.");
2385 goto failed;
2386 }
2387 JBIG2_ALLOC(pGRRD, CJBig2_GRRDProc());
2388 pGRRD->GRW = WOI + RDWI;
2389 pGRRD->GRH = HOI + RDHI;
2390 pGRRD->GRTEMPLATE = SBRTEMPLATE;
2391 pGRRD->GRREFERENCE = IBOI;
2392 pGRRD->GRREFERENCEDX = (RDWI >> 1) + RDXI;
2393 pGRRD->GRREFERENCEDY = (RDHI >> 1) + RDYI;
2394 pGRRD->TPGRON = 0;
2395 pGRRD->GRAT[0] = SBRAT[0];
2396 pGRRD->GRAT[1] = SBRAT[1];
2397 pGRRD->GRAT[2] = SBRAT[2];
2398 pGRRD->GRAT[3] = SBRAT[3];
2399 IBI = pGRRD->decode(pArithDecoder, grContext);
2400 if (IBI == NULL) {
2401 delete pGRRD;
2402 goto failed;
2403 }
2404 delete pGRRD;
2405 }
2406 WI = IBI->m_nWidth;
2407 HI = IBI->m_nHeight;
2408 if (TRANSPOSED == 0 && ((REFCORNER == JBIG2_CORNER_TOPRIGHT) ||
2409 (REFCORNER == JBIG2_CORNER_BOTTOMRIGHT))) {
2410 CURS = CURS + WI - 1;
2411 } else if (TRANSPOSED == 1 && ((REFCORNER == JBIG2_CORNER_BOTTOMLEFT) ||
2412 (REFCORNER == JBIG2_CORNER_BOTTOMRIGHT))) {
2413 CURS = CURS + HI - 1;
2414 }
2415 SI = CURS;
2416 if (TRANSPOSED == 0) {
2417 switch (REFCORNER) {
2418 case JBIG2_CORNER_TOPLEFT:
2419 SBREG->composeFrom(SI, TI, IBI, SBCOMBOP);
2420 break;
2421 case JBIG2_CORNER_TOPRIGHT:
2422 SBREG->composeFrom(SI - WI + 1, TI, IBI, SBCOMBOP);
2423 break;
2424 case JBIG2_CORNER_BOTTOMLEFT:
2425 SBREG->composeFrom(SI, TI - HI + 1, IBI, SBCOMBOP);
2426 break;
2427 case JBIG2_CORNER_BOTTOMRIGHT:
2428 SBREG->composeFrom(SI - WI + 1, TI - HI + 1, IBI, SBCOMBOP);
2429 break;
2430 }
2431 } else {
2432 switch (REFCORNER) {
2433 case JBIG2_CORNER_TOPLEFT:
2434 SBREG->composeFrom(TI, SI, IBI, SBCOMBOP);
2435 break;
2436 case JBIG2_CORNER_TOPRIGHT:
2437 SBREG->composeFrom(TI - WI + 1, SI, IBI, SBCOMBOP);
2438 break;
2439 case JBIG2_CORNER_BOTTOMLEFT:
2440 SBREG->composeFrom(TI, SI - HI + 1, IBI, SBCOMBOP);
2441 break;
2442 case JBIG2_CORNER_BOTTOMRIGHT:
2443 SBREG->composeFrom(TI - WI + 1, SI - HI + 1, IBI, SBCOMBOP);
2444 break;
2445 }
2446 }
2447 if (RI != 0) {
2448 delete IBI;
2449 }
2450 if (TRANSPOSED == 0 && ((REFCORNER == JBIG2_CORNER_TOPLEFT) ||
2451 (REFCORNER == JBIG2_CORNER_BOTTOMLEFT))) {
2452 CURS = CURS + WI - 1;
2453 } else if (TRANSPOSED == 1 && ((REFCORNER == JBIG2_CORNER_TOPLEFT) ||
2454 (REFCORNER == JBIG2_CORNER_TOPRIGHT))) {
2455 CURS = CURS + HI - 1;
2456 }
2457 NINSTANCES = NINSTANCES + 1;
2585 } 2458 }
2586 EXINDEX = 0; 2459 }
2587 CUREXFLAG = 0; 2460 if (bRetained == FALSE) {
2588 EXFLAGS = (FX_BOOL*)m_pModule->JBig2_Malloc2(sizeof(FX_BOOL), (SDNUMINSYMS + SDNUMNEWSYMS));
2589 while(EXINDEX < SDNUMINSYMS + SDNUMNEWSYMS) {
2590 if(IAEX->decode(pArithDecoder, (int*)&EXRUNLENGTH) == -1) {
2591 m_pModule->JBig2_Free(EXFLAGS);
2592 m_pModule->JBig2_Error("symbol dictionary decoding procedure (arith) : too short.");
2593 goto failed;
2594 }
2595 if (EXINDEX + EXRUNLENGTH > SDNUMINSYMS + SDNUMNEWSYMS) {
2596 m_pModule->JBig2_Free(EXFLAGS);
2597 m_pModule->JBig2_Error("symbol dictionary decoding procedure (arith) : Invalid EXRUNLENGTH value.");
2598 goto failed;
2599 }
2600 if(EXRUNLENGTH != 0) {
2601 for(I = EXINDEX; I < EXINDEX + EXRUNLENGTH; I++) {
2602 EXFLAGS[I] = CUREXFLAG;
2603 }
2604 }
2605 EXINDEX = EXINDEX + EXRUNLENGTH;
2606 CUREXFLAG = !CUREXFLAG;
2607 }
2608 JBIG2_ALLOC(pDict, CJBig2_SymbolDict());
2609 pDict->SDNUMEXSYMS = SDNUMEXSYMS;
2610 pDict->SDEXSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(sizeof(CJBig2_Ima ge*), SDNUMEXSYMS);
2611 I = J = 0;
2612 for(I = 0; I < SDNUMINSYMS + SDNUMNEWSYMS; I++) {
2613 if(EXFLAGS[I] && J < SDNUMEXSYMS) {
2614 if(I < SDNUMINSYMS) {
2615 JBIG2_ALLOC(pDict->SDEXSYMS[J], CJBig2_Image(*SDINSYMS[I]));
2616 } else {
2617 pDict->SDEXSYMS[J] = SDNEWSYMS[I - SDNUMINSYMS];
2618 }
2619 J = J + 1;
2620 } else if (!EXFLAGS[I] && I >= SDNUMINSYMS) {
2621 delete SDNEWSYMS[I - SDNUMINSYMS];
2622 }
2623 }
2624 if (J < SDNUMEXSYMS) {
2625 pDict->SDNUMEXSYMS = J;
2626 }
2627 m_pModule->JBig2_Free(EXFLAGS);
2628 m_pModule->JBig2_Free(SDNEWSYMS);
2629 delete IADH;
2630 delete IADW;
2631 delete IAAI;
2632 delete IARDX;
2633 delete IARDY;
2634 delete IAEX;
2635 delete IAID;
2636 delete IADT; 2461 delete IADT;
2637 delete IAFS; 2462 delete IAFS;
2638 delete IADS; 2463 delete IADS;
2639 delete IAIT; 2464 delete IAIT;
2640 delete IARI; 2465 delete IARI;
2641 delete IARDW; 2466 delete IARDW;
2642 delete IARDH; 2467 delete IARDH;
2643 return pDict;
2644 failed:
2645 for(I = 0; I < NSYMSDECODED; I++) {
2646 if (SDNEWSYMS[I]) {
2647 delete SDNEWSYMS[I];
2648 SDNEWSYMS[I] = NULL;
2649 }
2650 }
2651 m_pModule->JBig2_Free(SDNEWSYMS);
2652 delete IADH;
2653 delete IADW;
2654 delete IAAI;
2655 delete IARDX; 2468 delete IARDX;
2656 delete IARDY; 2469 delete IARDY;
2657 delete IAEX;
2658 delete IAID; 2470 delete IAID;
2471 }
2472 return SBREG;
2473 failed:
2474 if (bRetained == FALSE) {
2659 delete IADT; 2475 delete IADT;
2660 delete IAFS; 2476 delete IAFS;
2661 delete IADS; 2477 delete IADS;
2662 delete IAIT; 2478 delete IAIT;
2663 delete IARI; 2479 delete IARI;
2664 delete IARDW; 2480 delete IARDW;
2665 delete IARDH; 2481 delete IARDH;
2482 delete IARDX;
2483 delete IARDY;
2484 delete IAID;
2485 }
2486 delete SBREG;
2487 return NULL;
2488 }
2489 CJBig2_SymbolDict* CJBig2_SDDProc::decode_Arith(
2490 CJBig2_ArithDecoder* pArithDecoder,
2491 JBig2ArithCtx* gbContext,
2492 JBig2ArithCtx* grContext) {
2493 CJBig2_Image** SDNEWSYMS;
2494 FX_DWORD HCHEIGHT, NSYMSDECODED;
2495 int32_t HCDH;
2496 FX_DWORD SYMWIDTH, TOTWIDTH;
2497 int32_t DW;
2498 CJBig2_Image* BS;
2499 FX_DWORD I, J, REFAGGNINST;
2500 FX_BOOL* EXFLAGS;
2501 FX_DWORD EXINDEX;
2502 FX_BOOL CUREXFLAG;
2503 FX_DWORD EXRUNLENGTH;
2504 int32_t nVal;
2505 FX_DWORD nTmp;
2506 FX_DWORD SBNUMSYMS;
2507 uint8_t SBSYMCODELEN;
2508 FX_DWORD IDI;
2509 int32_t RDXI, RDYI;
2510 CJBig2_Image** SBSYMS;
2511 CJBig2_HuffmanTable *SBHUFFFS, *SBHUFFDS, *SBHUFFDT, *SBHUFFRDW, *SBHUFFRDH,
2512 *SBHUFFRDX, *SBHUFFRDY, *SBHUFFRSIZE;
2513 CJBig2_GRRDProc* pGRRD;
2514 CJBig2_GRDProc* pGRD;
2515 CJBig2_ArithIntDecoder *IADH, *IADW, *IAAI, *IARDX, *IARDY, *IAEX, *IADT,
2516 *IAFS, *IADS, *IAIT, *IARI, *IARDW, *IARDH;
2517 CJBig2_ArithIaidDecoder* IAID;
2518 CJBig2_SymbolDict* pDict;
2519 JBIG2_ALLOC(IADH, CJBig2_ArithIntDecoder());
2520 JBIG2_ALLOC(IADW, CJBig2_ArithIntDecoder());
2521 JBIG2_ALLOC(IAAI, CJBig2_ArithIntDecoder());
2522 JBIG2_ALLOC(IARDX, CJBig2_ArithIntDecoder());
2523 JBIG2_ALLOC(IARDY, CJBig2_ArithIntDecoder());
2524 JBIG2_ALLOC(IAEX, CJBig2_ArithIntDecoder());
2525 JBIG2_ALLOC(IADT, CJBig2_ArithIntDecoder());
2526 JBIG2_ALLOC(IAFS, CJBig2_ArithIntDecoder());
2527 JBIG2_ALLOC(IADS, CJBig2_ArithIntDecoder());
2528 JBIG2_ALLOC(IAIT, CJBig2_ArithIntDecoder());
2529 JBIG2_ALLOC(IARI, CJBig2_ArithIntDecoder());
2530 JBIG2_ALLOC(IARDW, CJBig2_ArithIntDecoder());
2531 JBIG2_ALLOC(IARDH, CJBig2_ArithIntDecoder());
2532 nTmp = 0;
2533 while ((FX_DWORD)(1 << nTmp) < (SDNUMINSYMS + SDNUMNEWSYMS)) {
2534 nTmp++;
2535 }
2536 JBIG2_ALLOC(IAID, CJBig2_ArithIaidDecoder((uint8_t)nTmp));
2537 SDNEWSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(SDNUMNEWSYMS,
2538 sizeof(CJBig2_Image*));
2539 FXSYS_memset(SDNEWSYMS, 0, SDNUMNEWSYMS * sizeof(CJBig2_Image*));
2540 HCHEIGHT = 0;
2541 NSYMSDECODED = 0;
2542 while (NSYMSDECODED < SDNUMNEWSYMS) {
2543 BS = NULL;
2544 if (IADH->decode(pArithDecoder, &HCDH) == -1) {
2545 m_pModule->JBig2_Error(
2546 "symbol dictionary decoding procedure (arith): too short.");
2547 goto failed;
2548 }
2549 HCHEIGHT = HCHEIGHT + HCDH;
2550 if ((int)HCHEIGHT < 0 || (int)HCHEIGHT > JBIG2_MAX_IMAGE_SIZE) {
2551 m_pModule->JBig2_Error(
2552 "symbol dictionary decoding procedure (arith): invalid HCHEIGHT "
2553 "value.");
2554 goto failed;
2555 }
2556 SYMWIDTH = 0;
2557 TOTWIDTH = 0;
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 = (uint8_t)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, SDNEWSYMS,
2636 NSYMSDECODED * sizeof(CJBig2_Image*));
2637 pDecoder->SBSYMS = SBSYMS;
2638 pDecoder->SBDEFPIXEL = 0;
2639 pDecoder->SBCOMBOP = JBIG2_COMPOSE_OR;
2640 pDecoder->TRANSPOSED = 0;
2641 pDecoder->REFCORNER = JBIG2_CORNER_TOPLEFT;
2642 pDecoder->SBDSOFFSET = 0;
2643 JBIG2_ALLOC(SBHUFFFS, CJBig2_HuffmanTable(HuffmanTable_B6,
2644 sizeof(HuffmanTable_B6) /
2645 sizeof(JBig2TableLine),
2646 HuffmanTable_HTOOB_B6));
2647 JBIG2_ALLOC(SBHUFFDS, CJBig2_HuffmanTable(HuffmanTable_B8,
2648 sizeof(HuffmanTable_B8) /
2649 sizeof(JBig2TableLine),
2650 HuffmanTable_HTOOB_B8));
2651 JBIG2_ALLOC(SBHUFFDT, CJBig2_HuffmanTable(HuffmanTable_B11,
2652 sizeof(HuffmanTable_B11) /
2653 sizeof(JBig2TableLine),
2654 HuffmanTable_HTOOB_B11));
2655 JBIG2_ALLOC(SBHUFFRDW, CJBig2_HuffmanTable(HuffmanTable_B15,
2656 sizeof(HuffmanTable_B15) /
2657 sizeof(JBig2TableLine),
2658 HuffmanTable_HTOOB_B15));
2659 JBIG2_ALLOC(SBHUFFRDH, CJBig2_HuffmanTable(HuffmanTable_B15,
2660 sizeof(HuffmanTable_B15) /
2661 sizeof(JBig2TableLine),
2662 HuffmanTable_HTOOB_B15));
2663 JBIG2_ALLOC(SBHUFFRDX, CJBig2_HuffmanTable(HuffmanTable_B15,
2664 sizeof(HuffmanTable_B15) /
2665 sizeof(JBig2TableLine),
2666 HuffmanTable_HTOOB_B15));
2667 JBIG2_ALLOC(SBHUFFRDY, CJBig2_HuffmanTable(HuffmanTable_B15,
2668 sizeof(HuffmanTable_B15) /
2669 sizeof(JBig2TableLine),
2670 HuffmanTable_HTOOB_B15));
2671 JBIG2_ALLOC(SBHUFFRSIZE,
2672 CJBig2_HuffmanTable(
2673 HuffmanTable_B1,
2674 sizeof(HuffmanTable_B1) / sizeof(JBig2TableLine),
2675 HuffmanTable_HTOOB_B1));
2676 pDecoder->SBHUFFFS = SBHUFFFS;
2677 pDecoder->SBHUFFDS = SBHUFFDS;
2678 pDecoder->SBHUFFDT = SBHUFFDT;
2679 pDecoder->SBHUFFRDW = SBHUFFRDW;
2680 pDecoder->SBHUFFRDH = SBHUFFRDH;
2681 pDecoder->SBHUFFRDX = SBHUFFRDX;
2682 pDecoder->SBHUFFRDY = SBHUFFRDY;
2683 pDecoder->SBHUFFRSIZE = SBHUFFRSIZE;
2684 pDecoder->SBRTEMPLATE = SDRTEMPLATE;
2685 pDecoder->SBRAT[0] = SDRAT[0];
2686 pDecoder->SBRAT[1] = SDRAT[1];
2687 pDecoder->SBRAT[2] = SDRAT[2];
2688 pDecoder->SBRAT[3] = SDRAT[3];
2689 JBig2IntDecoderState ids;
2690 ids.IADT = IADT;
2691 ids.IAFS = IAFS;
2692 ids.IADS = IADS;
2693 ids.IAIT = IAIT;
2694 ids.IARI = IARI;
2695 ids.IARDW = IARDW;
2696 ids.IARDH = IARDH;
2697 ids.IARDX = IARDX;
2698 ids.IARDY = IARDY;
2699 ids.IAID = IAID;
2700 BS = pDecoder->decode_Arith(pArithDecoder, grContext, &ids);
2701 if (BS == NULL) {
2702 m_pModule->JBig2_Free(SBSYMS);
2703 delete SBHUFFFS;
2704 delete SBHUFFDS;
2705 delete SBHUFFDT;
2706 delete SBHUFFRDW;
2707 delete SBHUFFRDH;
2708 delete SBHUFFRDX;
2709 delete SBHUFFRDY;
2710 delete SBHUFFRSIZE;
2711 delete pDecoder;
2712 goto failed;
2713 }
2714 m_pModule->JBig2_Free(SBSYMS);
2715 delete SBHUFFFS;
2716 delete SBHUFFDS;
2717 delete SBHUFFDT;
2718 delete SBHUFFRDW;
2719 delete SBHUFFRDH;
2720 delete SBHUFFRDX;
2721 delete SBHUFFRDY;
2722 delete SBHUFFRSIZE;
2723 delete pDecoder;
2724 } else if (REFAGGNINST == 1) {
2725 SBNUMSYMS = SDNUMINSYMS + NSYMSDECODED;
2726 if (IAID->decode(pArithDecoder, (int*)&IDI) == -1) {
2727 m_pModule->JBig2_Error(
2728 "symbol dictionary decoding procedure (arith): too short.");
2729 goto failed;
2730 }
2731 if ((IARDX->decode(pArithDecoder, &RDXI) == -1) ||
2732 (IARDY->decode(pArithDecoder, &RDYI) == -1)) {
2733 m_pModule->JBig2_Error(
2734 "symbol dictionary decoding procedure (arith): too short.");
2735 goto failed;
2736 }
2737 if (IDI >= SBNUMSYMS) {
2738 m_pModule->JBig2_Error(
2739 "symbol dictionary decoding procedure (arith):"
2740 " refinement references unknown symbol %d",
2741 IDI);
2742 goto failed;
2743 }
2744 SBSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(
2745 SBNUMSYMS, sizeof(CJBig2_Image*));
2746 JBIG2_memcpy(SBSYMS, SDINSYMS, SDNUMINSYMS * sizeof(CJBig2_Image*));
2747 JBIG2_memcpy(SBSYMS + SDNUMINSYMS, SDNEWSYMS,
2748 NSYMSDECODED * sizeof(CJBig2_Image*));
2749 if (!SBSYMS[IDI]) {
2750 m_pModule->JBig2_Free(SBSYMS);
2751 goto failed;
2752 }
2753 JBIG2_ALLOC(pGRRD, CJBig2_GRRDProc());
2754 pGRRD->GRW = SYMWIDTH;
2755 pGRRD->GRH = HCHEIGHT;
2756 pGRRD->GRTEMPLATE = SDRTEMPLATE;
2757 pGRRD->GRREFERENCE = SBSYMS[IDI];
2758 pGRRD->GRREFERENCEDX = RDXI;
2759 pGRRD->GRREFERENCEDY = RDYI;
2760 pGRRD->TPGRON = 0;
2761 pGRRD->GRAT[0] = SDRAT[0];
2762 pGRRD->GRAT[1] = SDRAT[1];
2763 pGRRD->GRAT[2] = SDRAT[2];
2764 pGRRD->GRAT[3] = SDRAT[3];
2765 BS = pGRRD->decode(pArithDecoder, grContext);
2766 if (BS == NULL) {
2767 m_pModule->JBig2_Free(SBSYMS);
2768 delete pGRRD;
2769 goto failed;
2770 }
2771 m_pModule->JBig2_Free(SBSYMS);
2772 delete pGRRD;
2773 }
2774 }
2775 SDNEWSYMS[NSYMSDECODED] = BS;
2776 BS = NULL;
2777 NSYMSDECODED = NSYMSDECODED + 1;
2778 }
2779 }
2780 EXINDEX = 0;
2781 CUREXFLAG = 0;
2782 EXFLAGS = (FX_BOOL*)m_pModule->JBig2_Malloc2(sizeof(FX_BOOL),
2783 (SDNUMINSYMS + SDNUMNEWSYMS));
2784 while (EXINDEX < SDNUMINSYMS + SDNUMNEWSYMS) {
2785 if (IAEX->decode(pArithDecoder, (int*)&EXRUNLENGTH) == -1) {
2786 m_pModule->JBig2_Free(EXFLAGS);
2787 m_pModule->JBig2_Error(
2788 "symbol dictionary decoding procedure (arith): too short.");
2789 goto failed;
2790 }
2791 if (EXINDEX + EXRUNLENGTH > SDNUMINSYMS + SDNUMNEWSYMS) {
2792 m_pModule->JBig2_Free(EXFLAGS);
2793 m_pModule->JBig2_Error(
2794 "symbol dictionary decoding procedure (arith): Invalid EXRUNLENGTH "
2795 "value.");
2796 goto failed;
2797 }
2798 if (EXRUNLENGTH != 0) {
2799 for (I = EXINDEX; I < EXINDEX + EXRUNLENGTH; I++) {
2800 EXFLAGS[I] = CUREXFLAG;
2801 }
2802 }
2803 EXINDEX = EXINDEX + EXRUNLENGTH;
2804 CUREXFLAG = !CUREXFLAG;
2805 }
2806 JBIG2_ALLOC(pDict, CJBig2_SymbolDict());
2807 pDict->SDNUMEXSYMS = SDNUMEXSYMS;
2808 pDict->SDEXSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(
2809 sizeof(CJBig2_Image*), SDNUMEXSYMS);
2810 I = J = 0;
2811 for (I = 0; I < SDNUMINSYMS + SDNUMNEWSYMS; I++) {
2812 if (EXFLAGS[I] && J < SDNUMEXSYMS) {
2813 if (I < SDNUMINSYMS) {
2814 JBIG2_ALLOC(pDict->SDEXSYMS[J], CJBig2_Image(*SDINSYMS[I]));
2815 } else {
2816 pDict->SDEXSYMS[J] = SDNEWSYMS[I - SDNUMINSYMS];
2817 }
2818 J = J + 1;
2819 } else if (!EXFLAGS[I] && I >= SDNUMINSYMS) {
2820 delete SDNEWSYMS[I - SDNUMINSYMS];
2821 }
2822 }
2823 if (J < SDNUMEXSYMS) {
2824 pDict->SDNUMEXSYMS = J;
2825 }
2826 m_pModule->JBig2_Free(EXFLAGS);
2827 m_pModule->JBig2_Free(SDNEWSYMS);
2828 delete IADH;
2829 delete IADW;
2830 delete IAAI;
2831 delete IARDX;
2832 delete IARDY;
2833 delete IAEX;
2834 delete IAID;
2835 delete IADT;
2836 delete IAFS;
2837 delete IADS;
2838 delete IAIT;
2839 delete IARI;
2840 delete IARDW;
2841 delete IARDH;
2842 return pDict;
2843 failed:
2844 for (I = 0; I < NSYMSDECODED; I++) {
2845 if (SDNEWSYMS[I]) {
2846 delete SDNEWSYMS[I];
2847 SDNEWSYMS[I] = NULL;
2848 }
2849 }
2850 m_pModule->JBig2_Free(SDNEWSYMS);
2851 delete IADH;
2852 delete IADW;
2853 delete IAAI;
2854 delete IARDX;
2855 delete IARDY;
2856 delete IAEX;
2857 delete IAID;
2858 delete IADT;
2859 delete IAFS;
2860 delete IADS;
2861 delete IAIT;
2862 delete IARI;
2863 delete IARDW;
2864 delete IARDH;
2865 return NULL;
2866 }
2867 CJBig2_SymbolDict* CJBig2_SDDProc::decode_Huffman(CJBig2_BitStream* pStream,
2868 JBig2ArithCtx* gbContext,
2869 JBig2ArithCtx* grContext,
2870 IFX_Pause* pPause) {
2871 CJBig2_Image** SDNEWSYMS;
2872 FX_DWORD* SDNEWSYMWIDTHS;
2873 FX_DWORD HCHEIGHT, NSYMSDECODED;
2874 int32_t HCDH;
2875 FX_DWORD SYMWIDTH, TOTWIDTH, HCFIRSTSYM;
2876 int32_t DW;
2877 CJBig2_Image *BS, *BHC;
2878 FX_DWORD I, J, REFAGGNINST;
2879 FX_BOOL* EXFLAGS;
2880 FX_DWORD EXINDEX;
2881 FX_BOOL CUREXFLAG;
2882 FX_DWORD EXRUNLENGTH;
2883 int32_t nVal, nBits;
2884 FX_DWORD nTmp;
2885 FX_DWORD SBNUMSYMS;
2886 uint8_t SBSYMCODELEN;
2887 JBig2HuffmanCode* SBSYMCODES;
2888 FX_DWORD IDI;
2889 int32_t RDXI, RDYI;
2890 FX_DWORD BMSIZE;
2891 FX_DWORD stride;
2892 CJBig2_Image** SBSYMS;
2893 CJBig2_HuffmanTable *SBHUFFFS, *SBHUFFDS, *SBHUFFDT, *SBHUFFRDW, *SBHUFFRDH,
2894 *SBHUFFRDX, *SBHUFFRDY, *SBHUFFRSIZE, *pTable;
2895 CJBig2_HuffmanDecoder* pHuffmanDecoder;
2896 CJBig2_GRRDProc* pGRRD;
2897 CJBig2_ArithDecoder* pArithDecoder;
2898 CJBig2_GRDProc* pGRD;
2899 CJBig2_SymbolDict* pDict;
2900 JBIG2_ALLOC(pHuffmanDecoder, CJBig2_HuffmanDecoder(pStream));
2901 SDNEWSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(SDNUMNEWSYMS,
2902 sizeof(CJBig2_Image*));
2903 FXSYS_memset(SDNEWSYMS, 0, SDNUMNEWSYMS * sizeof(CJBig2_Image*));
2904 SDNEWSYMWIDTHS = NULL;
2905 BHC = NULL;
2906 if (SDREFAGG == 0) {
2907 SDNEWSYMWIDTHS =
2908 (FX_DWORD*)m_pModule->JBig2_Malloc2(SDNUMNEWSYMS, sizeof(FX_DWORD));
2909 FXSYS_memset(SDNEWSYMWIDTHS, 0, SDNUMNEWSYMS * sizeof(FX_DWORD));
2910 }
2911 HCHEIGHT = 0;
2912 NSYMSDECODED = 0;
2913 BS = NULL;
2914 while (NSYMSDECODED < SDNUMNEWSYMS) {
2915 if (pHuffmanDecoder->decodeAValue(SDHUFFDH, &HCDH) != 0) {
2916 m_pModule->JBig2_Error(
2917 "symbol dictionary decoding procedure (huffman): too short.");
2918 goto failed;
2919 }
2920 HCHEIGHT = HCHEIGHT + HCDH;
2921 if ((int)HCHEIGHT < 0 || (int)HCHEIGHT > JBIG2_MAX_IMAGE_SIZE) {
2922 m_pModule->JBig2_Error(
2923 "symbol dictionary decoding procedure (huffman): invalid HCHEIGHT "
2924 "value.");
2925 goto failed;
2926 }
2927 SYMWIDTH = 0;
2928 TOTWIDTH = 0;
2929 HCFIRSTSYM = NSYMSDECODED;
2930 for (;;) {
2931 nVal = pHuffmanDecoder->decodeAValue(SDHUFFDW, &DW);
2932 if (nVal == JBIG2_OOB) {
2933 break;
2934 } else if (nVal != 0) {
2935 m_pModule->JBig2_Error(
2936 "symbol dictionary decoding procedure (huffman): too short.");
2937 goto failed;
2938 } else {
2939 if (NSYMSDECODED >= SDNUMNEWSYMS) {
2940 m_pModule->JBig2_Error(
2941 "symbol dictionary decoding procedure (huffman): NSYMSDECODED >= "
2942 "SDNUMNEWSYMS.");
2943 goto failed;
2944 }
2945 SYMWIDTH = SYMWIDTH + DW;
2946 if ((int)SYMWIDTH < 0 || (int)SYMWIDTH > JBIG2_MAX_IMAGE_SIZE) {
2947 m_pModule->JBig2_Error(
2948 "symbol dictionary decoding procedure (huffman): invalid "
2949 "SYMWIDTH value.");
2950 goto failed;
2951 } else if (HCHEIGHT == 0 || SYMWIDTH == 0) {
2952 TOTWIDTH = TOTWIDTH + SYMWIDTH;
2953 SDNEWSYMS[NSYMSDECODED] = NULL;
2954 NSYMSDECODED = NSYMSDECODED + 1;
2955 continue;
2956 }
2957 TOTWIDTH = TOTWIDTH + SYMWIDTH;
2958 }
2959 if (SDREFAGG == 1) {
2960 if (pHuffmanDecoder->decodeAValue(SDHUFFAGGINST, (int*)&REFAGGNINST) !=
2961 0) {
2962 m_pModule->JBig2_Error(
2963 "symbol dictionary decoding procedure (huffman): too short.");
2964 goto failed;
2965 }
2966 BS = NULL;
2967 if (REFAGGNINST > 1) {
2968 CJBig2_TRDProc* pDecoder;
2969 JBIG2_ALLOC(pDecoder, CJBig2_TRDProc());
2970 pDecoder->SBHUFF = SDHUFF;
2971 pDecoder->SBREFINE = 1;
2972 pDecoder->SBW = SYMWIDTH;
2973 pDecoder->SBH = HCHEIGHT;
2974 pDecoder->SBNUMINSTANCES = REFAGGNINST;
2975 pDecoder->SBSTRIPS = 1;
2976 pDecoder->SBNUMSYMS = SDNUMINSYMS + NSYMSDECODED;
2977 SBNUMSYMS = pDecoder->SBNUMSYMS;
2978 SBSYMCODES = (JBig2HuffmanCode*)m_pModule->JBig2_Malloc2(
2979 SBNUMSYMS, sizeof(JBig2HuffmanCode));
2980 nTmp = 1;
2981 while ((FX_DWORD)(1 << nTmp) < SBNUMSYMS) {
2982 nTmp++;
2983 }
2984 for (I = 0; I < SBNUMSYMS; I++) {
2985 SBSYMCODES[I].codelen = nTmp;
2986 SBSYMCODES[I].code = I;
2987 }
2988 pDecoder->SBSYMCODES = SBSYMCODES;
2989 SBSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(
2990 SBNUMSYMS, sizeof(CJBig2_Image*));
2991 JBIG2_memcpy(SBSYMS, SDINSYMS, SDNUMINSYMS * sizeof(CJBig2_Image*));
2992 JBIG2_memcpy(SBSYMS + SDNUMINSYMS, SDNEWSYMS,
2993 NSYMSDECODED * sizeof(CJBig2_Image*));
2994 pDecoder->SBSYMS = SBSYMS;
2995 pDecoder->SBDEFPIXEL = 0;
2996 pDecoder->SBCOMBOP = JBIG2_COMPOSE_OR;
2997 pDecoder->TRANSPOSED = 0;
2998 pDecoder->REFCORNER = JBIG2_CORNER_TOPLEFT;
2999 pDecoder->SBDSOFFSET = 0;
3000 JBIG2_ALLOC(SBHUFFFS, CJBig2_HuffmanTable(HuffmanTable_B6,
3001 sizeof(HuffmanTable_B6) /
3002 sizeof(JBig2TableLine),
3003 HuffmanTable_HTOOB_B6));
3004 JBIG2_ALLOC(SBHUFFDS, CJBig2_HuffmanTable(HuffmanTable_B8,
3005 sizeof(HuffmanTable_B8) /
3006 sizeof(JBig2TableLine),
3007 HuffmanTable_HTOOB_B8));
3008 JBIG2_ALLOC(SBHUFFDT, CJBig2_HuffmanTable(HuffmanTable_B11,
3009 sizeof(HuffmanTable_B11) /
3010 sizeof(JBig2TableLine),
3011 HuffmanTable_HTOOB_B11));
3012 JBIG2_ALLOC(SBHUFFRDW, CJBig2_HuffmanTable(HuffmanTable_B15,
3013 sizeof(HuffmanTable_B15) /
3014 sizeof(JBig2TableLine),
3015 HuffmanTable_HTOOB_B15));
3016 JBIG2_ALLOC(SBHUFFRDH, CJBig2_HuffmanTable(HuffmanTable_B15,
3017 sizeof(HuffmanTable_B15) /
3018 sizeof(JBig2TableLine),
3019 HuffmanTable_HTOOB_B15));
3020 JBIG2_ALLOC(SBHUFFRDX, CJBig2_HuffmanTable(HuffmanTable_B15,
3021 sizeof(HuffmanTable_B15) /
3022 sizeof(JBig2TableLine),
3023 HuffmanTable_HTOOB_B15));
3024 JBIG2_ALLOC(SBHUFFRDY, CJBig2_HuffmanTable(HuffmanTable_B15,
3025 sizeof(HuffmanTable_B15) /
3026 sizeof(JBig2TableLine),
3027 HuffmanTable_HTOOB_B15));
3028 JBIG2_ALLOC(SBHUFFRSIZE,
3029 CJBig2_HuffmanTable(
3030 HuffmanTable_B1,
3031 sizeof(HuffmanTable_B1) / sizeof(JBig2TableLine),
3032 HuffmanTable_HTOOB_B1));
3033 pDecoder->SBHUFFFS = SBHUFFFS;
3034 pDecoder->SBHUFFDS = SBHUFFDS;
3035 pDecoder->SBHUFFDT = SBHUFFDT;
3036 pDecoder->SBHUFFRDW = SBHUFFRDW;
3037 pDecoder->SBHUFFRDH = SBHUFFRDH;
3038 pDecoder->SBHUFFRDX = SBHUFFRDX;
3039 pDecoder->SBHUFFRDY = SBHUFFRDY;
3040 pDecoder->SBHUFFRSIZE = SBHUFFRSIZE;
3041 pDecoder->SBRTEMPLATE = SDRTEMPLATE;
3042 pDecoder->SBRAT[0] = SDRAT[0];
3043 pDecoder->SBRAT[1] = SDRAT[1];
3044 pDecoder->SBRAT[2] = SDRAT[2];
3045 pDecoder->SBRAT[3] = SDRAT[3];
3046 BS = pDecoder->decode_Huffman(pStream, grContext);
3047 if (BS == NULL) {
3048 m_pModule->JBig2_Free(SBSYMCODES);
3049 m_pModule->JBig2_Free(SBSYMS);
3050 delete SBHUFFFS;
3051 delete SBHUFFDS;
3052 delete SBHUFFDT;
3053 delete SBHUFFRDW;
3054 delete SBHUFFRDH;
3055 delete SBHUFFRDX;
3056 delete SBHUFFRDY;
3057 delete SBHUFFRSIZE;
3058 delete pDecoder;
3059 goto failed;
3060 }
3061 m_pModule->JBig2_Free(SBSYMCODES);
3062 m_pModule->JBig2_Free(SBSYMS);
3063 delete SBHUFFFS;
3064 delete SBHUFFDS;
3065 delete SBHUFFDT;
3066 delete SBHUFFRDW;
3067 delete SBHUFFRDH;
3068 delete SBHUFFRDX;
3069 delete SBHUFFRDY;
3070 delete SBHUFFRSIZE;
3071 delete pDecoder;
3072 } else if (REFAGGNINST == 1) {
3073 SBNUMSYMS = SDNUMINSYMS + SDNUMNEWSYMS;
3074 nTmp = 1;
3075 while ((FX_DWORD)(1 << nTmp) < SBNUMSYMS) {
3076 nTmp++;
3077 }
3078 SBSYMCODELEN = (uint8_t)nTmp;
3079 SBSYMCODES = (JBig2HuffmanCode*)m_pModule->JBig2_Malloc2(
3080 SBNUMSYMS, sizeof(JBig2HuffmanCode));
3081 for (I = 0; I < SBNUMSYMS; I++) {
3082 SBSYMCODES[I].codelen = SBSYMCODELEN;
3083 SBSYMCODES[I].code = I;
3084 }
3085 nVal = 0;
3086 nBits = 0;
3087 for (;;) {
3088 if (pStream->read1Bit(&nTmp) != 0) {
3089 m_pModule->JBig2_Free(SBSYMCODES);
3090 m_pModule->JBig2_Error(
3091 "symbol dictionary decoding procedure (huffman): too short.");
3092 goto failed;
3093 }
3094 nVal = (nVal << 1) | nTmp;
3095 for (IDI = 0; IDI < SBNUMSYMS; IDI++) {
3096 if ((nVal == SBSYMCODES[IDI].code) &&
3097 (nBits == SBSYMCODES[IDI].codelen)) {
3098 break;
3099 }
3100 }
3101 if (IDI < SBNUMSYMS) {
3102 break;
3103 }
3104 }
3105 m_pModule->JBig2_Free(SBSYMCODES);
3106 JBIG2_ALLOC(SBHUFFRDX, CJBig2_HuffmanTable(HuffmanTable_B15,
3107 sizeof(HuffmanTable_B15) /
3108 sizeof(JBig2TableLine),
3109 HuffmanTable_HTOOB_B15));
3110 JBIG2_ALLOC(SBHUFFRSIZE,
3111 CJBig2_HuffmanTable(
3112 HuffmanTable_B1,
3113 sizeof(HuffmanTable_B1) / sizeof(JBig2TableLine),
3114 HuffmanTable_HTOOB_B1));
3115 if ((pHuffmanDecoder->decodeAValue(SBHUFFRDX, &RDXI) != 0) ||
3116 (pHuffmanDecoder->decodeAValue(SBHUFFRDX, &RDYI) != 0) ||
3117 (pHuffmanDecoder->decodeAValue(SBHUFFRSIZE, &nVal) != 0)) {
3118 delete SBHUFFRDX;
3119 delete SBHUFFRSIZE;
3120 m_pModule->JBig2_Error(
3121 "symbol dictionary decoding procedure (huffman): too short.");
3122 goto failed;
3123 }
3124 delete SBHUFFRDX;
3125 delete SBHUFFRSIZE;
3126 pStream->alignByte();
3127 nTmp = pStream->getOffset();
3128 SBSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(
3129 SBNUMSYMS, sizeof(CJBig2_Image*));
3130 JBIG2_memcpy(SBSYMS, SDINSYMS, SDNUMINSYMS * sizeof(CJBig2_Image*));
3131 JBIG2_memcpy(SBSYMS + SDNUMINSYMS, SDNEWSYMS,
3132 NSYMSDECODED * sizeof(CJBig2_Image*));
3133 JBIG2_ALLOC(pGRRD, CJBig2_GRRDProc());
3134 pGRRD->GRW = SYMWIDTH;
3135 pGRRD->GRH = HCHEIGHT;
3136 pGRRD->GRTEMPLATE = SDRTEMPLATE;
3137 pGRRD->GRREFERENCE = SBSYMS[IDI];
3138 pGRRD->GRREFERENCEDX = RDXI;
3139 pGRRD->GRREFERENCEDY = RDYI;
3140 pGRRD->TPGRON = 0;
3141 pGRRD->GRAT[0] = SDRAT[0];
3142 pGRRD->GRAT[1] = SDRAT[1];
3143 pGRRD->GRAT[2] = SDRAT[2];
3144 pGRRD->GRAT[3] = SDRAT[3];
3145 JBIG2_ALLOC(pArithDecoder, CJBig2_ArithDecoder(pStream));
3146 BS = pGRRD->decode(pArithDecoder, grContext);
3147 if (BS == NULL) {
3148 m_pModule->JBig2_Free(SBSYMS);
3149 delete pGRRD;
3150 delete pArithDecoder;
3151 goto failed;
3152 }
3153 pStream->alignByte();
3154 pStream->offset(2);
3155 if ((FX_DWORD)nVal != (pStream->getOffset() - nTmp)) {
3156 delete BS;
3157 m_pModule->JBig2_Free(SBSYMS);
3158 delete pGRRD;
3159 delete pArithDecoder;
3160 m_pModule->JBig2_Error(
3161 "symbol dictionary decoding procedure (huffman):"
3162 "bytes processed by generic refinement region decoding "
3163 "procedure doesn't equal SBHUFFRSIZE.");
3164 goto failed;
3165 }
3166 m_pModule->JBig2_Free(SBSYMS);
3167 delete pGRRD;
3168 delete pArithDecoder;
3169 }
3170 SDNEWSYMS[NSYMSDECODED] = BS;
3171 }
3172 if (SDREFAGG == 0) {
3173 SDNEWSYMWIDTHS[NSYMSDECODED] = SYMWIDTH;
3174 }
3175 NSYMSDECODED = NSYMSDECODED + 1;
3176 }
3177 if (SDREFAGG == 0) {
3178 if (pHuffmanDecoder->decodeAValue(SDHUFFBMSIZE, (int32_t*)&BMSIZE) != 0) {
3179 m_pModule->JBig2_Error(
3180 "symbol dictionary decoding procedure (huffman): too short.");
3181 goto failed;
3182 }
3183 pStream->alignByte();
3184 if (BMSIZE == 0) {
3185 stride = (TOTWIDTH + 7) >> 3;
3186 if (pStream->getByteLeft() >= stride * HCHEIGHT) {
3187 JBIG2_ALLOC(BHC, CJBig2_Image(TOTWIDTH, HCHEIGHT));
3188 for (I = 0; I < HCHEIGHT; I++) {
3189 JBIG2_memcpy(BHC->m_pData + I * BHC->m_nStride,
3190 pStream->getPointer(), stride);
3191 pStream->offset(stride);
3192 }
3193 } else {
3194 m_pModule->JBig2_Error(
3195 "symbol dictionary decoding procedure (huffman): too short.");
3196 goto failed;
3197 }
3198 } else {
3199 JBIG2_ALLOC(pGRD, CJBig2_GRDProc());
3200 pGRD->MMR = 1;
3201 pGRD->GBW = TOTWIDTH;
3202 pGRD->GBH = HCHEIGHT;
3203 FXCODEC_STATUS status = pGRD->Start_decode_MMR(&BHC, pStream);
3204 while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
3205 pGRD->Continue_decode(pPause);
3206 }
3207 delete pGRD;
3208 pStream->alignByte();
3209 }
3210 nTmp = 0;
3211 if (!BHC) {
3212 continue;
3213 }
3214 for (I = HCFIRSTSYM; I < NSYMSDECODED; I++) {
3215 SDNEWSYMS[I] = BHC->subImage(nTmp, 0, SDNEWSYMWIDTHS[I], HCHEIGHT);
3216 nTmp += SDNEWSYMWIDTHS[I];
3217 }
3218 delete BHC;
3219 BHC = NULL;
3220 }
3221 }
3222 EXINDEX = 0;
3223 CUREXFLAG = 0;
3224 JBIG2_ALLOC(pTable, CJBig2_HuffmanTable(
3225 HuffmanTable_B1,
3226 sizeof(HuffmanTable_B1) / sizeof(JBig2TableLine),
3227 HuffmanTable_HTOOB_B1));
3228 EXFLAGS = (FX_BOOL*)m_pModule->JBig2_Malloc2(sizeof(FX_BOOL),
3229 (SDNUMINSYMS + SDNUMNEWSYMS));
3230 while (EXINDEX < SDNUMINSYMS + SDNUMNEWSYMS) {
3231 if (pHuffmanDecoder->decodeAValue(pTable, (int*)&EXRUNLENGTH) != 0) {
3232 delete pTable;
3233 m_pModule->JBig2_Free(EXFLAGS);
3234 m_pModule->JBig2_Error(
3235 "symbol dictionary decoding procedure (huffman): too short.");
3236 goto failed;
3237 }
3238 if (EXINDEX + EXRUNLENGTH > SDNUMINSYMS + SDNUMNEWSYMS) {
3239 delete pTable;
3240 m_pModule->JBig2_Free(EXFLAGS);
3241 m_pModule->JBig2_Error(
3242 "symbol dictionary decoding procedure (arith): Invalid EXRUNLENGTH "
3243 "value.");
3244 goto failed;
3245 }
3246 if (EXRUNLENGTH != 0) {
3247 for (I = EXINDEX; I < EXINDEX + EXRUNLENGTH; I++) {
3248 EXFLAGS[I] = CUREXFLAG;
3249 }
3250 }
3251 EXINDEX = EXINDEX + EXRUNLENGTH;
3252 CUREXFLAG = !CUREXFLAG;
3253 }
3254 delete pTable;
3255 JBIG2_ALLOC(pDict, CJBig2_SymbolDict());
3256 pDict->SDNUMEXSYMS = SDNUMEXSYMS;
3257 pDict->SDEXSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(
3258 sizeof(CJBig2_Image*), SDNUMEXSYMS);
3259 I = J = 0;
3260 for (I = 0; I < SDNUMINSYMS + SDNUMNEWSYMS; I++) {
3261 if (EXFLAGS[I] && J < SDNUMEXSYMS) {
3262 if (I < SDNUMINSYMS) {
3263 JBIG2_ALLOC(pDict->SDEXSYMS[J], CJBig2_Image(*SDINSYMS[I]));
3264 } else {
3265 pDict->SDEXSYMS[J] = SDNEWSYMS[I - SDNUMINSYMS];
3266 }
3267 J = J + 1;
3268 } else if (!EXFLAGS[I] && I >= SDNUMINSYMS) {
3269 delete SDNEWSYMS[I - SDNUMINSYMS];
3270 }
3271 }
3272 if (J < SDNUMEXSYMS) {
3273 pDict->SDNUMEXSYMS = J;
3274 }
3275 m_pModule->JBig2_Free(EXFLAGS);
3276 m_pModule->JBig2_Free(SDNEWSYMS);
3277 if (SDREFAGG == 0) {
3278 m_pModule->JBig2_Free(SDNEWSYMWIDTHS);
3279 }
3280 delete pHuffmanDecoder;
3281 return pDict;
3282 failed:
3283 for (I = 0; I < NSYMSDECODED; I++) {
3284 delete SDNEWSYMS[I];
3285 }
3286 m_pModule->JBig2_Free(SDNEWSYMS);
3287 if (SDREFAGG == 0) {
3288 m_pModule->JBig2_Free(SDNEWSYMWIDTHS);
3289 }
3290 delete pHuffmanDecoder;
3291 return NULL;
3292 }
3293 CJBig2_Image* CJBig2_HTRDProc::decode_Arith(CJBig2_ArithDecoder* pArithDecoder,
3294 JBig2ArithCtx* gbContext,
3295 IFX_Pause* pPause) {
3296 FX_DWORD ng, mg;
3297 int32_t x, y;
3298 CJBig2_Image* HSKIP;
3299 FX_DWORD HBPP;
3300 FX_DWORD* GI;
3301 CJBig2_Image* HTREG;
3302 CJBig2_GSIDProc* pGID;
3303 JBIG2_ALLOC(HTREG, CJBig2_Image(HBW, HBH));
3304 HTREG->fill(HDEFPIXEL);
3305 HSKIP = NULL;
3306 if (HENABLESKIP == 1) {
3307 JBIG2_ALLOC(HSKIP, CJBig2_Image(HGW, HGH));
3308 for (mg = 0; mg < HGH; mg++) {
3309 for (ng = 0; ng < HGW; ng++) {
3310 x = (HGX + mg * HRY + ng * HRX) >> 8;
3311 y = (HGY + mg * HRX - ng * HRY) >> 8;
3312 if ((x + HPW <= 0) | (x >= (int32_t)HBW) | (y + HPH <= 0) |
3313 (y >= (int32_t)HPH)) {
3314 HSKIP->setPixel(ng, mg, 1);
3315 } else {
3316 HSKIP->setPixel(ng, mg, 0);
3317 }
3318 }
3319 }
3320 }
3321 HBPP = 1;
3322 while ((FX_DWORD)(1 << HBPP) < HNUMPATS) {
3323 HBPP++;
3324 }
3325 JBIG2_ALLOC(pGID, CJBig2_GSIDProc());
3326 pGID->GSMMR = HMMR;
3327 pGID->GSW = HGW;
3328 pGID->GSH = HGH;
3329 pGID->GSBPP = (uint8_t)HBPP;
3330 pGID->GSUSESKIP = HENABLESKIP;
3331 pGID->GSKIP = HSKIP;
3332 pGID->GSTEMPLATE = HTEMPLATE;
3333 GI = pGID->decode_Arith(pArithDecoder, gbContext, pPause);
3334 if (GI == NULL) {
3335 goto failed;
3336 }
3337 for (mg = 0; mg < HGH; mg++) {
3338 for (ng = 0; ng < HGW; ng++) {
3339 x = (HGX + mg * HRY + ng * HRX) >> 8;
3340 y = (HGY + mg * HRX - ng * HRY) >> 8;
3341 FX_DWORD pat_index = GI[mg * HGW + ng];
3342 if (pat_index >= HNUMPATS) {
3343 pat_index = HNUMPATS - 1;
3344 }
3345 HTREG->composeFrom(x, y, HPATS[pat_index], HCOMBOP);
3346 }
3347 }
3348 m_pModule->JBig2_Free(GI);
3349 delete HSKIP;
3350 delete pGID;
3351 return HTREG;
3352 failed:
3353 delete HSKIP;
3354 delete pGID;
3355 delete HTREG;
3356 return NULL;
3357 }
3358 CJBig2_Image* CJBig2_HTRDProc::decode_MMR(CJBig2_BitStream* pStream,
3359 IFX_Pause* pPause) {
3360 FX_DWORD ng, mg;
3361 int32_t x, y;
3362 FX_DWORD HBPP;
3363 FX_DWORD* GI;
3364 CJBig2_Image* HTREG;
3365 CJBig2_GSIDProc* pGID;
3366 JBIG2_ALLOC(HTREG, CJBig2_Image(HBW, HBH));
3367 HTREG->fill(HDEFPIXEL);
3368 HBPP = 1;
3369 while ((FX_DWORD)(1 << HBPP) < HNUMPATS) {
3370 HBPP++;
3371 }
3372 JBIG2_ALLOC(pGID, CJBig2_GSIDProc());
3373 pGID->GSMMR = HMMR;
3374 pGID->GSW = HGW;
3375 pGID->GSH = HGH;
3376 pGID->GSBPP = (uint8_t)HBPP;
3377 pGID->GSUSESKIP = 0;
3378 GI = pGID->decode_MMR(pStream, pPause);
3379 if (GI == NULL) {
3380 goto failed;
3381 }
3382 for (mg = 0; mg < HGH; mg++) {
3383 for (ng = 0; ng < HGW; ng++) {
3384 x = (HGX + mg * HRY + ng * HRX) >> 8;
3385 y = (HGY + mg * HRX - ng * HRY) >> 8;
3386 FX_DWORD pat_index = GI[mg * HGW + ng];
3387 if (pat_index >= HNUMPATS) {
3388 pat_index = HNUMPATS - 1;
3389 }
3390 HTREG->composeFrom(x, y, HPATS[pat_index], HCOMBOP);
3391 }
3392 }
3393 m_pModule->JBig2_Free(GI);
3394 delete pGID;
3395 return HTREG;
3396 failed:
3397 delete pGID;
3398 delete HTREG;
3399 return NULL;
3400 }
3401 CJBig2_PatternDict* CJBig2_PDDProc::decode_Arith(
3402 CJBig2_ArithDecoder* pArithDecoder,
3403 JBig2ArithCtx* gbContext,
3404 IFX_Pause* pPause) {
3405 FX_DWORD GRAY;
3406 CJBig2_Image* BHDC = NULL;
3407 CJBig2_PatternDict* pDict;
3408 CJBig2_GRDProc* pGRD;
3409 JBIG2_ALLOC(pDict, CJBig2_PatternDict());
3410 pDict->NUMPATS = GRAYMAX + 1;
3411 pDict->HDPATS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(
3412 sizeof(CJBig2_Image*), pDict->NUMPATS);
3413 JBIG2_memset(pDict->HDPATS, 0, sizeof(CJBig2_Image*) * pDict->NUMPATS);
3414 JBIG2_ALLOC(pGRD, CJBig2_GRDProc());
3415 pGRD->MMR = HDMMR;
3416 pGRD->GBW = (GRAYMAX + 1) * HDPW;
3417 pGRD->GBH = HDPH;
3418 pGRD->GBTEMPLATE = HDTEMPLATE;
3419 pGRD->TPGDON = 0;
3420 pGRD->USESKIP = 0;
3421 pGRD->GBAT[0] = -(int32_t)HDPW;
3422 pGRD->GBAT[1] = 0;
3423 if (pGRD->GBTEMPLATE == 0) {
3424 pGRD->GBAT[2] = -3;
3425 pGRD->GBAT[3] = -1;
3426 pGRD->GBAT[4] = 2;
3427 pGRD->GBAT[5] = -2;
3428 pGRD->GBAT[6] = -2;
3429 pGRD->GBAT[7] = -2;
3430 }
3431 FXCODEC_STATUS status =
3432 pGRD->Start_decode_Arith(&BHDC, pArithDecoder, gbContext);
3433 while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
3434 pGRD->Continue_decode(pPause);
3435 }
3436 if (BHDC == NULL) {
3437 delete pGRD;
3438 goto failed;
3439 }
3440 delete pGRD;
3441 GRAY = 0;
3442 while (GRAY <= GRAYMAX) {
3443 pDict->HDPATS[GRAY] = BHDC->subImage(HDPW * GRAY, 0, HDPW, HDPH);
3444 GRAY = GRAY + 1;
3445 }
3446 delete BHDC;
3447 return pDict;
3448 failed:
3449 delete pDict;
3450 return NULL;
3451 }
3452
3453 CJBig2_PatternDict* CJBig2_PDDProc::decode_MMR(CJBig2_BitStream* pStream,
3454 IFX_Pause* pPause) {
3455 FX_DWORD GRAY;
3456 CJBig2_Image* BHDC = NULL;
3457 CJBig2_PatternDict* pDict;
3458 CJBig2_GRDProc* pGRD;
3459 JBIG2_ALLOC(pDict, CJBig2_PatternDict());
3460 pDict->NUMPATS = GRAYMAX + 1;
3461 pDict->HDPATS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(
3462 sizeof(CJBig2_Image*), pDict->NUMPATS);
3463 JBIG2_memset(pDict->HDPATS, 0, sizeof(CJBig2_Image*) * pDict->NUMPATS);
3464 JBIG2_ALLOC(pGRD, CJBig2_GRDProc());
3465 pGRD->MMR = HDMMR;
3466 pGRD->GBW = (GRAYMAX + 1) * HDPW;
3467 pGRD->GBH = HDPH;
3468 FXCODEC_STATUS status = pGRD->Start_decode_MMR(&BHDC, pStream);
3469 while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
3470 pGRD->Continue_decode(pPause);
3471 }
3472 if (BHDC == NULL) {
3473 delete pGRD;
3474 goto failed;
3475 }
3476 delete pGRD;
3477 GRAY = 0;
3478 while (GRAY <= GRAYMAX) {
3479 pDict->HDPATS[GRAY] = BHDC->subImage(HDPW * GRAY, 0, HDPW, HDPH);
3480 GRAY = GRAY + 1;
3481 }
3482 delete BHDC;
3483 return pDict;
3484 failed:
3485 delete pDict;
3486 return NULL;
3487 }
3488 FX_DWORD* CJBig2_GSIDProc::decode_Arith(CJBig2_ArithDecoder* pArithDecoder,
3489 JBig2ArithCtx* gbContext,
3490 IFX_Pause* pPause) {
3491 CJBig2_Image** GSPLANES;
3492 int32_t J, K;
3493 FX_DWORD x, y;
3494 FX_DWORD* GSVALS;
3495 CJBig2_GRDProc* pGRD;
3496 GSPLANES =
3497 (CJBig2_Image**)m_pModule->JBig2_Malloc2(sizeof(CJBig2_Image*), GSBPP);
3498 if (!GSPLANES) {
2666 return NULL; 3499 return NULL;
2667 } 3500 }
2668 CJBig2_SymbolDict *CJBig2_SDDProc::decode_Huffman(CJBig2_BitStream *pStream, 3501 GSVALS = (FX_DWORD*)m_pModule->JBig2_Malloc3(sizeof(FX_DWORD), GSW, GSH);
2669 JBig2ArithCtx *gbContext, JBig2ArithCtx *grContext, IFX_Pause* pPause) 3502 if (!GSVALS) {
2670 { 3503 m_pModule->JBig2_Free(GSPLANES);
2671 CJBig2_Image **SDNEWSYMS; 3504 return NULL;
2672 FX_DWORD *SDNEWSYMWIDTHS; 3505 }
2673 FX_DWORD HCHEIGHT, NSYMSDECODED; 3506 JBIG2_memset(GSPLANES, 0, sizeof(CJBig2_Image*) * GSBPP);
2674 int32_t HCDH; 3507 JBIG2_memset(GSVALS, 0, sizeof(FX_DWORD) * GSW * GSH);
2675 FX_DWORD SYMWIDTH, TOTWIDTH, HCFIRSTSYM; 3508 JBIG2_ALLOC(pGRD, CJBig2_GRDProc());
2676 int32_t DW; 3509 pGRD->MMR = GSMMR;
2677 CJBig2_Image *BS, *BHC; 3510 pGRD->GBW = GSW;
2678 FX_DWORD I, J, REFAGGNINST; 3511 pGRD->GBH = GSH;
2679 FX_BOOL *EXFLAGS; 3512 pGRD->GBTEMPLATE = GSTEMPLATE;
2680 FX_DWORD EXINDEX; 3513 pGRD->TPGDON = 0;
2681 FX_BOOL CUREXFLAG; 3514 pGRD->USESKIP = GSUSESKIP;
2682 FX_DWORD EXRUNLENGTH; 3515 pGRD->SKIP = GSKIP;
2683 int32_t nVal, nBits; 3516 if (GSTEMPLATE <= 1) {
2684 FX_DWORD nTmp; 3517 pGRD->GBAT[0] = 3;
2685 FX_DWORD SBNUMSYMS; 3518 } else {
2686 uint8_t SBSYMCODELEN; 3519 pGRD->GBAT[0] = 2;
2687 JBig2HuffmanCode *SBSYMCODES; 3520 }
2688 FX_DWORD IDI; 3521 pGRD->GBAT[1] = -1;
2689 int32_t RDXI, RDYI; 3522 if (pGRD->GBTEMPLATE == 0) {
2690 FX_DWORD BMSIZE; 3523 pGRD->GBAT[2] = -3;
2691 FX_DWORD stride; 3524 pGRD->GBAT[3] = -1;
2692 CJBig2_Image **SBSYMS; 3525 pGRD->GBAT[4] = 2;
2693 CJBig2_HuffmanTable *SBHUFFFS, *SBHUFFDS, *SBHUFFDT, *SBHUFFRDW, *SBHUFFRDH, *SBHUFFRDX, *SBHUFFRDY, 3526 pGRD->GBAT[5] = -2;
2694 *SBHUFFRSIZE, *pTable; 3527 pGRD->GBAT[6] = -2;
2695 CJBig2_HuffmanDecoder *pHuffmanDecoder; 3528 pGRD->GBAT[7] = -2;
2696 CJBig2_GRRDProc *pGRRD; 3529 }
2697 CJBig2_ArithDecoder *pArithDecoder; 3530 FXCODEC_STATUS status =
2698 CJBig2_GRDProc *pGRD; 3531 pGRD->Start_decode_Arith(&GSPLANES[GSBPP - 1], pArithDecoder, gbContext);
2699 CJBig2_SymbolDict *pDict; 3532 while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
2700 JBIG2_ALLOC(pHuffmanDecoder, CJBig2_HuffmanDecoder(pStream)); 3533 pGRD->Continue_decode(pPause);
2701 SDNEWSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(SDNUMNEWSYMS, sizeof(CJ Big2_Image*)); 3534 }
2702 FXSYS_memset(SDNEWSYMS, 0 , SDNUMNEWSYMS * sizeof(CJBig2_Image*)); 3535 if (GSPLANES[GSBPP - 1] == NULL) {
2703 SDNEWSYMWIDTHS = NULL; 3536 goto failed;
2704 BHC = NULL; 3537 }
2705 if(SDREFAGG == 0) { 3538 J = GSBPP - 2;
2706 SDNEWSYMWIDTHS = (FX_DWORD *)m_pModule->JBig2_Malloc2(SDNUMNEWSYMS, size of(FX_DWORD)); 3539 while (J >= 0) {
2707 FXSYS_memset(SDNEWSYMWIDTHS, 0 , SDNUMNEWSYMS * sizeof(FX_DWORD)); 3540 FXCODEC_STATUS status =
2708 } 3541 pGRD->Start_decode_Arith(&GSPLANES[J], pArithDecoder, gbContext);
2709 HCHEIGHT = 0; 3542 while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
2710 NSYMSDECODED = 0; 3543 pGRD->Continue_decode(pPause);
2711 BS = NULL; 3544 }
2712 while(NSYMSDECODED < SDNUMNEWSYMS) { 3545 if (GSPLANES[J] == NULL) {
2713 if(pHuffmanDecoder->decodeAValue(SDHUFFDH, &HCDH) != 0) { 3546 for (K = GSBPP - 1; K > J; K--) {
2714 m_pModule->JBig2_Error("symbol dictionary decoding procedure (huffma n): too short."); 3547 delete GSPLANES[K];
2715 goto failed; 3548 goto failed;
2716 } 3549 }
2717 HCHEIGHT = HCHEIGHT + HCDH; 3550 }
2718 if ((int)HCHEIGHT < 0 || (int)HCHEIGHT > JBIG2_MAX_IMAGE_SIZE) { 3551 GSPLANES[J]->composeFrom(0, 0, GSPLANES[J + 1], JBIG2_COMPOSE_XOR);
2719 m_pModule->JBig2_Error("symbol dictionary decoding procedure (huffma n): invalid HCHEIGHT value."); 3552 J = J - 1;
2720 goto failed; 3553 }
2721 } 3554 for (y = 0; y < GSH; y++) {
2722 SYMWIDTH = 0; 3555 for (x = 0; x < GSW; x++) {
2723 TOTWIDTH = 0; 3556 for (J = 0; J < GSBPP; J++) {
2724 HCFIRSTSYM = NSYMSDECODED; 3557 GSVALS[y * GSW + x] |= GSPLANES[J]->getPixel(x, y) << J;
2725 for(;;) { 3558 }
2726 nVal = pHuffmanDecoder->decodeAValue(SDHUFFDW, &DW); 3559 }
2727 if(nVal == JBIG2_OOB) { 3560 }
2728 break; 3561 for (J = 0; J < GSBPP; J++) {
2729 } else if(nVal != 0) { 3562 delete GSPLANES[J];
2730 m_pModule->JBig2_Error("symbol dictionary decoding procedure (hu ffman): too short."); 3563 }
2731 goto failed; 3564 m_pModule->JBig2_Free(GSPLANES);
2732 } else { 3565 delete pGRD;
2733 if (NSYMSDECODED >= SDNUMNEWSYMS) { 3566 return GSVALS;
2734 m_pModule->JBig2_Error("symbol dictionary decoding procedure (huffman): NSYMSDECODED >= SDNUMNEWSYMS.");
2735 goto failed;
2736 }
2737 SYMWIDTH = SYMWIDTH + DW;
2738 if ((int)SYMWIDTH < 0 || (int)SYMWIDTH > JBIG2_MAX_IMAGE_SIZE) {
2739 m_pModule->JBig2_Error("symbol dictionary decoding procedure (huffman): invalid SYMWIDTH value.");
2740 goto failed;
2741 } else if (HCHEIGHT == 0 || SYMWIDTH == 0) {
2742 TOTWIDTH = TOTWIDTH + SYMWIDTH;
2743 SDNEWSYMS[NSYMSDECODED] = NULL;
2744 NSYMSDECODED = NSYMSDECODED + 1;
2745 continue;
2746 }
2747 TOTWIDTH = TOTWIDTH + SYMWIDTH;
2748 }
2749 if(SDREFAGG == 1) {
2750 if(pHuffmanDecoder->decodeAValue(SDHUFFAGGINST, (int*)&REFAGGNIN ST) != 0) {
2751 m_pModule->JBig2_Error("symbol dictionary decoding procedure (huffman): too short.");
2752 goto failed;
2753 }
2754 BS = NULL;
2755 if(REFAGGNINST > 1) {
2756 CJBig2_TRDProc *pDecoder;
2757 JBIG2_ALLOC(pDecoder, CJBig2_TRDProc());
2758 pDecoder->SBHUFF = SDHUFF;
2759 pDecoder->SBREFINE = 1;
2760 pDecoder->SBW = SYMWIDTH;
2761 pDecoder->SBH = HCHEIGHT;
2762 pDecoder->SBNUMINSTANCES = REFAGGNINST;
2763 pDecoder->SBSTRIPS = 1;
2764 pDecoder->SBNUMSYMS = SDNUMINSYMS + NSYMSDECODED;
2765 SBNUMSYMS = pDecoder->SBNUMSYMS;
2766 SBSYMCODES = (JBig2HuffmanCode*)m_pModule->JBig2_Malloc2(SBN UMSYMS, sizeof(JBig2HuffmanCode));
2767 nTmp = 1;
2768 while((FX_DWORD)(1 << nTmp) < SBNUMSYMS) {
2769 nTmp ++;
2770 }
2771 for(I = 0; I < SBNUMSYMS; I++) {
2772 SBSYMCODES[I].codelen = nTmp;
2773 SBSYMCODES[I].code = I;
2774 }
2775 pDecoder->SBSYMCODES = SBSYMCODES;
2776 SBSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(SBNUMSYMS, sizeof(CJBig2_Image*));
2777 JBIG2_memcpy(SBSYMS, SDINSYMS, SDNUMINSYMS * sizeof(CJBig2_I mage*));
2778 JBIG2_memcpy(SBSYMS + SDNUMINSYMS, SDNEWSYMS, NSYMSDECODED * sizeof(CJBig2_Image*));
2779 pDecoder->SBSYMS = SBSYMS;
2780 pDecoder->SBDEFPIXEL = 0;
2781 pDecoder->SBCOMBOP = JBIG2_COMPOSE_OR;
2782 pDecoder->TRANSPOSED = 0;
2783 pDecoder->REFCORNER = JBIG2_CORNER_TOPLEFT;
2784 pDecoder->SBDSOFFSET = 0;
2785 JBIG2_ALLOC(SBHUFFFS, CJBig2_HuffmanTable(HuffmanTable_B6,
2786 sizeof(HuffmanTable_B6) / sizeof(JBig2TableLine) , HuffmanTable_HTOOB_B6));
2787 JBIG2_ALLOC(SBHUFFDS, CJBig2_HuffmanTable(HuffmanTable_B8,
2788 sizeof(HuffmanTable_B8) / sizeof(JBig2TableLine) , HuffmanTable_HTOOB_B8));
2789 JBIG2_ALLOC(SBHUFFDT, CJBig2_HuffmanTable(HuffmanTable_B11,
2790 sizeof(HuffmanTable_B11) / sizeof(JBig2TableLine ), HuffmanTable_HTOOB_B11));
2791 JBIG2_ALLOC(SBHUFFRDW, CJBig2_HuffmanTable(HuffmanTable_B15,
2792 sizeof(HuffmanTable_B15) / sizeof(JBig2TableLine ), HuffmanTable_HTOOB_B15));
2793 JBIG2_ALLOC(SBHUFFRDH, CJBig2_HuffmanTable(HuffmanTable_B15,
2794 sizeof(HuffmanTable_B15) / sizeof(JBig2TableLine ), HuffmanTable_HTOOB_B15));
2795 JBIG2_ALLOC(SBHUFFRDX, CJBig2_HuffmanTable(HuffmanTable_B15,
2796 sizeof(HuffmanTable_B15) / sizeof(JBig2TableLine ), HuffmanTable_HTOOB_B15));
2797 JBIG2_ALLOC(SBHUFFRDY, CJBig2_HuffmanTable(HuffmanTable_B15,
2798 sizeof(HuffmanTable_B15) / sizeof(JBig2TableLine ), HuffmanTable_HTOOB_B15));
2799 JBIG2_ALLOC(SBHUFFRSIZE, CJBig2_HuffmanTable(HuffmanTable_B1 ,
2800 sizeof(HuffmanTable_B1) / sizeof(JBig2TableLine) , HuffmanTable_HTOOB_B1));
2801 pDecoder->SBHUFFFS = SBHUFFFS;
2802 pDecoder->SBHUFFDS = SBHUFFDS;
2803 pDecoder->SBHUFFDT = SBHUFFDT;
2804 pDecoder->SBHUFFRDW = SBHUFFRDW;
2805 pDecoder->SBHUFFRDH = SBHUFFRDH;
2806 pDecoder->SBHUFFRDX = SBHUFFRDX;
2807 pDecoder->SBHUFFRDY = SBHUFFRDY;
2808 pDecoder->SBHUFFRSIZE = SBHUFFRSIZE;
2809 pDecoder->SBRTEMPLATE = SDRTEMPLATE;
2810 pDecoder->SBRAT[0] = SDRAT[0];
2811 pDecoder->SBRAT[1] = SDRAT[1];
2812 pDecoder->SBRAT[2] = SDRAT[2];
2813 pDecoder->SBRAT[3] = SDRAT[3];
2814 BS = pDecoder->decode_Huffman(pStream, grContext);
2815 if(BS == NULL) {
2816 m_pModule->JBig2_Free(SBSYMCODES);
2817 m_pModule->JBig2_Free(SBSYMS);
2818 delete SBHUFFFS;
2819 delete SBHUFFDS;
2820 delete SBHUFFDT;
2821 delete SBHUFFRDW;
2822 delete SBHUFFRDH;
2823 delete SBHUFFRDX;
2824 delete SBHUFFRDY;
2825 delete SBHUFFRSIZE;
2826 delete pDecoder;
2827 goto failed;
2828 }
2829 m_pModule->JBig2_Free(SBSYMCODES);
2830 m_pModule->JBig2_Free(SBSYMS);
2831 delete SBHUFFFS;
2832 delete SBHUFFDS;
2833 delete SBHUFFDT;
2834 delete SBHUFFRDW;
2835 delete SBHUFFRDH;
2836 delete SBHUFFRDX;
2837 delete SBHUFFRDY;
2838 delete SBHUFFRSIZE;
2839 delete pDecoder;
2840 } else if(REFAGGNINST == 1) {
2841 SBNUMSYMS = SDNUMINSYMS + SDNUMNEWSYMS;
2842 nTmp = 1;
2843 while((FX_DWORD)(1 << nTmp) < SBNUMSYMS) {
2844 nTmp ++;
2845 }
2846 SBSYMCODELEN = (uint8_t)nTmp;
2847 SBSYMCODES = (JBig2HuffmanCode*)m_pModule->JBig2_Malloc2(SBN UMSYMS, sizeof(JBig2HuffmanCode));
2848 for(I = 0; I < SBNUMSYMS; I++) {
2849 SBSYMCODES[I].codelen = SBSYMCODELEN;
2850 SBSYMCODES[I].code = I;
2851 }
2852 nVal = 0;
2853 nBits = 0;
2854 for(;;) {
2855 if(pStream->read1Bit(&nTmp) != 0) {
2856 m_pModule->JBig2_Free(SBSYMCODES);
2857 m_pModule->JBig2_Error("symbol dictionary decoding p rocedure (huffman): too short.");
2858 goto failed;
2859 }
2860 nVal = (nVal << 1) | nTmp;
2861 for(IDI = 0; IDI < SBNUMSYMS; IDI++) {
2862 if((nVal == SBSYMCODES[IDI].code)
2863 && (nBits == SBSYMCODES[IDI].codelen)) {
2864 break;
2865 }
2866 }
2867 if(IDI < SBNUMSYMS) {
2868 break;
2869 }
2870 }
2871 m_pModule->JBig2_Free(SBSYMCODES);
2872 JBIG2_ALLOC(SBHUFFRDX, CJBig2_HuffmanTable(HuffmanTable_B15,
2873 sizeof(HuffmanTable_B15) / sizeof(JBig2TableLine ), HuffmanTable_HTOOB_B15));
2874 JBIG2_ALLOC(SBHUFFRSIZE, CJBig2_HuffmanTable(HuffmanTable_B1 ,
2875 sizeof(HuffmanTable_B1) / sizeof(JBig2TableLine) , HuffmanTable_HTOOB_B1));
2876 if((pHuffmanDecoder->decodeAValue(SBHUFFRDX, &RDXI) != 0)
2877 || (pHuffmanDecoder->decodeAValue(SBHUFFRDX, &RDYI) != 0)
2878 || (pHuffmanDecoder->decodeAValue(SBHUFFRSIZE, &nVal ) != 0)) {
2879 delete SBHUFFRDX;
2880 delete SBHUFFRSIZE;
2881 m_pModule->JBig2_Error("symbol dictionary decoding proce dure (huffman): too short.");
2882 goto failed;
2883 }
2884 delete SBHUFFRDX;
2885 delete SBHUFFRSIZE;
2886 pStream->alignByte();
2887 nTmp = pStream->getOffset();
2888 SBSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(SBNUMSYMS, sizeof(CJBig2_Image*));
2889 JBIG2_memcpy(SBSYMS, SDINSYMS, SDNUMINSYMS * sizeof(CJBig2_I mage*));
2890 JBIG2_memcpy(SBSYMS + SDNUMINSYMS, SDNEWSYMS, NSYMSDECODED * sizeof(CJBig2_Image*));
2891 JBIG2_ALLOC(pGRRD, CJBig2_GRRDProc());
2892 pGRRD->GRW = SYMWIDTH;
2893 pGRRD->GRH = HCHEIGHT;
2894 pGRRD->GRTEMPLATE = SDRTEMPLATE;
2895 pGRRD->GRREFERENCE = SBSYMS[IDI];
2896 pGRRD->GRREFERENCEDX = RDXI;
2897 pGRRD->GRREFERENCEDY = RDYI;
2898 pGRRD->TPGRON = 0;
2899 pGRRD->GRAT[0] = SDRAT[0];
2900 pGRRD->GRAT[1] = SDRAT[1];
2901 pGRRD->GRAT[2] = SDRAT[2];
2902 pGRRD->GRAT[3] = SDRAT[3];
2903 JBIG2_ALLOC(pArithDecoder, CJBig2_ArithDecoder(pStream));
2904 BS = pGRRD->decode(pArithDecoder, grContext);
2905 if(BS == NULL) {
2906 m_pModule->JBig2_Free(SBSYMS);
2907 delete pGRRD;
2908 delete pArithDecoder;
2909 goto failed;
2910 }
2911 pStream->alignByte();
2912 pStream->offset(2);
2913 if((FX_DWORD)nVal != (pStream->getOffset() - nTmp)) {
2914 delete BS;
2915 m_pModule->JBig2_Free(SBSYMS);
2916 delete pGRRD;
2917 delete pArithDecoder;
2918 m_pModule->JBig2_Error("symbol dictionary decoding proce dure (huffman):"
2919 "bytes processed by generic refin ement region decoding procedure doesn't equal SBHUFFRSIZE.");
2920 goto failed;
2921 }
2922 m_pModule->JBig2_Free(SBSYMS);
2923 delete pGRRD;
2924 delete pArithDecoder;
2925 }
2926 SDNEWSYMS[NSYMSDECODED] = BS;
2927 }
2928 if(SDREFAGG == 0) {
2929 SDNEWSYMWIDTHS[NSYMSDECODED] = SYMWIDTH;
2930 }
2931 NSYMSDECODED = NSYMSDECODED + 1;
2932 }
2933 if(SDREFAGG == 0) {
2934 if(pHuffmanDecoder->decodeAValue(SDHUFFBMSIZE, (int32_t*)&BMSIZE) != 0) {
2935 m_pModule->JBig2_Error("symbol dictionary decoding procedure (hu ffman): too short.");
2936 goto failed;
2937 }
2938 pStream->alignByte();
2939 if(BMSIZE == 0) {
2940 stride = (TOTWIDTH + 7) >> 3;
2941 if(pStream->getByteLeft() >= stride * HCHEIGHT) {
2942 JBIG2_ALLOC(BHC, CJBig2_Image(TOTWIDTH, HCHEIGHT));
2943 for(I = 0; I < HCHEIGHT; I ++) {
2944 JBIG2_memcpy(BHC->m_pData + I * BHC->m_nStride, pStream- >getPointer(), stride);
2945 pStream->offset(stride);
2946 }
2947 } else {
2948 m_pModule->JBig2_Error("symbol dictionary decoding procedure (huffman): too short.");
2949 goto failed;
2950 }
2951 } else {
2952 JBIG2_ALLOC(pGRD, CJBig2_GRDProc());
2953 pGRD->MMR = 1;
2954 pGRD->GBW = TOTWIDTH;
2955 pGRD->GBH = HCHEIGHT;
2956 FXCODEC_STATUS status = pGRD->Start_decode_MMR(&BHC, pStream);
2957 while(status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
2958 pGRD->Continue_decode(pPause);
2959 }
2960 delete pGRD;
2961 pStream->alignByte();
2962 }
2963 nTmp = 0;
2964 if (!BHC) {
2965 continue;
2966 }
2967 for(I = HCFIRSTSYM; I < NSYMSDECODED; I++) {
2968 SDNEWSYMS[I] = BHC->subImage(nTmp, 0, SDNEWSYMWIDTHS[I], HCHEIGH T);
2969 nTmp += SDNEWSYMWIDTHS[I];
2970 }
2971 delete BHC;
2972 BHC = NULL;
2973 }
2974 }
2975 EXINDEX = 0;
2976 CUREXFLAG = 0;
2977 JBIG2_ALLOC(pTable, CJBig2_HuffmanTable(HuffmanTable_B1,
2978 sizeof(HuffmanTable_B1) / sizeof(JBi g2TableLine), HuffmanTable_HTOOB_B1));
2979 EXFLAGS = (FX_BOOL*)m_pModule->JBig2_Malloc2(sizeof(FX_BOOL), (SDNUMINSYMS + SDNUMNEWSYMS));
2980 while(EXINDEX < SDNUMINSYMS + SDNUMNEWSYMS) {
2981 if(pHuffmanDecoder->decodeAValue(pTable, (int*)&EXRUNLENGTH) != 0) {
2982 delete pTable;
2983 m_pModule->JBig2_Free(EXFLAGS);
2984 m_pModule->JBig2_Error("symbol dictionary decoding procedure (huffma n): too short.");
2985 goto failed;
2986 }
2987 if (EXINDEX + EXRUNLENGTH > SDNUMINSYMS + SDNUMNEWSYMS) {
2988 delete pTable;
2989 m_pModule->JBig2_Free(EXFLAGS);
2990 m_pModule->JBig2_Error("symbol dictionary decoding procedure (arith) : Invalid EXRUNLENGTH value.");
2991 goto failed;
2992 }
2993 if(EXRUNLENGTH != 0) {
2994 for(I = EXINDEX; I < EXINDEX + EXRUNLENGTH; I++) {
2995 EXFLAGS[I] = CUREXFLAG;
2996 }
2997 }
2998 EXINDEX = EXINDEX + EXRUNLENGTH;
2999 CUREXFLAG = !CUREXFLAG;
3000 }
3001 delete pTable;
3002 JBIG2_ALLOC(pDict, CJBig2_SymbolDict());
3003 pDict->SDNUMEXSYMS = SDNUMEXSYMS;
3004 pDict->SDEXSYMS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(sizeof(CJBig2_Ima ge*), SDNUMEXSYMS);
3005 I = J = 0;
3006 for(I = 0; I < SDNUMINSYMS + SDNUMNEWSYMS; I++) {
3007 if(EXFLAGS[I] && J < SDNUMEXSYMS) {
3008 if(I < SDNUMINSYMS) {
3009 JBIG2_ALLOC(pDict->SDEXSYMS[J], CJBig2_Image(*SDINSYMS[I]));
3010 } else {
3011 pDict->SDEXSYMS[J] = SDNEWSYMS[I - SDNUMINSYMS];
3012 }
3013 J = J + 1;
3014 } else if (!EXFLAGS[I] && I >= SDNUMINSYMS) {
3015 delete SDNEWSYMS[I - SDNUMINSYMS];
3016 }
3017 }
3018 if (J < SDNUMEXSYMS) {
3019 pDict->SDNUMEXSYMS = J;
3020 }
3021 m_pModule->JBig2_Free(EXFLAGS);
3022 m_pModule->JBig2_Free(SDNEWSYMS);
3023 if(SDREFAGG == 0) {
3024 m_pModule->JBig2_Free(SDNEWSYMWIDTHS);
3025 }
3026 delete pHuffmanDecoder;
3027 return pDict;
3028 failed: 3567 failed:
3029 for(I = 0; I < NSYMSDECODED; I++) { 3568 m_pModule->JBig2_Free(GSPLANES);
3030 delete SDNEWSYMS[I]; 3569 delete pGRD;
3031 } 3570 m_pModule->JBig2_Free(GSVALS);
3032 m_pModule->JBig2_Free(SDNEWSYMS); 3571 return NULL;
3033 if(SDREFAGG == 0) { 3572 }
3034 m_pModule->JBig2_Free(SDNEWSYMWIDTHS); 3573 FX_DWORD* CJBig2_GSIDProc::decode_MMR(CJBig2_BitStream* pStream,
3035 } 3574 IFX_Pause* pPause) {
3036 delete pHuffmanDecoder; 3575 CJBig2_Image** GSPLANES;
3576 int32_t J, K;
3577 FX_DWORD x, y;
3578 FX_DWORD* GSVALS;
3579 CJBig2_GRDProc* pGRD;
3580 GSPLANES =
3581 (CJBig2_Image**)m_pModule->JBig2_Malloc2(sizeof(CJBig2_Image*), GSBPP);
3582 if (!GSPLANES) {
3037 return NULL; 3583 return NULL;
3038 } 3584 }
3039 CJBig2_Image *CJBig2_HTRDProc::decode_Arith(CJBig2_ArithDecoder *pArithDecoder, 3585 GSVALS = (FX_DWORD*)m_pModule->JBig2_Malloc3(sizeof(FX_DWORD), GSW, GSH);
3040 JBig2ArithCtx *gbContext, IFX_Pause* pPause) 3586 if (!GSVALS) {
3041 { 3587 if (GSPLANES) {
3042 FX_DWORD ng, mg; 3588 m_pModule->JBig2_Free(GSPLANES);
3043 int32_t x, y; 3589 }
3044 CJBig2_Image *HSKIP; 3590 return NULL;
3045 FX_DWORD HBPP; 3591 }
3046 FX_DWORD *GI; 3592 JBIG2_memset(GSPLANES, 0, sizeof(CJBig2_Image*) * GSBPP);
3047 CJBig2_Image *HTREG; 3593 JBIG2_memset(GSVALS, 0, sizeof(FX_DWORD) * GSW * GSH);
3048 CJBig2_GSIDProc *pGID; 3594 JBIG2_ALLOC(pGRD, CJBig2_GRDProc());
3049 JBIG2_ALLOC(HTREG, CJBig2_Image(HBW, HBH)); 3595 pGRD->MMR = GSMMR;
3050 HTREG->fill(HDEFPIXEL); 3596 pGRD->GBW = GSW;
3051 HSKIP = NULL; 3597 pGRD->GBH = GSH;
3052 if(HENABLESKIP == 1) { 3598 FXCODEC_STATUS status = pGRD->Start_decode_MMR(&GSPLANES[GSBPP - 1], pStream);
3053 JBIG2_ALLOC(HSKIP, CJBig2_Image(HGW, HGH)); 3599 while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
3054 for(mg = 0; mg < HGH; mg++) { 3600 pGRD->Continue_decode(pPause);
3055 for(ng = 0; ng < HGW; ng++) { 3601 }
3056 x = (HGX + mg * HRY + ng * HRX) >> 8; 3602 if (GSPLANES[GSBPP - 1] == NULL) {
3057 y = (HGY + mg * HRX - ng * HRY) >> 8; 3603 goto failed;
3058 if((x + HPW <= 0) | (x >= (int32_t)HBW) 3604 }
3059 | (y + HPH <= 0) | (y >= (int32_t)HPH)) { 3605 pStream->alignByte();
3060 HSKIP->setPixel(ng, mg, 1); 3606 pStream->offset(3);
3061 } else { 3607 J = GSBPP - 2;
3062 HSKIP->setPixel(ng, mg, 0); 3608 while (J >= 0) {
3063 } 3609 FXCODEC_STATUS status = pGRD->Start_decode_MMR(&GSPLANES[J], pStream);
3064 } 3610 while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
3065 } 3611 pGRD->Continue_decode(pPause);
3066 } 3612 }
3067 HBPP = 1; 3613 if (GSPLANES[J] == NULL) {
3068 while((FX_DWORD)(1 << HBPP) < HNUMPATS) { 3614 for (K = GSBPP - 1; K > J; K--) {
3069 HBPP ++; 3615 delete GSPLANES[K];
3070 }
3071 JBIG2_ALLOC(pGID, CJBig2_GSIDProc());
3072 pGID->GSMMR = HMMR;
3073 pGID->GSW = HGW;
3074 pGID->GSH = HGH;
3075 pGID->GSBPP = (uint8_t)HBPP;
3076 pGID->GSUSESKIP = HENABLESKIP;
3077 pGID->GSKIP = HSKIP;
3078 pGID->GSTEMPLATE = HTEMPLATE;
3079 GI = pGID->decode_Arith(pArithDecoder, gbContext, pPause);
3080 if(GI == NULL) {
3081 goto failed; 3616 goto failed;
3082 } 3617 }
3083 for(mg = 0; mg < HGH; mg++) {
3084 for(ng = 0; ng < HGW; ng++) {
3085 x = (HGX + mg * HRY + ng * HRX) >> 8;
3086 y = (HGY + mg * HRX - ng * HRY) >> 8;
3087 FX_DWORD pat_index = GI[mg * HGW + ng];
3088 if (pat_index >= HNUMPATS) {
3089 pat_index = HNUMPATS - 1;
3090 }
3091 HTREG->composeFrom(x, y, HPATS[pat_index], HCOMBOP);
3092 }
3093 }
3094 m_pModule->JBig2_Free(GI);
3095 delete HSKIP;
3096 delete pGID;
3097 return HTREG;
3098 failed:
3099 delete HSKIP;
3100 delete pGID;
3101 delete HTREG;
3102 return NULL;
3103 }
3104 CJBig2_Image *CJBig2_HTRDProc::decode_MMR(CJBig2_BitStream *pStream, IFX_Pause* pPause)
3105 {
3106 FX_DWORD ng, mg;
3107 int32_t x, y;
3108 FX_DWORD HBPP;
3109 FX_DWORD *GI;
3110 CJBig2_Image *HTREG;
3111 CJBig2_GSIDProc *pGID;
3112 JBIG2_ALLOC(HTREG, CJBig2_Image(HBW, HBH));
3113 HTREG->fill(HDEFPIXEL);
3114 HBPP = 1;
3115 while((FX_DWORD)(1 << HBPP) < HNUMPATS) {
3116 HBPP ++;
3117 }
3118 JBIG2_ALLOC(pGID, CJBig2_GSIDProc());
3119 pGID->GSMMR = HMMR;
3120 pGID->GSW = HGW;
3121 pGID->GSH = HGH;
3122 pGID->GSBPP = (uint8_t)HBPP;
3123 pGID->GSUSESKIP = 0;
3124 GI = pGID->decode_MMR(pStream, pPause);
3125 if(GI == NULL) {
3126 goto failed;
3127 }
3128 for(mg = 0; mg < HGH; mg++) {
3129 for(ng = 0; ng < HGW; ng++) {
3130 x = (HGX + mg * HRY + ng * HRX) >> 8;
3131 y = (HGY + mg * HRX - ng * HRY) >> 8;
3132 FX_DWORD pat_index = GI[mg * HGW + ng];
3133 if (pat_index >= HNUMPATS) {
3134 pat_index = HNUMPATS - 1;
3135 }
3136 HTREG->composeFrom(x, y, HPATS[pat_index], HCOMBOP);
3137 }
3138 }
3139 m_pModule->JBig2_Free(GI);
3140 delete pGID;
3141 return HTREG;
3142 failed:
3143 delete pGID;
3144 delete HTREG;
3145 return NULL;
3146 }
3147 CJBig2_PatternDict *CJBig2_PDDProc::decode_Arith(CJBig2_ArithDecoder *pArithDeco der,
3148 JBig2ArithCtx *gbContext, IFX_Pause* pPause)
3149 {
3150 FX_DWORD GRAY;
3151 CJBig2_Image *BHDC = NULL;
3152 CJBig2_PatternDict *pDict;
3153 CJBig2_GRDProc *pGRD;
3154 JBIG2_ALLOC(pDict, CJBig2_PatternDict());
3155 pDict->NUMPATS = GRAYMAX + 1;
3156 pDict->HDPATS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(sizeof(CJBig2_Image *), pDict->NUMPATS);
3157 JBIG2_memset(pDict->HDPATS, 0, sizeof(CJBig2_Image*)*pDict->NUMPATS);
3158 JBIG2_ALLOC(pGRD, CJBig2_GRDProc());
3159 pGRD->MMR = HDMMR;
3160 pGRD->GBW = (GRAYMAX + 1) * HDPW;
3161 pGRD->GBH = HDPH;
3162 pGRD->GBTEMPLATE = HDTEMPLATE;
3163 pGRD->TPGDON = 0;
3164 pGRD->USESKIP = 0;
3165 pGRD->GBAT[0] = -(int32_t)HDPW;
3166 pGRD->GBAT[1] = 0;
3167 if(pGRD->GBTEMPLATE == 0) {
3168 pGRD->GBAT[2] = -3;
3169 pGRD->GBAT[3] = -1;
3170 pGRD->GBAT[4] = 2;
3171 pGRD->GBAT[5] = -2;
3172 pGRD->GBAT[6] = -2;
3173 pGRD->GBAT[7] = -2;
3174 }
3175 FXCODEC_STATUS status = pGRD->Start_decode_Arith(&BHDC, pArithDecoder, gbCon text);
3176 while(status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
3177 pGRD->Continue_decode(pPause);
3178 }
3179 if(BHDC == NULL) {
3180 delete pGRD;
3181 goto failed;
3182 }
3183 delete pGRD;
3184 GRAY = 0;
3185 while(GRAY <= GRAYMAX) {
3186 pDict->HDPATS[GRAY] = BHDC->subImage(HDPW * GRAY, 0, HDPW, HDPH);
3187 GRAY = GRAY + 1;
3188 }
3189 delete BHDC;
3190 return pDict;
3191 failed:
3192 delete pDict;
3193 return NULL;
3194 }
3195
3196 CJBig2_PatternDict *CJBig2_PDDProc::decode_MMR(CJBig2_BitStream *pStream, IFX_Pa use* pPause)
3197 {
3198 FX_DWORD GRAY;
3199 CJBig2_Image *BHDC = NULL;
3200 CJBig2_PatternDict *pDict;
3201 CJBig2_GRDProc *pGRD;
3202 JBIG2_ALLOC(pDict, CJBig2_PatternDict());
3203 pDict->NUMPATS = GRAYMAX + 1;
3204 pDict->HDPATS = (CJBig2_Image**)m_pModule->JBig2_Malloc2(sizeof(CJBig2_Image *), pDict->NUMPATS);
3205 JBIG2_memset(pDict->HDPATS, 0, sizeof(CJBig2_Image*)*pDict->NUMPATS);
3206 JBIG2_ALLOC(pGRD, CJBig2_GRDProc());
3207 pGRD->MMR = HDMMR;
3208 pGRD->GBW = (GRAYMAX + 1) * HDPW;
3209 pGRD->GBH = HDPH;
3210 FXCODEC_STATUS status = pGRD->Start_decode_MMR(&BHDC, pStream);
3211 while(status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
3212 pGRD->Continue_decode(pPause);
3213 }
3214 if(BHDC == NULL) {
3215 delete pGRD;
3216 goto failed;
3217 }
3218 delete pGRD;
3219 GRAY = 0;
3220 while(GRAY <= GRAYMAX) {
3221 pDict->HDPATS[GRAY] = BHDC->subImage(HDPW * GRAY, 0, HDPW, HDPH);
3222 GRAY = GRAY + 1;
3223 }
3224 delete BHDC;
3225 return pDict;
3226 failed:
3227 delete pDict;
3228 return NULL;
3229 }
3230 FX_DWORD *CJBig2_GSIDProc::decode_Arith(CJBig2_ArithDecoder *pArithDecoder,
3231 JBig2ArithCtx *gbContext, IFX_Pause* pPa use)
3232 {
3233 CJBig2_Image **GSPLANES;
3234 int32_t J, K;
3235 FX_DWORD x, y;
3236 FX_DWORD *GSVALS;
3237 CJBig2_GRDProc *pGRD;
3238 GSPLANES = (CJBig2_Image **)m_pModule->JBig2_Malloc2(sizeof(CJBig2_Image*), GSBPP);
3239 if (!GSPLANES) {
3240 return NULL;
3241 }
3242 GSVALS = (FX_DWORD*)m_pModule->JBig2_Malloc3(sizeof(FX_DWORD), GSW, GSH);
3243 if (!GSVALS) {
3244 m_pModule->JBig2_Free(GSPLANES);
3245 return NULL;
3246 }
3247 JBIG2_memset(GSPLANES, 0, sizeof(CJBig2_Image*)*GSBPP);
3248 JBIG2_memset(GSVALS, 0, sizeof(FX_DWORD)*GSW * GSH);
3249 JBIG2_ALLOC(pGRD, CJBig2_GRDProc());
3250 pGRD->MMR = GSMMR;
3251 pGRD->GBW = GSW;
3252 pGRD->GBH = GSH;
3253 pGRD->GBTEMPLATE = GSTEMPLATE;
3254 pGRD->TPGDON = 0;
3255 pGRD->USESKIP = GSUSESKIP;
3256 pGRD->SKIP = GSKIP;
3257 if(GSTEMPLATE <= 1) {
3258 pGRD->GBAT[0] = 3;
3259 } else {
3260 pGRD->GBAT[0] = 2;
3261 }
3262 pGRD->GBAT[1] = -1;
3263 if(pGRD->GBTEMPLATE == 0) {
3264 pGRD->GBAT[2] = -3;
3265 pGRD->GBAT[3] = -1;
3266 pGRD->GBAT[4] = 2;
3267 pGRD->GBAT[5] = -2;
3268 pGRD->GBAT[6] = -2;
3269 pGRD->GBAT[7] = -2;
3270 }
3271 FXCODEC_STATUS status = pGRD->Start_decode_Arith(&GSPLANES[GSBPP - 1], pArit hDecoder, gbContext);
3272 while(status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
3273 pGRD->Continue_decode(pPause);
3274 }
3275 if(GSPLANES[GSBPP - 1] == NULL) {
3276 goto failed;
3277 }
3278 J = GSBPP - 2;
3279 while(J >= 0) {
3280 FXCODEC_STATUS status = pGRD->Start_decode_Arith(&GSPLANES[J], pArithDec oder, gbContext);
3281 while(status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
3282 pGRD->Continue_decode(pPause);
3283 }
3284 if(GSPLANES[J] == NULL) {
3285 for(K = GSBPP - 1; K > J; K--) {
3286 delete GSPLANES[K];
3287 goto failed;
3288 }
3289 }
3290 GSPLANES[J]->composeFrom(0, 0, GSPLANES[J + 1], JBIG2_COMPOSE_XOR);
3291 J = J - 1;
3292 }
3293 for(y = 0; y < GSH; y++) {
3294 for(x = 0; x < GSW; x++) {
3295 for(J = 0; J < GSBPP; J++) {
3296 GSVALS[y * GSW + x] |= GSPLANES[J]->getPixel(x, y) << J;
3297 }
3298 }
3299 }
3300 for(J = 0; J < GSBPP; J++) {
3301 delete GSPLANES[J];
3302 }
3303 m_pModule->JBig2_Free(GSPLANES);
3304 delete pGRD;
3305 return GSVALS;
3306 failed:
3307 m_pModule->JBig2_Free(GSPLANES);
3308 delete pGRD;
3309 m_pModule->JBig2_Free(GSVALS);
3310 return NULL;
3311 }
3312 FX_DWORD *CJBig2_GSIDProc::decode_MMR(CJBig2_BitStream *pStream, IFX_Pause* pPau se)
3313 {
3314 CJBig2_Image **GSPLANES;
3315 int32_t J, K;
3316 FX_DWORD x, y;
3317 FX_DWORD *GSVALS;
3318 CJBig2_GRDProc *pGRD;
3319 GSPLANES = (CJBig2_Image **)m_pModule->JBig2_Malloc2(sizeof(CJBig2_Image*), GSBPP);
3320 if (!GSPLANES) {
3321 return NULL;
3322 }
3323 GSVALS = (FX_DWORD*)m_pModule->JBig2_Malloc3(sizeof(FX_DWORD), GSW, GSH);
3324 if (!GSVALS) {
3325 if (GSPLANES) {
3326 m_pModule->JBig2_Free(GSPLANES);
3327 }
3328 return NULL;
3329 }
3330 JBIG2_memset(GSPLANES, 0, sizeof(CJBig2_Image*)*GSBPP);
3331 JBIG2_memset(GSVALS, 0, sizeof(FX_DWORD)*GSW * GSH);
3332 JBIG2_ALLOC(pGRD, CJBig2_GRDProc());
3333 pGRD->MMR = GSMMR;
3334 pGRD->GBW = GSW;
3335 pGRD->GBH = GSH;
3336 FXCODEC_STATUS status = pGRD->Start_decode_MMR(&GSPLANES[GSBPP - 1], pStream );
3337 while(status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
3338 pGRD->Continue_decode(pPause);
3339 }
3340 if(GSPLANES[GSBPP - 1] == NULL) {
3341 goto failed;
3342 } 3618 }
3343 pStream->alignByte(); 3619 pStream->alignByte();
3344 pStream->offset(3); 3620 pStream->offset(3);
3345 J = GSBPP - 2; 3621 GSPLANES[J]->composeFrom(0, 0, GSPLANES[J + 1], JBIG2_COMPOSE_XOR);
3346 while(J >= 0) { 3622 J = J - 1;
3347 FXCODEC_STATUS status = pGRD->Start_decode_MMR(&GSPLANES[J], pStream); 3623 }
3348 while(status == FXCODEC_STATUS_DECODE_TOBECONTINUE) { 3624 for (y = 0; y < GSH; y++) {
3349 pGRD->Continue_decode(pPause); 3625 for (x = 0; x < GSW; x++) {
3350 } 3626 for (J = 0; J < GSBPP; J++) {
3351 if(GSPLANES[J] == NULL) { 3627 GSVALS[y * GSW + x] |= GSPLANES[J]->getPixel(x, y) << J;
3352 for(K = GSBPP - 1; K > J; K--) { 3628 }
3353 delete GSPLANES[K]; 3629 }
3354 goto failed; 3630 }
3355 } 3631 for (J = 0; J < GSBPP; J++) {
3356 } 3632 delete GSPLANES[J];
3357 pStream->alignByte(); 3633 }
3358 pStream->offset(3); 3634 m_pModule->JBig2_Free(GSPLANES);
3359 GSPLANES[J]->composeFrom(0, 0, GSPLANES[J + 1], JBIG2_COMPOSE_XOR); 3635 delete pGRD;
3360 J = J - 1; 3636 return GSVALS;
3361 }
3362 for(y = 0; y < GSH; y++) {
3363 for(x = 0; x < GSW; x++) {
3364 for(J = 0; J < GSBPP; J++) {
3365 GSVALS[y * GSW + x] |= GSPLANES[J]->getPixel(x, y) << J;
3366 }
3367 }
3368 }
3369 for(J = 0; J < GSBPP; J++) {
3370 delete GSPLANES[J];
3371 }
3372 m_pModule->JBig2_Free(GSPLANES);
3373 delete pGRD;
3374 return GSVALS;
3375 failed: 3637 failed:
3376 m_pModule->JBig2_Free(GSPLANES); 3638 m_pModule->JBig2_Free(GSPLANES);
3377 delete pGRD; 3639 delete pGRD;
3378 m_pModule->JBig2_Free(GSVALS); 3640 m_pModule->JBig2_Free(GSVALS);
3379 return NULL; 3641 return NULL;
3380 } 3642 }
3381 FXCODEC_STATUS CJBig2_GRDProc::Start_decode_Arith(CJBig2_Image** pImage, CJBig2_ ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext, IFX_Pause* pPause) 3643 FXCODEC_STATUS CJBig2_GRDProc::Start_decode_Arith(
3382 { 3644 CJBig2_Image** pImage,
3383 if (GBW == 0 || GBH == 0) { 3645 CJBig2_ArithDecoder* pArithDecoder,
3384 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH; 3646 JBig2ArithCtx* gbContext,
3385 return FXCODEC_STATUS_DECODE_FINISH; 3647 IFX_Pause* pPause) {
3386 } 3648 if (GBW == 0 || GBH == 0) {
3387 m_ProssiveStatus = FXCODEC_STATUS_DECODE_READY;
3388 m_pPause = pPause;
3389 if(*pImage == NULL) {
3390 JBIG2_ALLOC((*pImage), CJBig2_Image(GBW, GBH));
3391 }
3392 if ((*pImage)->m_pData == NULL) {
3393 delete *pImage;
3394 *pImage = NULL;
3395 m_pModule->JBig2_Error("Generic region decoding procedure: Create Image Failed with width = %d, height = %d\n", GBW, GBH);
3396 m_ProssiveStatus = FXCODEC_STATUS_ERROR;
3397 return FXCODEC_STATUS_ERROR;
3398 }
3399 m_DecodeType = 1;
3400 m_pImage = pImage;
3401 (*m_pImage)->fill(0);
3402 m_pArithDecoder = pArithDecoder;
3403 m_gbContext = gbContext;
3404 LTP = 0;
3405 m_pLine = NULL;
3406 m_loopIndex = 0;
3407 return decode_Arith(pPause);
3408 }
3409 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith(IFX_Pause* pPause)
3410 {
3411 int iline = m_loopIndex;
3412 CJBig2_Image* pImage = *m_pImage;
3413 if(GBTEMPLATE == 0) {
3414 if((GBAT[0] == 3) && (GBAT[1] == (signed char) - 1)
3415 && (GBAT[2] == (signed char) - 3) && (GBAT[3] == (signed char) - 1)
3416 && (GBAT[4] == 2) && (GBAT[5] == (signed char) - 2)
3417 && (GBAT[6] == (signed char) - 2) && (GBAT[7] == (signed char) - 2)) {
3418 m_ProssiveStatus = decode_Arith_Template0_opt3(pImage, m_pArithDecod er, m_gbContext, pPause);
3419 } else {
3420 m_ProssiveStatus = decode_Arith_Template0_unopt(pImage, m_pArithDeco der, m_gbContext, pPause);
3421 }
3422 } else if(GBTEMPLATE == 1) {
3423 if((GBAT[0] == 3) && (GBAT[1] == (signed char) - 1)) {
3424 m_ProssiveStatus = decode_Arith_Template1_opt3(pImage, m_pArithDecod er, m_gbContext, pPause);
3425 } else {
3426 m_ProssiveStatus = decode_Arith_Template1_unopt(pImage, m_pArithDeco der, m_gbContext, pPause);
3427 }
3428 } else if(GBTEMPLATE == 2) {
3429 if((GBAT[0] == 2) && (GBAT[1] == (signed char) - 1)) {
3430 m_ProssiveStatus = decode_Arith_Template2_opt3(pImage, m_pArithDeco der, m_gbContext, pPause);
3431 } else {
3432 m_ProssiveStatus = decode_Arith_Template2_unopt(pImage, m_pArithDec oder, m_gbContext, pPause);
3433 }
3434 } else {
3435 if((GBAT[0] == 2) && (GBAT[1] == (signed char) - 1)) {
3436 m_ProssiveStatus = decode_Arith_Template3_opt3(pImage, m_pArithDecod er, m_gbContext, pPause);
3437 } else {
3438 m_ProssiveStatus = decode_Arith_Template3_unopt(pImage, m_pArithDeco der, m_gbContext, pPause);
3439 }
3440 }
3441 m_ReplaceRect.left = 0;
3442 m_ReplaceRect.right = pImage->m_nWidth;
3443 m_ReplaceRect.top = iline;
3444 m_ReplaceRect.bottom = m_loopIndex;
3445 if(m_ProssiveStatus == FXCODEC_STATUS_DECODE_FINISH) {
3446 m_loopIndex = 0;
3447 }
3448 return m_ProssiveStatus;
3449 }
3450 FXCODEC_STATUS CJBig2_GRDProc::Start_decode_Arith_V2(CJBig2_Image** pImage, CJBi g2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext, IFX_Pause* pPause)
3451 {
3452 if(GBW == 0 || GBH == 0) {
3453 * pImage = NULL;
3454 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
3455 return FXCODEC_STATUS_DECODE_FINISH;
3456 }
3457 if(*pImage == NULL) {
3458 JBIG2_ALLOC((*pImage), CJBig2_Image(GBW, GBH));
3459 }
3460 if ((*pImage)->m_pData == NULL) {
3461 delete *pImage;
3462 *pImage = NULL;
3463 m_pModule->JBig2_Error("Generic region decoding procedure: Create Image Failed with width = %d, height = %d\n", GBW, GBH);
3464 m_ProssiveStatus = FXCODEC_STATUS_ERROR;
3465 return FXCODEC_STATUS_ERROR;
3466 }
3467 m_ProssiveStatus = FXCODEC_STATUS_DECODE_READY;
3468 m_DecodeType = 2;
3469 m_pPause = pPause;
3470 m_pImage = pImage;
3471 (*m_pImage)->fill(0);
3472 LTP = 0;
3473 m_loopIndex = 0;
3474 m_pArithDecoder = pArithDecoder;
3475 m_gbContext = gbContext;
3476 return decode_Arith_V2(pPause);
3477 }
3478 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_V2(IFX_Pause* pPause)
3479 {
3480 FX_BOOL SLTP, bVal;
3481 FX_DWORD CONTEXT;
3482 CJBig2_Image *GBREG = *m_pImage;
3483 FX_DWORD line1, line2, line3;
3484 LTP = 0;
3485 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
3486 GBREG->fill(0);
3487 for(; m_loopIndex < GBH; m_loopIndex++) {
3488 if(TPGDON) {
3489 switch(GBTEMPLATE) {
3490 case 0:
3491 CONTEXT = 0x9b25;
3492 break;
3493 case 1:
3494 CONTEXT = 0x0795;
3495 break;
3496 case 2:
3497 CONTEXT = 0x00e5;
3498 break;
3499 case 3:
3500 CONTEXT = 0x0195;
3501 break;
3502 }
3503 SLTP = m_pArithDecoder->DECODE(&m_gbContext[CONTEXT]);
3504 LTP = LTP ^ SLTP;
3505 }
3506 if(LTP == 1) {
3507 GBREG->copyLine(m_loopIndex, m_loopIndex - 1);
3508 } else {
3509 switch(GBTEMPLATE) {
3510 case 0: {
3511 line1 = GBREG->getPixel(1, m_loopIndex - 2);
3512 line1 |= GBREG->getPixel(0, m_loopIndex - 2) << 1;
3513 line2 = GBREG->getPixel(2, m_loopIndex - 1);
3514 line2 |= GBREG->getPixel(1, m_loopIndex - 1) << 1;
3515 line2 |= GBREG->getPixel(0, m_loopIndex - 1) << 2;
3516 line3 = 0;
3517 for(FX_DWORD w = 0; w < GBW; w++) {
3518 if(USESKIP && SKIP->getPixel(w, m_loopIndex)) {
3519 bVal = 0;
3520 } else {
3521 CONTEXT = line3;
3522 CONTEXT |= GBREG->getPixel(w + GBAT[0], m_loopIn dex + GBAT[1]) << 4;
3523 CONTEXT |= line2 << 5;
3524 CONTEXT |= GBREG->getPixel(w + GBAT[2], m_loopIn dex + GBAT[3]) << 10;
3525 CONTEXT |= GBREG->getPixel(w + GBAT[4], m_loopIn dex + GBAT[5]) << 11;
3526 CONTEXT |= line1 << 12;
3527 CONTEXT |= GBREG->getPixel(w + GBAT[6], m_loopIn dex + GBAT[7]) << 15;
3528 bVal = m_pArithDecoder->DECODE(&m_gbContext[CONT EXT]);
3529 }
3530 if(bVal) {
3531 GBREG->setPixel(w, m_loopIndex, bVal);
3532 }
3533 line1 = ((line1 << 1) | GBREG->getPixel(w + 2, m_loo pIndex - 2)) & 0x07;
3534 line2 = ((line2 << 1) | GBREG->getPixel(w + 3, m_loo pIndex - 1)) & 0x1f;
3535 line3 = ((line3 << 1) | bVal) & 0x0f;
3536 }
3537 }
3538 break;
3539 case 1: {
3540 line1 = GBREG->getPixel(2, m_loopIndex - 2);
3541 line1 |= GBREG->getPixel(1, m_loopIndex - 2) << 1;
3542 line1 |= GBREG->getPixel(0, m_loopIndex - 2) << 2;
3543 line2 = GBREG->getPixel(2, m_loopIndex - 1);
3544 line2 |= GBREG->getPixel(1, m_loopIndex - 1) << 1;
3545 line2 |= GBREG->getPixel(0, m_loopIndex - 1) << 2;
3546 line3 = 0;
3547 for(FX_DWORD w = 0; w < GBW; w++) {
3548 if(USESKIP && SKIP->getPixel(w, m_loopIndex)) {
3549 bVal = 0;
3550 } else {
3551 CONTEXT = line3;
3552 CONTEXT |= GBREG->getPixel(w + GBAT[0], m_loopIn dex + GBAT[1]) << 3;
3553 CONTEXT |= line2 << 4;
3554 CONTEXT |= line1 << 9;
3555 bVal = m_pArithDecoder->DECODE(&m_gbContext[CONT EXT]);
3556 }
3557 if(bVal) {
3558 GBREG->setPixel(w, m_loopIndex, bVal);
3559 }
3560 line1 = ((line1 << 1) | GBREG->getPixel(w + 3, m_loo pIndex - 2)) & 0x0f;
3561 line2 = ((line2 << 1) | GBREG->getPixel(w + 3, m_loo pIndex - 1)) & 0x1f;
3562 line3 = ((line3 << 1) | bVal) & 0x07;
3563 }
3564 }
3565 break;
3566 case 2: {
3567 line1 = GBREG->getPixel(1, m_loopIndex - 2);
3568 line1 |= GBREG->getPixel(0, m_loopIndex - 2) << 1;
3569 line2 = GBREG->getPixel(1, m_loopIndex - 1);
3570 line2 |= GBREG->getPixel(0, m_loopIndex - 1) << 1;
3571 line3 = 0;
3572 for(FX_DWORD w = 0; w < GBW; w++) {
3573 if(USESKIP && SKIP->getPixel(w, m_loopIndex)) {
3574 bVal = 0;
3575 } else {
3576 CONTEXT = line3;
3577 CONTEXT |= GBREG->getPixel(w + GBAT[0], m_loopIn dex + GBAT[1]) << 2;
3578 CONTEXT |= line2 << 3;
3579 CONTEXT |= line1 << 7;
3580 bVal = m_pArithDecoder->DECODE(&m_gbContext[CONT EXT]);
3581 }
3582 if(bVal) {
3583 GBREG->setPixel(w, m_loopIndex, bVal);
3584 }
3585 line1 = ((line1 << 1) | GBREG->getPixel(w + 2, m_loo pIndex - 2)) & 0x07;
3586 line2 = ((line2 << 1) | GBREG->getPixel(w + 2, m_loo pIndex - 1)) & 0x0f;
3587 line3 = ((line3 << 1) | bVal) & 0x03;
3588 }
3589 }
3590 break;
3591 case 3: {
3592 line1 = GBREG->getPixel(1, m_loopIndex - 1);
3593 line1 |= GBREG->getPixel(0, m_loopIndex - 1) << 1;
3594 line2 = 0;
3595 for(FX_DWORD w = 0; w < GBW; w++) {
3596 if(USESKIP && SKIP->getPixel(w, m_loopIndex)) {
3597 bVal = 0;
3598 } else {
3599 CONTEXT = line2;
3600 CONTEXT |= GBREG->getPixel(w + GBAT[0], m_loopIn dex + GBAT[1]) << 4;
3601 CONTEXT |= line1 << 5;
3602 bVal = m_pArithDecoder->DECODE(&m_gbContext[CONT EXT]);
3603 }
3604 if(bVal) {
3605 GBREG->setPixel(w, m_loopIndex, bVal);
3606 }
3607 line1 = ((line1 << 1) | GBREG->getPixel(w + 2, m_loo pIndex - 1)) & 0x1f;
3608 line2 = ((line2 << 1) | bVal) & 0x0f;
3609 }
3610 }
3611 break;
3612 }
3613 }
3614 if(pPause && pPause->NeedToPauseNow()) {
3615 m_loopIndex ++;
3616 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
3617 return FXCODEC_STATUS_DECODE_TOBECONTINUE;
3618 }
3619 }
3620 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH; 3649 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
3621 return FXCODEC_STATUS_DECODE_FINISH; 3650 return FXCODEC_STATUS_DECODE_FINISH;
3622 } 3651 }
3623 FXCODEC_STATUS CJBig2_GRDProc::Start_decode_Arith_V1(CJBig2_Image** pImage, CJBi g2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext, IFX_Pause* pPause) 3652 m_ProssiveStatus = FXCODEC_STATUS_DECODE_READY;
3624 { 3653 m_pPause = pPause;
3625 if(GBW == 0 || GBH == 0) { 3654 if (*pImage == NULL) {
3626 * pImage = NULL; 3655 JBIG2_ALLOC((*pImage), CJBig2_Image(GBW, GBH));
3627 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH; 3656 }
3628 return FXCODEC_STATUS_DECODE_FINISH; 3657 if ((*pImage)->m_pData == NULL) {
3629 } 3658 delete *pImage;
3630 if(*pImage == NULL) { 3659 *pImage = NULL;
3631 JBIG2_ALLOC((*pImage), CJBig2_Image(GBW, GBH)); 3660 m_pModule->JBig2_Error(
3632 } 3661 "Generic region decoding procedure: Create Image Failed with width = "
3633 if ((*pImage)->m_pData == NULL) { 3662 "%d, height = %d\n",
3634 delete *pImage; 3663 GBW, GBH);
3635 *pImage = NULL; 3664 m_ProssiveStatus = FXCODEC_STATUS_ERROR;
3636 m_pModule->JBig2_Error("Generic region decoding procedure: Create Image Failed with width = %d, height = %d\n", GBW, GBH); 3665 return FXCODEC_STATUS_ERROR;
3637 m_ProssiveStatus = FXCODEC_STATUS_ERROR; 3666 }
3638 return FXCODEC_STATUS_ERROR; 3667 m_DecodeType = 1;
3639 } 3668 m_pImage = pImage;
3640 m_ProssiveStatus = FXCODEC_STATUS_DECODE_READY; 3669 (*m_pImage)->fill(0);
3641 m_pPause = pPause; 3670 m_pArithDecoder = pArithDecoder;
3642 m_pImage = pImage; 3671 m_gbContext = gbContext;
3643 m_DecodeType = 3; 3672 LTP = 0;
3644 (*m_pImage)->fill(0); 3673 m_pLine = NULL;
3645 LTP = 0; 3674 m_loopIndex = 0;
3675 return decode_Arith(pPause);
3676 }
3677 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith(IFX_Pause* pPause) {
3678 int iline = m_loopIndex;
3679 CJBig2_Image* pImage = *m_pImage;
3680 if (GBTEMPLATE == 0) {
3681 if ((GBAT[0] == 3) && (GBAT[1] == (signed char)-1) &&
3682 (GBAT[2] == (signed char)-3) && (GBAT[3] == (signed char)-1) &&
3683 (GBAT[4] == 2) && (GBAT[5] == (signed char)-2) &&
3684 (GBAT[6] == (signed char)-2) && (GBAT[7] == (signed char)-2)) {
3685 m_ProssiveStatus = decode_Arith_Template0_opt3(pImage, m_pArithDecoder,
3686 m_gbContext, pPause);
3687 } else {
3688 m_ProssiveStatus = decode_Arith_Template0_unopt(pImage, m_pArithDecoder,
3689 m_gbContext, pPause);
3690 }
3691 } else if (GBTEMPLATE == 1) {
3692 if ((GBAT[0] == 3) && (GBAT[1] == (signed char)-1)) {
3693 m_ProssiveStatus = decode_Arith_Template1_opt3(pImage, m_pArithDecoder,
3694 m_gbContext, pPause);
3695 } else {
3696 m_ProssiveStatus = decode_Arith_Template1_unopt(pImage, m_pArithDecoder,
3697 m_gbContext, pPause);
3698 }
3699 } else if (GBTEMPLATE == 2) {
3700 if ((GBAT[0] == 2) && (GBAT[1] == (signed char)-1)) {
3701 m_ProssiveStatus = decode_Arith_Template2_opt3(pImage, m_pArithDecoder,
3702 m_gbContext, pPause);
3703 } else {
3704 m_ProssiveStatus = decode_Arith_Template2_unopt(pImage, m_pArithDecoder,
3705 m_gbContext, pPause);
3706 }
3707 } else {
3708 if ((GBAT[0] == 2) && (GBAT[1] == (signed char)-1)) {
3709 m_ProssiveStatus = decode_Arith_Template3_opt3(pImage, m_pArithDecoder,
3710 m_gbContext, pPause);
3711 } else {
3712 m_ProssiveStatus = decode_Arith_Template3_unopt(pImage, m_pArithDecoder,
3713 m_gbContext, pPause);
3714 }
3715 }
3716 m_ReplaceRect.left = 0;
3717 m_ReplaceRect.right = pImage->m_nWidth;
3718 m_ReplaceRect.top = iline;
3719 m_ReplaceRect.bottom = m_loopIndex;
3720 if (m_ProssiveStatus == FXCODEC_STATUS_DECODE_FINISH) {
3646 m_loopIndex = 0; 3721 m_loopIndex = 0;
3647 m_pArithDecoder = pArithDecoder; 3722 }
3648 m_gbContext = gbContext; 3723 return m_ProssiveStatus;
3649 return decode_Arith_V1(pPause); 3724 }
3650 } 3725 FXCODEC_STATUS CJBig2_GRDProc::Start_decode_Arith_V2(
3651 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_V1(IFX_Pause* pPause) 3726 CJBig2_Image** pImage,
3652 { 3727 CJBig2_ArithDecoder* pArithDecoder,
3653 FX_BOOL SLTP, bVal; 3728 JBig2ArithCtx* gbContext,
3654 FX_DWORD CONTEXT = 0; 3729 IFX_Pause* pPause) {
3655 CJBig2_Image *GBREG = (*m_pImage); 3730 if (GBW == 0 || GBH == 0) {
3656 for(; m_loopIndex < GBH; m_loopIndex++) { 3731 *pImage = NULL;
3657 if(TPGDON) {
3658 switch(GBTEMPLATE) {
3659 case 0:
3660 CONTEXT = 0x9b25;
3661 break;
3662 case 1:
3663 CONTEXT = 0x0795;
3664 break;
3665 case 2:
3666 CONTEXT = 0x00e5;
3667 break;
3668 case 3:
3669 CONTEXT = 0x0195;
3670 break;
3671 }
3672 SLTP = m_pArithDecoder->DECODE(&m_gbContext[CONTEXT]);
3673 LTP = LTP ^ SLTP;
3674 }
3675 if(LTP == 1) {
3676 for(FX_DWORD w = 0; w < GBW; w++) {
3677 GBREG->setPixel(w, m_loopIndex, GBREG->getPixel(w, m_loopIndex - 1));
3678 }
3679 } else {
3680 for(FX_DWORD w = 0; w < GBW; w++) {
3681 if(USESKIP && SKIP->getPixel(w, m_loopIndex)) {
3682 GBREG->setPixel(w, m_loopIndex, 0);
3683 } else {
3684 CONTEXT = 0;
3685 switch(GBTEMPLATE) {
3686 case 0:
3687 CONTEXT |= GBREG->getPixel(w - 1, m_loopIndex);
3688 CONTEXT |= GBREG->getPixel(w - 2, m_loopIndex) << 1;
3689 CONTEXT |= GBREG->getPixel(w - 3, m_loopIndex) << 2;
3690 CONTEXT |= GBREG->getPixel(w - 4, m_loopIndex) << 3;
3691 CONTEXT |= GBREG->getPixel(w + GBAT[0], m_loopIndex + GBAT[1]) << 4;
3692 CONTEXT |= GBREG->getPixel(w + 2, m_loopIndex - 1) < < 5;
3693 CONTEXT |= GBREG->getPixel(w + 1, m_loopIndex - 1) < < 6;
3694 CONTEXT |= GBREG->getPixel(w, m_loopIndex - 1) << 7;
3695 CONTEXT |= GBREG->getPixel(w - 1, m_loopIndex - 1) < < 8;
3696 CONTEXT |= GBREG->getPixel(w - 2, m_loopIndex - 1) < < 9;
3697 CONTEXT |= GBREG->getPixel(w + GBAT[2], m_loopIndex + GBAT[3]) << 10;
3698 CONTEXT |= GBREG->getPixel(w + GBAT[4], m_loopIndex + GBAT[5]) << 11;
3699 CONTEXT |= GBREG->getPixel(w + 1, m_loopIndex - 2) < < 12;
3700 CONTEXT |= GBREG->getPixel(w, m_loopIndex - 2) << 13 ;
3701 CONTEXT |= GBREG->getPixel(w - 1, m_loopIndex - 2) < < 14;
3702 CONTEXT |= GBREG->getPixel(w + GBAT[6], m_loopIndex + GBAT[7]) << 15;
3703 break;
3704 case 1:
3705 CONTEXT |= GBREG->getPixel(w - 1, m_loopIndex);
3706 CONTEXT |= GBREG->getPixel(w - 2, m_loopIndex) << 1;
3707 CONTEXT |= GBREG->getPixel(w - 3, m_loopIndex) << 2;
3708 CONTEXT |= GBREG->getPixel(w + GBAT[0], m_loopIndex + GBAT[1]) << 3;
3709 CONTEXT |= GBREG->getPixel(w + 2, m_loopIndex - 1) < < 4;
3710 CONTEXT |= GBREG->getPixel(w + 1, m_loopIndex - 1) < < 5;
3711 CONTEXT |= GBREG->getPixel(w, m_loopIndex - 1) << 6;
3712 CONTEXT |= GBREG->getPixel(w - 1, m_loopIndex - 1) < < 7;
3713 CONTEXT |= GBREG->getPixel(w - 2, m_loopIndex - 1) < < 8;
3714 CONTEXT |= GBREG->getPixel(w + 2, m_loopIndex - 2) < < 9;
3715 CONTEXT |= GBREG->getPixel(w + 1, m_loopIndex - 2) < < 10;
3716 CONTEXT |= GBREG->getPixel(w, m_loopIndex - 2) << 11 ;
3717 CONTEXT |= GBREG->getPixel(w - 1, m_loopIndex - 2) < < 12;
3718 break;
3719 case 2:
3720 CONTEXT |= GBREG->getPixel(w - 1, m_loopIndex);
3721 CONTEXT |= GBREG->getPixel(w - 2, m_loopIndex) << 1;
3722 CONTEXT |= GBREG->getPixel(w + GBAT[0], m_loopIndex + GBAT[1]) << 2;
3723 CONTEXT |= GBREG->getPixel(w + 1, m_loopIndex - 1) < < 3;
3724 CONTEXT |= GBREG->getPixel(w, m_loopIndex - 1) << 4;
3725 CONTEXT |= GBREG->getPixel(w - 1, m_loopIndex - 1) < < 5;
3726 CONTEXT |= GBREG->getPixel(w - 2, m_loopIndex - 1) < < 6;
3727 CONTEXT |= GBREG->getPixel(w + 1, m_loopIndex - 2) < < 7;
3728 CONTEXT |= GBREG->getPixel(w, m_loopIndex - 2) << 8;
3729 CONTEXT |= GBREG->getPixel(w - 1, m_loopIndex - 2) < < 9;
3730 break;
3731 case 3:
3732 CONTEXT |= GBREG->getPixel(w - 1, m_loopIndex);
3733 CONTEXT |= GBREG->getPixel(w - 2, m_loopIndex) << 1;
3734 CONTEXT |= GBREG->getPixel(w - 3, m_loopIndex) << 2;
3735 CONTEXT |= GBREG->getPixel(w - 4, m_loopIndex) << 3;
3736 CONTEXT |= GBREG->getPixel(w + GBAT[0], m_loopIndex + GBAT[1]) << 4;
3737 CONTEXT |= GBREG->getPixel(w + 1, m_loopIndex - 1) < < 5;
3738 CONTEXT |= GBREG->getPixel(w, m_loopIndex - 1) << 6;
3739 CONTEXT |= GBREG->getPixel(w - 1, m_loopIndex - 1) < < 7;
3740 CONTEXT |= GBREG->getPixel(w - 2, m_loopIndex - 1) < < 8;
3741 CONTEXT |= GBREG->getPixel(w - 3, m_loopIndex - 1) < < 9;
3742 break;
3743 }
3744 bVal = m_pArithDecoder->DECODE(&m_gbContext[CONTEXT]);
3745 GBREG->setPixel(w, m_loopIndex, bVal);
3746 }
3747 }
3748 }
3749 if(pPause && pPause->NeedToPauseNow()) {
3750 m_loopIndex ++;
3751 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
3752 return FXCODEC_STATUS_DECODE_TOBECONTINUE;
3753 }
3754 }
3755 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH; 3732 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
3756 return FXCODEC_STATUS_DECODE_FINISH; 3733 return FXCODEC_STATUS_DECODE_FINISH;
3757 } 3734 }
3758 FXCODEC_STATUS CJBig2_GRDProc::Start_decode_MMR(CJBig2_Image** pImage, CJBig2_Bi tStream *pStream, IFX_Pause* pPause) 3735 if (*pImage == NULL) {
3759 { 3736 JBIG2_ALLOC((*pImage), CJBig2_Image(GBW, GBH));
3760 int bitpos, i; 3737 }
3761 JBIG2_ALLOC((* pImage), CJBig2_Image(GBW, GBH)); 3738 if ((*pImage)->m_pData == NULL) {
3762 if ((* pImage)->m_pData == NULL) { 3739 delete *pImage;
3763 delete (* pImage); 3740 *pImage = NULL;
3764 (* pImage) = NULL; 3741 m_pModule->JBig2_Error(
3765 m_pModule->JBig2_Error("Generic region decoding procedure: Create Image Failed with width = %d, height = %d\n", GBW, GBH); 3742 "Generic region decoding procedure: Create Image Failed with width = "
3766 m_ProssiveStatus = FXCODEC_STATUS_ERROR; 3743 "%d, height = %d\n",
3767 return m_ProssiveStatus; 3744 GBW, GBH);
3768 } 3745 m_ProssiveStatus = FXCODEC_STATUS_ERROR;
3769 bitpos = (int)pStream->getBitPos(); 3746 return FXCODEC_STATUS_ERROR;
3770 _FaxG4Decode(m_pModule, pStream->getBuf(), pStream->getLength(), &bitpos, (* pImage)->m_pData, GBW, GBH, (* pImage)->m_nStride); 3747 }
3771 pStream->setBitPos(bitpos); 3748 m_ProssiveStatus = FXCODEC_STATUS_DECODE_READY;
3772 for(i = 0; (FX_DWORD)i < (* pImage)->m_nStride * GBH; i++) { 3749 m_DecodeType = 2;
3773 (* pImage)->m_pData[i] = ~(* pImage)->m_pData[i]; 3750 m_pPause = pPause;
3774 } 3751 m_pImage = pImage;
3752 (*m_pImage)->fill(0);
3753 LTP = 0;
3754 m_loopIndex = 0;
3755 m_pArithDecoder = pArithDecoder;
3756 m_gbContext = gbContext;
3757 return decode_Arith_V2(pPause);
3758 }
3759 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_V2(IFX_Pause* pPause) {
3760 FX_BOOL SLTP, bVal;
3761 FX_DWORD CONTEXT;
3762 CJBig2_Image* GBREG = *m_pImage;
3763 FX_DWORD line1, line2, line3;
3764 LTP = 0;
3765 JBIG2_ALLOC(GBREG, CJBig2_Image(GBW, GBH));
3766 GBREG->fill(0);
3767 for (; m_loopIndex < GBH; m_loopIndex++) {
3768 if (TPGDON) {
3769 switch (GBTEMPLATE) {
3770 case 0:
3771 CONTEXT = 0x9b25;
3772 break;
3773 case 1:
3774 CONTEXT = 0x0795;
3775 break;
3776 case 2:
3777 CONTEXT = 0x00e5;
3778 break;
3779 case 3:
3780 CONTEXT = 0x0195;
3781 break;
3782 }
3783 SLTP = m_pArithDecoder->DECODE(&m_gbContext[CONTEXT]);
3784 LTP = LTP ^ SLTP;
3785 }
3786 if (LTP == 1) {
3787 GBREG->copyLine(m_loopIndex, m_loopIndex - 1);
3788 } else {
3789 switch (GBTEMPLATE) {
3790 case 0: {
3791 line1 = GBREG->getPixel(1, m_loopIndex - 2);
3792 line1 |= GBREG->getPixel(0, m_loopIndex - 2) << 1;
3793 line2 = GBREG->getPixel(2, m_loopIndex - 1);
3794 line2 |= GBREG->getPixel(1, m_loopIndex - 1) << 1;
3795 line2 |= GBREG->getPixel(0, m_loopIndex - 1) << 2;
3796 line3 = 0;
3797 for (FX_DWORD w = 0; w < GBW; w++) {
3798 if (USESKIP && SKIP->getPixel(w, m_loopIndex)) {
3799 bVal = 0;
3800 } else {
3801 CONTEXT = line3;
3802 CONTEXT |= GBREG->getPixel(w + GBAT[0], m_loopIndex + GBAT[1])
3803 << 4;
3804 CONTEXT |= line2 << 5;
3805 CONTEXT |= GBREG->getPixel(w + GBAT[2], m_loopIndex + GBAT[3])
3806 << 10;
3807 CONTEXT |= GBREG->getPixel(w + GBAT[4], m_loopIndex + GBAT[5])
3808 << 11;
3809 CONTEXT |= line1 << 12;
3810 CONTEXT |= GBREG->getPixel(w + GBAT[6], m_loopIndex + GBAT[7])
3811 << 15;
3812 bVal = m_pArithDecoder->DECODE(&m_gbContext[CONTEXT]);
3813 }
3814 if (bVal) {
3815 GBREG->setPixel(w, m_loopIndex, bVal);
3816 }
3817 line1 =
3818 ((line1 << 1) | GBREG->getPixel(w + 2, m_loopIndex - 2)) & 0x07;
3819 line2 =
3820 ((line2 << 1) | GBREG->getPixel(w + 3, m_loopIndex - 1)) & 0x1f;
3821 line3 = ((line3 << 1) | bVal) & 0x0f;
3822 }
3823 } break;
3824 case 1: {
3825 line1 = GBREG->getPixel(2, m_loopIndex - 2);
3826 line1 |= GBREG->getPixel(1, m_loopIndex - 2) << 1;
3827 line1 |= GBREG->getPixel(0, m_loopIndex - 2) << 2;
3828 line2 = GBREG->getPixel(2, m_loopIndex - 1);
3829 line2 |= GBREG->getPixel(1, m_loopIndex - 1) << 1;
3830 line2 |= GBREG->getPixel(0, m_loopIndex - 1) << 2;
3831 line3 = 0;
3832 for (FX_DWORD w = 0; w < GBW; w++) {
3833 if (USESKIP && SKIP->getPixel(w, m_loopIndex)) {
3834 bVal = 0;
3835 } else {
3836 CONTEXT = line3;
3837 CONTEXT |= GBREG->getPixel(w + GBAT[0], m_loopIndex + GBAT[1])
3838 << 3;
3839 CONTEXT |= line2 << 4;
3840 CONTEXT |= line1 << 9;
3841 bVal = m_pArithDecoder->DECODE(&m_gbContext[CONTEXT]);
3842 }
3843 if (bVal) {
3844 GBREG->setPixel(w, m_loopIndex, bVal);
3845 }
3846 line1 =
3847 ((line1 << 1) | GBREG->getPixel(w + 3, m_loopIndex - 2)) & 0x0f;
3848 line2 =
3849 ((line2 << 1) | GBREG->getPixel(w + 3, m_loopIndex - 1)) & 0x1f;
3850 line3 = ((line3 << 1) | bVal) & 0x07;
3851 }
3852 } break;
3853 case 2: {
3854 line1 = GBREG->getPixel(1, m_loopIndex - 2);
3855 line1 |= GBREG->getPixel(0, m_loopIndex - 2) << 1;
3856 line2 = GBREG->getPixel(1, m_loopIndex - 1);
3857 line2 |= GBREG->getPixel(0, m_loopIndex - 1) << 1;
3858 line3 = 0;
3859 for (FX_DWORD w = 0; w < GBW; w++) {
3860 if (USESKIP && SKIP->getPixel(w, m_loopIndex)) {
3861 bVal = 0;
3862 } else {
3863 CONTEXT = line3;
3864 CONTEXT |= GBREG->getPixel(w + GBAT[0], m_loopIndex + GBAT[1])
3865 << 2;
3866 CONTEXT |= line2 << 3;
3867 CONTEXT |= line1 << 7;
3868 bVal = m_pArithDecoder->DECODE(&m_gbContext[CONTEXT]);
3869 }
3870 if (bVal) {
3871 GBREG->setPixel(w, m_loopIndex, bVal);
3872 }
3873 line1 =
3874 ((line1 << 1) | GBREG->getPixel(w + 2, m_loopIndex - 2)) & 0x07;
3875 line2 =
3876 ((line2 << 1) | GBREG->getPixel(w + 2, m_loopIndex - 1)) & 0x0f;
3877 line3 = ((line3 << 1) | bVal) & 0x03;
3878 }
3879 } break;
3880 case 3: {
3881 line1 = GBREG->getPixel(1, m_loopIndex - 1);
3882 line1 |= GBREG->getPixel(0, m_loopIndex - 1) << 1;
3883 line2 = 0;
3884 for (FX_DWORD w = 0; w < GBW; w++) {
3885 if (USESKIP && SKIP->getPixel(w, m_loopIndex)) {
3886 bVal = 0;
3887 } else {
3888 CONTEXT = line2;
3889 CONTEXT |= GBREG->getPixel(w + GBAT[0], m_loopIndex + GBAT[1])
3890 << 4;
3891 CONTEXT |= line1 << 5;
3892 bVal = m_pArithDecoder->DECODE(&m_gbContext[CONTEXT]);
3893 }
3894 if (bVal) {
3895 GBREG->setPixel(w, m_loopIndex, bVal);
3896 }
3897 line1 =
3898 ((line1 << 1) | GBREG->getPixel(w + 2, m_loopIndex - 1)) & 0x1f;
3899 line2 = ((line2 << 1) | bVal) & 0x0f;
3900 }
3901 } break;
3902 }
3903 }
3904 if (pPause && pPause->NeedToPauseNow()) {
3905 m_loopIndex++;
3906 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
3907 return FXCODEC_STATUS_DECODE_TOBECONTINUE;
3908 }
3909 }
3910 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
3911 return FXCODEC_STATUS_DECODE_FINISH;
3912 }
3913 FXCODEC_STATUS CJBig2_GRDProc::Start_decode_Arith_V1(
3914 CJBig2_Image** pImage,
3915 CJBig2_ArithDecoder* pArithDecoder,
3916 JBig2ArithCtx* gbContext,
3917 IFX_Pause* pPause) {
3918 if (GBW == 0 || GBH == 0) {
3919 *pImage = NULL;
3775 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH; 3920 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
3776 return m_ProssiveStatus; 3921 return FXCODEC_STATUS_DECODE_FINISH;
3777 } 3922 }
3778 FXCODEC_STATUS CJBig2_GRDProc::decode_MMR() 3923 if (*pImage == NULL) {
3779 { 3924 JBIG2_ALLOC((*pImage), CJBig2_Image(GBW, GBH));
3780 return m_ProssiveStatus; 3925 }
3781 } 3926 if ((*pImage)->m_pData == NULL) {
3782 FXCODEC_STATUS CJBig2_GRDProc::Continue_decode(IFX_Pause* pPause) 3927 delete *pImage;
3783 { 3928 *pImage = NULL;
3784 if(m_ProssiveStatus != FXCODEC_STATUS_DECODE_TOBECONTINUE) { 3929 m_pModule->JBig2_Error(
3785 return m_ProssiveStatus; 3930 "Generic region decoding procedure: Create Image Failed with width = "
3786 } 3931 "%d, height = %d\n",
3787 switch (m_DecodeType) { 3932 GBW, GBH);
3933 m_ProssiveStatus = FXCODEC_STATUS_ERROR;
3934 return FXCODEC_STATUS_ERROR;
3935 }
3936 m_ProssiveStatus = FXCODEC_STATUS_DECODE_READY;
3937 m_pPause = pPause;
3938 m_pImage = pImage;
3939 m_DecodeType = 3;
3940 (*m_pImage)->fill(0);
3941 LTP = 0;
3942 m_loopIndex = 0;
3943 m_pArithDecoder = pArithDecoder;
3944 m_gbContext = gbContext;
3945 return decode_Arith_V1(pPause);
3946 }
3947 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_V1(IFX_Pause* pPause) {
3948 FX_BOOL SLTP, bVal;
3949 FX_DWORD CONTEXT = 0;
3950 CJBig2_Image* GBREG = (*m_pImage);
3951 for (; m_loopIndex < GBH; m_loopIndex++) {
3952 if (TPGDON) {
3953 switch (GBTEMPLATE) {
3954 case 0:
3955 CONTEXT = 0x9b25;
3956 break;
3788 case 1: 3957 case 1:
3789 return decode_Arith(pPause); 3958 CONTEXT = 0x0795;
3959 break;
3790 case 2: 3960 case 2:
3791 return decode_Arith_V2(pPause); 3961 CONTEXT = 0x00e5;
3962 break;
3792 case 3: 3963 case 3:
3793 return decode_Arith_V1(pPause); 3964 CONTEXT = 0x0195;
3794 case 4: 3965 break;
3795 return decode_MMR(); 3966 }
3796 } 3967 SLTP = m_pArithDecoder->DECODE(&m_gbContext[CONTEXT]);
3968 LTP = LTP ^ SLTP;
3969 }
3970 if (LTP == 1) {
3971 for (FX_DWORD w = 0; w < GBW; w++) {
3972 GBREG->setPixel(w, m_loopIndex, GBREG->getPixel(w, m_loopIndex - 1));
3973 }
3974 } else {
3975 for (FX_DWORD w = 0; w < GBW; w++) {
3976 if (USESKIP && SKIP->getPixel(w, m_loopIndex)) {
3977 GBREG->setPixel(w, m_loopIndex, 0);
3978 } else {
3979 CONTEXT = 0;
3980 switch (GBTEMPLATE) {
3981 case 0:
3982 CONTEXT |= GBREG->getPixel(w - 1, m_loopIndex);
3983 CONTEXT |= GBREG->getPixel(w - 2, m_loopIndex) << 1;
3984 CONTEXT |= GBREG->getPixel(w - 3, m_loopIndex) << 2;
3985 CONTEXT |= GBREG->getPixel(w - 4, m_loopIndex) << 3;
3986 CONTEXT |= GBREG->getPixel(w + GBAT[0], m_loopIndex + GBAT[1])
3987 << 4;
3988 CONTEXT |= GBREG->getPixel(w + 2, m_loopIndex - 1) << 5;
3989 CONTEXT |= GBREG->getPixel(w + 1, m_loopIndex - 1) << 6;
3990 CONTEXT |= GBREG->getPixel(w, m_loopIndex - 1) << 7;
3991 CONTEXT |= GBREG->getPixel(w - 1, m_loopIndex - 1) << 8;
3992 CONTEXT |= GBREG->getPixel(w - 2, m_loopIndex - 1) << 9;
3993 CONTEXT |= GBREG->getPixel(w + GBAT[2], m_loopIndex + GBAT[3])
3994 << 10;
3995 CONTEXT |= GBREG->getPixel(w + GBAT[4], m_loopIndex + GBAT[5])
3996 << 11;
3997 CONTEXT |= GBREG->getPixel(w + 1, m_loopIndex - 2) << 12;
3998 CONTEXT |= GBREG->getPixel(w, m_loopIndex - 2) << 13;
3999 CONTEXT |= GBREG->getPixel(w - 1, m_loopIndex - 2) << 14;
4000 CONTEXT |= GBREG->getPixel(w + GBAT[6], m_loopIndex + GBAT[7])
4001 << 15;
4002 break;
4003 case 1:
4004 CONTEXT |= GBREG->getPixel(w - 1, m_loopIndex);
4005 CONTEXT |= GBREG->getPixel(w - 2, m_loopIndex) << 1;
4006 CONTEXT |= GBREG->getPixel(w - 3, m_loopIndex) << 2;
4007 CONTEXT |= GBREG->getPixel(w + GBAT[0], m_loopIndex + GBAT[1])
4008 << 3;
4009 CONTEXT |= GBREG->getPixel(w + 2, m_loopIndex - 1) << 4;
4010 CONTEXT |= GBREG->getPixel(w + 1, m_loopIndex - 1) << 5;
4011 CONTEXT |= GBREG->getPixel(w, m_loopIndex - 1) << 6;
4012 CONTEXT |= GBREG->getPixel(w - 1, m_loopIndex - 1) << 7;
4013 CONTEXT |= GBREG->getPixel(w - 2, m_loopIndex - 1) << 8;
4014 CONTEXT |= GBREG->getPixel(w + 2, m_loopIndex - 2) << 9;
4015 CONTEXT |= GBREG->getPixel(w + 1, m_loopIndex - 2) << 10;
4016 CONTEXT |= GBREG->getPixel(w, m_loopIndex - 2) << 11;
4017 CONTEXT |= GBREG->getPixel(w - 1, m_loopIndex - 2) << 12;
4018 break;
4019 case 2:
4020 CONTEXT |= GBREG->getPixel(w - 1, m_loopIndex);
4021 CONTEXT |= GBREG->getPixel(w - 2, m_loopIndex) << 1;
4022 CONTEXT |= GBREG->getPixel(w + GBAT[0], m_loopIndex + GBAT[1])
4023 << 2;
4024 CONTEXT |= GBREG->getPixel(w + 1, m_loopIndex - 1) << 3;
4025 CONTEXT |= GBREG->getPixel(w, m_loopIndex - 1) << 4;
4026 CONTEXT |= GBREG->getPixel(w - 1, m_loopIndex - 1) << 5;
4027 CONTEXT |= GBREG->getPixel(w - 2, m_loopIndex - 1) << 6;
4028 CONTEXT |= GBREG->getPixel(w + 1, m_loopIndex - 2) << 7;
4029 CONTEXT |= GBREG->getPixel(w, m_loopIndex - 2) << 8;
4030 CONTEXT |= GBREG->getPixel(w - 1, m_loopIndex - 2) << 9;
4031 break;
4032 case 3:
4033 CONTEXT |= GBREG->getPixel(w - 1, m_loopIndex);
4034 CONTEXT |= GBREG->getPixel(w - 2, m_loopIndex) << 1;
4035 CONTEXT |= GBREG->getPixel(w - 3, m_loopIndex) << 2;
4036 CONTEXT |= GBREG->getPixel(w - 4, m_loopIndex) << 3;
4037 CONTEXT |= GBREG->getPixel(w + GBAT[0], m_loopIndex + GBAT[1])
4038 << 4;
4039 CONTEXT |= GBREG->getPixel(w + 1, m_loopIndex - 1) << 5;
4040 CONTEXT |= GBREG->getPixel(w, m_loopIndex - 1) << 6;
4041 CONTEXT |= GBREG->getPixel(w - 1, m_loopIndex - 1) << 7;
4042 CONTEXT |= GBREG->getPixel(w - 2, m_loopIndex - 1) << 8;
4043 CONTEXT |= GBREG->getPixel(w - 3, m_loopIndex - 1) << 9;
4044 break;
4045 }
4046 bVal = m_pArithDecoder->DECODE(&m_gbContext[CONTEXT]);
4047 GBREG->setPixel(w, m_loopIndex, bVal);
4048 }
4049 }
4050 }
4051 if (pPause && pPause->NeedToPauseNow()) {
4052 m_loopIndex++;
4053 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
4054 return FXCODEC_STATUS_DECODE_TOBECONTINUE;
4055 }
4056 }
4057 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
4058 return FXCODEC_STATUS_DECODE_FINISH;
4059 }
4060 FXCODEC_STATUS CJBig2_GRDProc::Start_decode_MMR(CJBig2_Image** pImage,
4061 CJBig2_BitStream* pStream,
4062 IFX_Pause* pPause) {
4063 int bitpos, i;
4064 JBIG2_ALLOC((*pImage), CJBig2_Image(GBW, GBH));
4065 if ((*pImage)->m_pData == NULL) {
4066 delete (*pImage);
4067 (*pImage) = NULL;
4068 m_pModule->JBig2_Error(
4069 "Generic region decoding procedure: Create Image Failed with width = "
4070 "%d, height = %d\n",
4071 GBW, GBH);
3797 m_ProssiveStatus = FXCODEC_STATUS_ERROR; 4072 m_ProssiveStatus = FXCODEC_STATUS_ERROR;
3798 return m_ProssiveStatus; 4073 return m_ProssiveStatus;
3799 } 4074 }
3800 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template0_opt3(CJBig2_Image *pImage, CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext, IFX_Pause* pPause ) 4075 bitpos = (int)pStream->getBitPos();
3801 { 4076 _FaxG4Decode(m_pModule, pStream->getBuf(), pStream->getLength(), &bitpos,
3802 FX_BOOL SLTP, bVal; 4077 (*pImage)->m_pData, GBW, GBH, (*pImage)->m_nStride);
3803 FX_DWORD CONTEXT; 4078 pStream->setBitPos(bitpos);
3804 FX_DWORD line1, line2; 4079 for (i = 0; (FX_DWORD)i < (*pImage)->m_nStride * GBH; i++) {
3805 uint8_t *pLine1, *pLine2, cVal; 4080 (*pImage)->m_pData[i] = ~(*pImage)->m_pData[i];
3806 int32_t nStride, nStride2, k; 4081 }
3807 int32_t nLineBytes, nBitsLeft, cc; 4082 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
3808 if(m_pLine == NULL) { 4083 return m_ProssiveStatus;
3809 m_pLine = pImage->m_pData; 4084 }
3810 } 4085 FXCODEC_STATUS CJBig2_GRDProc::decode_MMR() {
3811 nStride = pImage->m_nStride; 4086 return m_ProssiveStatus;
3812 nStride2 = nStride << 1; 4087 }
3813 nLineBytes = ((GBW + 7) >> 3) - 1; 4088 FXCODEC_STATUS CJBig2_GRDProc::Continue_decode(IFX_Pause* pPause) {
3814 nBitsLeft = GBW - (nLineBytes << 3); 4089 if (m_ProssiveStatus != FXCODEC_STATUS_DECODE_TOBECONTINUE) {
3815 FX_DWORD height = GBH & 0x7fffffff; 4090 return m_ProssiveStatus;
3816 for(; m_loopIndex < height; m_loopIndex++) { 4091 }
3817 if(TPGDON) { 4092 switch (m_DecodeType) {
3818 SLTP = pArithDecoder->DECODE(&gbContext[0x9b25]); 4093 case 1:
3819 LTP = LTP ^ SLTP; 4094 return decode_Arith(pPause);
3820 } 4095 case 2:
3821 if(LTP == 1) { 4096 return decode_Arith_V2(pPause);
3822 pImage->copyLine(m_loopIndex, m_loopIndex - 1); 4097 case 3:
4098 return decode_Arith_V1(pPause);
4099 case 4:
4100 return decode_MMR();
4101 }
4102 m_ProssiveStatus = FXCODEC_STATUS_ERROR;
4103 return m_ProssiveStatus;
4104 }
4105 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template0_opt3(
4106 CJBig2_Image* pImage,
4107 CJBig2_ArithDecoder* pArithDecoder,
4108 JBig2ArithCtx* gbContext,
4109 IFX_Pause* pPause) {
4110 FX_BOOL SLTP, bVal;
4111 FX_DWORD CONTEXT;
4112 FX_DWORD line1, line2;
4113 uint8_t *pLine1, *pLine2, cVal;
4114 int32_t nStride, nStride2, k;
4115 int32_t nLineBytes, nBitsLeft, cc;
4116 if (m_pLine == NULL) {
4117 m_pLine = pImage->m_pData;
4118 }
4119 nStride = pImage->m_nStride;
4120 nStride2 = nStride << 1;
4121 nLineBytes = ((GBW + 7) >> 3) - 1;
4122 nBitsLeft = GBW - (nLineBytes << 3);
4123 FX_DWORD height = GBH & 0x7fffffff;
4124 for (; m_loopIndex < height; m_loopIndex++) {
4125 if (TPGDON) {
4126 SLTP = pArithDecoder->DECODE(&gbContext[0x9b25]);
4127 LTP = LTP ^ SLTP;
4128 }
4129 if (LTP == 1) {
4130 pImage->copyLine(m_loopIndex, m_loopIndex - 1);
4131 } else {
4132 if (m_loopIndex > 1) {
4133 pLine1 = m_pLine - nStride2;
4134 pLine2 = m_pLine - nStride;
4135 line1 = (*pLine1++) << 6;
4136 line2 = *pLine2++;
4137 CONTEXT = ((line1 & 0xf800) | (line2 & 0x07f0));
4138 for (cc = 0; cc < nLineBytes; cc++) {
4139 line1 = (line1 << 8) | ((*pLine1++) << 6);
4140 line2 = (line2 << 8) | (*pLine2++);
4141 cVal = 0;
4142 for (k = 7; k >= 0; k--) {
4143 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
4144 cVal |= bVal << k;
4145 CONTEXT = (((CONTEXT & 0x7bf7) << 1) | bVal |
4146 ((line1 >> k) & 0x0800) | ((line2 >> k) & 0x0010));
4147 }
4148 m_pLine[cc] = cVal;
4149 }
4150 line1 <<= 8;
4151 line2 <<= 8;
4152 cVal = 0;
4153 for (k = 0; k < nBitsLeft; k++) {
4154 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
4155 cVal |= bVal << (7 - k);
4156 CONTEXT =
4157 (((CONTEXT & 0x7bf7) << 1) | bVal |
4158 ((line1 >> (7 - k)) & 0x0800) | ((line2 >> (7 - k)) & 0x0010));
4159 }
4160 m_pLine[nLineBytes] = cVal;
4161 } else {
4162 pLine2 = m_pLine - nStride;
4163 line2 = (m_loopIndex & 1) ? (*pLine2++) : 0;
4164 CONTEXT = (line2 & 0x07f0);
4165 for (cc = 0; cc < nLineBytes; cc++) {
4166 if (m_loopIndex & 1) {
4167 line2 = (line2 << 8) | (*pLine2++);
4168 }
4169 cVal = 0;
4170 for (k = 7; k >= 0; k--) {
4171 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
4172 cVal |= bVal << k;
4173 CONTEXT =
4174 (((CONTEXT & 0x7bf7) << 1) | bVal | ((line2 >> k) & 0x0010));
4175 }
4176 m_pLine[cc] = cVal;
4177 }
4178 line2 <<= 8;
4179 cVal = 0;
4180 for (k = 0; k < nBitsLeft; k++) {
4181 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
4182 cVal |= bVal << (7 - k);
4183 CONTEXT = (((CONTEXT & 0x7bf7) << 1) | bVal |
4184 ((line2 >> (7 - k)) & 0x0010));
4185 }
4186 m_pLine[nLineBytes] = cVal;
4187 }
4188 }
4189 m_pLine += nStride;
4190 if (pPause && pPause->NeedToPauseNow()) {
4191 m_loopIndex++;
4192 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
4193 return FXCODEC_STATUS_DECODE_TOBECONTINUE;
4194 }
4195 }
4196 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
4197 return FXCODEC_STATUS_DECODE_FINISH;
4198 }
4199 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template0_unopt(
4200 CJBig2_Image* pImage,
4201 CJBig2_ArithDecoder* pArithDecoder,
4202 JBig2ArithCtx* gbContext,
4203 IFX_Pause* pPause) {
4204 FX_BOOL SLTP, bVal;
4205 FX_DWORD CONTEXT;
4206 FX_DWORD line1, line2, line3;
4207 for (; m_loopIndex < GBH; m_loopIndex++) {
4208 if (TPGDON) {
4209 SLTP = pArithDecoder->DECODE(&gbContext[0x9b25]);
4210 LTP = LTP ^ SLTP;
4211 }
4212 if (LTP == 1) {
4213 pImage->copyLine(m_loopIndex, m_loopIndex - 1);
4214 } else {
4215 line1 = pImage->getPixel(1, m_loopIndex - 2);
4216 line1 |= pImage->getPixel(0, m_loopIndex - 2) << 1;
4217 line2 = pImage->getPixel(2, m_loopIndex - 1);
4218 line2 |= pImage->getPixel(1, m_loopIndex - 1) << 1;
4219 line2 |= pImage->getPixel(0, m_loopIndex - 1) << 2;
4220 line3 = 0;
4221 for (FX_DWORD w = 0; w < GBW; w++) {
4222 if (USESKIP && SKIP->getPixel(w, m_loopIndex)) {
4223 bVal = 0;
3823 } else { 4224 } else {
3824 if(m_loopIndex > 1) { 4225 CONTEXT = line3;
3825 pLine1 = m_pLine - nStride2; 4226 CONTEXT |= pImage->getPixel(w + GBAT[0], m_loopIndex + GBAT[1]) << 4;
3826 pLine2 = m_pLine - nStride; 4227 CONTEXT |= line2 << 5;
3827 line1 = (*pLine1++) << 6; 4228 CONTEXT |= pImage->getPixel(w + GBAT[2], m_loopIndex + GBAT[3]) << 10;
3828 line2 = *pLine2++; 4229 CONTEXT |= pImage->getPixel(w + GBAT[4], m_loopIndex + GBAT[5]) << 11;
3829 CONTEXT = ((line1 & 0xf800) | (line2 & 0x07f0)); 4230 CONTEXT |= line1 << 12;
3830 for(cc = 0; cc < nLineBytes; cc++) { 4231 CONTEXT |= pImage->getPixel(w + GBAT[6], m_loopIndex + GBAT[7]) << 15;
3831 line1 = (line1 << 8) | ((*pLine1++) << 6); 4232 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
3832 line2 = (line2 << 8) | (*pLine2++); 4233 }
3833 cVal = 0; 4234 if (bVal) {
3834 for(k = 7; k >= 0; k--) { 4235 pImage->setPixel(w, m_loopIndex, bVal);
3835 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]); 4236 }
3836 cVal |= bVal << k; 4237 line1 =
3837 CONTEXT = (((CONTEXT & 0x7bf7) << 1) | bVal 4238 ((line1 << 1) | pImage->getPixel(w + 2, m_loopIndex - 2)) & 0x07;
3838 | ((line1 >> k) & 0x0800) 4239 line2 =
3839 | ((line2 >> k) & 0x0010)); 4240 ((line2 << 1) | pImage->getPixel(w + 3, m_loopIndex - 1)) & 0x1f;
3840 } 4241 line3 = ((line3 << 1) | bVal) & 0x0f;
3841 m_pLine[cc] = cVal; 4242 }
3842 } 4243 }
3843 line1 <<= 8; 4244 if (pPause && pPause->NeedToPauseNow()) {
3844 line2 <<= 8; 4245 m_loopIndex++;
3845 cVal = 0; 4246 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
3846 for(k = 0; k < nBitsLeft; k++) { 4247 return FXCODEC_STATUS_DECODE_TOBECONTINUE;
3847 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]); 4248 }
3848 cVal |= bVal << (7 - k); 4249 }
3849 CONTEXT = (((CONTEXT & 0x7bf7) << 1) | bVal 4250 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
3850 | ((line1 >> (7 - k)) & 0x0800) 4251 return FXCODEC_STATUS_DECODE_FINISH;
3851 | ((line2 >> (7 - k)) & 0x0010)); 4252 }
3852 } 4253 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template1_opt3(
3853 m_pLine[nLineBytes] = cVal; 4254 CJBig2_Image* pImage,
3854 } else { 4255 CJBig2_ArithDecoder* pArithDecoder,
3855 pLine2 = m_pLine - nStride; 4256 JBig2ArithCtx* gbContext,
3856 line2 = (m_loopIndex & 1) ? (*pLine2++) : 0; 4257 IFX_Pause* pPause) {
3857 CONTEXT = (line2 & 0x07f0); 4258 FX_BOOL SLTP, bVal;
3858 for(cc = 0; cc < nLineBytes; cc++) { 4259 FX_DWORD CONTEXT;
3859 if(m_loopIndex & 1) { 4260 FX_DWORD line1, line2;
3860 line2 = (line2 << 8) | (*pLine2++); 4261 uint8_t *pLine1, *pLine2, cVal;
3861 } 4262 int32_t nStride, nStride2, k;
3862 cVal = 0; 4263 int32_t nLineBytes, nBitsLeft, cc;
3863 for(k = 7; k >= 0; k--) { 4264 if (!m_pLine) {
3864 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]); 4265 m_pLine = pImage->m_pData;
3865 cVal |= bVal << k; 4266 }
3866 CONTEXT = (((CONTEXT & 0x7bf7) << 1) | bVal 4267 nStride = pImage->m_nStride;
3867 | ((line2 >> k) & 0x0010)); 4268 nStride2 = nStride << 1;
3868 } 4269 nLineBytes = ((GBW + 7) >> 3) - 1;
3869 m_pLine[cc] = cVal; 4270 nBitsLeft = GBW - (nLineBytes << 3);
3870 } 4271 for (; m_loopIndex < GBH; m_loopIndex++) {
3871 line2 <<= 8; 4272 if (TPGDON) {
3872 cVal = 0; 4273 SLTP = pArithDecoder->DECODE(&gbContext[0x0795]);
3873 for(k = 0; k < nBitsLeft; k++) { 4274 LTP = LTP ^ SLTP;
3874 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]); 4275 }
3875 cVal |= bVal << (7 - k); 4276 if (LTP == 1) {
3876 CONTEXT = (((CONTEXT & 0x7bf7) << 1) | bVal 4277 pImage->copyLine(m_loopIndex, m_loopIndex - 1);
3877 | ((line2 >> (7 - k)) & 0x0010)); 4278 } else {
3878 } 4279 if (m_loopIndex > 1) {
3879 m_pLine[nLineBytes] = cVal; 4280 pLine1 = m_pLine - nStride2;
3880 } 4281 pLine2 = m_pLine - nStride;
3881 } 4282 line1 = (*pLine1++) << 4;
3882 m_pLine += nStride; 4283 line2 = *pLine2++;
3883 if(pPause && pPause->NeedToPauseNow()) { 4284 CONTEXT = (line1 & 0x1e00) | ((line2 >> 1) & 0x01f8);
3884 m_loopIndex++; 4285 for (cc = 0; cc < nLineBytes; cc++) {
3885 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE; 4286 line1 = (line1 << 8) | ((*pLine1++) << 4);
3886 return FXCODEC_STATUS_DECODE_TOBECONTINUE; 4287 line2 = (line2 << 8) | (*pLine2++);
3887 } 4288 cVal = 0;
3888 } 4289 for (k = 7; k >= 0; k--) {
3889 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH; 4290 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
3890 return FXCODEC_STATUS_DECODE_FINISH; 4291 cVal |= bVal << k;
3891 } 4292 CONTEXT = ((CONTEXT & 0x0efb) << 1) | bVal |
3892 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template0_unopt(CJBig2_Image * pImag e, CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext, IFX_Pause* pPau se) 4293 ((line1 >> k) & 0x0200) | ((line2 >> (k + 1)) & 0x0008);
3893 { 4294 }
3894 FX_BOOL SLTP, bVal; 4295 m_pLine[cc] = cVal;
3895 FX_DWORD CONTEXT; 4296 }
3896 FX_DWORD line1, line2, line3; 4297 line1 <<= 8;
3897 for(; m_loopIndex < GBH; m_loopIndex++) { 4298 line2 <<= 8;
3898 if(TPGDON) { 4299 cVal = 0;
3899 SLTP = pArithDecoder->DECODE(&gbContext[0x9b25]); 4300 for (k = 0; k < nBitsLeft; k++) {
3900 LTP = LTP ^ SLTP; 4301 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
3901 } 4302 cVal |= bVal << (7 - k);
3902 if(LTP == 1) { 4303 CONTEXT = ((CONTEXT & 0x0efb) << 1) | bVal |
3903 pImage->copyLine(m_loopIndex, m_loopIndex - 1); 4304 ((line1 >> (7 - k)) & 0x0200) |
4305 ((line2 >> (8 - k)) & 0x0008);
4306 }
4307 m_pLine[nLineBytes] = cVal;
4308 } else {
4309 pLine2 = m_pLine - nStride;
4310 line2 = (m_loopIndex & 1) ? (*pLine2++) : 0;
4311 CONTEXT = (line2 >> 1) & 0x01f8;
4312 for (cc = 0; cc < nLineBytes; cc++) {
4313 if (m_loopIndex & 1) {
4314 line2 = (line2 << 8) | (*pLine2++);
4315 }
4316 cVal = 0;
4317 for (k = 7; k >= 0; k--) {
4318 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
4319 cVal |= bVal << k;
4320 CONTEXT = ((CONTEXT & 0x0efb) << 1) | bVal |
4321 ((line2 >> (k + 1)) & 0x0008);
4322 }
4323 m_pLine[cc] = cVal;
4324 }
4325 line2 <<= 8;
4326 cVal = 0;
4327 for (k = 0; k < nBitsLeft; k++) {
4328 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
4329 cVal |= bVal << (7 - k);
4330 CONTEXT =
4331 ((CONTEXT & 0x0efb) << 1) | bVal | ((line2 >> (8 - k)) & 0x0008);
4332 }
4333 m_pLine[nLineBytes] = cVal;
4334 }
4335 }
4336 m_pLine += nStride;
4337 if (pPause && pPause->NeedToPauseNow()) {
4338 m_loopIndex++;
4339 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
4340 return FXCODEC_STATUS_DECODE_TOBECONTINUE;
4341 }
4342 }
4343 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
4344 return FXCODEC_STATUS_DECODE_FINISH;
4345 }
4346 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template1_unopt(
4347 CJBig2_Image* pImage,
4348 CJBig2_ArithDecoder* pArithDecoder,
4349 JBig2ArithCtx* gbContext,
4350 IFX_Pause* pPause) {
4351 FX_BOOL SLTP, bVal;
4352 FX_DWORD CONTEXT;
4353 FX_DWORD line1, line2, line3;
4354 for (FX_DWORD h = 0; h < GBH; h++) {
4355 if (TPGDON) {
4356 SLTP = pArithDecoder->DECODE(&gbContext[0x0795]);
4357 LTP = LTP ^ SLTP;
4358 }
4359 if (LTP == 1) {
4360 pImage->copyLine(h, h - 1);
4361 } else {
4362 line1 = pImage->getPixel(2, h - 2);
4363 line1 |= pImage->getPixel(1, h - 2) << 1;
4364 line1 |= pImage->getPixel(0, h - 2) << 2;
4365 line2 = pImage->getPixel(2, h - 1);
4366 line2 |= pImage->getPixel(1, h - 1) << 1;
4367 line2 |= pImage->getPixel(0, h - 1) << 2;
4368 line3 = 0;
4369 for (FX_DWORD w = 0; w < GBW; w++) {
4370 if (USESKIP && SKIP->getPixel(w, h)) {
4371 bVal = 0;
3904 } else { 4372 } else {
3905 line1 = pImage->getPixel(1, m_loopIndex - 2); 4373 CONTEXT = line3;
3906 line1 |= pImage->getPixel(0, m_loopIndex - 2) << 1; 4374 CONTEXT |= pImage->getPixel(w + GBAT[0], h + GBAT[1]) << 3;
3907 line2 = pImage->getPixel(2, m_loopIndex - 1); 4375 CONTEXT |= line2 << 4;
3908 line2 |= pImage->getPixel(1, m_loopIndex - 1) << 1; 4376 CONTEXT |= line1 << 9;
3909 line2 |= pImage->getPixel(0, m_loopIndex - 1) << 2; 4377 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
3910 line3 = 0; 4378 }
3911 for(FX_DWORD w = 0; w < GBW; w++) { 4379 if (bVal) {
3912 if(USESKIP && SKIP->getPixel(w, m_loopIndex)) { 4380 pImage->setPixel(w, h, bVal);
3913 bVal = 0; 4381 }
3914 } else { 4382 line1 = ((line1 << 1) | pImage->getPixel(w + 3, h - 2)) & 0x0f;
3915 CONTEXT = line3; 4383 line2 = ((line2 << 1) | pImage->getPixel(w + 3, h - 1)) & 0x1f;
3916 CONTEXT |= pImage->getPixel(w + GBAT[0], m_loopIndex + GBAT[ 1]) << 4; 4384 line3 = ((line3 << 1) | bVal) & 0x07;
3917 CONTEXT |= line2 << 5; 4385 }
3918 CONTEXT |= pImage->getPixel(w + GBAT[2], m_loopIndex + GBAT[ 3]) << 10; 4386 }
3919 CONTEXT |= pImage->getPixel(w + GBAT[4], m_loopIndex + GBAT[ 5]) << 11; 4387 if (pPause && pPause->NeedToPauseNow()) {
3920 CONTEXT |= line1 << 12; 4388 m_loopIndex++;
3921 CONTEXT |= pImage->getPixel(w + GBAT[6], m_loopIndex + GBAT[ 7]) << 15; 4389 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
3922 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]); 4390 return FXCODEC_STATUS_DECODE_TOBECONTINUE;
3923 } 4391 }
3924 if(bVal) { 4392 }
3925 pImage->setPixel(w, m_loopIndex, bVal); 4393 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
3926 } 4394 return FXCODEC_STATUS_DECODE_FINISH;
3927 line1 = ((line1 << 1) | pImage->getPixel(w + 2, m_loopIndex - 2) ) & 0x07; 4395 }
3928 line2 = ((line2 << 1) | pImage->getPixel(w + 3, m_loopIndex - 1) ) & 0x1f; 4396 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template2_opt3(
3929 line3 = ((line3 << 1) | bVal) & 0x0f; 4397 CJBig2_Image* pImage,
3930 } 4398 CJBig2_ArithDecoder* pArithDecoder,
3931 } 4399 JBig2ArithCtx* gbContext,
3932 if(pPause && pPause->NeedToPauseNow()) { 4400 IFX_Pause* pPause) {
3933 m_loopIndex++; 4401 FX_BOOL SLTP, bVal;
3934 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE; 4402 FX_DWORD CONTEXT;
3935 return FXCODEC_STATUS_DECODE_TOBECONTINUE; 4403 FX_DWORD line1, line2;
3936 } 4404 uint8_t *pLine1, *pLine2, cVal;
3937 } 4405 int32_t nStride, nStride2, k;
3938 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH; 4406 int32_t nLineBytes, nBitsLeft, cc;
3939 return FXCODEC_STATUS_DECODE_FINISH; 4407 if (!m_pLine) {
3940 } 4408 m_pLine = pImage->m_pData;
3941 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template1_opt3(CJBig2_Image *pImage, CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext, IFX_Pause* pPause ) 4409 }
3942 { 4410 nStride = pImage->m_nStride;
3943 FX_BOOL SLTP, bVal; 4411 nStride2 = nStride << 1;
3944 FX_DWORD CONTEXT; 4412 nLineBytes = ((GBW + 7) >> 3) - 1;
3945 FX_DWORD line1, line2; 4413 nBitsLeft = GBW - (nLineBytes << 3);
3946 uint8_t *pLine1, *pLine2, cVal; 4414 for (; m_loopIndex < GBH; m_loopIndex++) {
3947 int32_t nStride, nStride2, k; 4415 if (TPGDON) {
3948 int32_t nLineBytes, nBitsLeft, cc; 4416 SLTP = pArithDecoder->DECODE(&gbContext[0x00e5]);
3949 if (!m_pLine) { 4417 LTP = LTP ^ SLTP;
3950 m_pLine = pImage->m_pData; 4418 }
3951 } 4419 if (LTP == 1) {
3952 nStride = pImage->m_nStride; 4420 pImage->copyLine(m_loopIndex, m_loopIndex - 1);
3953 nStride2 = nStride << 1; 4421 } else {
3954 nLineBytes = ((GBW + 7) >> 3) - 1; 4422 if (m_loopIndex > 1) {
3955 nBitsLeft = GBW - (nLineBytes << 3); 4423 pLine1 = m_pLine - nStride2;
3956 for(; m_loopIndex < GBH; m_loopIndex++) { 4424 pLine2 = m_pLine - nStride;
3957 if(TPGDON) { 4425 line1 = (*pLine1++) << 1;
3958 SLTP = pArithDecoder->DECODE(&gbContext[0x0795]); 4426 line2 = *pLine2++;
3959 LTP = LTP ^ SLTP; 4427 CONTEXT = (line1 & 0x0380) | ((line2 >> 3) & 0x007c);
3960 } 4428 for (cc = 0; cc < nLineBytes; cc++) {
3961 if(LTP == 1) { 4429 line1 = (line1 << 8) | ((*pLine1++) << 1);
3962 pImage->copyLine(m_loopIndex, m_loopIndex - 1); 4430 line2 = (line2 << 8) | (*pLine2++);
4431 cVal = 0;
4432 for (k = 7; k >= 0; k--) {
4433 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
4434 cVal |= bVal << k;
4435 CONTEXT = ((CONTEXT & 0x01bd) << 1) | bVal |
4436 ((line1 >> k) & 0x0080) | ((line2 >> (k + 3)) & 0x0004);
4437 }
4438 m_pLine[cc] = cVal;
4439 }
4440 line1 <<= 8;
4441 line2 <<= 8;
4442 cVal = 0;
4443 for (k = 0; k < nBitsLeft; k++) {
4444 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
4445 cVal |= bVal << (7 - k);
4446 CONTEXT = ((CONTEXT & 0x01bd) << 1) | bVal |
4447 ((line1 >> (7 - k)) & 0x0080) |
4448 ((line2 >> (10 - k)) & 0x0004);
4449 }
4450 m_pLine[nLineBytes] = cVal;
4451 } else {
4452 pLine2 = m_pLine - nStride;
4453 line2 = (m_loopIndex & 1) ? (*pLine2++) : 0;
4454 CONTEXT = (line2 >> 3) & 0x007c;
4455 for (cc = 0; cc < nLineBytes; cc++) {
4456 if (m_loopIndex & 1) {
4457 line2 = (line2 << 8) | (*pLine2++);
4458 }
4459 cVal = 0;
4460 for (k = 7; k >= 0; k--) {
4461 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
4462 cVal |= bVal << k;
4463 CONTEXT = ((CONTEXT & 0x01bd) << 1) | bVal |
4464 ((line2 >> (k + 3)) & 0x0004);
4465 }
4466 m_pLine[cc] = cVal;
4467 }
4468 line2 <<= 8;
4469 cVal = 0;
4470 for (k = 0; k < nBitsLeft; k++) {
4471 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
4472 cVal |= bVal << (7 - k);
4473 CONTEXT = ((CONTEXT & 0x01bd) << 1) | bVal |
4474 (((line2 >> (10 - k))) & 0x0004);
4475 }
4476 m_pLine[nLineBytes] = cVal;
4477 }
4478 }
4479 m_pLine += nStride;
4480 if (pPause && m_loopIndex % 50 == 0 && pPause->NeedToPauseNow()) {
4481 m_loopIndex++;
4482 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
4483 return FXCODEC_STATUS_DECODE_TOBECONTINUE;
4484 }
4485 }
4486 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
4487 return FXCODEC_STATUS_DECODE_FINISH;
4488 }
4489 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template2_unopt(
4490 CJBig2_Image* pImage,
4491 CJBig2_ArithDecoder* pArithDecoder,
4492 JBig2ArithCtx* gbContext,
4493 IFX_Pause* pPause) {
4494 FX_BOOL SLTP, bVal;
4495 FX_DWORD CONTEXT;
4496 FX_DWORD line1, line2, line3;
4497 for (; m_loopIndex < GBH; m_loopIndex++) {
4498 if (TPGDON) {
4499 SLTP = pArithDecoder->DECODE(&gbContext[0x00e5]);
4500 LTP = LTP ^ SLTP;
4501 }
4502 if (LTP == 1) {
4503 pImage->copyLine(m_loopIndex, m_loopIndex - 1);
4504 } else {
4505 line1 = pImage->getPixel(1, m_loopIndex - 2);
4506 line1 |= pImage->getPixel(0, m_loopIndex - 2) << 1;
4507 line2 = pImage->getPixel(1, m_loopIndex - 1);
4508 line2 |= pImage->getPixel(0, m_loopIndex - 1) << 1;
4509 line3 = 0;
4510 for (FX_DWORD w = 0; w < GBW; w++) {
4511 if (USESKIP && SKIP->getPixel(w, m_loopIndex)) {
4512 bVal = 0;
3963 } else { 4513 } else {
3964 if(m_loopIndex > 1) { 4514 CONTEXT = line3;
3965 pLine1 = m_pLine - nStride2; 4515 CONTEXT |= pImage->getPixel(w + GBAT[0], m_loopIndex + GBAT[1]) << 2;
3966 pLine2 = m_pLine - nStride; 4516 CONTEXT |= line2 << 3;
3967 line1 = (*pLine1++) << 4; 4517 CONTEXT |= line1 << 7;
3968 line2 = *pLine2++; 4518 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
3969 CONTEXT = (line1 & 0x1e00) | ((line2 >> 1) & 0x01f8); 4519 }
3970 for(cc = 0; cc < nLineBytes; cc++) { 4520 if (bVal) {
3971 line1 = (line1 << 8) | ((*pLine1++) << 4); 4521 pImage->setPixel(w, m_loopIndex, bVal);
3972 line2 = (line2 << 8) | (*pLine2++); 4522 }
3973 cVal = 0; 4523 line1 =
3974 for(k = 7; k >= 0; k--) { 4524 ((line1 << 1) | pImage->getPixel(w + 2, m_loopIndex - 2)) & 0x07;
3975 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]); 4525 line2 =
3976 cVal |= bVal << k; 4526 ((line2 << 1) | pImage->getPixel(w + 2, m_loopIndex - 1)) & 0x0f;
3977 CONTEXT = ((CONTEXT & 0x0efb) << 1) | bVal 4527 line3 = ((line3 << 1) | bVal) & 0x03;
3978 | ((line1 >> k) & 0x0200) 4528 }
3979 | ((line2 >> (k + 1)) & 0x0008); 4529 }
3980 } 4530 if (pPause && pPause->NeedToPauseNow()) {
3981 m_pLine[cc] = cVal; 4531 m_loopIndex++;
3982 } 4532 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
3983 line1 <<= 8; 4533 return FXCODEC_STATUS_DECODE_TOBECONTINUE;
3984 line2 <<= 8; 4534 }
3985 cVal = 0; 4535 }
3986 for(k = 0; k < nBitsLeft; k++) { 4536 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
3987 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]); 4537 return FXCODEC_STATUS_DECODE_FINISH;
3988 cVal |= bVal << (7 - k); 4538 }
3989 CONTEXT = ((CONTEXT & 0x0efb) << 1) | bVal 4539 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template3_opt3(
3990 | ((line1 >> (7 - k)) & 0x0200) 4540 CJBig2_Image* pImage,
3991 | ((line2 >> (8 - k)) & 0x0008); 4541 CJBig2_ArithDecoder* pArithDecoder,
3992 } 4542 JBig2ArithCtx* gbContext,
3993 m_pLine[nLineBytes] = cVal; 4543 IFX_Pause* pPause) {
3994 } else { 4544 FX_BOOL SLTP, bVal;
3995 pLine2 = m_pLine - nStride; 4545 FX_DWORD CONTEXT;
3996 line2 = (m_loopIndex & 1) ? (*pLine2++) : 0; 4546 FX_DWORD line1;
3997 CONTEXT = (line2 >> 1) & 0x01f8; 4547 uint8_t *pLine1, cVal;
3998 for(cc = 0; cc < nLineBytes; cc++) { 4548 int32_t nStride, k;
3999 if(m_loopIndex & 1) { 4549 int32_t nLineBytes, nBitsLeft, cc;
4000 line2 = (line2 << 8) | (*pLine2++); 4550 if (!m_pLine) {
4001 } 4551 m_pLine = pImage->m_pData;
4002 cVal = 0; 4552 }
4003 for(k = 7; k >= 0; k--) { 4553 nStride = pImage->m_nStride;
4004 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]); 4554 nLineBytes = ((GBW + 7) >> 3) - 1;
4005 cVal |= bVal << k; 4555 nBitsLeft = GBW - (nLineBytes << 3);
4006 CONTEXT = ((CONTEXT & 0x0efb) << 1) | bVal 4556 for (; m_loopIndex < GBH; m_loopIndex++) {
4007 | ((line2 >> (k + 1)) & 0x0008); 4557 if (TPGDON) {
4008 } 4558 SLTP = pArithDecoder->DECODE(&gbContext[0x0195]);
4009 m_pLine[cc] = cVal; 4559 LTP = LTP ^ SLTP;
4010 } 4560 }
4011 line2 <<= 8; 4561 if (LTP == 1) {
4012 cVal = 0; 4562 pImage->copyLine(m_loopIndex, m_loopIndex - 1);
4013 for(k = 0; k < nBitsLeft; k++) { 4563 } else {
4014 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]); 4564 if (m_loopIndex > 0) {
4015 cVal |= bVal << (7 - k); 4565 pLine1 = m_pLine - nStride;
4016 CONTEXT = ((CONTEXT & 0x0efb) << 1) | bVal 4566 line1 = *pLine1++;
4017 | ((line2 >> (8 - k)) & 0x0008); 4567 CONTEXT = (line1 >> 1) & 0x03f0;
4018 } 4568 for (cc = 0; cc < nLineBytes; cc++) {
4019 m_pLine[nLineBytes] = cVal; 4569 line1 = (line1 << 8) | (*pLine1++);
4020 } 4570 cVal = 0;
4021 } 4571 for (k = 7; k >= 0; k--) {
4022 m_pLine += nStride; 4572 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
4023 if(pPause && pPause->NeedToPauseNow()) { 4573 cVal |= bVal << k;
4024 m_loopIndex++; 4574 CONTEXT = ((CONTEXT & 0x01f7) << 1) | bVal |
4025 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE; 4575 ((line1 >> (k + 1)) & 0x0010);
4026 return FXCODEC_STATUS_DECODE_TOBECONTINUE; 4576 }
4027 } 4577 m_pLine[cc] = cVal;
4028 } 4578 }
4029 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH; 4579 line1 <<= 8;
4030 return FXCODEC_STATUS_DECODE_FINISH; 4580 cVal = 0;
4031 } 4581 for (k = 0; k < nBitsLeft; k++) {
4032 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template1_unopt(CJBig2_Image * pImag e, CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext, IFX_Pause* pPau se) 4582 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
4033 { 4583 cVal |= bVal << (7 - k);
4034 FX_BOOL SLTP, bVal; 4584 CONTEXT =
4035 FX_DWORD CONTEXT; 4585 ((CONTEXT & 0x01f7) << 1) | bVal | ((line1 >> (8 - k)) & 0x0010);
4036 FX_DWORD line1, line2, line3; 4586 }
4037 for(FX_DWORD h = 0; h < GBH; h++) { 4587 m_pLine[nLineBytes] = cVal;
4038 if(TPGDON) { 4588 } else {
4039 SLTP = pArithDecoder->DECODE(&gbContext[0x0795]); 4589 CONTEXT = 0;
4040 LTP = LTP ^ SLTP; 4590 for (cc = 0; cc < nLineBytes; cc++) {
4041 } 4591 cVal = 0;
4042 if(LTP == 1) { 4592 for (k = 7; k >= 0; k--) {
4043 pImage->copyLine(h, h - 1); 4593 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
4594 cVal |= bVal << k;
4595 CONTEXT = ((CONTEXT & 0x01f7) << 1) | bVal;
4596 }
4597 m_pLine[cc] = cVal;
4598 }
4599 cVal = 0;
4600 for (k = 0; k < nBitsLeft; k++) {
4601 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
4602 cVal |= bVal << (7 - k);
4603 CONTEXT = ((CONTEXT & 0x01f7) << 1) | bVal;
4604 }
4605 m_pLine[nLineBytes] = cVal;
4606 }
4607 }
4608 m_pLine += nStride;
4609 if (pPause && pPause->NeedToPauseNow()) {
4610 m_loopIndex++;
4611 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
4612 return FXCODEC_STATUS_DECODE_TOBECONTINUE;
4613 }
4614 }
4615 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
4616 return FXCODEC_STATUS_DECODE_FINISH;
4617 }
4618 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template3_unopt(
4619 CJBig2_Image* pImage,
4620 CJBig2_ArithDecoder* pArithDecoder,
4621 JBig2ArithCtx* gbContext,
4622 IFX_Pause* pPause) {
4623 FX_BOOL SLTP, bVal;
4624 FX_DWORD CONTEXT;
4625 FX_DWORD line1, line2;
4626 for (; m_loopIndex < GBH; m_loopIndex++) {
4627 if (TPGDON) {
4628 SLTP = pArithDecoder->DECODE(&gbContext[0x0195]);
4629 LTP = LTP ^ SLTP;
4630 }
4631 if (LTP == 1) {
4632 pImage->copyLine(m_loopIndex, m_loopIndex - 1);
4633 } else {
4634 line1 = pImage->getPixel(1, m_loopIndex - 1);
4635 line1 |= pImage->getPixel(0, m_loopIndex - 1) << 1;
4636 line2 = 0;
4637 for (FX_DWORD w = 0; w < GBW; w++) {
4638 if (USESKIP && SKIP->getPixel(w, m_loopIndex)) {
4639 bVal = 0;
4044 } else { 4640 } else {
4045 line1 = pImage->getPixel(2, h - 2); 4641 CONTEXT = line2;
4046 line1 |= pImage->getPixel(1, h - 2) << 1; 4642 CONTEXT |= pImage->getPixel(w + GBAT[0], m_loopIndex + GBAT[1]) << 4;
4047 line1 |= pImage->getPixel(0, h - 2) << 2; 4643 CONTEXT |= line1 << 5;
4048 line2 = pImage->getPixel(2, h - 1); 4644 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
4049 line2 |= pImage->getPixel(1, h - 1) << 1; 4645 }
4050 line2 |= pImage->getPixel(0, h - 1) << 2; 4646 if (bVal) {
4051 line3 = 0; 4647 pImage->setPixel(w, m_loopIndex, bVal);
4052 for(FX_DWORD w = 0; w < GBW; w++) { 4648 }
4053 if(USESKIP && SKIP->getPixel(w, h)) { 4649 line1 =
4054 bVal = 0; 4650 ((line1 << 1) | pImage->getPixel(w + 2, m_loopIndex - 1)) & 0x1f;
4055 } else { 4651 line2 = ((line2 << 1) | bVal) & 0x0f;
4056 CONTEXT = line3; 4652 }
4057 CONTEXT |= pImage->getPixel(w + GBAT[0], h + GBAT[1]) << 3; 4653 }
4058 CONTEXT |= line2 << 4; 4654 if (pPause && pPause->NeedToPauseNow()) {
4059 CONTEXT |= line1 << 9; 4655 m_loopIndex++;
4060 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]); 4656 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
4061 } 4657 return FXCODEC_STATUS_DECODE_TOBECONTINUE;
4062 if(bVal) { 4658 }
4063 pImage->setPixel(w, h, bVal); 4659 }
4064 } 4660 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
4065 line1 = ((line1 << 1) | pImage->getPixel(w + 3, h - 2)) & 0x0f; 4661 return FXCODEC_STATUS_DECODE_FINISH;
4066 line2 = ((line2 << 1) | pImage->getPixel(w + 3, h - 1)) & 0x1f; 4662 }
4067 line3 = ((line3 << 1) | bVal) & 0x07;
4068 }
4069 }
4070 if(pPause && pPause->NeedToPauseNow()) {
4071 m_loopIndex++;
4072 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
4073 return FXCODEC_STATUS_DECODE_TOBECONTINUE;
4074 }
4075 }
4076 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
4077 return FXCODEC_STATUS_DECODE_FINISH;
4078 }
4079 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template2_opt3(CJBig2_Image *pImage, CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext, IFX_Pause* pPause )
4080 {
4081 FX_BOOL SLTP, bVal;
4082 FX_DWORD CONTEXT;
4083 FX_DWORD line1, line2;
4084 uint8_t *pLine1, *pLine2, cVal;
4085 int32_t nStride, nStride2, k;
4086 int32_t nLineBytes, nBitsLeft, cc;
4087 if(!m_pLine) {
4088 m_pLine = pImage->m_pData;
4089 }
4090 nStride = pImage->m_nStride;
4091 nStride2 = nStride << 1;
4092 nLineBytes = ((GBW + 7) >> 3) - 1;
4093 nBitsLeft = GBW - (nLineBytes << 3);
4094 for(; m_loopIndex < GBH; m_loopIndex++) {
4095 if(TPGDON) {
4096 SLTP = pArithDecoder->DECODE(&gbContext[0x00e5]);
4097 LTP = LTP ^ SLTP;
4098 }
4099 if(LTP == 1) {
4100 pImage->copyLine(m_loopIndex, m_loopIndex - 1);
4101 } else {
4102 if(m_loopIndex > 1) {
4103 pLine1 = m_pLine - nStride2;
4104 pLine2 = m_pLine - nStride;
4105 line1 = (*pLine1++) << 1;
4106 line2 = *pLine2++;
4107 CONTEXT = (line1 & 0x0380) | ((line2 >> 3) & 0x007c);
4108 for(cc = 0; cc < nLineBytes; cc++) {
4109 line1 = (line1 << 8) | ((*pLine1++) << 1);
4110 line2 = (line2 << 8) | (*pLine2++);
4111 cVal = 0;
4112 for(k = 7; k >= 0; k--) {
4113 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
4114 cVal |= bVal << k;
4115 CONTEXT = ((CONTEXT & 0x01bd) << 1) | bVal
4116 | ((line1 >> k) & 0x0080)
4117 | ((line2 >> (k + 3)) & 0x0004);
4118 }
4119 m_pLine[cc] = cVal;
4120 }
4121 line1 <<= 8;
4122 line2 <<= 8;
4123 cVal = 0;
4124 for(k = 0; k < nBitsLeft; k++) {
4125 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
4126 cVal |= bVal << (7 - k);
4127 CONTEXT = ((CONTEXT & 0x01bd) << 1) | bVal
4128 | ((line1 >> (7 - k)) & 0x0080)
4129 | ((line2 >> (10 - k)) & 0x0004);
4130 }
4131 m_pLine[nLineBytes] = cVal;
4132 } else {
4133 pLine2 = m_pLine - nStride;
4134 line2 = (m_loopIndex & 1) ? (*pLine2++) : 0;
4135 CONTEXT = (line2 >> 3) & 0x007c;
4136 for(cc = 0; cc < nLineBytes; cc++) {
4137 if(m_loopIndex & 1) {
4138 line2 = (line2 << 8) | (*pLine2++);
4139 }
4140 cVal = 0;
4141 for(k = 7; k >= 0; k--) {
4142 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
4143 cVal |= bVal << k;
4144 CONTEXT = ((CONTEXT & 0x01bd) << 1) | bVal
4145 | ((line2 >> (k + 3)) & 0x0004);
4146 }
4147 m_pLine[cc] = cVal;
4148 }
4149 line2 <<= 8;
4150 cVal = 0;
4151 for(k = 0; k < nBitsLeft; k++) {
4152 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
4153 cVal |= bVal << (7 - k);
4154 CONTEXT = ((CONTEXT & 0x01bd) << 1) | bVal
4155 | (((line2 >> (10 - k))) & 0x0004);
4156 }
4157 m_pLine[nLineBytes] = cVal;
4158 }
4159 }
4160 m_pLine += nStride;
4161 if(pPause && m_loopIndex % 50 == 0 && pPause->NeedToPauseNow()) {
4162 m_loopIndex++;
4163 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
4164 return FXCODEC_STATUS_DECODE_TOBECONTINUE;
4165 }
4166 }
4167 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
4168 return FXCODEC_STATUS_DECODE_FINISH;
4169 }
4170 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template2_unopt(CJBig2_Image * pImag e, CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext, IFX_Pause* pPau se)
4171 {
4172 FX_BOOL SLTP, bVal;
4173 FX_DWORD CONTEXT;
4174 FX_DWORD line1, line2, line3;
4175 for(; m_loopIndex < GBH; m_loopIndex++) {
4176 if(TPGDON) {
4177 SLTP = pArithDecoder->DECODE(&gbContext[0x00e5]);
4178 LTP = LTP ^ SLTP;
4179 }
4180 if(LTP == 1) {
4181 pImage->copyLine(m_loopIndex, m_loopIndex - 1);
4182 } else {
4183 line1 = pImage->getPixel(1, m_loopIndex - 2);
4184 line1 |= pImage->getPixel(0, m_loopIndex - 2) << 1;
4185 line2 = pImage->getPixel(1, m_loopIndex - 1);
4186 line2 |= pImage->getPixel(0, m_loopIndex - 1) << 1;
4187 line3 = 0;
4188 for(FX_DWORD w = 0; w < GBW; w++) {
4189 if(USESKIP && SKIP->getPixel(w, m_loopIndex)) {
4190 bVal = 0;
4191 } else {
4192 CONTEXT = line3;
4193 CONTEXT |= pImage->getPixel(w + GBAT[0], m_loopIndex + GBAT[ 1]) << 2;
4194 CONTEXT |= line2 << 3;
4195 CONTEXT |= line1 << 7;
4196 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
4197 }
4198 if(bVal) {
4199 pImage->setPixel(w, m_loopIndex, bVal);
4200 }
4201 line1 = ((line1 << 1) | pImage->getPixel(w + 2, m_loopIndex - 2) ) & 0x07;
4202 line2 = ((line2 << 1) | pImage->getPixel(w + 2, m_loopIndex - 1) ) & 0x0f;
4203 line3 = ((line3 << 1) | bVal) & 0x03;
4204 }
4205 }
4206 if(pPause && pPause->NeedToPauseNow()) {
4207 m_loopIndex++;
4208 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
4209 return FXCODEC_STATUS_DECODE_TOBECONTINUE;
4210 }
4211 }
4212 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
4213 return FXCODEC_STATUS_DECODE_FINISH;
4214 }
4215 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template3_opt3(CJBig2_Image *pImage, CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext, IFX_Pause* pPause )
4216 {
4217 FX_BOOL SLTP, bVal;
4218 FX_DWORD CONTEXT;
4219 FX_DWORD line1;
4220 uint8_t *pLine1, cVal;
4221 int32_t nStride, k;
4222 int32_t nLineBytes, nBitsLeft, cc;
4223 if (!m_pLine) {
4224 m_pLine = pImage->m_pData;
4225 }
4226 nStride = pImage->m_nStride;
4227 nLineBytes = ((GBW + 7) >> 3) - 1;
4228 nBitsLeft = GBW - (nLineBytes << 3);
4229 for(; m_loopIndex < GBH; m_loopIndex++) {
4230 if(TPGDON) {
4231 SLTP = pArithDecoder->DECODE(&gbContext[0x0195]);
4232 LTP = LTP ^ SLTP;
4233 }
4234 if(LTP == 1) {
4235 pImage->copyLine(m_loopIndex, m_loopIndex - 1);
4236 } else {
4237 if(m_loopIndex > 0) {
4238 pLine1 = m_pLine - nStride;
4239 line1 = *pLine1++;
4240 CONTEXT = (line1 >> 1) & 0x03f0;
4241 for(cc = 0; cc < nLineBytes; cc++) {
4242 line1 = (line1 << 8) | (*pLine1++);
4243 cVal = 0;
4244 for(k = 7; k >= 0; k--) {
4245 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
4246 cVal |= bVal << k;
4247 CONTEXT = ((CONTEXT & 0x01f7) << 1) | bVal
4248 | ((line1 >> (k + 1)) & 0x0010);
4249 }
4250 m_pLine[cc] = cVal;
4251 }
4252 line1 <<= 8;
4253 cVal = 0;
4254 for(k = 0; k < nBitsLeft; k++) {
4255 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
4256 cVal |= bVal << (7 - k);
4257 CONTEXT = ((CONTEXT & 0x01f7) << 1) | bVal
4258 | ((line1 >> (8 - k)) & 0x0010);
4259 }
4260 m_pLine[nLineBytes] = cVal;
4261 } else {
4262 CONTEXT = 0;
4263 for(cc = 0; cc < nLineBytes; cc++) {
4264 cVal = 0;
4265 for(k = 7; k >= 0; k--) {
4266 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
4267 cVal |= bVal << k;
4268 CONTEXT = ((CONTEXT & 0x01f7) << 1) | bVal;
4269 }
4270 m_pLine[cc] = cVal;
4271 }
4272 cVal = 0;
4273 for(k = 0; k < nBitsLeft; k++) {
4274 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
4275 cVal |= bVal << (7 - k);
4276 CONTEXT = ((CONTEXT & 0x01f7) << 1) | bVal;
4277 }
4278 m_pLine[nLineBytes] = cVal;
4279 }
4280 }
4281 m_pLine += nStride;
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 }
4291 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template3_unopt(CJBig2_Image * pImag e, CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext, IFX_Pause* pPau se)
4292 {
4293 FX_BOOL SLTP, bVal;
4294 FX_DWORD CONTEXT;
4295 FX_DWORD line1, line2;
4296 for(; m_loopIndex < GBH; m_loopIndex++) {
4297 if(TPGDON) {
4298 SLTP = pArithDecoder->DECODE(&gbContext[0x0195]);
4299 LTP = LTP ^ SLTP;
4300 }
4301 if(LTP == 1) {
4302 pImage->copyLine(m_loopIndex, m_loopIndex - 1);
4303 } else {
4304 line1 = pImage->getPixel(1, m_loopIndex - 1);
4305 line1 |= pImage->getPixel(0, m_loopIndex - 1) << 1;
4306 line2 = 0;
4307 for(FX_DWORD w = 0; w < GBW; w++) {
4308 if(USESKIP && SKIP->getPixel(w, m_loopIndex)) {
4309 bVal = 0;
4310 } else {
4311 CONTEXT = line2;
4312 CONTEXT |= pImage->getPixel(w + GBAT[0], m_loopIndex + GBAT[ 1]) << 4;
4313 CONTEXT |= line1 << 5;
4314 bVal = pArithDecoder->DECODE(&gbContext[CONTEXT]);
4315 }
4316 if(bVal) {
4317 pImage->setPixel(w, m_loopIndex, bVal);
4318 }
4319 line1 = ((line1 << 1) | pImage->getPixel(w + 2, m_loopIndex - 1) ) & 0x1f;
4320 line2 = ((line2 << 1) | bVal) & 0x0f;
4321 }
4322 }
4323 if(pPause && pPause->NeedToPauseNow()) {
4324 m_loopIndex++;
4325 m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
4326 return FXCODEC_STATUS_DECODE_TOBECONTINUE;
4327 }
4328 }
4329 m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
4330 return FXCODEC_STATUS_DECODE_FINISH;
4331 }
OLDNEW
« no previous file with comments | « core/src/fxcodec/jbig2/JBig2_GeneralDecoder.h ('k') | core/src/fxcodec/jbig2/JBig2_HuffmanDecoder.h » ('j') | fpdfsdk/src/javascript/Consts.cpp » ('J')

Powered by Google App Engine
This is Rietveld 408576698