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