1 /* Lzma2Enc.c -- LZMA2 Encoder 2 2018-07-04 : Igor Pavlov : Public domain */ 3 4 #include "Precomp.h" 5 6 #include <string.h> 7 8 /* #define _7ZIP_ST */ 9 10 #include "Lzma2Enc.h" 11 12 #ifndef _7ZIP_ST 13 #include "MtCoder.h" 14 #else 15 #define MTCODER__THREADS_MAX 1 16 #endif 17 18 #define LZMA2_CONTROL_LZMA (1 << 7) 19 #define LZMA2_CONTROL_COPY_NO_RESET 2 20 #define LZMA2_CONTROL_COPY_RESET_DIC 1 21 #define LZMA2_CONTROL_EOF 0 22 23 #define LZMA2_LCLP_MAX 4 24 25 #define LZMA2_DIC_SIZE_FROM_PROP(p) (((UInt32)2 | ((p) & 1)) << ((p) / 2 + 11)) 26 27 #define LZMA2_PACK_SIZE_MAX (1 << 16) 28 #define LZMA2_COPY_CHUNK_SIZE LZMA2_PACK_SIZE_MAX 29 #define LZMA2_UNPACK_SIZE_MAX (1 << 21) 30 #define LZMA2_KEEP_WINDOW_SIZE LZMA2_UNPACK_SIZE_MAX 31 32 #define LZMA2_CHUNK_SIZE_COMPRESSED_MAX ((1 << 16) + 16) 33 34 35 #define PRF(x) /* x */ 36 37 38 /* ---------- CLimitedSeqInStream ---------- */ 39 40 typedef struct 41 { 42 ISeqInStream vt; 43 ISeqInStream *realStream; 44 UInt64 limit; 45 UInt64 processed; 46 int finished; 47 } CLimitedSeqInStream; 48 49 static void LimitedSeqInStream_Init(CLimitedSeqInStream *p) 50 { 51 p->limit = (UInt64)(Int64)-1; 52 p->processed = 0; 53 p->finished = 0; 54 } 55 56 static SRes LimitedSeqInStream_Read(const ISeqInStream *pp, void *data, size_t *size) 57 { 58 CLimitedSeqInStream *p = CONTAINER_FROM_VTBL(pp, CLimitedSeqInStream, vt); 59 size_t size2 = *size; 60 SRes res = SZ_OK; 61 62 if (p->limit != (UInt64)(Int64)-1) 63 { 64 UInt64 rem = p->limit - p->processed; 65 if (size2 > rem) 66 size2 = (size_t)rem; 67 } 68 if (size2 != 0) 69 { 70 res = ISeqInStream_Read(p->realStream, data, &size2); 71 p->finished = (size2 == 0 ? 1 : 0); 72 p->processed += size2; 73 } 74 *size = size2; 75 return res; 76 } 77 78 79 /* ---------- CLzma2EncInt ---------- */ 80 81 typedef struct 82 { 83 CLzmaEncHandle enc; 84 Byte propsAreSet; 85 Byte propsByte; 86 Byte needInitState; 87 Byte needInitProp; 88 UInt64 srcPos; 89 } CLzma2EncInt; 90 91 92 static SRes Lzma2EncInt_InitStream(CLzma2EncInt *p, const CLzma2EncProps *props) 93 { 94 if (!p->propsAreSet) 95 { 96 SizeT propsSize = LZMA_PROPS_SIZE; 97 Byte propsEncoded[LZMA_PROPS_SIZE]; 98 RINOK(LzmaEnc_SetProps(p->enc, &props->lzmaProps)); 99 RINOK(LzmaEnc_WriteProperties(p->enc, propsEncoded, &propsSize)); 100 p->propsByte = propsEncoded[0]; 101 p->propsAreSet = True; 102 } 103 return SZ_OK; 104 } 105 106 static void Lzma2EncInt_InitBlock(CLzma2EncInt *p) 107 { 108 p->srcPos = 0; 109 p->needInitState = True; 110 p->needInitProp = True; 111 } 112 113 114 SRes LzmaEnc_PrepareForLzma2(CLzmaEncHandle pp, ISeqInStream *inStream, UInt32 keepWindowSize, 115 ISzAllocPtr alloc, ISzAllocPtr allocBig); 116 SRes LzmaEnc_MemPrepare(CLzmaEncHandle pp, const Byte *src, SizeT srcLen, 117 UInt32 keepWindowSize, ISzAllocPtr alloc, ISzAllocPtr allocBig); 118 SRes LzmaEnc_CodeOneMemBlock(CLzmaEncHandle pp, BoolInt reInit, 119 Byte *dest, size_t *destLen, UInt32 desiredPackSize, UInt32 *unpackSize); 120 const Byte *LzmaEnc_GetCurBuf(CLzmaEncHandle pp); 121 void LzmaEnc_Finish(CLzmaEncHandle pp); 122 void LzmaEnc_SaveState(CLzmaEncHandle pp); 123 void LzmaEnc_RestoreState(CLzmaEncHandle pp); 124 125 /* 126 UInt32 LzmaEnc_GetNumAvailableBytes(CLzmaEncHandle pp); 127 */ 128 129 static SRes Lzma2EncInt_EncodeSubblock(CLzma2EncInt *p, Byte *outBuf, 130 size_t *packSizeRes, ISeqOutStream *outStream) 131 { 132 size_t packSizeLimit = *packSizeRes; 133 size_t packSize = packSizeLimit; 134 UInt32 unpackSize = LZMA2_UNPACK_SIZE_MAX; 135 unsigned lzHeaderSize = 5 + (p->needInitProp ? 1 : 0); 136 BoolInt useCopyBlock; 137 SRes res; 138 139 *packSizeRes = 0; 140 if (packSize < lzHeaderSize) 141 return SZ_ERROR_OUTPUT_EOF; 142 packSize -= lzHeaderSize; 143 144 LzmaEnc_SaveState(p->enc); 145 res = LzmaEnc_CodeOneMemBlock(p->enc, p->needInitState, 146 outBuf + lzHeaderSize, &packSize, LZMA2_PACK_SIZE_MAX, &unpackSize); 147 148 PRF(printf("\npackSize = %7d unpackSize = %7d ", packSize, unpackSize)); 149 150 if (unpackSize == 0) 151 return res; 152 153 if (res == SZ_OK) 154 useCopyBlock = (packSize + 2 >= unpackSize || packSize > (1 << 16)); 155 else 156 { 157 if (res != SZ_ERROR_OUTPUT_EOF) 158 return res; 159 res = SZ_OK; 160 useCopyBlock = True; 161 } 162 163 if (useCopyBlock) 164 { 165 size_t destPos = 0; 166 PRF(printf("################# COPY ")); 167 168 while (unpackSize > 0) 169 { 170 UInt32 u = (unpackSize < LZMA2_COPY_CHUNK_SIZE) ? unpackSize : LZMA2_COPY_CHUNK_SIZE; 171 if (packSizeLimit - destPos < u + 3) 172 return SZ_ERROR_OUTPUT_EOF; 173 outBuf[destPos++] = (Byte)(p->srcPos == 0 ? LZMA2_CONTROL_COPY_RESET_DIC : LZMA2_CONTROL_COPY_NO_RESET); 174 outBuf[destPos++] = (Byte)((u - 1) >> 8); 175 outBuf[destPos++] = (Byte)(u - 1); 176 memcpy(outBuf + destPos, LzmaEnc_GetCurBuf(p->enc) - unpackSize, u); 177 unpackSize -= u; 178 destPos += u; 179 p->srcPos += u; 180 181 if (outStream) 182 { 183 *packSizeRes += destPos; 184 if (ISeqOutStream_Write(outStream, outBuf, destPos) != destPos) 185 return SZ_ERROR_WRITE; 186 destPos = 0; 187 } 188 else 189 *packSizeRes = destPos; 190 /* needInitState = True; */ 191 } 192 193 LzmaEnc_RestoreState(p->enc); 194 return SZ_OK; 195 } 196 197 { 198 size_t destPos = 0; 199 UInt32 u = unpackSize - 1; 200 UInt32 pm = (UInt32)(packSize - 1); 201 unsigned mode = (p->srcPos == 0) ? 3 : (p->needInitState ? (p->needInitProp ? 2 : 1) : 0); 202 203 PRF(printf(" ")); 204 205 outBuf[destPos++] = (Byte)(LZMA2_CONTROL_LZMA | (mode << 5) | ((u >> 16) & 0x1F)); 206 outBuf[destPos++] = (Byte)(u >> 8); 207 outBuf[destPos++] = (Byte)u; 208 outBuf[destPos++] = (Byte)(pm >> 8); 209 outBuf[destPos++] = (Byte)pm; 210 211 if (p->needInitProp) 212 outBuf[destPos++] = p->propsByte; 213 214 p->needInitProp = False; 215 p->needInitState = False; 216 destPos += packSize; 217 p->srcPos += unpackSize; 218 219 if (outStream) 220 if (ISeqOutStream_Write(outStream, outBuf, destPos) != destPos) 221 return SZ_ERROR_WRITE; 222 223 *packSizeRes = destPos; 224 return SZ_OK; 225 } 226 } 227 228 229 /* ---------- Lzma2 Props ---------- */ 230 231 void Lzma2EncProps_Init(CLzma2EncProps *p) 232 { 233 LzmaEncProps_Init(&p->lzmaProps); 234 p->blockSize = LZMA2_ENC_PROPS__BLOCK_SIZE__AUTO; 235 p->numBlockThreads_Reduced = -1; 236 p->numBlockThreads_Max = -1; 237 p->numTotalThreads = -1; 238 } 239 240 void Lzma2EncProps_Normalize(CLzma2EncProps *p) 241 { 242 UInt64 fileSize; 243 int t1, t1n, t2, t2r, t3; 244 { 245 CLzmaEncProps lzmaProps = p->lzmaProps; 246 LzmaEncProps_Normalize(&lzmaProps); 247 t1n = lzmaProps.numThreads; 248 } 249 250 t1 = p->lzmaProps.numThreads; 251 t2 = p->numBlockThreads_Max; 252 t3 = p->numTotalThreads; 253 254 if (t2 > MTCODER__THREADS_MAX) 255 t2 = MTCODER__THREADS_MAX; 256 257 if (t3 <= 0) 258 { 259 if (t2 <= 0) 260 t2 = 1; 261 t3 = t1n * t2; 262 } 263 else if (t2 <= 0) 264 { 265 t2 = t3 / t1n; 266 if (t2 == 0) 267 { 268 t1 = 1; 269 t2 = t3; 270 } 271 if (t2 > MTCODER__THREADS_MAX) 272 t2 = MTCODER__THREADS_MAX; 273 } 274 else if (t1 <= 0) 275 { 276 t1 = t3 / t2; 277 if (t1 == 0) 278 t1 = 1; 279 } 280 else 281 t3 = t1n * t2; 282 283 p->lzmaProps.numThreads = t1; 284 285 t2r = t2; 286 287 fileSize = p->lzmaProps.reduceSize; 288 289 if ( p->blockSize != LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID 290 && p->blockSize != LZMA2_ENC_PROPS__BLOCK_SIZE__AUTO 291 && (p->blockSize < fileSize || fileSize == (UInt64)(Int64)-1)) 292 p->lzmaProps.reduceSize = p->blockSize; 293 294 LzmaEncProps_Normalize(&p->lzmaProps); 295 296 p->lzmaProps.reduceSize = fileSize; 297 298 t1 = p->lzmaProps.numThreads; 299 300 if (p->blockSize == LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID) 301 { 302 t2r = t2 = 1; 303 t3 = t1; 304 } 305 else if (p->blockSize == LZMA2_ENC_PROPS__BLOCK_SIZE__AUTO && t2 <= 1) 306 { 307 /* if there is no block multi-threading, we use SOLID block */ 308 p->blockSize = LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID; 309 } 310 else 311 { 312 if (p->blockSize == LZMA2_ENC_PROPS__BLOCK_SIZE__AUTO) 313 { 314 const UInt32 kMinSize = (UInt32)1 << 20; 315 const UInt32 kMaxSize = (UInt32)1 << 28; 316 const UInt32 dictSize = p->lzmaProps.dictSize; 317 UInt64 blockSize = (UInt64)dictSize << 2; 318 if (blockSize < kMinSize) blockSize = kMinSize; 319 if (blockSize > kMaxSize) blockSize = kMaxSize; 320 if (blockSize < dictSize) blockSize = dictSize; 321 blockSize += (kMinSize - 1); 322 blockSize &= ~(UInt64)(kMinSize - 1); 323 p->blockSize = blockSize; 324 } 325 326 if (t2 > 1 && fileSize != (UInt64)(Int64)-1) 327 { 328 UInt64 numBlocks = fileSize / p->blockSize; 329 if (numBlocks * p->blockSize != fileSize) 330 numBlocks++; 331 if (numBlocks < (unsigned)t2) 332 { 333 t2r = (unsigned)numBlocks; 334 if (t2r == 0) 335 t2r = 1; 336 t3 = t1 * t2r; 337 } 338 } 339 } 340 341 p->numBlockThreads_Max = t2; 342 p->numBlockThreads_Reduced = t2r; 343 p->numTotalThreads = t3; 344 } 345 346 347 static SRes Progress(ICompressProgress *p, UInt64 inSize, UInt64 outSize) 348 { 349 return (p && ICompressProgress_Progress(p, inSize, outSize) != SZ_OK) ? SZ_ERROR_PROGRESS : SZ_OK; 350 } 351 352 353 /* ---------- Lzma2 ---------- */ 354 355 typedef struct 356 { 357 Byte propEncoded; 358 CLzma2EncProps props; 359 UInt64 expectedDataSize; 360 361 Byte *tempBufLzma; 362 363 ISzAllocPtr alloc; 364 ISzAllocPtr allocBig; 365 366 CLzma2EncInt coders[MTCODER__THREADS_MAX]; 367 368 #ifndef _7ZIP_ST 369 370 ISeqOutStream *outStream; 371 Byte *outBuf; 372 size_t outBuf_Rem; /* remainder in outBuf */ 373 374 size_t outBufSize; /* size of allocated outBufs[i] */ 375 size_t outBufsDataSizes[MTCODER__BLOCKS_MAX]; 376 BoolInt mtCoder_WasConstructed; 377 CMtCoder mtCoder; 378 Byte *outBufs[MTCODER__BLOCKS_MAX]; 379 380 #endif 381 382 } CLzma2Enc; 383 384 385 386 CLzma2EncHandle Lzma2Enc_Create(ISzAllocPtr alloc, ISzAllocPtr allocBig) 387 { 388 CLzma2Enc *p = (CLzma2Enc *)ISzAlloc_Alloc(alloc, sizeof(CLzma2Enc)); 389 if (!p) 390 return NULL; 391 Lzma2EncProps_Init(&p->props); 392 Lzma2EncProps_Normalize(&p->props); 393 p->expectedDataSize = (UInt64)(Int64)-1; 394 p->tempBufLzma = NULL; 395 p->alloc = alloc; 396 p->allocBig = allocBig; 397 { 398 unsigned i; 399 for (i = 0; i < MTCODER__THREADS_MAX; i++) 400 p->coders[i].enc = NULL; 401 } 402 403 #ifndef _7ZIP_ST 404 p->mtCoder_WasConstructed = False; 405 { 406 unsigned i; 407 for (i = 0; i < MTCODER__BLOCKS_MAX; i++) 408 p->outBufs[i] = NULL; 409 p->outBufSize = 0; 410 } 411 #endif 412 413 return p; 414 } 415 416 417 #ifndef _7ZIP_ST 418 419 static void Lzma2Enc_FreeOutBufs(CLzma2Enc *p) 420 { 421 unsigned i; 422 for (i = 0; i < MTCODER__BLOCKS_MAX; i++) 423 if (p->outBufs[i]) 424 { 425 ISzAlloc_Free(p->alloc, p->outBufs[i]); 426 p->outBufs[i] = NULL; 427 } 428 p->outBufSize = 0; 429 } 430 431 #endif 432 433 434 void Lzma2Enc_Destroy(CLzma2EncHandle pp) 435 { 436 CLzma2Enc *p = (CLzma2Enc *)pp; 437 unsigned i; 438 for (i = 0; i < MTCODER__THREADS_MAX; i++) 439 { 440 CLzma2EncInt *t = &p->coders[i]; 441 if (t->enc) 442 { 443 LzmaEnc_Destroy(t->enc, p->alloc, p->allocBig); 444 t->enc = NULL; 445 } 446 } 447 448 449 #ifndef _7ZIP_ST 450 if (p->mtCoder_WasConstructed) 451 { 452 MtCoder_Destruct(&p->mtCoder); 453 p->mtCoder_WasConstructed = False; 454 } 455 Lzma2Enc_FreeOutBufs(p); 456 #endif 457 458 ISzAlloc_Free(p->alloc, p->tempBufLzma); 459 p->tempBufLzma = NULL; 460 461 ISzAlloc_Free(p->alloc, pp); 462 } 463 464 465 SRes Lzma2Enc_SetProps(CLzma2EncHandle pp, const CLzma2EncProps *props) 466 { 467 CLzma2Enc *p = (CLzma2Enc *)pp; 468 CLzmaEncProps lzmaProps = props->lzmaProps; 469 LzmaEncProps_Normalize(&lzmaProps); 470 if (lzmaProps.lc + lzmaProps.lp > LZMA2_LCLP_MAX) 471 return SZ_ERROR_PARAM; 472 p->props = *props; 473 Lzma2EncProps_Normalize(&p->props); 474 return SZ_OK; 475 } 476 477 478 void Lzma2Enc_SetDataSize(CLzmaEncHandle pp, UInt64 expectedDataSiize) 479 { 480 CLzma2Enc *p = (CLzma2Enc *)pp; 481 p->expectedDataSize = expectedDataSiize; 482 } 483 484 485 Byte Lzma2Enc_WriteProperties(CLzma2EncHandle pp) 486 { 487 CLzma2Enc *p = (CLzma2Enc *)pp; 488 unsigned i; 489 UInt32 dicSize = LzmaEncProps_GetDictSize(&p->props.lzmaProps); 490 for (i = 0; i < 40; i++) 491 if (dicSize <= LZMA2_DIC_SIZE_FROM_PROP(i)) 492 break; 493 return (Byte)i; 494 } 495 496 497 static SRes Lzma2Enc_EncodeMt1( 498 CLzma2Enc *me, 499 CLzma2EncInt *p, 500 ISeqOutStream *outStream, 501 Byte *outBuf, size_t *outBufSize, 502 ISeqInStream *inStream, 503 const Byte *inData, size_t inDataSize, 504 int finished, 505 ICompressProgress *progress) 506 { 507 UInt64 unpackTotal = 0; 508 UInt64 packTotal = 0; 509 size_t outLim = 0; 510 CLimitedSeqInStream limitedInStream; 511 512 if (outBuf) 513 { 514 outLim = *outBufSize; 515 *outBufSize = 0; 516 } 517 518 if (!p->enc) 519 { 520 p->propsAreSet = False; 521 p->enc = LzmaEnc_Create(me->alloc); 522 if (!p->enc) 523 return SZ_ERROR_MEM; 524 } 525 526 limitedInStream.realStream = inStream; 527 if (inStream) 528 { 529 limitedInStream.vt.Read = LimitedSeqInStream_Read; 530 } 531 532 if (!outBuf) 533 { 534 // outStream version works only in one thread. So we use CLzma2Enc::tempBufLzma 535 if (!me->tempBufLzma) 536 { 537 me->tempBufLzma = (Byte *)ISzAlloc_Alloc(me->alloc, LZMA2_CHUNK_SIZE_COMPRESSED_MAX); 538 if (!me->tempBufLzma) 539 return SZ_ERROR_MEM; 540 } 541 } 542 543 RINOK(Lzma2EncInt_InitStream(p, &me->props)); 544 545 for (;;) 546 { 547 SRes res = SZ_OK; 548 size_t inSizeCur = 0; 549 550 Lzma2EncInt_InitBlock(p); 551 552 LimitedSeqInStream_Init(&limitedInStream); 553 limitedInStream.limit = me->props.blockSize; 554 555 if (inStream) 556 { 557 UInt64 expected = (UInt64)(Int64)-1; 558 // inStream version works only in one thread. So we use CLzma2Enc::expectedDataSize 559 if (me->expectedDataSize != (UInt64)(Int64)-1 560 && me->expectedDataSize >= unpackTotal) 561 expected = me->expectedDataSize - unpackTotal; 562 if (me->props.blockSize != LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID 563 && expected > me->props.blockSize) 564 expected = (size_t)me->props.blockSize; 565 566 LzmaEnc_SetDataSize(p->enc, expected); 567 568 RINOK(LzmaEnc_PrepareForLzma2(p->enc, 569 &limitedInStream.vt, 570 LZMA2_KEEP_WINDOW_SIZE, 571 me->alloc, 572 me->allocBig)); 573 } 574 else 575 { 576 inSizeCur = inDataSize - (size_t)unpackTotal; 577 if (me->props.blockSize != LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID 578 && inSizeCur > me->props.blockSize) 579 inSizeCur = (size_t)me->props.blockSize; 580 581 // LzmaEnc_SetDataSize(p->enc, inSizeCur); 582 583 RINOK(LzmaEnc_MemPrepare(p->enc, 584 inData + (size_t)unpackTotal, inSizeCur, 585 LZMA2_KEEP_WINDOW_SIZE, 586 me->alloc, 587 me->allocBig)); 588 } 589 590 for (;;) 591 { 592 size_t packSize = LZMA2_CHUNK_SIZE_COMPRESSED_MAX; 593 if (outBuf) 594 packSize = outLim - (size_t)packTotal; 595 596 res = Lzma2EncInt_EncodeSubblock(p, 597 outBuf ? outBuf + (size_t)packTotal : me->tempBufLzma, &packSize, 598 outBuf ? NULL : outStream); 599 600 if (res != SZ_OK) 601 break; 602 603 packTotal += packSize; 604 if (outBuf) 605 *outBufSize = (size_t)packTotal; 606 607 res = Progress(progress, unpackTotal + p->srcPos, packTotal); 608 if (res != SZ_OK) 609 break; 610 611 /* 612 if (LzmaEnc_GetNumAvailableBytes(p->enc) == 0) 613 break; 614 */ 615 616 if (packSize == 0) 617 break; 618 } 619 620 LzmaEnc_Finish(p->enc); 621 622 unpackTotal += p->srcPos; 623 624 RINOK(res); 625 626 if (p->srcPos != (inStream ? limitedInStream.processed : inSizeCur)) 627 return SZ_ERROR_FAIL; 628 629 if (inStream ? limitedInStream.finished : (unpackTotal == inDataSize)) 630 { 631 if (finished) 632 { 633 if (outBuf) 634 { 635 size_t destPos = *outBufSize; 636 if (destPos >= outLim) 637 return SZ_ERROR_OUTPUT_EOF; 638 outBuf[destPos] = 0; 639 *outBufSize = destPos + 1; 640 } 641 else 642 { 643 Byte b = 0; 644 if (ISeqOutStream_Write(outStream, &b, 1) != 1) 645 return SZ_ERROR_WRITE; 646 } 647 } 648 return SZ_OK; 649 } 650 } 651 } 652 653 654 655 #ifndef _7ZIP_ST 656 657 static SRes Lzma2Enc_MtCallback_Code(void *pp, unsigned coderIndex, unsigned outBufIndex, 658 const Byte *src, size_t srcSize, int finished) 659 { 660 CLzma2Enc *me = (CLzma2Enc *)pp; 661 size_t destSize = me->outBufSize; 662 SRes res; 663 CMtProgressThunk progressThunk; 664 665 Byte *dest = me->outBufs[outBufIndex]; 666 667 me->outBufsDataSizes[outBufIndex] = 0; 668 669 if (!dest) 670 { 671 dest = (Byte *)ISzAlloc_Alloc(me->alloc, me->outBufSize); 672 if (!dest) 673 return SZ_ERROR_MEM; 674 me->outBufs[outBufIndex] = dest; 675 } 676 677 MtProgressThunk_CreateVTable(&progressThunk); 678 progressThunk.mtProgress = &me->mtCoder.mtProgress; 679 progressThunk.inSize = 0; 680 progressThunk.outSize = 0; 681 682 res = Lzma2Enc_EncodeMt1(me, 683 &me->coders[coderIndex], 684 NULL, dest, &destSize, 685 NULL, src, srcSize, 686 finished, 687 &progressThunk.vt); 688 689 me->outBufsDataSizes[outBufIndex] = destSize; 690 691 return res; 692 } 693 694 695 static SRes Lzma2Enc_MtCallback_Write(void *pp, unsigned outBufIndex) 696 { 697 CLzma2Enc *me = (CLzma2Enc *)pp; 698 size_t size = me->outBufsDataSizes[outBufIndex]; 699 const Byte *data = me->outBufs[outBufIndex]; 700 701 if (me->outStream) 702 return ISeqOutStream_Write(me->outStream, data, size) == size ? SZ_OK : SZ_ERROR_WRITE; 703 704 if (size > me->outBuf_Rem) 705 return SZ_ERROR_OUTPUT_EOF; 706 memcpy(me->outBuf, data, size); 707 me->outBuf_Rem -= size; 708 me->outBuf += size; 709 return SZ_OK; 710 } 711 712 #endif 713 714 715 716 SRes Lzma2Enc_Encode2(CLzma2EncHandle pp, 717 ISeqOutStream *outStream, 718 Byte *outBuf, size_t *outBufSize, 719 ISeqInStream *inStream, 720 const Byte *inData, size_t inDataSize, 721 ICompressProgress *progress) 722 { 723 CLzma2Enc *p = (CLzma2Enc *)pp; 724 725 if (inStream && inData) 726 return SZ_ERROR_PARAM; 727 728 if (outStream && outBuf) 729 return SZ_ERROR_PARAM; 730 731 { 732 unsigned i; 733 for (i = 0; i < MTCODER__THREADS_MAX; i++) 734 p->coders[i].propsAreSet = False; 735 } 736 737 #ifndef _7ZIP_ST 738 739 if (p->props.numBlockThreads_Reduced > 1) 740 { 741 IMtCoderCallback2 vt; 742 743 if (!p->mtCoder_WasConstructed) 744 { 745 p->mtCoder_WasConstructed = True; 746 MtCoder_Construct(&p->mtCoder); 747 } 748 749 vt.Code = Lzma2Enc_MtCallback_Code; 750 vt.Write = Lzma2Enc_MtCallback_Write; 751 752 p->outStream = outStream; 753 p->outBuf = NULL; 754 p->outBuf_Rem = 0; 755 if (!outStream) 756 { 757 p->outBuf = outBuf; 758 p->outBuf_Rem = *outBufSize; 759 *outBufSize = 0; 760 } 761 762 p->mtCoder.allocBig = p->allocBig; 763 p->mtCoder.progress = progress; 764 p->mtCoder.inStream = inStream; 765 p->mtCoder.inData = inData; 766 p->mtCoder.inDataSize = inDataSize; 767 p->mtCoder.mtCallback = &vt; 768 p->mtCoder.mtCallbackObject = p; 769 770 p->mtCoder.blockSize = (size_t)p->props.blockSize; 771 if (p->mtCoder.blockSize != p->props.blockSize) 772 return SZ_ERROR_PARAM; /* SZ_ERROR_MEM */ 773 774 { 775 size_t destBlockSize = p->mtCoder.blockSize + (p->mtCoder.blockSize >> 10) + 16; 776 if (destBlockSize < p->mtCoder.blockSize) 777 return SZ_ERROR_PARAM; 778 if (p->outBufSize != destBlockSize) 779 Lzma2Enc_FreeOutBufs(p); 780 p->outBufSize = destBlockSize; 781 } 782 783 p->mtCoder.numThreadsMax = p->props.numBlockThreads_Max; 784 p->mtCoder.expectedDataSize = p->expectedDataSize; 785 786 { 787 SRes res = MtCoder_Code(&p->mtCoder); 788 if (!outStream) 789 *outBufSize = p->outBuf - outBuf; 790 return res; 791 } 792 } 793 794 #endif 795 796 797 return Lzma2Enc_EncodeMt1(p, 798 &p->coders[0], 799 outStream, outBuf, outBufSize, 800 inStream, inData, inDataSize, 801 True, /* finished */ 802 progress); 803 } 804
