1 /* Lzma2Dec.c -- LZMA2 Decoder 2 2018-07-04 : Igor Pavlov : Public domain */ 3 4 /* #define SHOW_DEBUG_INFO */ 5 6 #include "Precomp.h" 7 8 #ifdef SHOW_DEBUG_INFO 9 #include <stdio.h> 10 #endif 11 12 #include <string.h> 13 14 #include "Lzma2Dec.h" 15 16 /* 17 00000000 - End of data 18 00000001 U U - Uncompressed, reset dic, need reset state and set new prop 19 00000010 U U - Uncompressed, no reset 20 100uuuuu U U P P - LZMA, no reset 21 101uuuuu U U P P - LZMA, reset state 22 110uuuuu U U P P S - LZMA, reset state + set new prop 23 111uuuuu U U P P S - LZMA, reset state + set new prop, reset dic 24 25 u, U - Unpack Size 26 P - Pack Size 27 S - Props 28 */ 29 30 #define LZMA2_CONTROL_COPY_RESET_DIC 1 31 32 #define LZMA2_IS_UNCOMPRESSED_STATE(p) (((p)->control & (1 << 7)) == 0) 33 34 #define LZMA2_LCLP_MAX 4 35 #define LZMA2_DIC_SIZE_FROM_PROP(p) (((UInt32)2 | ((p) & 1)) << ((p) / 2 + 11)) 36 37 #ifdef SHOW_DEBUG_INFO 38 #define PRF(x) x 39 #else 40 #define PRF(x) 41 #endif 42 43 typedef enum 44 { 45 LZMA2_STATE_CONTROL, 46 LZMA2_STATE_UNPACK0, 47 LZMA2_STATE_UNPACK1, 48 LZMA2_STATE_PACK0, 49 LZMA2_STATE_PACK1, 50 LZMA2_STATE_PROP, 51 LZMA2_STATE_DATA, 52 LZMA2_STATE_DATA_CONT, 53 LZMA2_STATE_FINISHED, 54 LZMA2_STATE_ERROR 55 } ELzma2State; 56 57 static SRes Lzma2Dec_GetOldProps(Byte prop, Byte *props) 58 { 59 UInt32 dicSize; 60 if (prop > 40) 61 return SZ_ERROR_UNSUPPORTED; 62 dicSize = (prop == 40) ? 0xFFFFFFFF : LZMA2_DIC_SIZE_FROM_PROP(prop); 63 props[0] = (Byte)LZMA2_LCLP_MAX; 64 props[1] = (Byte)(dicSize); 65 props[2] = (Byte)(dicSize >> 8); 66 props[3] = (Byte)(dicSize >> 16); 67 props[4] = (Byte)(dicSize >> 24); 68 return SZ_OK; 69 } 70 71 SRes Lzma2Dec_AllocateProbs(CLzma2Dec *p, Byte prop, ISzAllocPtr alloc) 72 { 73 Byte props[LZMA_PROPS_SIZE]; 74 RINOK(Lzma2Dec_GetOldProps(prop, props)); 75 return LzmaDec_AllocateProbs(&p->decoder, props, LZMA_PROPS_SIZE, alloc); 76 } 77 78 SRes Lzma2Dec_Allocate(CLzma2Dec *p, Byte prop, ISzAllocPtr alloc) 79 { 80 Byte props[LZMA_PROPS_SIZE]; 81 RINOK(Lzma2Dec_GetOldProps(prop, props)); 82 return LzmaDec_Allocate(&p->decoder, props, LZMA_PROPS_SIZE, alloc); 83 } 84 85 void Lzma2Dec_Init(CLzma2Dec *p) 86 { 87 p->state = LZMA2_STATE_CONTROL; 88 p->needInitLevel = 0xE0; 89 p->isExtraMode = False; 90 p->unpackSize = 0; 91 92 // p->decoder.dicPos = 0; // we can use it instead of full init 93 LzmaDec_Init(&p->decoder); 94 } 95 96 static ELzma2State Lzma2Dec_UpdateState(CLzma2Dec *p, Byte b) 97 { 98 switch (p->state) 99 { 100 case LZMA2_STATE_CONTROL: 101 p->isExtraMode = False; 102 p->control = b; 103 PRF(printf("\n %8X", (unsigned)p->decoder.dicPos)); 104 PRF(printf(" %02X", (unsigned)b)); 105 if (b == 0) 106 return LZMA2_STATE_FINISHED; 107 if (LZMA2_IS_UNCOMPRESSED_STATE(p)) 108 { 109 if (b == LZMA2_CONTROL_COPY_RESET_DIC) 110 p->needInitLevel = 0xC0; 111 else if (b > 2 || p->needInitLevel == 0xE0) 112 return LZMA2_STATE_ERROR; 113 } 114 else 115 { 116 if (b < p->needInitLevel) 117 return LZMA2_STATE_ERROR; 118 p->needInitLevel = 0; 119 p->unpackSize = (UInt32)(b & 0x1F) << 16; 120 } 121 return LZMA2_STATE_UNPACK0; 122 123 case LZMA2_STATE_UNPACK0: 124 p->unpackSize |= (UInt32)b << 8; 125 return LZMA2_STATE_UNPACK1; 126 127 case LZMA2_STATE_UNPACK1: 128 p->unpackSize |= (UInt32)b; 129 p->unpackSize++; 130 PRF(printf(" %7u", (unsigned)p->unpackSize)); 131 return LZMA2_IS_UNCOMPRESSED_STATE(p) ? LZMA2_STATE_DATA : LZMA2_STATE_PACK0; 132 133 case LZMA2_STATE_PACK0: 134 p->packSize = (UInt32)b << 8; 135 return LZMA2_STATE_PACK1; 136 137 case LZMA2_STATE_PACK1: 138 p->packSize |= (UInt32)b; 139 p->packSize++; 140 // if (p->packSize < 5) return LZMA2_STATE_ERROR; 141 PRF(printf(" %5u", (unsigned)p->packSize)); 142 return (p->control & 0x40) ? LZMA2_STATE_PROP : LZMA2_STATE_DATA; 143 144 case LZMA2_STATE_PROP: 145 { 146 unsigned lc, lp; 147 if (b >= (9 * 5 * 5)) 148 return LZMA2_STATE_ERROR; 149 lc = b % 9; 150 b /= 9; 151 p->decoder.prop.pb = (Byte)(b / 5); 152 lp = b % 5; 153 if (lc + lp > LZMA2_LCLP_MAX) 154 return LZMA2_STATE_ERROR; 155 p->decoder.prop.lc = (Byte)lc; 156 p->decoder.prop.lp = (Byte)lp; 157 return LZMA2_STATE_DATA; 158 } 159 } 160 return LZMA2_STATE_ERROR; 161 } 162 163 static void LzmaDec_UpdateWithUncompressed(CLzmaDec *p, const Byte *src, SizeT size) 164 { 165 memcpy(p->dic + p->dicPos, src, size); 166 p->dicPos += size; 167 if (p->checkDicSize == 0 && p->prop.dicSize - p->processedPos <= size) 168 p->checkDicSize = p->prop.dicSize; 169 p->processedPos += (UInt32)size; 170 } 171 172 void LzmaDec_InitDicAndState(CLzmaDec *p, BoolInt initDic, BoolInt initState); 173 174 175 SRes Lzma2Dec_DecodeToDic(CLzma2Dec *p, SizeT dicLimit, 176 const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status) 177 { 178 SizeT inSize = *srcLen; 179 *srcLen = 0; 180 *status = LZMA_STATUS_NOT_SPECIFIED; 181 182 while (p->state != LZMA2_STATE_ERROR) 183 { 184 SizeT dicPos; 185 186 if (p->state == LZMA2_STATE_FINISHED) 187 { 188 *status = LZMA_STATUS_FINISHED_WITH_MARK; 189 return SZ_OK; 190 } 191 192 dicPos = p->decoder.dicPos; 193 194 if (dicPos == dicLimit && finishMode == LZMA_FINISH_ANY) 195 { 196 *status = LZMA_STATUS_NOT_FINISHED; 197 return SZ_OK; 198 } 199 200 if (p->state != LZMA2_STATE_DATA && p->state != LZMA2_STATE_DATA_CONT) 201 { 202 if (*srcLen == inSize) 203 { 204 *status = LZMA_STATUS_NEEDS_MORE_INPUT; 205 return SZ_OK; 206 } 207 (*srcLen)++; 208 p->state = Lzma2Dec_UpdateState(p, *src++); 209 if (dicPos == dicLimit && p->state != LZMA2_STATE_FINISHED) 210 break; 211 continue; 212 } 213 214 { 215 SizeT inCur = inSize - *srcLen; 216 SizeT outCur = dicLimit - dicPos; 217 ELzmaFinishMode curFinishMode = LZMA_FINISH_ANY; 218 219 if (outCur >= p->unpackSize) 220 { 221 outCur = (SizeT)p->unpackSize; 222 curFinishMode = LZMA_FINISH_END; 223 } 224 225 if (LZMA2_IS_UNCOMPRESSED_STATE(p)) 226 { 227 if (inCur == 0) 228 { 229 *status = LZMA_STATUS_NEEDS_MORE_INPUT; 230 return SZ_OK; 231 } 232 233 if (p->state == LZMA2_STATE_DATA) 234 { 235 BoolInt initDic = (p->control == LZMA2_CONTROL_COPY_RESET_DIC); 236 LzmaDec_InitDicAndState(&p->decoder, initDic, False); 237 } 238 239 if (inCur > outCur) 240 inCur = outCur; 241 if (inCur == 0) 242 break; 243 244 LzmaDec_UpdateWithUncompressed(&p->decoder, src, inCur); 245 246 src += inCur; 247 *srcLen += inCur; 248 p->unpackSize -= (UInt32)inCur; 249 p->state = (p->unpackSize == 0) ? LZMA2_STATE_CONTROL : LZMA2_STATE_DATA_CONT; 250 } 251 else 252 { 253 SRes res; 254 255 if (p->state == LZMA2_STATE_DATA) 256 { 257 BoolInt initDic = (p->control >= 0xE0); 258 BoolInt initState = (p->control >= 0xA0); 259 LzmaDec_InitDicAndState(&p->decoder, initDic, initState); 260 p->state = LZMA2_STATE_DATA_CONT; 261 } 262 263 if (inCur > p->packSize) 264 inCur = (SizeT)p->packSize; 265 266 res = LzmaDec_DecodeToDic(&p->decoder, dicPos + outCur, src, &inCur, curFinishMode, status); 267 268 src += inCur; 269 *srcLen += inCur; 270 p->packSize -= (UInt32)inCur; 271 outCur = p->decoder.dicPos - dicPos; 272 p->unpackSize -= (UInt32)outCur; 273 274 if (res != 0) 275 break; 276 277 if (*status == LZMA_STATUS_NEEDS_MORE_INPUT) 278 { 279 if (p->packSize == 0) 280 break; 281 return SZ_OK; 282 } 283 284 if (inCur == 0 && outCur == 0) 285 { 286 if (*status != LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK 287 || p->unpackSize != 0 288 || p->packSize != 0) 289 break; 290 p->state = LZMA2_STATE_CONTROL; 291 } 292 293 *status = LZMA_STATUS_NOT_SPECIFIED; 294 } 295 } 296 } 297 298 *status = LZMA_STATUS_NOT_SPECIFIED; 299 p->state = LZMA2_STATE_ERROR; 300 return SZ_ERROR_DATA; 301 } 302 303 304 305 306 ELzma2ParseStatus Lzma2Dec_Parse(CLzma2Dec *p, 307 SizeT outSize, 308 const Byte *src, SizeT *srcLen, 309 int checkFinishBlock) 310 { 311 SizeT inSize = *srcLen; 312 *srcLen = 0; 313 314 while (p->state != LZMA2_STATE_ERROR) 315 { 316 if (p->state == LZMA2_STATE_FINISHED) 317 return LZMA_STATUS_FINISHED_WITH_MARK; 318 319 if (outSize == 0 && !checkFinishBlock) 320 return LZMA_STATUS_NOT_FINISHED; 321 322 if (p->state != LZMA2_STATE_DATA && p->state != LZMA2_STATE_DATA_CONT) 323 { 324 if (*srcLen == inSize) 325 return LZMA_STATUS_NEEDS_MORE_INPUT; 326 (*srcLen)++; 327 328 p->state = Lzma2Dec_UpdateState(p, *src++); 329 330 if (p->state == LZMA2_STATE_UNPACK0) 331 { 332 // if (p->decoder.dicPos != 0) 333 if (p->control == LZMA2_CONTROL_COPY_RESET_DIC || p->control >= 0xE0) 334 return LZMA2_PARSE_STATUS_NEW_BLOCK; 335 // if (outSize == 0) return LZMA_STATUS_NOT_FINISHED; 336 } 337 338 // The following code can be commented. 339 // It's not big problem, if we read additional input bytes. 340 // It will be stopped later in LZMA2_STATE_DATA / LZMA2_STATE_DATA_CONT state. 341 342 if (outSize == 0 && p->state != LZMA2_STATE_FINISHED) 343 { 344 // checkFinishBlock is true. So we expect that block must be finished, 345 // We can return LZMA_STATUS_NOT_SPECIFIED or LZMA_STATUS_NOT_FINISHED here 346 // break; 347 return LZMA_STATUS_NOT_FINISHED; 348 } 349 350 if (p->state == LZMA2_STATE_DATA) 351 return LZMA2_PARSE_STATUS_NEW_CHUNK; 352 353 continue; 354 } 355 356 if (outSize == 0) 357 return LZMA_STATUS_NOT_FINISHED; 358 359 { 360 SizeT inCur = inSize - *srcLen; 361 362 if (LZMA2_IS_UNCOMPRESSED_STATE(p)) 363 { 364 if (inCur == 0) 365 return LZMA_STATUS_NEEDS_MORE_INPUT; 366 if (inCur > p->unpackSize) 367 inCur = p->unpackSize; 368 if (inCur > outSize) 369 inCur = outSize; 370 p->decoder.dicPos += inCur; 371 src += inCur; 372 *srcLen += inCur; 373 outSize -= inCur; 374 p->unpackSize -= (UInt32)inCur; 375 p->state = (p->unpackSize == 0) ? LZMA2_STATE_CONTROL : LZMA2_STATE_DATA_CONT; 376 } 377 else 378 { 379 p->isExtraMode = True; 380 381 if (inCur == 0) 382 { 383 if (p->packSize != 0) 384 return LZMA_STATUS_NEEDS_MORE_INPUT; 385 } 386 else if (p->state == LZMA2_STATE_DATA) 387 { 388 p->state = LZMA2_STATE_DATA_CONT; 389 if (*src != 0) 390 { 391 // first byte of lzma chunk must be Zero 392 *srcLen += 1; 393 p->packSize--; 394 break; 395 } 396 } 397 398 if (inCur > p->packSize) 399 inCur = (SizeT)p->packSize; 400 401 src += inCur; 402 *srcLen += inCur; 403 p->packSize -= (UInt32)inCur; 404 405 if (p->packSize == 0) 406 { 407 SizeT rem = outSize; 408 if (rem > p->unpackSize) 409 rem = p->unpackSize; 410 p->decoder.dicPos += rem; 411 p->unpackSize -= (UInt32)rem; 412 outSize -= rem; 413 if (p->unpackSize == 0) 414 p->state = LZMA2_STATE_CONTROL; 415 } 416 } 417 } 418 } 419 420 p->state = LZMA2_STATE_ERROR; 421 return LZMA_STATUS_NOT_SPECIFIED; 422 } 423 424 425 426 427 SRes Lzma2Dec_DecodeToBuf(CLzma2Dec *p, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status) 428 { 429 SizeT outSize = *destLen, inSize = *srcLen; 430 *srcLen = *destLen = 0; 431 432 for (;;) 433 { 434 SizeT inCur = inSize, outCur, dicPos; 435 ELzmaFinishMode curFinishMode; 436 SRes res; 437 438 if (p->decoder.dicPos == p->decoder.dicBufSize) 439 p->decoder.dicPos = 0; 440 dicPos = p->decoder.dicPos; 441 curFinishMode = LZMA_FINISH_ANY; 442 outCur = p->decoder.dicBufSize - dicPos; 443 444 if (outCur >= outSize) 445 { 446 outCur = outSize; 447 curFinishMode = finishMode; 448 } 449 450 res = Lzma2Dec_DecodeToDic(p, dicPos + outCur, src, &inCur, curFinishMode, status); 451 452 src += inCur; 453 inSize -= inCur; 454 *srcLen += inCur; 455 outCur = p->decoder.dicPos - dicPos; 456 memcpy(dest, p->decoder.dic + dicPos, outCur); 457 dest += outCur; 458 outSize -= outCur; 459 *destLen += outCur; 460 if (res != 0) 461 return res; 462 if (outCur == 0 || outSize == 0) 463 return SZ_OK; 464 } 465 } 466 467 468 SRes Lzma2Decode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, 469 Byte prop, ELzmaFinishMode finishMode, ELzmaStatus *status, ISzAllocPtr alloc) 470 { 471 CLzma2Dec p; 472 SRes res; 473 SizeT outSize = *destLen, inSize = *srcLen; 474 *destLen = *srcLen = 0; 475 *status = LZMA_STATUS_NOT_SPECIFIED; 476 Lzma2Dec_Construct(&p); 477 RINOK(Lzma2Dec_AllocateProbs(&p, prop, alloc)); 478 p.decoder.dic = dest; 479 p.decoder.dicBufSize = outSize; 480 Lzma2Dec_Init(&p); 481 *srcLen = inSize; 482 res = Lzma2Dec_DecodeToDic(&p, outSize, src, srcLen, finishMode, status); 483 *destLen = p.decoder.dicPos; 484 if (res == SZ_OK && *status == LZMA_STATUS_NEEDS_MORE_INPUT) 485 res = SZ_ERROR_INPUT_EOF; 486 Lzma2Dec_FreeProbs(&p, alloc); 487 return res; 488 } 489
