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_SddProc.h" 8 9#include <algorithm> 10#include <memory> 11#include <utility> 12#include <vector> 13 14#include "core/fxcodec/jbig2/JBig2_ArithIntDecoder.h" 15#include "core/fxcodec/jbig2/JBig2_GrdProc.h" 16#include "core/fxcodec/jbig2/JBig2_GrrdProc.h" 17#include "core/fxcodec/jbig2/JBig2_HuffmanDecoder.h" 18#include "core/fxcodec/jbig2/JBig2_HuffmanTable.h" 19#include "core/fxcodec/jbig2/JBig2_HuffmanTable_Standard.h" 20#include "core/fxcodec/jbig2/JBig2_SymbolDict.h" 21#include "core/fxcodec/jbig2/JBig2_TrdProc.h" 22#include "third_party/base/ptr_util.h" 23 24std::unique_ptr<CJBig2_SymbolDict> CJBig2_SDDProc::decode_Arith( 25 CJBig2_ArithDecoder* pArithDecoder, 26 std::vector<JBig2ArithCtx>* gbContext, 27 std::vector<JBig2ArithCtx>* grContext) { 28 std::vector<std::unique_ptr<CJBig2_Image>> SDNEWSYMS; 29 uint32_t HCHEIGHT, NSYMSDECODED; 30 int32_t HCDH; 31 uint32_t SYMWIDTH, TOTWIDTH; 32 int32_t DW; 33 uint32_t I, J, REFAGGNINST; 34 std::vector<bool> EXFLAGS; 35 uint32_t EXINDEX; 36 bool CUREXFLAG; 37 uint32_t EXRUNLENGTH; 38 uint32_t nTmp; 39 uint32_t SBNUMSYMS; 40 uint8_t SBSYMCODELEN; 41 int32_t RDXI, RDYI; 42 uint32_t num_ex_syms; 43 // Pointers are not owned 44 std::vector<CJBig2_Image*> SBSYMS; 45 std::unique_ptr<CJBig2_ArithIaidDecoder> IAID; 46 std::unique_ptr<CJBig2_SymbolDict> pDict; 47 auto IADH = pdfium::MakeUnique<CJBig2_ArithIntDecoder>(); 48 auto IADW = pdfium::MakeUnique<CJBig2_ArithIntDecoder>(); 49 auto IAAI = pdfium::MakeUnique<CJBig2_ArithIntDecoder>(); 50 auto IARDX = pdfium::MakeUnique<CJBig2_ArithIntDecoder>(); 51 auto IARDY = pdfium::MakeUnique<CJBig2_ArithIntDecoder>(); 52 auto IAEX = pdfium::MakeUnique<CJBig2_ArithIntDecoder>(); 53 auto IADT = pdfium::MakeUnique<CJBig2_ArithIntDecoder>(); 54 auto IAFS = pdfium::MakeUnique<CJBig2_ArithIntDecoder>(); 55 auto IADS = pdfium::MakeUnique<CJBig2_ArithIntDecoder>(); 56 auto IAIT = pdfium::MakeUnique<CJBig2_ArithIntDecoder>(); 57 auto IARI = pdfium::MakeUnique<CJBig2_ArithIntDecoder>(); 58 auto IARDW = pdfium::MakeUnique<CJBig2_ArithIntDecoder>(); 59 auto IARDH = pdfium::MakeUnique<CJBig2_ArithIntDecoder>(); 60 nTmp = 0; 61 while ((uint32_t)(1 << nTmp) < (SDNUMINSYMS + SDNUMNEWSYMS)) { 62 nTmp++; 63 } 64 IAID = pdfium::MakeUnique<CJBig2_ArithIaidDecoder>((uint8_t)nTmp); 65 SDNEWSYMS.resize(SDNUMNEWSYMS); 66 67 HCHEIGHT = 0; 68 NSYMSDECODED = 0; 69 while (NSYMSDECODED < SDNUMNEWSYMS) { 70 std::unique_ptr<CJBig2_Image> BS; 71 IADH->decode(pArithDecoder, &HCDH); 72 HCHEIGHT = HCHEIGHT + HCDH; 73 if ((int)HCHEIGHT < 0 || (int)HCHEIGHT > JBIG2_MAX_IMAGE_SIZE) 74 return nullptr; 75 76 SYMWIDTH = 0; 77 TOTWIDTH = 0; 78 for (;;) { 79 if (!IADW->decode(pArithDecoder, &DW)) 80 break; 81 82 if (NSYMSDECODED >= SDNUMNEWSYMS) 83 return nullptr; 84 85 SYMWIDTH = SYMWIDTH + DW; 86 if ((int)SYMWIDTH < 0 || (int)SYMWIDTH > JBIG2_MAX_IMAGE_SIZE) 87 return nullptr; 88 89 if (HCHEIGHT == 0 || SYMWIDTH == 0) { 90 TOTWIDTH = TOTWIDTH + SYMWIDTH; 91 SDNEWSYMS[NSYMSDECODED] = nullptr; 92 NSYMSDECODED = NSYMSDECODED + 1; 93 continue; 94 } 95 TOTWIDTH = TOTWIDTH + SYMWIDTH; 96 if (SDREFAGG == 0) { 97 auto pGRD = pdfium::MakeUnique<CJBig2_GRDProc>(); 98 pGRD->MMR = 0; 99 pGRD->GBW = SYMWIDTH; 100 pGRD->GBH = HCHEIGHT; 101 pGRD->GBTEMPLATE = SDTEMPLATE; 102 pGRD->TPGDON = 0; 103 pGRD->USESKIP = 0; 104 pGRD->GBAT[0] = SDAT[0]; 105 pGRD->GBAT[1] = SDAT[1]; 106 pGRD->GBAT[2] = SDAT[2]; 107 pGRD->GBAT[3] = SDAT[3]; 108 pGRD->GBAT[4] = SDAT[4]; 109 pGRD->GBAT[5] = SDAT[5]; 110 pGRD->GBAT[6] = SDAT[6]; 111 pGRD->GBAT[7] = SDAT[7]; 112 BS = pGRD->decode_Arith(pArithDecoder, gbContext->data()); 113 if (!BS) 114 return nullptr; 115 } else { 116 IAAI->decode(pArithDecoder, (int*)&REFAGGNINST); 117 if (REFAGGNINST > 1) { 118 auto pDecoder = pdfium::MakeUnique<CJBig2_TRDProc>(); 119 pDecoder->SBHUFF = SDHUFF; 120 pDecoder->SBREFINE = 1; 121 pDecoder->SBW = SYMWIDTH; 122 pDecoder->SBH = HCHEIGHT; 123 pDecoder->SBNUMINSTANCES = REFAGGNINST; 124 pDecoder->SBSTRIPS = 1; 125 pDecoder->SBNUMSYMS = SDNUMINSYMS + NSYMSDECODED; 126 SBNUMSYMS = pDecoder->SBNUMSYMS; 127 nTmp = 0; 128 while ((uint32_t)(1 << nTmp) < SBNUMSYMS) { 129 nTmp++; 130 } 131 SBSYMCODELEN = (uint8_t)nTmp; 132 pDecoder->SBSYMCODELEN = SBSYMCODELEN; 133 SBSYMS.resize(SBNUMSYMS); 134 std::copy(SDINSYMS, SDINSYMS + SDNUMINSYMS, SBSYMS.begin()); 135 for (size_t i = 0; i < NSYMSDECODED; ++i) 136 SBSYMS[i + SDNUMINSYMS] = SDNEWSYMS[i].get(); 137 pDecoder->SBSYMS = SBSYMS.data(); 138 pDecoder->SBDEFPIXEL = 0; 139 pDecoder->SBCOMBOP = JBIG2_COMPOSE_OR; 140 pDecoder->TRANSPOSED = 0; 141 pDecoder->REFCORNER = JBIG2_CORNER_TOPLEFT; 142 pDecoder->SBDSOFFSET = 0; 143 auto SBHUFFFS = pdfium::MakeUnique<CJBig2_HuffmanTable>( 144 HuffmanTable_B6, HuffmanTable_B6_Size, HuffmanTable_HTOOB_B6); 145 auto SBHUFFDS = pdfium::MakeUnique<CJBig2_HuffmanTable>( 146 HuffmanTable_B8, HuffmanTable_B8_Size, HuffmanTable_HTOOB_B8); 147 auto SBHUFFDT = pdfium::MakeUnique<CJBig2_HuffmanTable>( 148 HuffmanTable_B11, HuffmanTable_B11_Size, HuffmanTable_HTOOB_B11); 149 auto SBHUFFRDW = pdfium::MakeUnique<CJBig2_HuffmanTable>( 150 HuffmanTable_B15, HuffmanTable_B15_Size, HuffmanTable_HTOOB_B15); 151 auto SBHUFFRDH = pdfium::MakeUnique<CJBig2_HuffmanTable>( 152 HuffmanTable_B15, HuffmanTable_B15_Size, HuffmanTable_HTOOB_B15); 153 auto SBHUFFRDX = pdfium::MakeUnique<CJBig2_HuffmanTable>( 154 HuffmanTable_B15, HuffmanTable_B15_Size, HuffmanTable_HTOOB_B15); 155 auto SBHUFFRDY = pdfium::MakeUnique<CJBig2_HuffmanTable>( 156 HuffmanTable_B15, HuffmanTable_B15_Size, HuffmanTable_HTOOB_B15); 157 auto SBHUFFRSIZE = pdfium::MakeUnique<CJBig2_HuffmanTable>( 158 HuffmanTable_B1, HuffmanTable_B1_Size, HuffmanTable_HTOOB_B1); 159 pDecoder->SBHUFFFS = SBHUFFFS.get(); 160 pDecoder->SBHUFFDS = SBHUFFDS.get(); 161 pDecoder->SBHUFFDT = SBHUFFDT.get(); 162 pDecoder->SBHUFFRDW = SBHUFFRDW.get(); 163 pDecoder->SBHUFFRDH = SBHUFFRDH.get(); 164 pDecoder->SBHUFFRDX = SBHUFFRDX.get(); 165 pDecoder->SBHUFFRDY = SBHUFFRDY.get(); 166 pDecoder->SBHUFFRSIZE = SBHUFFRSIZE.get(); 167 pDecoder->SBRTEMPLATE = SDRTEMPLATE; 168 pDecoder->SBRAT[0] = SDRAT[0]; 169 pDecoder->SBRAT[1] = SDRAT[1]; 170 pDecoder->SBRAT[2] = SDRAT[2]; 171 pDecoder->SBRAT[3] = SDRAT[3]; 172 JBig2IntDecoderState ids; 173 ids.IADT = IADT.get(); 174 ids.IAFS = IAFS.get(); 175 ids.IADS = IADS.get(); 176 ids.IAIT = IAIT.get(); 177 ids.IARI = IARI.get(); 178 ids.IARDW = IARDW.get(); 179 ids.IARDH = IARDH.get(); 180 ids.IARDX = IARDX.get(); 181 ids.IARDY = IARDY.get(); 182 ids.IAID = IAID.get(); 183 BS = pDecoder->decode_Arith(pArithDecoder, grContext->data(), &ids); 184 if (!BS) 185 return nullptr; 186 } else if (REFAGGNINST == 1) { 187 SBNUMSYMS = SDNUMINSYMS + NSYMSDECODED; 188 uint32_t IDI; 189 IAID->decode(pArithDecoder, &IDI); 190 IARDX->decode(pArithDecoder, &RDXI); 191 IARDY->decode(pArithDecoder, &RDYI); 192 if (IDI >= SBNUMSYMS) 193 return nullptr; 194 195 SBSYMS.resize(SBNUMSYMS); 196 std::copy(SDINSYMS, SDINSYMS + SDNUMINSYMS, SBSYMS.begin()); 197 for (size_t i = 0; i < NSYMSDECODED; ++i) 198 SBSYMS[i + SDNUMINSYMS] = SDNEWSYMS[i].get(); 199 if (!SBSYMS[IDI]) 200 return nullptr; 201 202 auto pGRRD = pdfium::MakeUnique<CJBig2_GRRDProc>(); 203 pGRRD->GRW = SYMWIDTH; 204 pGRRD->GRH = HCHEIGHT; 205 pGRRD->GRTEMPLATE = SDRTEMPLATE; 206 pGRRD->GRREFERENCE = SBSYMS[IDI]; 207 pGRRD->GRREFERENCEDX = RDXI; 208 pGRRD->GRREFERENCEDY = RDYI; 209 pGRRD->TPGRON = 0; 210 pGRRD->GRAT[0] = SDRAT[0]; 211 pGRRD->GRAT[1] = SDRAT[1]; 212 pGRRD->GRAT[2] = SDRAT[2]; 213 pGRRD->GRAT[3] = SDRAT[3]; 214 BS = pGRRD->decode(pArithDecoder, grContext->data()); 215 if (!BS) 216 return nullptr; 217 } 218 } 219 SDNEWSYMS[NSYMSDECODED] = std::move(BS); 220 NSYMSDECODED = NSYMSDECODED + 1; 221 } 222 } 223 EXINDEX = 0; 224 CUREXFLAG = 0; 225 EXFLAGS.resize(SDNUMINSYMS + SDNUMNEWSYMS); 226 num_ex_syms = 0; 227 while (EXINDEX < SDNUMINSYMS + SDNUMNEWSYMS) { 228 IAEX->decode(pArithDecoder, (int*)&EXRUNLENGTH); 229 if (EXINDEX + EXRUNLENGTH > SDNUMINSYMS + SDNUMNEWSYMS) 230 return nullptr; 231 232 if (EXRUNLENGTH != 0) { 233 for (I = EXINDEX; I < EXINDEX + EXRUNLENGTH; I++) { 234 if (CUREXFLAG) 235 num_ex_syms++; 236 EXFLAGS[I] = CUREXFLAG; 237 } 238 } 239 EXINDEX = EXINDEX + EXRUNLENGTH; 240 CUREXFLAG = !CUREXFLAG; 241 } 242 if (num_ex_syms > SDNUMEXSYMS) 243 return nullptr; 244 245 pDict = pdfium::MakeUnique<CJBig2_SymbolDict>(); 246 I = J = 0; 247 for (I = 0; I < SDNUMINSYMS + SDNUMNEWSYMS; I++) { 248 if (!EXFLAGS[I] || J >= SDNUMEXSYMS) 249 continue; 250 if (I < SDNUMINSYMS) { 251 pDict->AddImage(SDINSYMS[I] 252 ? pdfium::MakeUnique<CJBig2_Image>(*SDINSYMS[I]) 253 : nullptr); 254 } else { 255 pDict->AddImage(std::move(SDNEWSYMS[I - SDNUMINSYMS])); 256 } 257 ++J; 258 } 259 return pDict; 260} 261 262std::unique_ptr<CJBig2_SymbolDict> CJBig2_SDDProc::decode_Huffman( 263 CJBig2_BitStream* pStream, 264 std::vector<JBig2ArithCtx>* gbContext, 265 std::vector<JBig2ArithCtx>* grContext) { 266 std::vector<std::unique_ptr<CJBig2_Image>> SDNEWSYMS; 267 std::vector<uint32_t> SDNEWSYMWIDTHS; 268 uint32_t HCHEIGHT, NSYMSDECODED; 269 int32_t HCDH; 270 uint32_t SYMWIDTH, TOTWIDTH, HCFIRSTSYM; 271 int32_t DW; 272 uint32_t I, J, REFAGGNINST; 273 std::vector<bool> EXFLAGS; 274 uint32_t EXINDEX; 275 bool CUREXFLAG; 276 uint32_t EXRUNLENGTH; 277 int32_t nVal; 278 uint32_t nTmp; 279 uint32_t SBNUMSYMS; 280 uint8_t SBSYMCODELEN; 281 uint32_t IDI; 282 int32_t RDXI, RDYI; 283 uint32_t BMSIZE; 284 uint32_t stride; 285 uint32_t num_ex_syms; 286 // Pointers are not owned 287 std::vector<CJBig2_Image*> SBSYMS; 288 auto pHuffmanDecoder = pdfium::MakeUnique<CJBig2_HuffmanDecoder>(pStream); 289 SDNEWSYMS.resize(SDNUMNEWSYMS); 290 if (SDREFAGG == 0) 291 SDNEWSYMWIDTHS.resize(SDNUMNEWSYMS); 292 auto pDict = pdfium::MakeUnique<CJBig2_SymbolDict>(); 293 std::unique_ptr<CJBig2_HuffmanTable> pTable; 294 295 HCHEIGHT = 0; 296 NSYMSDECODED = 0; 297 std::unique_ptr<CJBig2_Image> BS; 298 while (NSYMSDECODED < SDNUMNEWSYMS) { 299 if (pHuffmanDecoder->decodeAValue(SDHUFFDH, &HCDH) != 0) 300 return nullptr; 301 302 HCHEIGHT = HCHEIGHT + HCDH; 303 if ((int)HCHEIGHT < 0 || (int)HCHEIGHT > JBIG2_MAX_IMAGE_SIZE) 304 return nullptr; 305 306 SYMWIDTH = 0; 307 TOTWIDTH = 0; 308 HCFIRSTSYM = NSYMSDECODED; 309 for (;;) { 310 nVal = pHuffmanDecoder->decodeAValue(SDHUFFDW, &DW); 311 if (nVal == JBIG2_OOB) 312 break; 313 if (nVal != 0) 314 return nullptr; 315 if (NSYMSDECODED >= SDNUMNEWSYMS) 316 return nullptr; 317 318 SYMWIDTH = SYMWIDTH + DW; 319 if ((int)SYMWIDTH < 0 || (int)SYMWIDTH > JBIG2_MAX_IMAGE_SIZE) 320 return nullptr; 321 if (HCHEIGHT == 0 || SYMWIDTH == 0) { 322 TOTWIDTH = TOTWIDTH + SYMWIDTH; 323 SDNEWSYMS[NSYMSDECODED] = nullptr; 324 NSYMSDECODED = NSYMSDECODED + 1; 325 continue; 326 } 327 TOTWIDTH = TOTWIDTH + SYMWIDTH; 328 if (SDREFAGG == 1) { 329 if (pHuffmanDecoder->decodeAValue(SDHUFFAGGINST, (int*)&REFAGGNINST) != 330 0) { 331 return nullptr; 332 } 333 BS = nullptr; 334 if (REFAGGNINST > 1) { 335 auto pDecoder = pdfium::MakeUnique<CJBig2_TRDProc>(); 336 pDecoder->SBHUFF = SDHUFF; 337 pDecoder->SBREFINE = 1; 338 pDecoder->SBW = SYMWIDTH; 339 pDecoder->SBH = HCHEIGHT; 340 pDecoder->SBNUMINSTANCES = REFAGGNINST; 341 pDecoder->SBSTRIPS = 1; 342 pDecoder->SBNUMSYMS = SDNUMINSYMS + NSYMSDECODED; 343 SBNUMSYMS = pDecoder->SBNUMSYMS; 344 std::vector<JBig2HuffmanCode> SBSYMCODES(SBNUMSYMS); 345 nTmp = 1; 346 while (static_cast<uint32_t>(1 << nTmp) < SBNUMSYMS) 347 ++nTmp; 348 for (I = 0; I < SBNUMSYMS; ++I) { 349 SBSYMCODES[I].codelen = nTmp; 350 SBSYMCODES[I].code = I; 351 } 352 pDecoder->SBSYMCODES = std::move(SBSYMCODES); 353 SBSYMS.resize(SBNUMSYMS); 354 std::copy(SDINSYMS, SDINSYMS + SDNUMINSYMS, SBSYMS.begin()); 355 for (size_t i = 0; i < NSYMSDECODED; ++i) 356 SBSYMS[i + SDNUMINSYMS] = SDNEWSYMS[i].get(); 357 pDecoder->SBSYMS = SBSYMS.data(); 358 pDecoder->SBDEFPIXEL = 0; 359 pDecoder->SBCOMBOP = JBIG2_COMPOSE_OR; 360 pDecoder->TRANSPOSED = 0; 361 pDecoder->REFCORNER = JBIG2_CORNER_TOPLEFT; 362 pDecoder->SBDSOFFSET = 0; 363 auto SBHUFFFS = pdfium::MakeUnique<CJBig2_HuffmanTable>( 364 HuffmanTable_B6, HuffmanTable_B6_Size, HuffmanTable_HTOOB_B6); 365 auto SBHUFFDS = pdfium::MakeUnique<CJBig2_HuffmanTable>( 366 HuffmanTable_B8, HuffmanTable_B8_Size, HuffmanTable_HTOOB_B8); 367 auto SBHUFFDT = pdfium::MakeUnique<CJBig2_HuffmanTable>( 368 HuffmanTable_B11, HuffmanTable_B11_Size, HuffmanTable_HTOOB_B11); 369 auto SBHUFFRDW = pdfium::MakeUnique<CJBig2_HuffmanTable>( 370 HuffmanTable_B15, HuffmanTable_B15_Size, HuffmanTable_HTOOB_B15); 371 auto SBHUFFRDH = pdfium::MakeUnique<CJBig2_HuffmanTable>( 372 HuffmanTable_B15, HuffmanTable_B15_Size, HuffmanTable_HTOOB_B15); 373 auto SBHUFFRDX = pdfium::MakeUnique<CJBig2_HuffmanTable>( 374 HuffmanTable_B15, HuffmanTable_B15_Size, HuffmanTable_HTOOB_B15); 375 auto SBHUFFRDY = pdfium::MakeUnique<CJBig2_HuffmanTable>( 376 HuffmanTable_B15, HuffmanTable_B15_Size, HuffmanTable_HTOOB_B15); 377 auto SBHUFFRSIZE = pdfium::MakeUnique<CJBig2_HuffmanTable>( 378 HuffmanTable_B1, HuffmanTable_B1_Size, HuffmanTable_HTOOB_B1); 379 pDecoder->SBHUFFFS = SBHUFFFS.get(); 380 pDecoder->SBHUFFDS = SBHUFFDS.get(); 381 pDecoder->SBHUFFDT = SBHUFFDT.get(); 382 pDecoder->SBHUFFRDW = SBHUFFRDW.get(); 383 pDecoder->SBHUFFRDH = SBHUFFRDH.get(); 384 pDecoder->SBHUFFRDX = SBHUFFRDX.get(); 385 pDecoder->SBHUFFRDY = SBHUFFRDY.get(); 386 pDecoder->SBHUFFRSIZE = SBHUFFRSIZE.get(); 387 pDecoder->SBRTEMPLATE = SDRTEMPLATE; 388 pDecoder->SBRAT[0] = SDRAT[0]; 389 pDecoder->SBRAT[1] = SDRAT[1]; 390 pDecoder->SBRAT[2] = SDRAT[2]; 391 pDecoder->SBRAT[3] = SDRAT[3]; 392 BS = pDecoder->decode_Huffman(pStream, grContext->data()); 393 if (!BS) 394 return nullptr; 395 396 } else if (REFAGGNINST == 1) { 397 SBNUMSYMS = SDNUMINSYMS + SDNUMNEWSYMS; 398 nTmp = 1; 399 while ((uint32_t)(1 << nTmp) < SBNUMSYMS) { 400 nTmp++; 401 } 402 SBSYMCODELEN = (uint8_t)nTmp; 403 uint32_t uVal = 0; 404 for (;;) { 405 if (pStream->read1Bit(&nTmp) != 0) 406 return nullptr; 407 408 uVal = (uVal << 1) | nTmp; 409 if (uVal >= SBNUMSYMS) 410 return nullptr; 411 412 IDI = SBSYMCODELEN == 0 ? uVal : SBNUMSYMS; 413 if (IDI < SBNUMSYMS) 414 break; 415 } 416 auto SBHUFFRDX = pdfium::MakeUnique<CJBig2_HuffmanTable>( 417 HuffmanTable_B15, HuffmanTable_B15_Size, HuffmanTable_HTOOB_B15); 418 auto SBHUFFRSIZE = pdfium::MakeUnique<CJBig2_HuffmanTable>( 419 HuffmanTable_B1, HuffmanTable_B1_Size, HuffmanTable_HTOOB_B1); 420 if ((pHuffmanDecoder->decodeAValue(SBHUFFRDX.get(), &RDXI) != 0) || 421 (pHuffmanDecoder->decodeAValue(SBHUFFRDX.get(), &RDYI) != 0) || 422 (pHuffmanDecoder->decodeAValue(SBHUFFRSIZE.get(), &nVal) != 0)) { 423 return nullptr; 424 } 425 pStream->alignByte(); 426 nTmp = pStream->getOffset(); 427 SBSYMS.resize(SBNUMSYMS); 428 std::copy(SDINSYMS, SDINSYMS + SDNUMINSYMS, SBSYMS.begin()); 429 for (size_t i = 0; i < NSYMSDECODED; ++i) 430 SBSYMS[i + SDNUMINSYMS] = SDNEWSYMS[i].get(); 431 auto pGRRD = pdfium::MakeUnique<CJBig2_GRRDProc>(); 432 pGRRD->GRW = SYMWIDTH; 433 pGRRD->GRH = HCHEIGHT; 434 pGRRD->GRTEMPLATE = SDRTEMPLATE; 435 pGRRD->GRREFERENCE = SBSYMS[IDI]; 436 pGRRD->GRREFERENCEDX = RDXI; 437 pGRRD->GRREFERENCEDY = RDYI; 438 pGRRD->TPGRON = 0; 439 pGRRD->GRAT[0] = SDRAT[0]; 440 pGRRD->GRAT[1] = SDRAT[1]; 441 pGRRD->GRAT[2] = SDRAT[2]; 442 pGRRD->GRAT[3] = SDRAT[3]; 443 auto pArithDecoder = pdfium::MakeUnique<CJBig2_ArithDecoder>(pStream); 444 BS = pGRRD->decode(pArithDecoder.get(), grContext->data()); 445 if (!BS) 446 return nullptr; 447 448 pStream->alignByte(); 449 pStream->offset(2); 450 if ((uint32_t)nVal != (pStream->getOffset() - nTmp)) 451 return nullptr; 452 } 453 SDNEWSYMS[NSYMSDECODED] = std::move(BS); 454 } 455 if (SDREFAGG == 0) 456 SDNEWSYMWIDTHS[NSYMSDECODED] = SYMWIDTH; 457 NSYMSDECODED = NSYMSDECODED + 1; 458 } 459 if (SDREFAGG == 0) { 460 if (pHuffmanDecoder->decodeAValue(SDHUFFBMSIZE, (int32_t*)&BMSIZE) != 0) 461 return nullptr; 462 463 pStream->alignByte(); 464 std::unique_ptr<CJBig2_Image> BHC; 465 if (BMSIZE == 0) { 466 stride = (TOTWIDTH + 7) >> 3; 467 if (pStream->getByteLeft() >= stride * HCHEIGHT) { 468 BHC = pdfium::MakeUnique<CJBig2_Image>(TOTWIDTH, HCHEIGHT); 469 for (I = 0; I < HCHEIGHT; I++) { 470 JBIG2_memcpy(BHC->data() + I * BHC->stride(), pStream->getPointer(), 471 stride); 472 pStream->offset(stride); 473 } 474 } else { 475 return nullptr; 476 } 477 } else { 478 auto pGRD = pdfium::MakeUnique<CJBig2_GRDProc>(); 479 pGRD->MMR = 1; 480 pGRD->GBW = TOTWIDTH; 481 pGRD->GBH = HCHEIGHT; 482 pGRD->Start_decode_MMR(&BHC, pStream); 483 pStream->alignByte(); 484 } 485 nTmp = 0; 486 if (!BHC) 487 continue; 488 489 for (I = HCFIRSTSYM; I < NSYMSDECODED; ++I) { 490 SDNEWSYMS[I] = BHC->subImage(nTmp, 0, SDNEWSYMWIDTHS[I], HCHEIGHT); 491 nTmp += SDNEWSYMWIDTHS[I]; 492 } 493 } 494 } 495 EXINDEX = 0; 496 CUREXFLAG = 0; 497 pTable = pdfium::MakeUnique<CJBig2_HuffmanTable>( 498 HuffmanTable_B1, HuffmanTable_B1_Size, HuffmanTable_HTOOB_B1); 499 EXFLAGS.resize(SDNUMINSYMS + SDNUMNEWSYMS); 500 num_ex_syms = 0; 501 while (EXINDEX < SDNUMINSYMS + SDNUMNEWSYMS) { 502 if (pHuffmanDecoder->decodeAValue(pTable.get(), (int*)&EXRUNLENGTH) != 0) 503 return nullptr; 504 505 if (EXINDEX + EXRUNLENGTH > SDNUMINSYMS + SDNUMNEWSYMS) 506 return nullptr; 507 508 if (EXRUNLENGTH != 0) { 509 for (I = EXINDEX; I < EXINDEX + EXRUNLENGTH; ++I) { 510 if (CUREXFLAG) 511 num_ex_syms++; 512 513 EXFLAGS[I] = CUREXFLAG; 514 } 515 } 516 EXINDEX = EXINDEX + EXRUNLENGTH; 517 CUREXFLAG = !CUREXFLAG; 518 } 519 if (num_ex_syms > SDNUMEXSYMS) 520 return nullptr; 521 522 I = J = 0; 523 for (I = 0; I < SDNUMINSYMS + SDNUMNEWSYMS; ++I) { 524 if (!EXFLAGS[I] || J >= SDNUMEXSYMS) 525 continue; 526 if (I < SDNUMINSYMS) { 527 pDict->AddImage(SDINSYMS[I] 528 ? pdfium::MakeUnique<CJBig2_Image>(*SDINSYMS[I]) 529 : nullptr); 530 } else { 531 pDict->AddImage(std::move(SDNEWSYMS[I - SDNUMINSYMS])); 532 } 533 ++J; 534 } 535 return pDict; 536} 537