1 // Copyright 2015 PDFium Authors. All rights reserved.
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_TrdProc.h"
8
9 #include <memory>
10
11 #include "core/fxcodec/jbig2/JBig2_ArithDecoder.h"
12 #include "core/fxcodec/jbig2/JBig2_ArithIntDecoder.h"
13 #include "core/fxcodec/jbig2/JBig2_GrrdProc.h"
14 #include "core/fxcodec/jbig2/JBig2_HuffmanDecoder.h"
15 #include "third_party/base/ptr_util.h"
16
decode_Huffman(CJBig2_BitStream * pStream,JBig2ArithCtx * grContext)17 CJBig2_Image* CJBig2_TRDProc::decode_Huffman(CJBig2_BitStream* pStream,
18 JBig2ArithCtx* grContext) {
19 std::unique_ptr<CJBig2_HuffmanDecoder> pHuffmanDecoder(
20 new CJBig2_HuffmanDecoder(pStream));
21 std::unique_ptr<CJBig2_Image> SBREG(new CJBig2_Image(SBW, SBH));
22 SBREG->fill(SBDEFPIXEL);
23 int32_t STRIPT;
24 if (pHuffmanDecoder->decodeAValue(SBHUFFDT, &STRIPT) != 0)
25 return nullptr;
26
27 STRIPT *= SBSTRIPS;
28 STRIPT = -STRIPT;
29 int32_t FIRSTS = 0;
30 uint32_t NINSTANCES = 0;
31 while (NINSTANCES < SBNUMINSTANCES) {
32 int32_t DT;
33 if (pHuffmanDecoder->decodeAValue(SBHUFFDT, &DT) != 0)
34 return nullptr;
35
36 DT *= SBSTRIPS;
37 STRIPT = STRIPT + DT;
38 bool bFirst = true;
39 int32_t CURS = 0;
40 for (;;) {
41 if (bFirst) {
42 int32_t DFS;
43 if (pHuffmanDecoder->decodeAValue(SBHUFFFS, &DFS) != 0)
44 return nullptr;
45
46 FIRSTS = FIRSTS + DFS;
47 CURS = FIRSTS;
48 bFirst = false;
49 } else {
50 int32_t IDS;
51 int32_t nVal = pHuffmanDecoder->decodeAValue(SBHUFFDS, &IDS);
52 if (nVal == JBIG2_OOB) {
53 break;
54 } else if (nVal != 0) {
55 return nullptr;
56 } else {
57 CURS = CURS + IDS + SBDSOFFSET;
58 }
59 }
60 uint8_t CURT = 0;
61 if (SBSTRIPS != 1) {
62 uint32_t nTmp = 1;
63 while ((uint32_t)(1 << nTmp) < SBSTRIPS) {
64 nTmp++;
65 }
66 int32_t nVal;
67 if (pStream->readNBits(nTmp, &nVal) != 0)
68 return nullptr;
69
70 CURT = nVal;
71 }
72 int32_t TI = STRIPT + CURT;
73 int32_t nVal = 0;
74 int32_t nBits = 0;
75 uint32_t IDI;
76 for (;;) {
77 uint32_t nTmp;
78 if (pStream->read1Bit(&nTmp) != 0)
79 return nullptr;
80
81 nVal = (nVal << 1) | nTmp;
82 nBits++;
83 for (IDI = 0; IDI < SBNUMSYMS; IDI++) {
84 if ((nBits == SBSYMCODES[IDI].codelen) &&
85 (nVal == SBSYMCODES[IDI].code)) {
86 break;
87 }
88 }
89 if (IDI < SBNUMSYMS) {
90 break;
91 }
92 }
93 bool RI = 0;
94 if (SBREFINE != 0 && pStream->read1Bit(&RI) != 0) {
95 return nullptr;
96 }
97 CJBig2_Image* IBI = nullptr;
98 if (RI == 0) {
99 IBI = SBSYMS[IDI];
100 } else {
101 int32_t RDWI;
102 int32_t RDHI;
103 int32_t RDXI;
104 int32_t RDYI;
105 if ((pHuffmanDecoder->decodeAValue(SBHUFFRDW, &RDWI) != 0) ||
106 (pHuffmanDecoder->decodeAValue(SBHUFFRDH, &RDHI) != 0) ||
107 (pHuffmanDecoder->decodeAValue(SBHUFFRDX, &RDXI) != 0) ||
108 (pHuffmanDecoder->decodeAValue(SBHUFFRDY, &RDYI) != 0) ||
109 (pHuffmanDecoder->decodeAValue(SBHUFFRSIZE, &nVal) != 0)) {
110 return nullptr;
111 }
112 pStream->alignByte();
113 uint32_t nTmp = pStream->getOffset();
114 CJBig2_Image* IBOI = SBSYMS[IDI];
115 if (!IBOI)
116 return nullptr;
117
118 uint32_t WOI = IBOI->width();
119 uint32_t HOI = IBOI->height();
120 if ((int)(WOI + RDWI) < 0 || (int)(HOI + RDHI) < 0)
121 return nullptr;
122
123 std::unique_ptr<CJBig2_GRRDProc> pGRRD(new CJBig2_GRRDProc());
124 pGRRD->GRW = WOI + RDWI;
125 pGRRD->GRH = HOI + RDHI;
126 pGRRD->GRTEMPLATE = SBRTEMPLATE;
127 pGRRD->GRREFERENCE = IBOI;
128 pGRRD->GRREFERENCEDX = (RDWI >> 2) + RDXI;
129 pGRRD->GRREFERENCEDY = (RDHI >> 2) + RDYI;
130 pGRRD->TPGRON = 0;
131 pGRRD->GRAT[0] = SBRAT[0];
132 pGRRD->GRAT[1] = SBRAT[1];
133 pGRRD->GRAT[2] = SBRAT[2];
134 pGRRD->GRAT[3] = SBRAT[3];
135
136 {
137 std::unique_ptr<CJBig2_ArithDecoder> pArithDecoder(
138 new CJBig2_ArithDecoder(pStream));
139 IBI = pGRRD->decode(pArithDecoder.get(), grContext);
140 if (!IBI)
141 return nullptr;
142 }
143
144 pStream->alignByte();
145 pStream->offset(2);
146 if ((uint32_t)nVal != (pStream->getOffset() - nTmp)) {
147 delete IBI;
148 return nullptr;
149 }
150 }
151 if (!IBI) {
152 continue;
153 }
154 uint32_t WI = IBI->width();
155 uint32_t HI = IBI->height();
156 if (TRANSPOSED == 0 && ((REFCORNER == JBIG2_CORNER_TOPRIGHT) ||
157 (REFCORNER == JBIG2_CORNER_BOTTOMRIGHT))) {
158 CURS = CURS + WI - 1;
159 } else if (TRANSPOSED == 1 && ((REFCORNER == JBIG2_CORNER_BOTTOMLEFT) ||
160 (REFCORNER == JBIG2_CORNER_BOTTOMRIGHT))) {
161 CURS = CURS + HI - 1;
162 }
163 int32_t SI = CURS;
164 if (TRANSPOSED == 0) {
165 switch (REFCORNER) {
166 case JBIG2_CORNER_TOPLEFT:
167 SBREG->composeFrom(SI, TI, IBI, SBCOMBOP);
168 break;
169 case JBIG2_CORNER_TOPRIGHT:
170 SBREG->composeFrom(SI - WI + 1, TI, IBI, SBCOMBOP);
171 break;
172 case JBIG2_CORNER_BOTTOMLEFT:
173 SBREG->composeFrom(SI, TI - HI + 1, IBI, SBCOMBOP);
174 break;
175 case JBIG2_CORNER_BOTTOMRIGHT:
176 SBREG->composeFrom(SI - WI + 1, TI - HI + 1, IBI, SBCOMBOP);
177 break;
178 }
179 } else {
180 switch (REFCORNER) {
181 case JBIG2_CORNER_TOPLEFT:
182 SBREG->composeFrom(TI, SI, IBI, SBCOMBOP);
183 break;
184 case JBIG2_CORNER_TOPRIGHT:
185 SBREG->composeFrom(TI - WI + 1, SI, IBI, SBCOMBOP);
186 break;
187 case JBIG2_CORNER_BOTTOMLEFT:
188 SBREG->composeFrom(TI, SI - HI + 1, IBI, SBCOMBOP);
189 break;
190 case JBIG2_CORNER_BOTTOMRIGHT:
191 SBREG->composeFrom(TI - WI + 1, SI - HI + 1, IBI, SBCOMBOP);
192 break;
193 }
194 }
195 if (RI != 0) {
196 delete IBI;
197 }
198 if (TRANSPOSED == 0 && ((REFCORNER == JBIG2_CORNER_TOPLEFT) ||
199 (REFCORNER == JBIG2_CORNER_BOTTOMLEFT))) {
200 CURS = CURS + WI - 1;
201 } else if (TRANSPOSED == 1 && ((REFCORNER == JBIG2_CORNER_TOPLEFT) ||
202 (REFCORNER == JBIG2_CORNER_TOPRIGHT))) {
203 CURS = CURS + HI - 1;
204 }
205 NINSTANCES = NINSTANCES + 1;
206 }
207 }
208 return SBREG.release();
209 }
210
decode_Arith(CJBig2_ArithDecoder * pArithDecoder,JBig2ArithCtx * grContext,JBig2IntDecoderState * pIDS)211 CJBig2_Image* CJBig2_TRDProc::decode_Arith(CJBig2_ArithDecoder* pArithDecoder,
212 JBig2ArithCtx* grContext,
213 JBig2IntDecoderState* pIDS) {
214 std::unique_ptr<CJBig2_ArithIntDecoder> IADT;
215 std::unique_ptr<CJBig2_ArithIntDecoder> IAFS;
216 std::unique_ptr<CJBig2_ArithIntDecoder> IADS;
217 std::unique_ptr<CJBig2_ArithIntDecoder> IAIT;
218 std::unique_ptr<CJBig2_ArithIntDecoder> IARI;
219 std::unique_ptr<CJBig2_ArithIntDecoder> IARDW;
220 std::unique_ptr<CJBig2_ArithIntDecoder> IARDH;
221 std::unique_ptr<CJBig2_ArithIntDecoder> IARDX;
222 std::unique_ptr<CJBig2_ArithIntDecoder> IARDY;
223 std::unique_ptr<CJBig2_ArithIaidDecoder> IAID;
224 CJBig2_ArithIntDecoder* pIADT;
225 CJBig2_ArithIntDecoder* pIAFS;
226 CJBig2_ArithIntDecoder* pIADS;
227 CJBig2_ArithIntDecoder* pIAIT;
228 CJBig2_ArithIntDecoder* pIARI;
229 CJBig2_ArithIntDecoder* pIARDW;
230 CJBig2_ArithIntDecoder* pIARDH;
231 CJBig2_ArithIntDecoder* pIARDX;
232 CJBig2_ArithIntDecoder* pIARDY;
233 CJBig2_ArithIaidDecoder* pIAID;
234 if (pIDS) {
235 pIADT = pIDS->IADT;
236 pIAFS = pIDS->IAFS;
237 pIADS = pIDS->IADS;
238 pIAIT = pIDS->IAIT;
239 pIARI = pIDS->IARI;
240 pIARDW = pIDS->IARDW;
241 pIARDH = pIDS->IARDH;
242 pIARDX = pIDS->IARDX;
243 pIARDY = pIDS->IARDY;
244 pIAID = pIDS->IAID;
245 } else {
246 IADT = pdfium::MakeUnique<CJBig2_ArithIntDecoder>();
247 IAFS = pdfium::MakeUnique<CJBig2_ArithIntDecoder>();
248 IADS = pdfium::MakeUnique<CJBig2_ArithIntDecoder>();
249 IAIT = pdfium::MakeUnique<CJBig2_ArithIntDecoder>();
250 IARI = pdfium::MakeUnique<CJBig2_ArithIntDecoder>();
251 IARDW = pdfium::MakeUnique<CJBig2_ArithIntDecoder>();
252 IARDH = pdfium::MakeUnique<CJBig2_ArithIntDecoder>();
253 IARDX = pdfium::MakeUnique<CJBig2_ArithIntDecoder>();
254 IARDY = pdfium::MakeUnique<CJBig2_ArithIntDecoder>();
255 IAID = pdfium::MakeUnique<CJBig2_ArithIaidDecoder>(SBSYMCODELEN);
256 pIADT = IADT.get();
257 pIAFS = IAFS.get();
258 pIADS = IADS.get();
259 pIAIT = IAIT.get();
260 pIARI = IARI.get();
261 pIARDW = IARDW.get();
262 pIARDH = IARDH.get();
263 pIARDX = IARDX.get();
264 pIARDY = IARDY.get();
265 pIAID = IAID.get();
266 }
267 std::unique_ptr<CJBig2_Image> SBREG(new CJBig2_Image(SBW, SBH));
268 SBREG->fill(SBDEFPIXEL);
269 int32_t STRIPT;
270 if (!pIADT->decode(pArithDecoder, &STRIPT))
271 return nullptr;
272 STRIPT *= SBSTRIPS;
273 STRIPT = -STRIPT;
274 int32_t FIRSTS = 0;
275 uint32_t NINSTANCES = 0;
276 while (NINSTANCES < SBNUMINSTANCES) {
277 int32_t CURS = 0;
278 int32_t DT;
279 if (!pIADT->decode(pArithDecoder, &DT))
280 return nullptr;
281 DT *= SBSTRIPS;
282 STRIPT += DT;
283 bool bFirst = true;
284 for (;;) {
285 if (bFirst) {
286 int32_t DFS;
287 pIAFS->decode(pArithDecoder, &DFS);
288 FIRSTS += DFS;
289 CURS = FIRSTS;
290 bFirst = false;
291 } else {
292 int32_t IDS;
293 if (!pIADS->decode(pArithDecoder, &IDS))
294 break;
295 CURS += IDS + SBDSOFFSET;
296 }
297 if (NINSTANCES >= SBNUMINSTANCES) {
298 break;
299 }
300 int CURT = 0;
301 if (SBSTRIPS != 1)
302 pIAIT->decode(pArithDecoder, &CURT);
303
304 int32_t TI = STRIPT + CURT;
305 uint32_t IDI;
306 pIAID->decode(pArithDecoder, &IDI);
307 if (IDI >= SBNUMSYMS)
308 return nullptr;
309
310 int RI;
311 if (SBREFINE == 0)
312 RI = 0;
313 else
314 pIARI->decode(pArithDecoder, &RI);
315
316 std::unique_ptr<CJBig2_Image> IBI;
317 CJBig2_Image* pIBI;
318 if (RI == 0) {
319 pIBI = SBSYMS[IDI];
320 } else {
321 int32_t RDWI;
322 int32_t RDHI;
323 int32_t RDXI;
324 int32_t RDYI;
325 pIARDW->decode(pArithDecoder, &RDWI);
326 pIARDH->decode(pArithDecoder, &RDHI);
327 pIARDX->decode(pArithDecoder, &RDXI);
328 pIARDY->decode(pArithDecoder, &RDYI);
329 CJBig2_Image* IBOI = SBSYMS[IDI];
330 if (!IBOI)
331 return nullptr;
332
333 uint32_t WOI = IBOI->width();
334 uint32_t HOI = IBOI->height();
335 if ((int)(WOI + RDWI) < 0 || (int)(HOI + RDHI) < 0)
336 return nullptr;
337
338 std::unique_ptr<CJBig2_GRRDProc> pGRRD(new CJBig2_GRRDProc());
339 pGRRD->GRW = WOI + RDWI;
340 pGRRD->GRH = HOI + RDHI;
341 pGRRD->GRTEMPLATE = SBRTEMPLATE;
342 pGRRD->GRREFERENCE = IBOI;
343 pGRRD->GRREFERENCEDX = (RDWI >> 1) + RDXI;
344 pGRRD->GRREFERENCEDY = (RDHI >> 1) + RDYI;
345 pGRRD->TPGRON = 0;
346 pGRRD->GRAT[0] = SBRAT[0];
347 pGRRD->GRAT[1] = SBRAT[1];
348 pGRRD->GRAT[2] = SBRAT[2];
349 pGRRD->GRAT[3] = SBRAT[3];
350 IBI.reset(pGRRD->decode(pArithDecoder, grContext));
351 pIBI = IBI.get();
352 }
353 if (!pIBI)
354 return nullptr;
355
356 uint32_t WI = pIBI->width();
357 uint32_t HI = pIBI->height();
358 if (TRANSPOSED == 0 && ((REFCORNER == JBIG2_CORNER_TOPRIGHT) ||
359 (REFCORNER == JBIG2_CORNER_BOTTOMRIGHT))) {
360 CURS += WI - 1;
361 } else if (TRANSPOSED == 1 && ((REFCORNER == JBIG2_CORNER_BOTTOMLEFT) ||
362 (REFCORNER == JBIG2_CORNER_BOTTOMRIGHT))) {
363 CURS += HI - 1;
364 }
365 int32_t SI = CURS;
366 if (TRANSPOSED == 0) {
367 switch (REFCORNER) {
368 case JBIG2_CORNER_TOPLEFT:
369 SBREG->composeFrom(SI, TI, pIBI, SBCOMBOP);
370 break;
371 case JBIG2_CORNER_TOPRIGHT:
372 SBREG->composeFrom(SI - WI + 1, TI, pIBI, SBCOMBOP);
373 break;
374 case JBIG2_CORNER_BOTTOMLEFT:
375 SBREG->composeFrom(SI, TI - HI + 1, pIBI, SBCOMBOP);
376 break;
377 case JBIG2_CORNER_BOTTOMRIGHT:
378 SBREG->composeFrom(SI - WI + 1, TI - HI + 1, pIBI, SBCOMBOP);
379 break;
380 }
381 } else {
382 switch (REFCORNER) {
383 case JBIG2_CORNER_TOPLEFT:
384 SBREG->composeFrom(TI, SI, pIBI, SBCOMBOP);
385 break;
386 case JBIG2_CORNER_TOPRIGHT:
387 SBREG->composeFrom(TI - WI + 1, SI, pIBI, SBCOMBOP);
388 break;
389 case JBIG2_CORNER_BOTTOMLEFT:
390 SBREG->composeFrom(TI, SI - HI + 1, pIBI, SBCOMBOP);
391 break;
392 case JBIG2_CORNER_BOTTOMRIGHT:
393 SBREG->composeFrom(TI - WI + 1, SI - HI + 1, pIBI, SBCOMBOP);
394 break;
395 }
396 }
397 if (TRANSPOSED == 0 && ((REFCORNER == JBIG2_CORNER_TOPLEFT) ||
398 (REFCORNER == JBIG2_CORNER_BOTTOMLEFT))) {
399 CURS += WI - 1;
400 } else if (TRANSPOSED == 1 && ((REFCORNER == JBIG2_CORNER_TOPLEFT) ||
401 (REFCORNER == JBIG2_CORNER_TOPRIGHT))) {
402 CURS += HI - 1;
403 }
404 ++NINSTANCES;
405 }
406 }
407 return SBREG.release();
408 }
409