1/* LzmaDec.c -- LZMA Decoder 22008-11-06 : Igor Pavlov : Public domain */ 3 4#include "LzmaDec.h" 5#ifndef BCMLZMA 6#include <string.h> 7#endif 8 9#define kNumTopBits 24 10#define kTopValue ((UInt32)1 << kNumTopBits) 11 12#define kNumBitModelTotalBits 11 13#define kBitModelTotal (1 << kNumBitModelTotalBits) 14#define kNumMoveBits 5 15 16#define RC_INIT_SIZE 5 17 18#define NORMALIZE if (range < kTopValue) { range <<= 8; code = (code << 8) | (*buf++); } 19 20#define IF_BIT_0(p) ttt = *(p); NORMALIZE; bound = (range >> kNumBitModelTotalBits) * ttt; if (code < bound) 21#define UPDATE_0(p) range = bound; *(p) = (CLzmaProb)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits)); 22#define UPDATE_1(p) range -= bound; code -= bound; *(p) = (CLzmaProb)(ttt - (ttt >> kNumMoveBits)); 23#define GET_BIT2(p, i, A0, A1) IF_BIT_0(p) \ 24 { UPDATE_0(p); i = (i + i); A0; } else \ 25 { UPDATE_1(p); i = (i + i) + 1; A1; } 26#define GET_BIT(p, i) GET_BIT2(p, i, ; , ;) 27 28#define TREE_GET_BIT(probs, i) { GET_BIT((probs + i), i); } 29#define TREE_DECODE(probs, limit, i) \ 30 { i = 1; do { TREE_GET_BIT(probs, i); } while (i < limit); i -= limit; } 31 32/* #define _LZMA_SIZE_OPT */ 33 34#ifdef _LZMA_SIZE_OPT 35#define TREE_6_DECODE(probs, i) TREE_DECODE(probs, (1 << 6), i) 36#else 37#define TREE_6_DECODE(probs, i) \ 38 { i = 1; \ 39 TREE_GET_BIT(probs, i); \ 40 TREE_GET_BIT(probs, i); \ 41 TREE_GET_BIT(probs, i); \ 42 TREE_GET_BIT(probs, i); \ 43 TREE_GET_BIT(probs, i); \ 44 TREE_GET_BIT(probs, i); \ 45 i -= 0x40; } 46#endif 47 48#define NORMALIZE_CHECK if (range < kTopValue) { if (buf >= bufLimit) return DUMMY_ERROR; range <<= 8; code = (code << 8) | (*buf++); } 49 50#define IF_BIT_0_CHECK(p) ttt = *(p); NORMALIZE_CHECK; bound = (range >> kNumBitModelTotalBits) * ttt; if (code < bound) 51#define UPDATE_0_CHECK range = bound; 52#define UPDATE_1_CHECK range -= bound; code -= bound; 53#define GET_BIT2_CHECK(p, i, A0, A1) IF_BIT_0_CHECK(p) \ 54 { UPDATE_0_CHECK; i = (i + i); A0; } else \ 55 { UPDATE_1_CHECK; i = (i + i) + 1; A1; } 56#define GET_BIT_CHECK(p, i) GET_BIT2_CHECK(p, i, ; , ;) 57#define TREE_DECODE_CHECK(probs, limit, i) \ 58 { i = 1; do { GET_BIT_CHECK(probs + i, i) } while (i < limit); i -= limit; } 59 60 61#define kNumPosBitsMax 4 62#define kNumPosStatesMax (1 << kNumPosBitsMax) 63 64#define kLenNumLowBits 3 65#define kLenNumLowSymbols (1 << kLenNumLowBits) 66#define kLenNumMidBits 3 67#define kLenNumMidSymbols (1 << kLenNumMidBits) 68#define kLenNumHighBits 8 69#define kLenNumHighSymbols (1 << kLenNumHighBits) 70 71#define LenChoice 0 72#define LenChoice2 (LenChoice + 1) 73#define LenLow (LenChoice2 + 1) 74#define LenMid (LenLow + (kNumPosStatesMax << kLenNumLowBits)) 75#define LenHigh (LenMid + (kNumPosStatesMax << kLenNumMidBits)) 76#define kNumLenProbs (LenHigh + kLenNumHighSymbols) 77 78 79#define kNumStates 12 80#define kNumLitStates 7 81 82#define kStartPosModelIndex 4 83#define kEndPosModelIndex 14 84#define kNumFullDistances (1 << (kEndPosModelIndex >> 1)) 85 86#define kNumPosSlotBits 6 87#define kNumLenToPosStates 4 88 89#define kNumAlignBits 4 90#define kAlignTableSize (1 << kNumAlignBits) 91 92#define kMatchMinLen 2 93#define kMatchSpecLenStart (kMatchMinLen + kLenNumLowSymbols + kLenNumMidSymbols + kLenNumHighSymbols) 94 95#define IsMatch 0 96#define IsRep (IsMatch + (kNumStates << kNumPosBitsMax)) 97#define IsRepG0 (IsRep + kNumStates) 98#define IsRepG1 (IsRepG0 + kNumStates) 99#define IsRepG2 (IsRepG1 + kNumStates) 100#define IsRep0Long (IsRepG2 + kNumStates) 101#define PosSlot (IsRep0Long + (kNumStates << kNumPosBitsMax)) 102#define SpecPos (PosSlot + (kNumLenToPosStates << kNumPosSlotBits)) 103#define Align (SpecPos + kNumFullDistances - kEndPosModelIndex) 104#define LenCoder (Align + kAlignTableSize) 105#define RepLenCoder (LenCoder + kNumLenProbs) 106#define Literal (RepLenCoder + kNumLenProbs) 107 108#define LZMA_BASE_SIZE 1846 109#define LZMA_LIT_SIZE 768 110 111#define LzmaProps_GetNumProbs(p) ((UInt32)LZMA_BASE_SIZE + (LZMA_LIT_SIZE << ((p)->lc + (p)->lp))) 112 113#if Literal != LZMA_BASE_SIZE 114StopCompilingDueBUG 115#endif 116 117static const Byte kLiteralNextStates[kNumStates * 2] = 118{ 119 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 4, 5, 120 7, 7, 7, 7, 7, 7, 7, 10, 10, 10, 10, 10 121}; 122 123#define LZMA_DIC_MIN (1 << 12) 124 125/* First LZMA-symbol is always decoded. 126And it decodes new LZMA-symbols while (buf < bufLimit), but "buf" is without last normalization 127Out: 128 Result: 129 SZ_OK - OK 130 SZ_ERROR_DATA - Error 131 p->remainLen: 132 < kMatchSpecLenStart : normal remain 133 = kMatchSpecLenStart : finished 134 = kMatchSpecLenStart + 1 : Flush marker 135 = kMatchSpecLenStart + 2 : State Init Marker 136*/ 137 138static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte *bufLimit) 139{ 140 CLzmaProb *probs = p->probs; 141 142 unsigned state = p->state; 143 UInt32 rep0 = p->reps[0], rep1 = p->reps[1], rep2 = p->reps[2], rep3 = p->reps[3]; 144 unsigned pbMask = ((unsigned)1 << (p->prop.pb)) - 1; 145 unsigned lpMask = ((unsigned)1 << (p->prop.lp)) - 1; 146 unsigned lc = p->prop.lc; 147 148 Byte *dic = p->dic; 149 SizeT dicBufSize = p->dicBufSize; 150 SizeT dicPos = p->dicPos; 151 152 UInt32 processedPos = p->processedPos; 153 UInt32 checkDicSize = p->checkDicSize; 154 unsigned len = 0; 155 156 const Byte *buf = p->buf; 157 UInt32 range = p->range; 158 UInt32 code = p->code; 159 160 do 161 { 162 CLzmaProb *prob; 163 UInt32 bound; 164 unsigned ttt; 165 unsigned posState = processedPos & pbMask; 166 167 prob = probs + IsMatch + (state << kNumPosBitsMax) + posState; 168 IF_BIT_0(prob) 169 { 170 unsigned symbol; 171 UPDATE_0(prob); 172 prob = probs + Literal; 173 if (checkDicSize != 0 || processedPos != 0) 174 prob += (LZMA_LIT_SIZE * (((processedPos & lpMask) << lc) + 175 (dic[(dicPos == 0 ? dicBufSize : dicPos) - 1] >> (8 - lc)))); 176 177 if (state < kNumLitStates) 178 { 179 symbol = 1; 180 do { GET_BIT(prob + symbol, symbol) } while (symbol < 0x100); 181 } 182 else 183 { 184 unsigned matchByte = p->dic[(dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0)]; 185 unsigned offs = 0x100; 186 symbol = 1; 187 do 188 { 189 unsigned bit; 190 CLzmaProb *probLit; 191 matchByte <<= 1; 192 bit = (matchByte & offs); 193 probLit = prob + offs + bit + symbol; 194 GET_BIT2(probLit, symbol, offs &= ~bit, offs &= bit) 195 } 196 while (symbol < 0x100); 197 } 198 dic[dicPos++] = (Byte)symbol; 199 processedPos++; 200 201 state = kLiteralNextStates[state]; 202 /* if (state < 4) state = 0; else if (state < 10) state -= 3; else state -= 6; */ 203 continue; 204 } 205 else 206 { 207 UPDATE_1(prob); 208 prob = probs + IsRep + state; 209 IF_BIT_0(prob) 210 { 211 UPDATE_0(prob); 212 state += kNumStates; 213 prob = probs + LenCoder; 214 } 215 else 216 { 217 UPDATE_1(prob); 218 if (checkDicSize == 0 && processedPos == 0) 219 return SZ_ERROR_DATA; 220 prob = probs + IsRepG0 + state; 221 IF_BIT_0(prob) 222 { 223 UPDATE_0(prob); 224 prob = probs + IsRep0Long + (state << kNumPosBitsMax) + posState; 225 IF_BIT_0(prob) 226 { 227 UPDATE_0(prob); 228 dic[dicPos] = dic[(dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0)]; 229 dicPos++; 230 processedPos++; 231 state = state < kNumLitStates ? 9 : 11; 232 continue; 233 } 234 UPDATE_1(prob); 235 } 236 else 237 { 238 UInt32 distance; 239 UPDATE_1(prob); 240 prob = probs + IsRepG1 + state; 241 IF_BIT_0(prob) 242 { 243 UPDATE_0(prob); 244 distance = rep1; 245 } 246 else 247 { 248 UPDATE_1(prob); 249 prob = probs + IsRepG2 + state; 250 IF_BIT_0(prob) 251 { 252 UPDATE_0(prob); 253 distance = rep2; 254 } 255 else 256 { 257 UPDATE_1(prob); 258 distance = rep3; 259 rep3 = rep2; 260 } 261 rep2 = rep1; 262 } 263 rep1 = rep0; 264 rep0 = distance; 265 } 266 state = state < kNumLitStates ? 8 : 11; 267 prob = probs + RepLenCoder; 268 } 269 { 270 unsigned limit, offset; 271 CLzmaProb *probLen = prob + LenChoice; 272 IF_BIT_0(probLen) 273 { 274 UPDATE_0(probLen); 275 probLen = prob + LenLow + (posState << kLenNumLowBits); 276 offset = 0; 277 limit = (1 << kLenNumLowBits); 278 } 279 else 280 { 281 UPDATE_1(probLen); 282 probLen = prob + LenChoice2; 283 IF_BIT_0(probLen) 284 { 285 UPDATE_0(probLen); 286 probLen = prob + LenMid + (posState << kLenNumMidBits); 287 offset = kLenNumLowSymbols; 288 limit = (1 << kLenNumMidBits); 289 } 290 else 291 { 292 UPDATE_1(probLen); 293 probLen = prob + LenHigh; 294 offset = kLenNumLowSymbols + kLenNumMidSymbols; 295 limit = (1 << kLenNumHighBits); 296 } 297 } 298 TREE_DECODE(probLen, limit, len); 299 len += offset; 300 } 301 302 if (state >= kNumStates) 303 { 304 UInt32 distance; 305 prob = probs + PosSlot + 306 ((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) << kNumPosSlotBits); 307 TREE_6_DECODE(prob, distance); 308 if (distance >= kStartPosModelIndex) 309 { 310 unsigned posSlot = (unsigned)distance; 311 int numDirectBits = (int)(((distance >> 1) - 1)); 312 distance = (2 | (distance & 1)); 313 if (posSlot < kEndPosModelIndex) 314 { 315 distance <<= numDirectBits; 316 prob = probs + SpecPos + distance - posSlot - 1; 317 { 318 UInt32 mask = 1; 319 unsigned i = 1; 320 do 321 { 322 GET_BIT2(prob + i, i, ; , distance |= mask); 323 mask <<= 1; 324 } 325 while (--numDirectBits != 0); 326 } 327 } 328 else 329 { 330 numDirectBits -= kNumAlignBits; 331 do 332 { 333 NORMALIZE 334 range >>= 1; 335 336 { 337 UInt32 t; 338 code -= range; 339 t = (0 - ((UInt32)code >> 31)); /* (UInt32)((Int32)code >> 31) */ 340 distance = (distance << 1) + (t + 1); 341 code += range & t; 342 } 343 /* 344 distance <<= 1; 345 if (code >= range) 346 { 347 code -= range; 348 distance |= 1; 349 } 350 */ 351 } 352 while (--numDirectBits != 0); 353 prob = probs + Align; 354 distance <<= kNumAlignBits; 355 { 356 unsigned i = 1; 357 GET_BIT2(prob + i, i, ; , distance |= 1); 358 GET_BIT2(prob + i, i, ; , distance |= 2); 359 GET_BIT2(prob + i, i, ; , distance |= 4); 360 GET_BIT2(prob + i, i, ; , distance |= 8); 361 } 362 if (distance == (UInt32)0xFFFFFFFF) 363 { 364 len += kMatchSpecLenStart; 365 state -= kNumStates; 366 break; 367 } 368 } 369 } 370 rep3 = rep2; 371 rep2 = rep1; 372 rep1 = rep0; 373 rep0 = distance + 1; 374 if (checkDicSize == 0) 375 { 376 if (distance >= processedPos) 377 return SZ_ERROR_DATA; 378 } 379 else if (distance >= checkDicSize) 380 return SZ_ERROR_DATA; 381 state = (state < kNumStates + kNumLitStates) ? kNumLitStates : kNumLitStates + 3; 382 /* state = kLiteralNextStates[state]; */ 383 } 384 385 len += kMatchMinLen; 386 387 if (limit == dicPos) 388 return SZ_ERROR_DATA; 389 { 390 SizeT rem = limit - dicPos; 391 unsigned curLen = ((rem < len) ? (unsigned)rem : len); 392 SizeT pos = (dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0); 393 394 processedPos += curLen; 395 396 len -= curLen; 397 if (pos + curLen <= dicBufSize) 398 { 399 Byte *dest = dic + dicPos; 400 int src = (int)pos - (int)dicPos; 401 const Byte *lim = dest + curLen; 402 dicPos += curLen; 403 do 404 *(dest) = (Byte)*(dest + src); 405 while (++dest != lim); 406 } 407 else 408 { 409 do 410 { 411 dic[dicPos++] = dic[pos]; 412 if (++pos == dicBufSize) 413 pos = 0; 414 } 415 while (--curLen != 0); 416 } 417 } 418 } 419 } 420 while (dicPos < limit && buf < bufLimit); 421 NORMALIZE; 422 p->buf = buf; 423 p->range = range; 424 p->code = code; 425 p->remainLen = len; 426 p->dicPos = dicPos; 427 p->processedPos = processedPos; 428 p->reps[0] = rep0; 429 p->reps[1] = rep1; 430 p->reps[2] = rep2; 431 p->reps[3] = rep3; 432 p->state = state; 433 434 return SZ_OK; 435} 436 437static void MY_FAST_CALL LzmaDec_WriteRem(CLzmaDec *p, SizeT limit) 438{ 439 if (p->remainLen != 0 && p->remainLen < kMatchSpecLenStart) 440 { 441 Byte *dic = p->dic; 442 SizeT dicPos = p->dicPos; 443 SizeT dicBufSize = p->dicBufSize; 444 unsigned len = p->remainLen; 445 UInt32 rep0 = p->reps[0]; 446 if (limit - dicPos < len) 447 len = (unsigned)(limit - dicPos); 448 449 if (p->checkDicSize == 0 && p->prop.dicSize - p->processedPos <= len) 450 p->checkDicSize = p->prop.dicSize; 451 452 p->processedPos += len; 453 p->remainLen -= len; 454 while (len-- != 0) 455 { 456 dic[dicPos] = dic[(dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0)]; 457 dicPos++; 458 } 459 p->dicPos = dicPos; 460 } 461} 462 463static int MY_FAST_CALL LzmaDec_DecodeReal2(CLzmaDec *p, SizeT limit, const Byte *bufLimit) 464{ 465 do 466 { 467 SizeT limit2 = limit; 468 if (p->checkDicSize == 0) 469 { 470 UInt32 rem = p->prop.dicSize - p->processedPos; 471 if (limit - p->dicPos > rem) 472 limit2 = p->dicPos + rem; 473 } 474 RINOK(LzmaDec_DecodeReal(p, limit2, bufLimit)); 475 if (p->processedPos >= p->prop.dicSize) 476 p->checkDicSize = p->prop.dicSize; 477 LzmaDec_WriteRem(p, limit); 478 } 479 while (p->dicPos < limit && p->buf < bufLimit && p->remainLen < kMatchSpecLenStart); 480 481 if (p->remainLen > kMatchSpecLenStart) 482 { 483 p->remainLen = kMatchSpecLenStart; 484 } 485 return 0; 486} 487 488typedef enum 489{ 490 DUMMY_ERROR, /* unexpected end of input stream */ 491 DUMMY_LIT, 492 DUMMY_MATCH, 493 DUMMY_REP 494} ELzmaDummy; 495 496static ELzmaDummy LzmaDec_TryDummy(const CLzmaDec *p, const Byte *buf, SizeT inSize) 497{ 498 UInt32 range = p->range; 499 UInt32 code = p->code; 500 const Byte *bufLimit = buf + inSize; 501 CLzmaProb *probs = p->probs; 502 unsigned state = p->state; 503 ELzmaDummy res; 504 505 { 506 CLzmaProb *prob; 507 UInt32 bound; 508 unsigned ttt; 509 unsigned posState = (p->processedPos) & ((1 << p->prop.pb) - 1); 510 511 prob = probs + IsMatch + (state << kNumPosBitsMax) + posState; 512 IF_BIT_0_CHECK(prob) 513 { 514 UPDATE_0_CHECK 515 516 /* if (bufLimit - buf >= 7) return DUMMY_LIT; */ 517 518 prob = probs + Literal; 519 if (p->checkDicSize != 0 || p->processedPos != 0) 520 prob += (LZMA_LIT_SIZE * 521 ((((p->processedPos) & ((1 << (p->prop.lp)) - 1)) << p->prop.lc) + 522 (p->dic[(p->dicPos == 0 ? p->dicBufSize : p->dicPos) - 1] >> (8 - p->prop.lc)))); 523 524 if (state < kNumLitStates) 525 { 526 unsigned symbol = 1; 527 do { GET_BIT_CHECK(prob + symbol, symbol) } while (symbol < 0x100); 528 } 529 else 530 { 531 unsigned matchByte = p->dic[p->dicPos - p->reps[0] + 532 ((p->dicPos < p->reps[0]) ? p->dicBufSize : 0)]; 533 unsigned offs = 0x100; 534 unsigned symbol = 1; 535 do 536 { 537 unsigned bit; 538 CLzmaProb *probLit; 539 matchByte <<= 1; 540 bit = (matchByte & offs); 541 probLit = prob + offs + bit + symbol; 542 GET_BIT2_CHECK(probLit, symbol, offs &= ~bit, offs &= bit) 543 } 544 while (symbol < 0x100); 545 } 546 res = DUMMY_LIT; 547 } 548 else 549 { 550 unsigned len; 551 UPDATE_1_CHECK; 552 553 prob = probs + IsRep + state; 554 IF_BIT_0_CHECK(prob) 555 { 556 UPDATE_0_CHECK; 557 state = 0; 558 prob = probs + LenCoder; 559 res = DUMMY_MATCH; 560 } 561 else 562 { 563 UPDATE_1_CHECK; 564 res = DUMMY_REP; 565 prob = probs + IsRepG0 + state; 566 IF_BIT_0_CHECK(prob) 567 { 568 UPDATE_0_CHECK; 569 prob = probs + IsRep0Long + (state << kNumPosBitsMax) + posState; 570 IF_BIT_0_CHECK(prob) 571 { 572 UPDATE_0_CHECK; 573 NORMALIZE_CHECK; 574 return DUMMY_REP; 575 } 576 else 577 { 578 UPDATE_1_CHECK; 579 } 580 } 581 else 582 { 583 UPDATE_1_CHECK; 584 prob = probs + IsRepG1 + state; 585 IF_BIT_0_CHECK(prob) 586 { 587 UPDATE_0_CHECK; 588 } 589 else 590 { 591 UPDATE_1_CHECK; 592 prob = probs + IsRepG2 + state; 593 IF_BIT_0_CHECK(prob) 594 { 595 UPDATE_0_CHECK; 596 } 597 else 598 { 599 UPDATE_1_CHECK; 600 } 601 } 602 } 603 state = kNumStates; 604 prob = probs + RepLenCoder; 605 } 606 { 607 unsigned limit, offset; 608 CLzmaProb *probLen = prob + LenChoice; 609 IF_BIT_0_CHECK(probLen) 610 { 611 UPDATE_0_CHECK; 612 probLen = prob + LenLow + (posState << kLenNumLowBits); 613 offset = 0; 614 limit = 1 << kLenNumLowBits; 615 } 616 else 617 { 618 UPDATE_1_CHECK; 619 probLen = prob + LenChoice2; 620 IF_BIT_0_CHECK(probLen) 621 { 622 UPDATE_0_CHECK; 623 probLen = prob + LenMid + (posState << kLenNumMidBits); 624 offset = kLenNumLowSymbols; 625 limit = 1 << kLenNumMidBits; 626 } 627 else 628 { 629 UPDATE_1_CHECK; 630 probLen = prob + LenHigh; 631 offset = kLenNumLowSymbols + kLenNumMidSymbols; 632 limit = 1 << kLenNumHighBits; 633 } 634 } 635 TREE_DECODE_CHECK(probLen, limit, len); 636 len += offset; 637 } 638 639 if (state < 4) 640 { 641 unsigned posSlot; 642 prob = probs + PosSlot + 643 ((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) << 644 kNumPosSlotBits); 645 TREE_DECODE_CHECK(prob, 1 << kNumPosSlotBits, posSlot); 646 if (posSlot >= kStartPosModelIndex) 647 { 648 int numDirectBits = ((posSlot >> 1) - 1); 649 650 /* if (bufLimit - buf >= 8) return DUMMY_MATCH; */ 651 652 if (posSlot < kEndPosModelIndex) 653 { 654 prob = probs + SpecPos + ((2 | (posSlot & 1)) << numDirectBits) - posSlot - 1; 655 } 656 else 657 { 658 numDirectBits -= kNumAlignBits; 659 do 660 { 661 NORMALIZE_CHECK 662 range >>= 1; 663 code -= range & (((code - range) >> 31) - 1); 664 /* if (code >= range) code -= range; */ 665 } 666 while (--numDirectBits != 0); 667 prob = probs + Align; 668 numDirectBits = kNumAlignBits; 669 } 670 { 671 unsigned i = 1; 672 do 673 { 674 GET_BIT_CHECK(prob + i, i); 675 } 676 while (--numDirectBits != 0); 677 } 678 } 679 } 680 } 681 } 682 NORMALIZE_CHECK; 683 return res; 684} 685 686 687static void LzmaDec_InitRc(CLzmaDec *p, const Byte *data) 688{ 689 p->code = ((UInt32)data[1] << 24) | ((UInt32)data[2] << 16) | ((UInt32)data[3] << 8) | ((UInt32)data[4]); 690 p->range = 0xFFFFFFFF; 691 p->needFlush = 0; 692} 693 694static void LzmaDec_InitDicAndState(CLzmaDec *p, Bool initDic, Bool initState) 695{ 696 p->needFlush = 1; 697 p->remainLen = 0; 698 p->tempBufSize = 0; 699 700 if (initDic) 701 { 702 p->processedPos = 0; 703 p->checkDicSize = 0; 704 p->needInitState = 1; 705 } 706 if (initState) 707 p->needInitState = 1; 708} 709 710void LzmaDec_Init(CLzmaDec *p) 711{ 712 p->dicPos = 0; 713 LzmaDec_InitDicAndState(p, True, True); 714} 715 716static void LzmaDec_InitStateReal(CLzmaDec *p) 717{ 718 UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (p->prop.lc + p->prop.lp)); 719 UInt32 i; 720 CLzmaProb *probs = p->probs; 721 for (i = 0; i < numProbs; i++) 722 probs[i] = kBitModelTotal >> 1; 723 p->reps[0] = p->reps[1] = p->reps[2] = p->reps[3] = 1; 724 p->state = 0; 725 p->needInitState = 0; 726} 727 728SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *srcLen, 729 ELzmaFinishMode finishMode, ELzmaStatus *status) 730{ 731 SizeT inSize = *srcLen; 732 (*srcLen) = 0; 733 LzmaDec_WriteRem(p, dicLimit); 734 735 *status = LZMA_STATUS_NOT_SPECIFIED; 736 737 while (p->remainLen != kMatchSpecLenStart) 738 { 739 int checkEndMarkNow; 740 741 if (p->needFlush != 0) 742 { 743 for (; inSize > 0 && p->tempBufSize < RC_INIT_SIZE; (*srcLen)++, inSize--) 744 p->tempBuf[p->tempBufSize++] = *src++; 745 if (p->tempBufSize < RC_INIT_SIZE) 746 { 747 *status = LZMA_STATUS_NEEDS_MORE_INPUT; 748 return SZ_OK; 749 } 750 if (p->tempBuf[0] != 0) 751 return SZ_ERROR_DATA; 752 753 LzmaDec_InitRc(p, p->tempBuf); 754 p->tempBufSize = 0; 755 } 756 757 checkEndMarkNow = 0; 758 if (p->dicPos >= dicLimit) 759 { 760 if (p->remainLen == 0 && p->code == 0) 761 { 762 *status = LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK; 763 return SZ_OK; 764 } 765 if (finishMode == LZMA_FINISH_ANY) 766 { 767 *status = LZMA_STATUS_NOT_FINISHED; 768 return SZ_OK; 769 } 770 if (p->remainLen != 0) 771 { 772 *status = LZMA_STATUS_NOT_FINISHED; 773 return SZ_ERROR_DATA; 774 } 775 checkEndMarkNow = 1; 776 } 777 778 if (p->needInitState) 779 LzmaDec_InitStateReal(p); 780 781 if (p->tempBufSize == 0) 782 { 783 SizeT processed; 784 const Byte *bufLimit; 785 if (inSize < LZMA_REQUIRED_INPUT_MAX || checkEndMarkNow) 786 { 787 int dummyRes = LzmaDec_TryDummy(p, src, inSize); 788 if (dummyRes == DUMMY_ERROR) 789 { 790 memcpy(p->tempBuf, src, inSize); 791 p->tempBufSize = (unsigned)inSize; 792 (*srcLen) += inSize; 793 *status = LZMA_STATUS_NEEDS_MORE_INPUT; 794 return SZ_OK; 795 } 796 if (checkEndMarkNow && dummyRes != DUMMY_MATCH) 797 { 798 *status = LZMA_STATUS_NOT_FINISHED; 799 return SZ_ERROR_DATA; 800 } 801 bufLimit = src; 802 } 803 else 804 bufLimit = src + inSize - LZMA_REQUIRED_INPUT_MAX; 805 p->buf = src; 806 if (LzmaDec_DecodeReal2(p, dicLimit, bufLimit) != 0) 807 return SZ_ERROR_DATA; 808 processed = (SizeT)(p->buf - src); 809 (*srcLen) += processed; 810 src += processed; 811 inSize -= processed; 812 } 813 else 814 { 815 unsigned rem = p->tempBufSize, lookAhead = 0; 816 while (rem < LZMA_REQUIRED_INPUT_MAX && lookAhead < inSize) 817 p->tempBuf[rem++] = src[lookAhead++]; 818 p->tempBufSize = rem; 819 if (rem < LZMA_REQUIRED_INPUT_MAX || checkEndMarkNow) 820 { 821 int dummyRes = LzmaDec_TryDummy(p, p->tempBuf, rem); 822 if (dummyRes == DUMMY_ERROR) 823 { 824 (*srcLen) += lookAhead; 825 *status = LZMA_STATUS_NEEDS_MORE_INPUT; 826 return SZ_OK; 827 } 828 if (checkEndMarkNow && dummyRes != DUMMY_MATCH) 829 { 830 *status = LZMA_STATUS_NOT_FINISHED; 831 return SZ_ERROR_DATA; 832 } 833 } 834 p->buf = p->tempBuf; 835 if (LzmaDec_DecodeReal2(p, dicLimit, p->buf) != 0) 836 return SZ_ERROR_DATA; 837 lookAhead -= (rem - (unsigned)(p->buf - p->tempBuf)); 838 (*srcLen) += lookAhead; 839 src += lookAhead; 840 inSize -= lookAhead; 841 p->tempBufSize = 0; 842 } 843 } 844 if (p->code == 0) 845 *status = LZMA_STATUS_FINISHED_WITH_MARK; 846 return (p->code == 0) ? SZ_OK : SZ_ERROR_DATA; 847} 848 849SRes LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status) 850{ 851 SizeT outSize = *destLen; 852 SizeT inSize = *srcLen; 853 *srcLen = *destLen = 0; 854 for (;;) 855 { 856 SizeT inSizeCur = inSize, outSizeCur, dicPos; 857 ELzmaFinishMode curFinishMode; 858 SRes res; 859 if (p->dicPos == p->dicBufSize) 860 p->dicPos = 0; 861 dicPos = p->dicPos; 862 if (outSize > p->dicBufSize - dicPos) 863 { 864 outSizeCur = p->dicBufSize; 865 curFinishMode = LZMA_FINISH_ANY; 866 } 867 else 868 { 869 outSizeCur = dicPos + outSize; 870 curFinishMode = finishMode; 871 } 872 873 res = LzmaDec_DecodeToDic(p, outSizeCur, src, &inSizeCur, curFinishMode, status); 874 src += inSizeCur; 875 inSize -= inSizeCur; 876 *srcLen += inSizeCur; 877 outSizeCur = p->dicPos - dicPos; 878 memcpy(dest, p->dic + dicPos, outSizeCur); 879 dest += outSizeCur; 880 outSize -= outSizeCur; 881 *destLen += outSizeCur; 882 if (res != 0) 883 return res; 884 if (outSizeCur == 0 || outSize == 0) 885 return SZ_OK; 886 } 887} 888 889void LzmaDec_FreeProbs(CLzmaDec *p, ISzAlloc *alloc) 890{ 891 alloc->Free(alloc, p->probs); 892 p->probs = 0; 893} 894 895static void LzmaDec_FreeDict(CLzmaDec *p, ISzAlloc *alloc) 896{ 897 alloc->Free(alloc, p->dic); 898 p->dic = 0; 899} 900 901void LzmaDec_Free(CLzmaDec *p, ISzAlloc *alloc) 902{ 903 LzmaDec_FreeProbs(p, alloc); 904 LzmaDec_FreeDict(p, alloc); 905} 906 907SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size) 908{ 909 UInt32 dicSize; 910 Byte d; 911 912 if (size < LZMA_PROPS_SIZE) 913 return SZ_ERROR_UNSUPPORTED; 914 else 915 dicSize = data[1] | ((UInt32)data[2] << 8) | ((UInt32)data[3] << 16) | ((UInt32)data[4] << 24); 916 917 if (dicSize < LZMA_DIC_MIN) 918 dicSize = LZMA_DIC_MIN; 919 p->dicSize = dicSize; 920 921 d = data[0]; 922 if (d >= (9 * 5 * 5)) 923 return SZ_ERROR_UNSUPPORTED; 924 925 p->lc = d % 9; 926 d /= 9; 927 p->pb = d / 5; 928 p->lp = d % 5; 929 930 return SZ_OK; 931} 932 933static SRes LzmaDec_AllocateProbs2(CLzmaDec *p, const CLzmaProps *propNew, ISzAlloc *alloc) 934{ 935 UInt32 numProbs = LzmaProps_GetNumProbs(propNew); 936 if (p->probs == 0 || numProbs != p->numProbs) 937 { 938 LzmaDec_FreeProbs(p, alloc); 939 p->probs = (CLzmaProb *)alloc->Alloc(alloc, numProbs * sizeof(CLzmaProb)); 940 p->numProbs = numProbs; 941 if (p->probs == 0) 942 return SZ_ERROR_MEM; 943 } 944 return SZ_OK; 945} 946 947SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAlloc *alloc) 948{ 949 CLzmaProps propNew; 950 RINOK(LzmaProps_Decode(&propNew, props, propsSize)); 951 RINOK(LzmaDec_AllocateProbs2(p, &propNew, alloc)); 952 p->prop = propNew; 953 return SZ_OK; 954} 955 956SRes LzmaDec_Allocate(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAlloc *alloc) 957{ 958 CLzmaProps propNew; 959 SizeT dicBufSize; 960 RINOK(LzmaProps_Decode(&propNew, props, propsSize)); 961 RINOK(LzmaDec_AllocateProbs2(p, &propNew, alloc)); 962 dicBufSize = propNew.dicSize; 963 if (p->dic == 0 || dicBufSize != p->dicBufSize) 964 { 965 LzmaDec_FreeDict(p, alloc); 966 p->dic = (Byte *)alloc->Alloc(alloc, dicBufSize); 967 if (p->dic == 0) 968 { 969 LzmaDec_FreeProbs(p, alloc); 970 return SZ_ERROR_MEM; 971 } 972 } 973 p->dicBufSize = dicBufSize; 974 p->prop = propNew; 975 return SZ_OK; 976} 977 978SRes LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, 979 const Byte *propData, unsigned propSize, ELzmaFinishMode finishMode, 980 ELzmaStatus *status, ISzAlloc *alloc) 981{ 982 CLzmaDec p; 983 SRes res; 984 SizeT inSize = *srcLen; 985 SizeT outSize = *destLen; 986 *srcLen = *destLen = 0; 987 if (inSize < RC_INIT_SIZE) 988 return SZ_ERROR_INPUT_EOF; 989 990 LzmaDec_Construct(&p); 991 res = LzmaDec_AllocateProbs(&p, propData, propSize, alloc); 992 if (res != 0) 993 return res; 994 p.dic = dest; 995 p.dicBufSize = outSize; 996 997 LzmaDec_Init(&p); 998 999 *srcLen = inSize; 1000 res = LzmaDec_DecodeToDic(&p, outSize, src, srcLen, finishMode, status); 1001 1002 if (res == SZ_OK && *status == LZMA_STATUS_NEEDS_MORE_INPUT) 1003 res = SZ_ERROR_INPUT_EOF; 1004 1005 (*destLen) = p.dicPos; 1006 LzmaDec_FreeProbs(&p, alloc); 1007 return res; 1008} 1009