Qt
Internal/Contributor docs for the Qt SDK. Note: These are NOT official API docs; those are found at https://doc.qt.io/
Loading...
Searching...
No Matches
JBig2_GrdProc.cpp
Go to the documentation of this file.
1// Copyright 2015 The PDFium Authors
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
6
7#include "core/fxcodec/jbig2/JBig2_GrdProc.h"
8
9#include <functional>
10#include <memory>
11#include <utility>
12
13#include "core/fxcodec/fax/faxmodule.h"
14#include "core/fxcodec/jbig2/JBig2_ArithDecoder.h"
15#include "core/fxcodec/jbig2/JBig2_BitStream.h"
16#include "core/fxcodec/jbig2/JBig2_Image.h"
17#include "core/fxcrt/pauseindicator_iface.h"
18
19namespace {
20
21// TODO(npm): Name this constants better or merge some together.
22constexpr uint16_t kOptConstant1[] = {0x9b25, 0x0795, 0x00e5};
23constexpr uint16_t kOptConstant2[] = {0x0006, 0x0004, 0x0001};
24constexpr uint16_t kOptConstant3[] = {0xf800, 0x1e00, 0x0380};
25constexpr uint16_t kOptConstant4[] = {0x0000, 0x0001, 0x0003};
26constexpr uint16_t kOptConstant5[] = {0x07f0, 0x01f8, 0x007c};
27constexpr uint16_t kOptConstant6[] = {0x7bf7, 0x0efb, 0x01bd};
28constexpr uint16_t kOptConstant7[] = {0x0800, 0x0200, 0x0080};
29constexpr uint16_t kOptConstant8[] = {0x0010, 0x0008, 0x0004};
30constexpr uint16_t kOptConstant9[] = {0x000c, 0x0009, 0x0007};
31constexpr uint16_t kOptConstant10[] = {0x0007, 0x000f, 0x0007};
32constexpr uint16_t kOptConstant11[] = {0x001f, 0x001f, 0x000f};
33constexpr uint16_t kOptConstant12[] = {0x000f, 0x0007, 0x0003};
34
35} // namespace
36
37CJBig2_GRDProc::ProgressiveArithDecodeState::ProgressiveArithDecodeState() =
38 default;
39
40CJBig2_GRDProc::ProgressiveArithDecodeState::~ProgressiveArithDecodeState() =
41 default;
42
43CJBig2_GRDProc::CJBig2_GRDProc() = default;
44
45CJBig2_GRDProc::~CJBig2_GRDProc() = default;
46
47bool CJBig2_GRDProc::UseTemplate0Opt3() const {
48 return (GBAT[0] == 3) && (GBAT[1] == -1) && (GBAT[2] == -3) &&
49 (GBAT[3] == -1) && (GBAT[4] == 2) && (GBAT[5] == -2) &&
50 (GBAT[6] == -2) && (GBAT[7] == -2);
51}
52
53bool CJBig2_GRDProc::UseTemplate1Opt3() const {
54 return (GBAT[0] == 3) && (GBAT[1] == -1);
55}
56
57bool CJBig2_GRDProc::UseTemplate23Opt3() const {
58 return (GBAT[0] == 2) && (GBAT[1] == -1);
59}
60
61std::unique_ptr<CJBig2_Image> CJBig2_GRDProc::DecodeArith(
62 CJBig2_ArithDecoder* pArithDecoder,
63 JBig2ArithCtx* gbContext) {
64 if (!CJBig2_Image::IsValidImageSize(GBW, GBH))
65 return std::make_unique<CJBig2_Image>(GBW, GBH);
66
67 switch (GBTEMPLATE) {
68 case 0:
69 return UseTemplate0Opt3()
70 ? DecodeArithOpt3(pArithDecoder, gbContext, 0)
71 : DecodeArithTemplateUnopt(pArithDecoder, gbContext, 0);
72 case 1:
73 return UseTemplate1Opt3()
74 ? DecodeArithOpt3(pArithDecoder, gbContext, 1)
75 : DecodeArithTemplateUnopt(pArithDecoder, gbContext, 1);
76 case 2:
77 return UseTemplate23Opt3()
78 ? DecodeArithOpt3(pArithDecoder, gbContext, 2)
79 : DecodeArithTemplateUnopt(pArithDecoder, gbContext, 2);
80 default:
81 return UseTemplate23Opt3()
82 ? DecodeArithTemplate3Opt3(pArithDecoder, gbContext)
83 : DecodeArithTemplate3Unopt(pArithDecoder, gbContext);
84 }
85}
86
87std::unique_ptr<CJBig2_Image> CJBig2_GRDProc::DecodeArithOpt3(
88 CJBig2_ArithDecoder* pArithDecoder,
89 JBig2ArithCtx* gbContext,
90 int OPT) {
91 auto GBREG = std::make_unique<CJBig2_Image>(GBW, GBH);
92 if (!GBREG->data())
93 return nullptr;
94
95 int LTP = 0;
96 uint8_t* pLine = GBREG->data();
97 int32_t nStride = GBREG->stride();
98 int32_t nStride2 = nStride << 1;
99 int32_t nLineBytes = ((GBW + 7) >> 3) - 1;
100 int32_t nBitsLeft = GBW - (nLineBytes << 3);
101 // TODO(npm): Why is the height only trimmed when OPT is 0?
102 uint32_t height = OPT == 0 ? GBH & 0x7fffffff : GBH;
103 for (uint32_t h = 0; h < height; ++h) {
104 if (TPGDON) {
105 if (pArithDecoder->IsComplete())
106 return nullptr;
107
108 LTP = LTP ^ pArithDecoder->Decode(&gbContext[kOptConstant1[OPT]]);
109 }
110 if (LTP) {
111 GBREG->CopyLine(h, h - 1);
112 } else {
113 if (h > 1) {
114 uint8_t* pLine1 = pLine - nStride2;
115 uint8_t* pLine2 = pLine - nStride;
116 uint32_t line1 = (*pLine1++) << kOptConstant2[OPT];
117 uint32_t line2 = *pLine2++;
118 uint32_t CONTEXT = (line1 & kOptConstant3[OPT]) |
119 ((line2 >> kOptConstant4[OPT]) & kOptConstant5[OPT]);
120 for (int32_t cc = 0; cc < nLineBytes; ++cc) {
121 line1 = (line1 << 8) | ((*pLine1++) << kOptConstant2[OPT]);
122 line2 = (line2 << 8) | (*pLine2++);
123 uint8_t cVal = 0;
124 for (int32_t k = 7; k >= 0; --k) {
125 if (pArithDecoder->IsComplete())
126 return nullptr;
127
128 int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
129 cVal |= bVal << k;
130 CONTEXT =
131 (((CONTEXT & kOptConstant6[OPT]) << 1) | bVal |
132 ((line1 >> k) & kOptConstant7[OPT]) |
133 ((line2 >> (k + kOptConstant4[OPT])) & kOptConstant8[OPT]));
134 }
135 pLine[cc] = cVal;
136 }
137 line1 <<= 8;
138 line2 <<= 8;
139 uint8_t cVal1 = 0;
140 for (int32_t k = 0; k < nBitsLeft; ++k) {
141 if (pArithDecoder->IsComplete())
142 return nullptr;
143
144 int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
145 cVal1 |= bVal << (7 - k);
146 CONTEXT =
147 (((CONTEXT & kOptConstant6[OPT]) << 1) | bVal |
148 ((line1 >> (7 - k)) & kOptConstant7[OPT]) |
149 ((line2 >> (7 + kOptConstant4[OPT] - k)) & kOptConstant8[OPT]));
150 }
151 pLine[nLineBytes] = cVal1;
152 } else {
153 uint8_t* pLine2 = pLine - nStride;
154 uint32_t line2 = (h & 1) ? (*pLine2++) : 0;
155 uint32_t CONTEXT = ((line2 >> kOptConstant4[OPT]) & kOptConstant5[OPT]);
156 for (int32_t cc = 0; cc < nLineBytes; ++cc) {
157 if (h & 1) {
158 line2 = (line2 << 8) | (*pLine2++);
159 }
160 uint8_t cVal = 0;
161 for (int32_t k = 7; k >= 0; --k) {
162 if (pArithDecoder->IsComplete())
163 return nullptr;
164
165 int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
166 cVal |= bVal << k;
167 CONTEXT =
168 (((CONTEXT & kOptConstant6[OPT]) << 1) | bVal |
169 ((line2 >> (k + kOptConstant4[OPT])) & kOptConstant8[OPT]));
170 }
171 pLine[cc] = cVal;
172 }
173 line2 <<= 8;
174 uint8_t cVal1 = 0;
175 for (int32_t k = 0; k < nBitsLeft; ++k) {
176 if (pArithDecoder->IsComplete())
177 return nullptr;
178
179 int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
180 cVal1 |= bVal << (7 - k);
181 CONTEXT = (((CONTEXT & kOptConstant6[OPT]) << 1) | bVal |
182 (((line2 >> (7 + kOptConstant4[OPT] - k))) &
183 kOptConstant8[OPT]));
184 }
185 pLine[nLineBytes] = cVal1;
186 }
187 }
188 pLine += nStride;
189 }
190 return GBREG;
191}
192
193std::unique_ptr<CJBig2_Image> CJBig2_GRDProc::DecodeArithTemplateUnopt(
194 CJBig2_ArithDecoder* pArithDecoder,
195 JBig2ArithCtx* gbContext,
196 int UNOPT) {
197 auto GBREG = std::make_unique<CJBig2_Image>(GBW, GBH);
198 if (!GBREG->data())
199 return nullptr;
200
201 GBREG->Fill(false);
202 int LTP = 0;
203 uint8_t MOD2 = UNOPT % 2;
204 uint8_t DIV2 = UNOPT / 2;
205 uint8_t SHIFT = 4 - UNOPT;
206 for (uint32_t h = 0; h < GBH; h++) {
207 if (TPGDON) {
208 if (pArithDecoder->IsComplete())
209 return nullptr;
210
211 LTP = LTP ^ pArithDecoder->Decode(&gbContext[kOptConstant1[UNOPT]]);
212 }
213 if (LTP) {
214 GBREG->CopyLine(h, h - 1);
215 continue;
216 }
217 uint32_t line1 = GBREG->GetPixel(1 + MOD2, h - 2);
218 line1 |= GBREG->GetPixel(MOD2, h - 2) << 1;
219 if (UNOPT == 1)
220 line1 |= GBREG->GetPixel(0, h - 2) << 2;
221 uint32_t line2 = GBREG->GetPixel(2 - DIV2, h - 1);
222 line2 |= GBREG->GetPixel(1 - DIV2, h - 1) << 1;
223 if (UNOPT < 2)
224 line2 |= GBREG->GetPixel(0, h - 1) << 2;
225 uint32_t line3 = 0;
226 for (uint32_t w = 0; w < GBW; w++) {
227 int bVal = 0;
228 if (!USESKIP || !SKIP->GetPixel(w, h)) {
229 if (pArithDecoder->IsComplete())
230 return nullptr;
231
232 uint32_t CONTEXT = line3;
233 CONTEXT |= GBREG->GetPixel(w + GBAT[0], h + GBAT[1]) << SHIFT;
234 CONTEXT |= line2 << (SHIFT + 1);
235 CONTEXT |= line1 << kOptConstant9[UNOPT];
236 if (UNOPT == 0) {
237 CONTEXT |= GBREG->GetPixel(w + GBAT[2], h + GBAT[3]) << 10;
238 CONTEXT |= GBREG->GetPixel(w + GBAT[4], h + GBAT[5]) << 11;
239 CONTEXT |= GBREG->GetPixel(w + GBAT[6], h + GBAT[7]) << 15;
240 }
241 bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
242 if (bVal)
243 GBREG->SetPixel(w, h, bVal);
244 }
245 line1 = ((line1 << 1) | GBREG->GetPixel(w + 2 + MOD2, h - 2)) &
246 kOptConstant10[UNOPT];
247 line2 = ((line2 << 1) | GBREG->GetPixel(w + 3 - DIV2, h - 1)) &
248 kOptConstant11[UNOPT];
249 line3 = ((line3 << 1) | bVal) & kOptConstant12[UNOPT];
250 }
251 }
252 return GBREG;
253}
254
255std::unique_ptr<CJBig2_Image> CJBig2_GRDProc::DecodeArithTemplate3Opt3(
256 CJBig2_ArithDecoder* pArithDecoder,
257 JBig2ArithCtx* gbContext) {
258 auto GBREG = std::make_unique<CJBig2_Image>(GBW, GBH);
259 if (!GBREG->data())
260 return nullptr;
261
262 int LTP = 0;
263 uint8_t* pLine = GBREG->data();
264 int32_t nStride = GBREG->stride();
265 int32_t nLineBytes = ((GBW + 7) >> 3) - 1;
266 int32_t nBitsLeft = GBW - (nLineBytes << 3);
267
268 for (uint32_t h = 0; h < GBH; h++) {
269 if (TPGDON) {
270 if (pArithDecoder->IsComplete())
271 return nullptr;
272
273 LTP = LTP ^ pArithDecoder->Decode(&gbContext[0x0195]);
274 }
275
276 if (LTP) {
277 GBREG->CopyLine(h, h - 1);
278 } else {
279 if (h > 0) {
280 uint8_t* pLine1 = pLine - nStride;
281 uint32_t line1 = *pLine1++;
282 uint32_t CONTEXT = (line1 >> 1) & 0x03f0;
283 for (int32_t cc = 0; cc < nLineBytes; cc++) {
284 line1 = (line1 << 8) | (*pLine1++);
285 uint8_t cVal = 0;
286 for (int32_t k = 7; k >= 0; k--) {
287 if (pArithDecoder->IsComplete())
288 return nullptr;
289
290 int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
291 cVal |= bVal << k;
292 CONTEXT = ((CONTEXT & 0x01f7) << 1) | bVal |
293 ((line1 >> (k + 1)) & 0x0010);
294 }
295 pLine[cc] = cVal;
296 }
297 line1 <<= 8;
298 uint8_t cVal1 = 0;
299 for (int32_t k = 0; k < nBitsLeft; k++) {
300 if (pArithDecoder->IsComplete())
301 return nullptr;
302
303 int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
304 cVal1 |= bVal << (7 - k);
305 CONTEXT =
306 ((CONTEXT & 0x01f7) << 1) | bVal | ((line1 >> (8 - k)) & 0x0010);
307 }
308 pLine[nLineBytes] = cVal1;
309 } else {
310 uint32_t CONTEXT = 0;
311 for (int32_t cc = 0; cc < nLineBytes; cc++) {
312 uint8_t cVal = 0;
313 for (int32_t k = 7; k >= 0; k--) {
314 if (pArithDecoder->IsComplete())
315 return nullptr;
316
317 int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
318 cVal |= bVal << k;
319 CONTEXT = ((CONTEXT & 0x01f7) << 1) | bVal;
320 }
321 pLine[cc] = cVal;
322 }
323 uint8_t cVal1 = 0;
324 for (int32_t k = 0; k < nBitsLeft; k++) {
325 if (pArithDecoder->IsComplete())
326 return nullptr;
327
328 int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
329 cVal1 |= bVal << (7 - k);
330 CONTEXT = ((CONTEXT & 0x01f7) << 1) | bVal;
331 }
332 pLine[nLineBytes] = cVal1;
333 }
334 }
335 pLine += nStride;
336 }
337 return GBREG;
338}
339
340std::unique_ptr<CJBig2_Image> CJBig2_GRDProc::DecodeArithTemplate3Unopt(
341 CJBig2_ArithDecoder* pArithDecoder,
342 JBig2ArithCtx* gbContext) {
343 auto GBREG = std::make_unique<CJBig2_Image>(GBW, GBH);
344 if (!GBREG->data())
345 return nullptr;
346
347 GBREG->Fill(false);
348 int LTP = 0;
349 for (uint32_t h = 0; h < GBH; h++) {
350 if (TPGDON) {
351 if (pArithDecoder->IsComplete())
352 return nullptr;
353
354 LTP = LTP ^ pArithDecoder->Decode(&gbContext[0x0195]);
355 }
356 if (LTP == 1) {
357 GBREG->CopyLine(h, h - 1);
358 } else {
359 uint32_t line1 = GBREG->GetPixel(1, h - 1);
360 line1 |= GBREG->GetPixel(0, h - 1) << 1;
361 uint32_t line2 = 0;
362 for (uint32_t w = 0; w < GBW; w++) {
363 int bVal;
364 if (USESKIP && SKIP->GetPixel(w, h)) {
365 bVal = 0;
366 } else {
367 uint32_t CONTEXT = line2;
368 CONTEXT |= GBREG->GetPixel(w + GBAT[0], h + GBAT[1]) << 4;
369 CONTEXT |= line1 << 5;
370 if (pArithDecoder->IsComplete())
371 return nullptr;
372
373 bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
374 }
375 if (bVal) {
376 GBREG->SetPixel(w, h, bVal);
377 }
378 line1 = ((line1 << 1) | GBREG->GetPixel(w + 2, h - 1)) & 0x1f;
379 line2 = ((line2 << 1) | bVal) & 0x0f;
380 }
381 }
382 }
383 return GBREG;
384}
385
386FXCODEC_STATUS CJBig2_GRDProc::StartDecodeArith(
387 ProgressiveArithDecodeState* pState) {
388 if (!CJBig2_Image::IsValidImageSize(GBW, GBH)) {
389 m_ProgressiveStatus = FXCODEC_STATUS::kDecodeFinished;
390 return FXCODEC_STATUS::kDecodeFinished;
391 }
392 m_ProgressiveStatus = FXCODEC_STATUS::kDecodeReady;
393 std::unique_ptr<CJBig2_Image>* pImage = pState->pImage;
394 if (!*pImage)
395 *pImage = std::make_unique<CJBig2_Image>(GBW, GBH);
396 if (!(*pImage)->data()) {
397 *pImage = nullptr;
398 m_ProgressiveStatus = FXCODEC_STATUS::kError;
399 return FXCODEC_STATUS::kError;
400 }
401 pImage->get()->Fill(false);
402 m_DecodeType = 1;
403 m_LTP = 0;
404 m_pLine = nullptr;
405 m_loopIndex = 0;
406 return ProgressiveDecodeArith(pState);
407}
408
409FXCODEC_STATUS CJBig2_GRDProc::ProgressiveDecodeArith(
410 ProgressiveArithDecodeState* pState) {
411 int iline = m_loopIndex;
412
413 using DecodeFunction = std::function<FXCODEC_STATUS(
414 CJBig2_GRDProc&, ProgressiveArithDecodeState*)>;
415 DecodeFunction func;
416 switch (GBTEMPLATE) {
417 case 0:
418 func = UseTemplate0Opt3()
419 ? &CJBig2_GRDProc::ProgressiveDecodeArithTemplate0Opt3
420 : &CJBig2_GRDProc::ProgressiveDecodeArithTemplate0Unopt;
421 break;
422 case 1:
423 func = UseTemplate1Opt3()
424 ? &CJBig2_GRDProc::ProgressiveDecodeArithTemplate1Opt3
425 : &CJBig2_GRDProc::ProgressiveDecodeArithTemplate1Unopt;
426 break;
427 case 2:
428 func = UseTemplate23Opt3()
429 ? &CJBig2_GRDProc::ProgressiveDecodeArithTemplate2Opt3
430 : &CJBig2_GRDProc::ProgressiveDecodeArithTemplate2Unopt;
431 break;
432 default:
433 func = UseTemplate23Opt3()
434 ? &CJBig2_GRDProc::ProgressiveDecodeArithTemplate3Opt3
435 : &CJBig2_GRDProc::ProgressiveDecodeArithTemplate3Unopt;
436 break;
437 }
438 CJBig2_Image* pImage = pState->pImage->get();
439 m_ProgressiveStatus = func(*this, pState);
440 m_ReplaceRect.left = 0;
441 m_ReplaceRect.right = pImage->width();
442 m_ReplaceRect.top = iline;
443 m_ReplaceRect.bottom = m_loopIndex;
444 if (m_ProgressiveStatus == FXCODEC_STATUS::kDecodeFinished)
445 m_loopIndex = 0;
446
447 return m_ProgressiveStatus;
448}
449
450FXCODEC_STATUS CJBig2_GRDProc::StartDecodeMMR(
451 std::unique_ptr<CJBig2_Image>* pImage,
452 CJBig2_BitStream* pStream) {
453 auto image = std::make_unique<CJBig2_Image>(GBW, GBH);
454 if (!image->data()) {
455 *pImage = nullptr;
456 m_ProgressiveStatus = FXCODEC_STATUS::kError;
457 return m_ProgressiveStatus;
458 }
459 int bitpos = static_cast<int>(pStream->getBitPos());
460 bitpos =
461 FaxModule::FaxG4Decode(pStream->getBuf(), pStream->getLength(), bitpos,
462 GBW, GBH, image->stride(), image->data());
463 pStream->setBitPos(bitpos);
464 for (uint32_t i = 0; i < image->stride() * GBH; ++i)
465 image->data()[i] = ~image->data()[i];
466 m_ProgressiveStatus = FXCODEC_STATUS::kDecodeFinished;
467 *pImage = std::move(image);
468 return m_ProgressiveStatus;
469}
470
471FXCODEC_STATUS CJBig2_GRDProc::ContinueDecode(
472 ProgressiveArithDecodeState* pState) {
473 if (m_ProgressiveStatus != FXCODEC_STATUS::kDecodeToBeContinued)
474 return m_ProgressiveStatus;
475
476 if (m_DecodeType != 1) {
477 m_ProgressiveStatus = FXCODEC_STATUS::kError;
478 return m_ProgressiveStatus;
479 }
480 return ProgressiveDecodeArith(pState);
481}
482
483FXCODEC_STATUS CJBig2_GRDProc::ProgressiveDecodeArithTemplate0Opt3(
484 ProgressiveArithDecodeState* pState) {
485 CJBig2_Image* pImage = pState->pImage->get();
486 JBig2ArithCtx* gbContext = pState->gbContext;
487 CJBig2_ArithDecoder* pArithDecoder = pState->pArithDecoder;
488 if (!m_pLine)
489 m_pLine = pImage->data();
490 int32_t nStride = pImage->stride();
491 int32_t nStride2 = nStride << 1;
492 int32_t nLineBytes = ((GBW + 7) >> 3) - 1;
493 int32_t nBitsLeft = GBW - (nLineBytes << 3);
494 uint32_t height = GBH & 0x7fffffff;
495
496 for (; m_loopIndex < height; m_loopIndex++) {
497 if (TPGDON) {
498 if (pArithDecoder->IsComplete())
499 return FXCODEC_STATUS::kError;
500
501 m_LTP = m_LTP ^ pArithDecoder->Decode(&gbContext[0x9b25]);
502 }
503 if (m_LTP) {
504 pImage->CopyLine(m_loopIndex, m_loopIndex - 1);
505 } else {
506 if (m_loopIndex > 1) {
507 uint8_t* pLine1 = m_pLine - nStride2;
508 uint8_t* pLine2 = m_pLine - nStride;
509 uint32_t line1 = (*pLine1++) << 6;
510 uint32_t line2 = *pLine2++;
511 uint32_t CONTEXT = ((line1 & 0xf800) | (line2 & 0x07f0));
512 for (int32_t cc = 0; cc < nLineBytes; cc++) {
513 line1 = (line1 << 8) | ((*pLine1++) << 6);
514 line2 = (line2 << 8) | (*pLine2++);
515 uint8_t cVal = 0;
516 for (int32_t k = 7; k >= 0; k--) {
517 if (pArithDecoder->IsComplete())
518 return FXCODEC_STATUS::kError;
519
520 int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
521 cVal |= bVal << k;
522 CONTEXT = (((CONTEXT & 0x7bf7) << 1) | bVal |
523 ((line1 >> k) & 0x0800) | ((line2 >> k) & 0x0010));
524 }
525 m_pLine[cc] = cVal;
526 }
527 line1 <<= 8;
528 line2 <<= 8;
529 uint8_t cVal1 = 0;
530 for (int32_t k = 0; k < nBitsLeft; k++) {
531 if (pArithDecoder->IsComplete())
532 return FXCODEC_STATUS::kError;
533
534 int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
535 cVal1 |= bVal << (7 - k);
536 CONTEXT =
537 (((CONTEXT & 0x7bf7) << 1) | bVal |
538 ((line1 >> (7 - k)) & 0x0800) | ((line2 >> (7 - k)) & 0x0010));
539 }
540 m_pLine[nLineBytes] = cVal1;
541 } else {
542 uint8_t* pLine2 = m_pLine - nStride;
543 uint32_t line2 = (m_loopIndex & 1) ? (*pLine2++) : 0;
544 uint32_t CONTEXT = (line2 & 0x07f0);
545 for (int32_t cc = 0; cc < nLineBytes; cc++) {
546 if (m_loopIndex & 1) {
547 line2 = (line2 << 8) | (*pLine2++);
548 }
549 uint8_t cVal = 0;
550 for (int32_t k = 7; k >= 0; k--) {
551 if (pArithDecoder->IsComplete())
552 return FXCODEC_STATUS::kError;
553
554 int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
555 cVal |= bVal << k;
556 CONTEXT =
557 (((CONTEXT & 0x7bf7) << 1) | bVal | ((line2 >> k) & 0x0010));
558 }
559 m_pLine[cc] = cVal;
560 }
561 line2 <<= 8;
562 uint8_t cVal1 = 0;
563 for (int32_t k = 0; k < nBitsLeft; k++) {
564 if (pArithDecoder->IsComplete())
565 return FXCODEC_STATUS::kError;
566
567 int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
568 cVal1 |= bVal << (7 - k);
569 CONTEXT = (((CONTEXT & 0x7bf7) << 1) | bVal |
570 ((line2 >> (7 - k)) & 0x0010));
571 }
572 m_pLine[nLineBytes] = cVal1;
573 }
574 }
575 m_pLine += nStride;
576 if (pState->pPause && pState->pPause->NeedToPauseNow()) {
577 m_loopIndex++;
578 m_ProgressiveStatus = FXCODEC_STATUS::kDecodeToBeContinued;
579 return FXCODEC_STATUS::kDecodeToBeContinued;
580 }
581 }
582 m_ProgressiveStatus = FXCODEC_STATUS::kDecodeFinished;
583 return FXCODEC_STATUS::kDecodeFinished;
584}
585
586FXCODEC_STATUS CJBig2_GRDProc::ProgressiveDecodeArithTemplate0Unopt(
587 ProgressiveArithDecodeState* pState) {
588 CJBig2_Image* pImage = pState->pImage->get();
589 JBig2ArithCtx* gbContext = pState->gbContext;
590 CJBig2_ArithDecoder* pArithDecoder = pState->pArithDecoder;
591 for (; m_loopIndex < GBH; m_loopIndex++) {
592 if (TPGDON) {
593 if (pArithDecoder->IsComplete())
594 return FXCODEC_STATUS::kError;
595
596 m_LTP = m_LTP ^ pArithDecoder->Decode(&gbContext[0x9b25]);
597 }
598 if (m_LTP) {
599 pImage->CopyLine(m_loopIndex, m_loopIndex - 1);
600 } else {
601 uint32_t line1 = pImage->GetPixel(1, m_loopIndex - 2);
602 line1 |= pImage->GetPixel(0, m_loopIndex - 2) << 1;
603 uint32_t line2 = pImage->GetPixel(2, m_loopIndex - 1);
604 line2 |= pImage->GetPixel(1, m_loopIndex - 1) << 1;
605 line2 |= pImage->GetPixel(0, m_loopIndex - 1) << 2;
606 uint32_t line3 = 0;
607 for (uint32_t w = 0; w < GBW; w++) {
608 int bVal;
609 if (USESKIP && SKIP->GetPixel(w, m_loopIndex)) {
610 bVal = 0;
611 } else {
612 uint32_t CONTEXT = line3;
613 CONTEXT |= pImage->GetPixel(w + GBAT[0], m_loopIndex + GBAT[1]) << 4;
614 CONTEXT |= line2 << 5;
615 CONTEXT |= pImage->GetPixel(w + GBAT[2], m_loopIndex + GBAT[3]) << 10;
616 CONTEXT |= pImage->GetPixel(w + GBAT[4], m_loopIndex + GBAT[5]) << 11;
617 CONTEXT |= line1 << 12;
618 CONTEXT |= pImage->GetPixel(w + GBAT[6], m_loopIndex + GBAT[7]) << 15;
619 if (pArithDecoder->IsComplete())
620 return FXCODEC_STATUS::kError;
621
622 bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
623 }
624 if (bVal) {
625 pImage->SetPixel(w, m_loopIndex, bVal);
626 }
627 line1 =
628 ((line1 << 1) | pImage->GetPixel(w + 2, m_loopIndex - 2)) & 0x07;
629 line2 =
630 ((line2 << 1) | pImage->GetPixel(w + 3, m_loopIndex - 1)) & 0x1f;
631 line3 = ((line3 << 1) | bVal) & 0x0f;
632 }
633 }
634 if (pState->pPause && pState->pPause->NeedToPauseNow()) {
635 m_loopIndex++;
636 m_ProgressiveStatus = FXCODEC_STATUS::kDecodeToBeContinued;
637 return FXCODEC_STATUS::kDecodeToBeContinued;
638 }
639 }
640 m_ProgressiveStatus = FXCODEC_STATUS::kDecodeFinished;
641 return FXCODEC_STATUS::kDecodeFinished;
642}
643
644FXCODEC_STATUS CJBig2_GRDProc::ProgressiveDecodeArithTemplate1Opt3(
645 ProgressiveArithDecodeState* pState) {
646 CJBig2_Image* pImage = pState->pImage->get();
647 JBig2ArithCtx* gbContext = pState->gbContext;
648 CJBig2_ArithDecoder* pArithDecoder = pState->pArithDecoder;
649 if (!m_pLine)
650 m_pLine = pImage->data();
651 int32_t nStride = pImage->stride();
652 int32_t nStride2 = nStride << 1;
653 int32_t nLineBytes = ((GBW + 7) >> 3) - 1;
654 int32_t nBitsLeft = GBW - (nLineBytes << 3);
655 for (; m_loopIndex < GBH; m_loopIndex++) {
656 if (TPGDON) {
657 if (pArithDecoder->IsComplete())
658 return FXCODEC_STATUS::kError;
659
660 m_LTP = m_LTP ^ pArithDecoder->Decode(&gbContext[0x0795]);
661 }
662 if (m_LTP) {
663 pImage->CopyLine(m_loopIndex, m_loopIndex - 1);
664 } else {
665 if (m_loopIndex > 1) {
666 uint8_t* pLine1 = m_pLine - nStride2;
667 uint8_t* pLine2 = m_pLine - nStride;
668 uint32_t line1 = (*pLine1++) << 4;
669 uint32_t line2 = *pLine2++;
670 uint32_t CONTEXT = (line1 & 0x1e00) | ((line2 >> 1) & 0x01f8);
671 for (int32_t cc = 0; cc < nLineBytes; cc++) {
672 line1 = (line1 << 8) | ((*pLine1++) << 4);
673 line2 = (line2 << 8) | (*pLine2++);
674 uint8_t cVal = 0;
675 for (int32_t k = 7; k >= 0; k--) {
676 if (pArithDecoder->IsComplete())
677 return FXCODEC_STATUS::kError;
678
679 int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
680 cVal |= bVal << k;
681 CONTEXT = ((CONTEXT & 0x0efb) << 1) | bVal |
682 ((line1 >> k) & 0x0200) | ((line2 >> (k + 1)) & 0x0008);
683 }
684 m_pLine[cc] = cVal;
685 }
686 line1 <<= 8;
687 line2 <<= 8;
688 uint8_t cVal1 = 0;
689 for (int32_t k = 0; k < nBitsLeft; k++) {
690 if (pArithDecoder->IsComplete())
691 return FXCODEC_STATUS::kError;
692
693 int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
694 cVal1 |= bVal << (7 - k);
695 CONTEXT = ((CONTEXT & 0x0efb) << 1) | bVal |
696 ((line1 >> (7 - k)) & 0x0200) |
697 ((line2 >> (8 - k)) & 0x0008);
698 }
699 m_pLine[nLineBytes] = cVal1;
700 } else {
701 uint8_t* pLine2 = m_pLine - nStride;
702 uint32_t line2 = (m_loopIndex & 1) ? (*pLine2++) : 0;
703 uint32_t CONTEXT = (line2 >> 1) & 0x01f8;
704 for (int32_t cc = 0; cc < nLineBytes; cc++) {
705 if (m_loopIndex & 1) {
706 line2 = (line2 << 8) | (*pLine2++);
707 }
708 uint8_t cVal = 0;
709 for (int32_t k = 7; k >= 0; k--) {
710 if (pArithDecoder->IsComplete())
711 return FXCODEC_STATUS::kError;
712
713 int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
714 cVal |= bVal << k;
715 CONTEXT = ((CONTEXT & 0x0efb) << 1) | bVal |
716 ((line2 >> (k + 1)) & 0x0008);
717 }
718 m_pLine[cc] = cVal;
719 }
720 line2 <<= 8;
721 uint8_t cVal1 = 0;
722 for (int32_t k = 0; k < nBitsLeft; k++) {
723 if (pArithDecoder->IsComplete())
724 return FXCODEC_STATUS::kError;
725
726 int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
727 cVal1 |= bVal << (7 - k);
728 CONTEXT =
729 ((CONTEXT & 0x0efb) << 1) | bVal | ((line2 >> (8 - k)) & 0x0008);
730 }
731 m_pLine[nLineBytes] = cVal1;
732 }
733 }
734 m_pLine += nStride;
735 if (pState->pPause && pState->pPause->NeedToPauseNow()) {
736 m_loopIndex++;
737 m_ProgressiveStatus = FXCODEC_STATUS::kDecodeToBeContinued;
738 return FXCODEC_STATUS::kDecodeToBeContinued;
739 }
740 }
741 m_ProgressiveStatus = FXCODEC_STATUS::kDecodeFinished;
742 return FXCODEC_STATUS::kDecodeFinished;
743}
744
745FXCODEC_STATUS CJBig2_GRDProc::ProgressiveDecodeArithTemplate1Unopt(
746 ProgressiveArithDecodeState* pState) {
747 CJBig2_Image* pImage = pState->pImage->get();
748 JBig2ArithCtx* gbContext = pState->gbContext;
749 CJBig2_ArithDecoder* pArithDecoder = pState->pArithDecoder;
750 for (uint32_t h = 0; h < GBH; h++) {
751 if (TPGDON) {
752 if (pArithDecoder->IsComplete())
753 return FXCODEC_STATUS::kError;
754
755 m_LTP = m_LTP ^ pArithDecoder->Decode(&gbContext[0x0795]);
756 }
757 if (m_LTP) {
758 pImage->CopyLine(h, h - 1);
759 } else {
760 uint32_t line1 = pImage->GetPixel(2, h - 2);
761 line1 |= pImage->GetPixel(1, h - 2) << 1;
762 line1 |= pImage->GetPixel(0, h - 2) << 2;
763 uint32_t line2 = pImage->GetPixel(2, h - 1);
764 line2 |= pImage->GetPixel(1, h - 1) << 1;
765 line2 |= pImage->GetPixel(0, h - 1) << 2;
766 uint32_t line3 = 0;
767 for (uint32_t w = 0; w < GBW; w++) {
768 int bVal;
769 if (USESKIP && SKIP->GetPixel(w, h)) {
770 bVal = 0;
771 } else {
772 uint32_t CONTEXT = line3;
773 CONTEXT |= pImage->GetPixel(w + GBAT[0], h + GBAT[1]) << 3;
774 CONTEXT |= line2 << 4;
775 CONTEXT |= line1 << 9;
776 if (pArithDecoder->IsComplete())
777 return FXCODEC_STATUS::kError;
778
779 bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
780 }
781 if (bVal) {
782 pImage->SetPixel(w, h, bVal);
783 }
784 line1 = ((line1 << 1) | pImage->GetPixel(w + 3, h - 2)) & 0x0f;
785 line2 = ((line2 << 1) | pImage->GetPixel(w + 3, h - 1)) & 0x1f;
786 line3 = ((line3 << 1) | bVal) & 0x07;
787 }
788 }
789 if (pState->pPause && pState->pPause->NeedToPauseNow()) {
790 m_loopIndex++;
791 m_ProgressiveStatus = FXCODEC_STATUS::kDecodeToBeContinued;
792 return FXCODEC_STATUS::kDecodeToBeContinued;
793 }
794 }
795 m_ProgressiveStatus = FXCODEC_STATUS::kDecodeFinished;
796 return FXCODEC_STATUS::kDecodeFinished;
797}
798
799FXCODEC_STATUS CJBig2_GRDProc::ProgressiveDecodeArithTemplate2Opt3(
800 ProgressiveArithDecodeState* pState) {
801 CJBig2_Image* pImage = pState->pImage->get();
802 JBig2ArithCtx* gbContext = pState->gbContext;
803 CJBig2_ArithDecoder* pArithDecoder = pState->pArithDecoder;
804 if (!m_pLine)
805 m_pLine = pImage->data();
806 int32_t nStride = pImage->stride();
807 int32_t nStride2 = nStride << 1;
808 int32_t nLineBytes = ((GBW + 7) >> 3) - 1;
809 int32_t nBitsLeft = GBW - (nLineBytes << 3);
810 for (; m_loopIndex < GBH; m_loopIndex++) {
811 if (TPGDON) {
812 if (pArithDecoder->IsComplete())
813 return FXCODEC_STATUS::kError;
814
815 m_LTP = m_LTP ^ pArithDecoder->Decode(&gbContext[0x00e5]);
816 }
817 if (m_LTP) {
818 pImage->CopyLine(m_loopIndex, m_loopIndex - 1);
819 } else {
820 if (m_loopIndex > 1) {
821 uint8_t* pLine1 = m_pLine - nStride2;
822 uint8_t* pLine2 = m_pLine - nStride;
823 uint32_t line1 = (*pLine1++) << 1;
824 uint32_t line2 = *pLine2++;
825 uint32_t CONTEXT = (line1 & 0x0380) | ((line2 >> 3) & 0x007c);
826 for (int32_t cc = 0; cc < nLineBytes; cc++) {
827 line1 = (line1 << 8) | ((*pLine1++) << 1);
828 line2 = (line2 << 8) | (*pLine2++);
829 uint8_t cVal = 0;
830 for (int32_t k = 7; k >= 0; k--) {
831 if (pArithDecoder->IsComplete())
832 return FXCODEC_STATUS::kError;
833
834 int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
835 cVal |= bVal << k;
836 CONTEXT = ((CONTEXT & 0x01bd) << 1) | bVal |
837 ((line1 >> k) & 0x0080) | ((line2 >> (k + 3)) & 0x0004);
838 }
839 m_pLine[cc] = cVal;
840 }
841 line1 <<= 8;
842 line2 <<= 8;
843 uint8_t cVal1 = 0;
844 for (int32_t k = 0; k < nBitsLeft; k++) {
845 if (pArithDecoder->IsComplete())
846 return FXCODEC_STATUS::kError;
847
848 int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
849 cVal1 |= bVal << (7 - k);
850 CONTEXT = ((CONTEXT & 0x01bd) << 1) | bVal |
851 ((line1 >> (7 - k)) & 0x0080) |
852 ((line2 >> (10 - k)) & 0x0004);
853 }
854 m_pLine[nLineBytes] = cVal1;
855 } else {
856 uint8_t* pLine2 = m_pLine - nStride;
857 uint32_t line2 = (m_loopIndex & 1) ? (*pLine2++) : 0;
858 uint32_t CONTEXT = (line2 >> 3) & 0x007c;
859 for (int32_t cc = 0; cc < nLineBytes; cc++) {
860 if (m_loopIndex & 1) {
861 line2 = (line2 << 8) | (*pLine2++);
862 }
863 uint8_t cVal = 0;
864 for (int32_t k = 7; k >= 0; k--) {
865 if (pArithDecoder->IsComplete())
866 return FXCODEC_STATUS::kError;
867
868 int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
869 cVal |= bVal << k;
870 CONTEXT = ((CONTEXT & 0x01bd) << 1) | bVal |
871 ((line2 >> (k + 3)) & 0x0004);
872 }
873 m_pLine[cc] = cVal;
874 }
875 line2 <<= 8;
876 uint8_t cVal1 = 0;
877 for (int32_t k = 0; k < nBitsLeft; k++) {
878 if (pArithDecoder->IsComplete())
879 return FXCODEC_STATUS::kError;
880
881 int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
882 cVal1 |= bVal << (7 - k);
883 CONTEXT = ((CONTEXT & 0x01bd) << 1) | bVal |
884 (((line2 >> (10 - k))) & 0x0004);
885 }
886 m_pLine[nLineBytes] = cVal1;
887 }
888 }
889 m_pLine += nStride;
890 if (pState->pPause && m_loopIndex % 50 == 0 &&
891 pState->pPause->NeedToPauseNow()) {
892 m_loopIndex++;
893 m_ProgressiveStatus = FXCODEC_STATUS::kDecodeToBeContinued;
894 return FXCODEC_STATUS::kDecodeToBeContinued;
895 }
896 }
897 m_ProgressiveStatus = FXCODEC_STATUS::kDecodeFinished;
898 return FXCODEC_STATUS::kDecodeFinished;
899}
900
901FXCODEC_STATUS CJBig2_GRDProc::ProgressiveDecodeArithTemplate2Unopt(
902 ProgressiveArithDecodeState* pState) {
903 CJBig2_Image* pImage = pState->pImage->get();
904 JBig2ArithCtx* gbContext = pState->gbContext;
905 CJBig2_ArithDecoder* pArithDecoder = pState->pArithDecoder;
906 for (; m_loopIndex < GBH; m_loopIndex++) {
907 if (TPGDON) {
908 if (pArithDecoder->IsComplete())
909 return FXCODEC_STATUS::kError;
910
911 m_LTP = m_LTP ^ pArithDecoder->Decode(&gbContext[0x00e5]);
912 }
913 if (m_LTP) {
914 pImage->CopyLine(m_loopIndex, m_loopIndex - 1);
915 } else {
916 uint32_t line1 = pImage->GetPixel(1, m_loopIndex - 2);
917 line1 |= pImage->GetPixel(0, m_loopIndex - 2) << 1;
918 uint32_t line2 = pImage->GetPixel(1, m_loopIndex - 1);
919 line2 |= pImage->GetPixel(0, m_loopIndex - 1) << 1;
920 uint32_t line3 = 0;
921 for (uint32_t w = 0; w < GBW; w++) {
922 int bVal;
923 if (USESKIP && SKIP->GetPixel(w, m_loopIndex)) {
924 bVal = 0;
925 } else {
926 uint32_t CONTEXT = line3;
927 CONTEXT |= pImage->GetPixel(w + GBAT[0], m_loopIndex + GBAT[1]) << 2;
928 CONTEXT |= line2 << 3;
929 CONTEXT |= line1 << 7;
930 if (pArithDecoder->IsComplete())
931 return FXCODEC_STATUS::kError;
932
933 bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
934 }
935 if (bVal) {
936 pImage->SetPixel(w, m_loopIndex, bVal);
937 }
938 line1 =
939 ((line1 << 1) | pImage->GetPixel(w + 2, m_loopIndex - 2)) & 0x07;
940 line2 =
941 ((line2 << 1) | pImage->GetPixel(w + 2, m_loopIndex - 1)) & 0x0f;
942 line3 = ((line3 << 1) | bVal) & 0x03;
943 }
944 }
945 if (pState->pPause && pState->pPause->NeedToPauseNow()) {
946 m_loopIndex++;
947 m_ProgressiveStatus = FXCODEC_STATUS::kDecodeToBeContinued;
948 return FXCODEC_STATUS::kDecodeToBeContinued;
949 }
950 }
951 m_ProgressiveStatus = FXCODEC_STATUS::kDecodeFinished;
952 return FXCODEC_STATUS::kDecodeFinished;
953}
954
955FXCODEC_STATUS CJBig2_GRDProc::ProgressiveDecodeArithTemplate3Opt3(
956 ProgressiveArithDecodeState* pState) {
957 CJBig2_Image* pImage = pState->pImage->get();
958 JBig2ArithCtx* gbContext = pState->gbContext;
959 CJBig2_ArithDecoder* pArithDecoder = pState->pArithDecoder;
960 if (!m_pLine)
961 m_pLine = pImage->data();
962 int32_t nStride = pImage->stride();
963 int32_t nLineBytes = ((GBW + 7) >> 3) - 1;
964 int32_t nBitsLeft = GBW - (nLineBytes << 3);
965 for (; m_loopIndex < GBH; m_loopIndex++) {
966 if (TPGDON) {
967 if (pArithDecoder->IsComplete())
968 return FXCODEC_STATUS::kError;
969
970 m_LTP = m_LTP ^ pArithDecoder->Decode(&gbContext[0x0195]);
971 }
972 if (m_LTP) {
973 pImage->CopyLine(m_loopIndex, m_loopIndex - 1);
974 } else {
975 if (m_loopIndex > 0) {
976 uint8_t* pLine1 = m_pLine - nStride;
977 uint32_t line1 = *pLine1++;
978 uint32_t CONTEXT = (line1 >> 1) & 0x03f0;
979 for (int32_t cc = 0; cc < nLineBytes; cc++) {
980 line1 = (line1 << 8) | (*pLine1++);
981 uint8_t cVal = 0;
982 for (int32_t k = 7; k >= 0; k--) {
983 if (pArithDecoder->IsComplete())
984 return FXCODEC_STATUS::kError;
985
986 int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
987 cVal |= bVal << k;
988 CONTEXT = ((CONTEXT & 0x01f7) << 1) | bVal |
989 ((line1 >> (k + 1)) & 0x0010);
990 }
991 m_pLine[cc] = cVal;
992 }
993 line1 <<= 8;
994 uint8_t cVal1 = 0;
995 for (int32_t k = 0; k < nBitsLeft; k++) {
996 if (pArithDecoder->IsComplete())
997 return FXCODEC_STATUS::kError;
998
999 int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
1000 cVal1 |= bVal << (7 - k);
1001 CONTEXT =
1002 ((CONTEXT & 0x01f7) << 1) | bVal | ((line1 >> (8 - k)) & 0x0010);
1003 }
1004 m_pLine[nLineBytes] = cVal1;
1005 } else {
1006 uint32_t CONTEXT = 0;
1007 for (int32_t cc = 0; cc < nLineBytes; cc++) {
1008 uint8_t cVal = 0;
1009 for (int32_t k = 7; k >= 0; k--) {
1010 if (pArithDecoder->IsComplete())
1011 return FXCODEC_STATUS::kError;
1012
1013 int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
1014 cVal |= bVal << k;
1015 CONTEXT = ((CONTEXT & 0x01f7) << 1) | bVal;
1016 }
1017 m_pLine[cc] = cVal;
1018 }
1019 uint8_t cVal1 = 0;
1020 for (int32_t k = 0; k < nBitsLeft; k++) {
1021 if (pArithDecoder->IsComplete())
1022 return FXCODEC_STATUS::kError;
1023
1024 int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
1025 cVal1 |= bVal << (7 - k);
1026 CONTEXT = ((CONTEXT & 0x01f7) << 1) | bVal;
1027 }
1028 m_pLine[nLineBytes] = cVal1;
1029 }
1030 }
1031 m_pLine += nStride;
1032 if (pState->pPause && pState->pPause->NeedToPauseNow()) {
1033 m_loopIndex++;
1034 m_ProgressiveStatus = FXCODEC_STATUS::kDecodeToBeContinued;
1035 return FXCODEC_STATUS::kDecodeToBeContinued;
1036 }
1037 }
1038 m_ProgressiveStatus = FXCODEC_STATUS::kDecodeFinished;
1039 return FXCODEC_STATUS::kDecodeFinished;
1040}
1041
1042FXCODEC_STATUS CJBig2_GRDProc::ProgressiveDecodeArithTemplate3Unopt(
1043 ProgressiveArithDecodeState* pState) {
1044 CJBig2_Image* pImage = pState->pImage->get();
1045 JBig2ArithCtx* gbContext = pState->gbContext;
1046 CJBig2_ArithDecoder* pArithDecoder = pState->pArithDecoder;
1047 for (; m_loopIndex < GBH; m_loopIndex++) {
1048 if (TPGDON) {
1049 if (pArithDecoder->IsComplete())
1050 return FXCODEC_STATUS::kError;
1051
1052 m_LTP = m_LTP ^ pArithDecoder->Decode(&gbContext[0x0195]);
1053 }
1054 if (m_LTP) {
1055 pImage->CopyLine(m_loopIndex, m_loopIndex - 1);
1056 } else {
1057 uint32_t line1 = pImage->GetPixel(1, m_loopIndex - 1);
1058 line1 |= pImage->GetPixel(0, m_loopIndex - 1) << 1;
1059 uint32_t line2 = 0;
1060 for (uint32_t w = 0; w < GBW; w++) {
1061 int bVal;
1062 if (USESKIP && SKIP->GetPixel(w, m_loopIndex)) {
1063 bVal = 0;
1064 } else {
1065 uint32_t CONTEXT = line2;
1066 CONTEXT |= pImage->GetPixel(w + GBAT[0], m_loopIndex + GBAT[1]) << 4;
1067 CONTEXT |= line1 << 5;
1068 if (pArithDecoder->IsComplete())
1069 return FXCODEC_STATUS::kError;
1070
1071 bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
1072 }
1073 if (bVal) {
1074 pImage->SetPixel(w, m_loopIndex, bVal);
1075 }
1076 line1 =
1077 ((line1 << 1) | pImage->GetPixel(w + 2, m_loopIndex - 1)) & 0x1f;
1078 line2 = ((line2 << 1) | bVal) & 0x0f;
1079 }
1080 }
1081 if (pState->pPause && pState->pPause->NeedToPauseNow()) {
1082 m_loopIndex++;
1083 m_ProgressiveStatus = FXCODEC_STATUS::kDecodeToBeContinued;
1084 return FXCODEC_STATUS::kDecodeToBeContinued;
1085 }
1086 }
1087 m_ProgressiveStatus = FXCODEC_STATUS::kDecodeFinished;
1088 return FXCODEC_STATUS::kDecodeFinished;
1089}
CJBig2_ArithDecoder
Definition JBig2_ArithDecoder.h:39
CJBig2_ArithDecoder::IsComplete
bool IsComplete() const
Definition JBig2_ArithDecoder.h:46
CJBig2_ArithDecoder::Decode
int Decode(JBig2ArithCtx *pCX)
Definition JBig2_ArithDecoder.cpp:68
CJBig2_BitStream
Definition JBig2_BitStream.h:13
CJBig2_BitStream::getBitPos
uint32_t getBitPos() const
Definition JBig2_BitStream.cpp:151
CJBig2_BitStream::setBitPos
void setBitPos(uint32_t dwBitPos)
Definition JBig2_BitStream.cpp:155
CJBig2_BitStream::getLength
uint32_t getLength() const
Definition JBig2_BitStream.cpp:164
CJBig2_BitStream::getBuf
const uint8_t * getBuf() const
Definition JBig2_BitStream.cpp:160
CJBig2_GRDProc::ProgressiveArithDecodeState
Definition JBig2_GrdProc.h:27
CJBig2_GRDProc::ProgressiveArithDecodeState::~ProgressiveArithDecodeState
~ProgressiveArithDecodeState()
CJBig2_GRDProc::ProgressiveArithDecodeState::ProgressiveArithDecodeState
ProgressiveArithDecodeState()
CJBig2_GRDProc
Definition JBig2_GrdProc.h:25
CJBig2_GRDProc::GBW
uint32_t GBW
Definition JBig2_GrdProc.h:54
CJBig2_GRDProc::GBAT
int8_t GBAT[8]
Definition JBig2_GrdProc.h:57
CJBig2_GRDProc::GBTEMPLATE
uint8_t GBTEMPLATE
Definition JBig2_GrdProc.h:53
CJBig2_GRDProc::GBH
uint32_t GBH
Definition JBig2_GrdProc.h:55
CJBig2_GRDProc::~CJBig2_GRDProc
~CJBig2_GRDProc()
CJBig2_GRDProc::StartDecodeMMR
FXCODEC_STATUS StartDecodeMMR(std::unique_ptr< CJBig2_Image > *pImage, CJBig2_BitStream *pStream)
Definition JBig2_GrdProc.cpp:450
CJBig2_GRDProc::TPGDON
bool TPGDON
Definition JBig2_GrdProc.h:51
CJBig2_GRDProc::CJBig2_GRDProc
CJBig2_GRDProc()
CJBig2_GRDProc::ContinueDecode
FXCODEC_STATUS ContinueDecode(ProgressiveArithDecodeState *pState)
Definition JBig2_GrdProc.cpp:471
CJBig2_GRDProc::DecodeArith
std::unique_ptr< CJBig2_Image > DecodeArith(CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext)
Definition JBig2_GrdProc.cpp:61
CJBig2_GRDProc::StartDecodeArith
FXCODEC_STATUS StartDecodeArith(ProgressiveArithDecodeState *pState)
Definition JBig2_GrdProc.cpp:386
CJBig2_Image
Definition JBig2_Image.h:27
CJBig2_Image::SetPixel
void SetPixel(int32_t x, int32_t y, int v)
Definition JBig2_Image.cpp:118
CJBig2_Image::CopyLine
void CopyLine(int32_t hTo, int32_t hFrom)
Definition JBig2_Image.cpp:137
CJBig2_Image::data
uint8_t * data() const
Definition JBig2_Image.h:43
CJBig2_Image::IsValidImageSize
static bool IsValidImageSize(int32_t w, int32_t h)
Definition JBig2_Image.cpp:98
CJBig2_Image::GetPixel
int GetPixel(int32_t x, int32_t y) const
Definition JBig2_Image.cpp:102
CJBig2_Image::stride
int32_t stride() const
Definition JBig2_Image.h:41
CJBig2_Image::width
int32_t width() const
Definition JBig2_Image.h:39
fxcodec::FaxModule::FaxG4Decode
static int FaxG4Decode(const uint8_t *src_buf, uint32_t src_size, int starting_bitpos, int width, int height, int pitch, uint8_t *dest_buf)
Definition faxmodule.cpp:625
FXCODEC_STATUS
FXCODEC_STATUS
Definition fx_codec_def.h:10
FXCODEC_STATUS::kDecodeFinished
@ kDecodeFinished
FXCODEC_STATUS::kDecodeReady
@ kDecodeReady
FXCODEC_STATUS::kError
@ kError
FXCODEC_STATUS::kDecodeToBeContinued
@ kDecodeToBeContinued
FX_RECT::bottom
int32_t bottom
Definition fx_coordinates.h:185
FX_RECT::right
int32_t right
Definition fx_coordinates.h:184
FX_RECT::top
int32_t top
Definition fx_coordinates.h:183
FX_RECT::left
int32_t left
Definition fx_coordinates.h:182