Lines Matching refs:pZip
132 DECLCALLBACKMEMBER(int, pfnCompress)(PRTZIPCOMP pZip, const void *pvBuf, size_t cbBuf);
137 DECLCALLBACKMEMBER(int, pfnFinish)(PRTZIPCOMP pZip);
142 DECLCALLBACKMEMBER(int, pfnDestroy)(PRTZIPCOMP pZip);
200 DECLCALLBACKMEMBER(int, pfnDecompress)(PRTZIPDECOMP pZip, void *pvBuf, size_t cbBuf, size_t *pcbWritten);
205 DECLCALLBACKMEMBER(int, pfnDestroy)(PRTZIPDECOMP pZip);
262 static DECLCALLBACK(int) rtZipStoreCompress(PRTZIPCOMP pZip, const void *pvBuf, size_t cbBuf)
264 uint8_t *pbDst = pZip->u.Store.pb;
270 size_t cb = sizeof(pZip->abBuffer) - (size_t)(pbDst - &pZip->abBuffer[0]); /* careful here, g++ 4.1.2 screws up easily */
273 int rc = pZip->pfnOut(pZip->pvUser, &pZip->abBuffer[0], sizeof(pZip->abBuffer));
277 cb = sizeof(pZip->abBuffer);
278 pbDst = &pZip->abBuffer[0];
292 pZip->u.Store.pb = pbDst;
300 static DECLCALLBACK(int) rtZipStoreCompFinish(PRTZIPCOMP pZip)
302 size_t cb = (uintptr_t)pZip->u.Store.pb - (uintptr_t)&pZip->abBuffer[0];
305 int rc = pZip->pfnOut(pZip->pvUser, &pZip->abBuffer[0], cb);
316 static DECLCALLBACK(int) rtZipStoreCompDestroy(PRTZIPCOMP pZip)
318 NOREF(pZip);
326 * @param pZip The compressor instance.
329 static DECLCALLBACK(int) rtZipStoreCompInit(PRTZIPCOMP pZip, RTZIPLEVEL enmLevel)
332 pZip->pfnCompress = rtZipStoreCompress;
333 pZip->pfnFinish = rtZipStoreCompFinish;
334 pZip->pfnDestroy = rtZipStoreCompDestroy;
336 pZip->u.Store.pb = &pZip->abBuffer[1];
344 static DECLCALLBACK(int) rtZipStoreDecompress(PRTZIPDECOMP pZip, void *pvBuf, size_t cbBuf, size_t *pcbWritten)
352 size_t cb = pZip->u.Store.cbBuffer;
355 int rc = pZip->pfnIn(pZip->pvUser, &pZip->abBuffer[0], sizeof(pZip->abBuffer), &cb);
358 pZip->u.Store.cbBuffer = cb;
359 pZip->u.Store.pb = &pZip->abBuffer[0];
380 memcpy(pvBuf, pZip->u.Store.pb, cb);
381 pZip->u.Store.pb += cb;
382 pZip->u.Store.cbBuffer -= cb;
396 static DECLCALLBACK(int) rtZipStoreDecompDestroy(PRTZIPDECOMP pZip)
398 NOREF(pZip);
406 * @param pZip The decompressor instance.
408 static DECLCALLBACK(int) rtZipStoreDecompInit(PRTZIPDECOMP pZip)
410 pZip->pfnDecompress = rtZipStoreDecompress;
411 pZip->pfnDestroy = rtZipStoreDecompDestroy;
413 pZip->u.Store.pb = &pZip->abBuffer[0];
414 pZip->u.Store.cbBuffer = 0;
475 static DECLCALLBACK(int) rtZipZlibCompress(PRTZIPCOMP pZip, const void *pvBuf, size_t cbBuf)
477 pZip->u.Zlib.next_in = (Bytef *)pvBuf;
478 pZip->u.Zlib.avail_in = (uInt)cbBuf; Assert(pZip->u.Zlib.avail_in == cbBuf);
479 while (pZip->u.Zlib.avail_in > 0)
484 if (pZip->u.Zlib.avail_out <= 0)
486 int rc = pZip->pfnOut(pZip->pvUser, &pZip->abBuffer[0], sizeof(pZip->abBuffer) - pZip->u.Zlib.avail_out);
489 pZip->u.Zlib.avail_out = sizeof(pZip->abBuffer);
490 pZip->u.Zlib.next_out = &pZip->abBuffer[0];
496 int rc = deflate(&pZip->u.Zlib, Z_NO_FLUSH);
507 static DECLCALLBACK(int) rtZipZlibCompFinish(PRTZIPCOMP pZip)
515 if (rc == Z_STREAM_END || pZip->u.Zlib.avail_out <= 0)
517 int rc2 = pZip->pfnOut(pZip->pvUser, &pZip->abBuffer[0], sizeof(pZip->abBuffer) - pZip->u.Zlib.avail_out);
520 pZip->u.Zlib.avail_out = sizeof(pZip->abBuffer);
521 pZip->u.Zlib.next_out = &pZip->abBuffer[0];
529 rc = deflate(&pZip->u.Zlib, Z_FINISH);
540 static DECLCALLBACK(int) rtZipZlibCompDestroy(PRTZIPCOMP pZip)
545 int rc = deflateEnd(&pZip->u.Zlib);
555 * @param pZip The compressor instance.
559 static DECLCALLBACK(int) rtZipZlibCompInit(PRTZIPCOMP pZip, RTZIPLEVEL enmLevel, bool fZlibHeader)
561 pZip->pfnCompress = rtZipZlibCompress;
562 pZip->pfnFinish = rtZipZlibCompFinish;
563 pZip->pfnDestroy = rtZipZlibCompDestroy;
574 memset(&pZip->u.Zlib, 0, sizeof(pZip->u.Zlib));
575 pZip->u.Zlib.next_out = &pZip->abBuffer[1];
576 pZip->u.Zlib.avail_out = sizeof(pZip->abBuffer) - 1;
577 pZip->u.Zlib.opaque = pZip;
579 int rc = deflateInit2(&pZip->u.Zlib, iLevel, Z_DEFLATED, fZlibHeader ? Z_DEF_WBITS : -Z_DEF_WBITS,
588 static DECLCALLBACK(int) rtZipZlibDecompress(PRTZIPDECOMP pZip, void *pvBuf, size_t cbBuf, size_t *pcbWritten)
590 pZip->u.Zlib.next_out = (Bytef *)pvBuf;
591 pZip->u.Zlib.avail_out = (uInt)cbBuf;
592 Assert(pZip->u.Zlib.avail_out == cbBuf);
599 while (pZip->u.Zlib.avail_out > 0 || pZip->u.Zlib.avail_in <= 0)
604 if (pZip->u.Zlib.avail_in <= 0)
606 size_t cb = sizeof(pZip->abBuffer);
607 int rc = pZip->pfnIn(pZip->pvUser, &pZip->abBuffer[0], sizeof(pZip->abBuffer), &cb);
610 pZip->u.Zlib.avail_in = (uInt)cb; Assert(pZip->u.Zlib.avail_in == cb);
611 pZip->u.Zlib.next_in = &pZip->abBuffer[0];
617 int rc = inflate(&pZip->u.Zlib, Z_NO_FLUSH);
621 *pcbWritten = cbBuf - pZip->u.Zlib.avail_out;
622 else if (pZip->u.Zlib.avail_out > 0)
636 static DECLCALLBACK(int) rtZipZlibDecompDestroy(PRTZIPDECOMP pZip)
641 int rc = inflateEnd(&pZip->u.Zlib);
651 * @param pZip The decompressor instance.
654 static DECLCALLBACK(int) rtZipZlibDecompInit(PRTZIPDECOMP pZip, bool fZlibHeader)
656 pZip->pfnDecompress = rtZipZlibDecompress;
657 pZip->pfnDestroy = rtZipZlibDecompDestroy;
659 memset(&pZip->u.Zlib, 0, sizeof(pZip->u.Zlib));
660 pZip->u.Zlib.opaque = pZip;
662 int rc = inflateInit2(&pZip->u.Zlib, fZlibHeader ? Z_DEF_WBITS : -Z_DEF_WBITS);
707 static DECLCALLBACK(int) rtZipBZlibCompress(PRTZIPCOMP pZip, const void *pvBuf, size_t cbBuf)
709 pZip->u.BZlib.next_in = (char *)pvBuf;
710 pZip->u.BZlib.avail_in = cbBuf;
711 while (pZip->u.BZlib.avail_in > 0)
716 if (pZip->u.BZlib.avail_out <= 0)
718 int rc = pZip->pfnOut(pZip->pvUser, &pZip->abBuffer[0], sizeof(pZip->abBuffer) - pZip->u.BZlib.avail_out);
721 pZip->u.BZlib.avail_out = sizeof(pZip->abBuffer);
722 pZip->u.BZlib.next_out = (char *)&pZip->abBuffer[0];
728 int rc = BZ2_bzCompress(&pZip->u.BZlib, BZ_RUN);
739 static DECLCALLBACK(int) rtZipBZlibCompFinish(PRTZIPCOMP pZip)
747 if (rc == BZ_STREAM_END || pZip->u.BZlib.avail_out <= 0)
749 int rc2 = pZip->pfnOut(pZip->pvUser, &pZip->abBuffer[0], sizeof(pZip->abBuffer) - pZip->u.BZlib.avail_out);
752 pZip->u.BZlib.avail_out = sizeof(pZip->abBuffer);
753 pZip->u.BZlib.next_out = (char *)&pZip->abBuffer[0];
761 rc = BZ2_bzCompress(&pZip->u.BZlib, BZ_FINISH);
772 static DECLCALLBACK(int) rtZipBZlibCompDestroy(PRTZIPCOMP pZip)
777 int rc = BZ2_bzCompressEnd(&pZip->u.BZlib);
787 * @param pZip The compressor instance.
790 static DECLCALLBACK(int) rtZipBZlibCompInit(PRTZIPCOMP pZip, RTZIPLEVEL enmLevel)
792 pZip->pfnCompress = rtZipBZlibCompress;
793 pZip->pfnFinish = rtZipBZlibCompFinish;
794 pZip->pfnDestroy = rtZipBZlibCompDestroy;
806 memset(&pZip->u.BZlib, 0, sizeof(pZip->u.BZlib));
807 pZip->u.BZlib.next_out = (char *)&pZip->abBuffer[1];
808 pZip->u.BZlib.avail_out = sizeof(pZip->abBuffer) - 1;
809 pZip->u.BZlib.opaque = pZip;
811 int rc = BZ2_bzCompressInit(&pZip->u.BZlib, iSize, 0, iWork);
819 static DECLCALLBACK(int) rtZipBZlibDecompress(PRTZIPDECOMP pZip, void *pvBuf, size_t cbBuf, size_t *pcbWritten)
821 pZip->u.BZlib.next_out = (char *)pvBuf;
822 pZip->u.BZlib.avail_out = cbBuf;
823 while (pZip->u.BZlib.avail_out > 0)
828 if (pZip->u.BZlib.avail_in <= 0)
831 int rc = pZip->pfnIn(pZip->pvUser, &pZip->abBuffer[0], sizeof(pZip->abBuffer), &cb);
834 pZip->u.BZlib.avail_in = cb;
835 pZip->u.BZlib.next_in = (char *)&pZip->abBuffer[0];
841 int rc = BZ2_bzDecompress(&pZip->u.BZlib);
845 *pcbWritten = cbBuf - pZip->u.BZlib.avail_out;
846 else if (pZip->u.BZlib.avail_out > 0)
860 static DECLCALLBACK(int) rtZipBZlibDecompDestroy(PRTZIPDECOMP pZip)
865 int rc = BZ2_bzDecompressEnd(&pZip->u.BZlib);
875 * @param pZip The decompressor instance.
877 static DECLCALLBACK(int) rtZipBZlibDecompInit(PRTZIPDECOMP pZip)
879 pZip->pfnDecompress = rtZipBZlibDecompress;
880 pZip->pfnDestroy = rtZipBZlibDecompDestroy;
882 memset(&pZip->u.BZlib, 0, sizeof(pZip->u.BZlib));
883 pZip->u.BZlib.opaque = pZip;
885 int rc = BZ2_bzDecompressInit(&pZip->u.BZlib, 0, 0);
897 * @param pZip The compressor instance.
899 static int rtZipLZFCompFlushOutput(PRTZIPCOMP pZip)
901 size_t cb = pZip->u.LZF.pbOutput - &pZip->abBuffer[0];
902 pZip->u.LZF.pbOutput = &pZip->abBuffer[0];
903 return pZip->pfnOut(pZip->pvUser, &pZip->abBuffer[0], cb);
911 * @param pZip The compressor instance.
915 static int rtZipLZFCompressBuffer(PRTZIPCOMP pZip, const uint8_t *pbBuf, size_t cbBuf)
923 unsigned cbFree = (unsigned)(sizeof(pZip->abBuffer) - (pZip->u.LZF.pbOutput - &pZip->abBuffer[0]));
927 int rc = rtZipLZFCompFlushOutput(pZip);
931 cbFree = sizeof(pZip->abBuffer);
937 PRTZIPLZFHDR pHdr = (PRTZIPLZFHDR)pZip->u.LZF.pbOutput; /* warning: This might be unaligned! */
943 pZip->u.LZF.pbOutput += sizeof(*pHdr);
955 unsigned cbOutput = lzf_compress(pbBuf, cbInput, pZip->u.LZF.pbOutput, cbFree);
967 cbOutput = lzf_compress(pbBuf, cbInput, pZip->u.LZF.pbOutput, cbFree);
979 pZip->u.LZF.pbOutput += cbOutput;
990 * @param pZip The compressor instance.
992 static int rtZipLZFCompFlushInput(PRTZIPCOMP pZip)
994 size_t cb = pZip->u.LZF.pbInput - &pZip->u.LZF.abInput[0];
995 pZip->u.LZF.pbInput = &pZip->u.LZF.abInput[0];
996 pZip->u.LZF.cbInputFree = sizeof(pZip->u.LZF.abInput);
998 return rtZipLZFCompressBuffer(pZip, pZip->u.LZF.abInput, cb);
1006 static DECLCALLBACK(int) rtZipLZFCompress(PRTZIPCOMP pZip, const void *pvBuf, size_t cbBuf)
1014 && cbBuf > pZip->u.LZF.cbInputFree)
1016 && pZip->u.LZF.cbInputFree != sizeof(pZip->u.LZF.abInput))
1019 int rc = rtZipLZFCompFlushInput(pZip);
1030 Assert(pZip->u.LZF.cbInputFree >= cbBuf);
1031 memcpy(pZip->u.LZF.pbInput, pvBuf, cbBuf);
1032 pZip->u.LZF.pbInput += cbBuf;
1033 pZip->u.LZF.cbInputFree -= cbBuf;
1037 Assert(pZip->u.LZF.cbInputFree == sizeof(pZip->u.LZF.abInput));
1038 int rc = rtZipLZFCompressBuffer(pZip, (const uint8_t *)pvBuf, cbBuf);
1049 static DECLCALLBACK(int) rtZipLZFCompFinish(PRTZIPCOMP pZip)
1051 int rc = rtZipLZFCompFlushInput(pZip);
1053 rc = rtZipLZFCompFlushOutput(pZip);
1061 static DECLCALLBACK(int) rtZipLZFCompDestroy(PRTZIPCOMP pZip)
1063 NOREF(pZip);
1071 * @param pZip The compressor instance.
1074 static DECLCALLBACK(int) rtZipLZFCompInit(PRTZIPCOMP pZip, RTZIPLEVEL enmLevel)
1077 pZip->pfnCompress = rtZipLZFCompress;
1078 pZip->pfnFinish = rtZipLZFCompFinish;
1079 pZip->pfnDestroy = rtZipLZFCompDestroy;
1081 pZip->u.LZF.pbOutput = &pZip->abBuffer[1];
1082 pZip->u.LZF.pbInput = &pZip->u.LZF.abInput[0];
1083 pZip->u.LZF.cbInputFree = sizeof(pZip->u.LZF.abInput);
1113 static DECLCALLBACK(int) rtZipLZFDecompress(PRTZIPDECOMP pZip, void *pvBuf, size_t cbBuf, size_t *pcbWritten)
1133 if (pZip->u.LZF.cbSpill > 0)
1135 unsigned cb = (unsigned)RT_MIN(pZip->u.LZF.cbSpill, cbBuf);
1136 memcpy(pvBuf, pZip->u.LZF.pbSpill, cb);
1137 pZip->u.LZF.pbSpill += cb;
1138 pZip->u.LZF.cbSpill -= cb;
1150 int rc = pZip->pfnIn(pZip->pvUser, &Hdr, sizeof(Hdr), NULL);
1157 rc = pZip->pfnIn(pZip->pvUser, &pZip->abBuffer[0], Hdr.cbData, NULL);
1169 unsigned cbOutput = lzf_decompress(&pZip->abBuffer[0], Hdr.cbData, pvBuf, cbUncompressed);
1182 unsigned cbOutput = lzf_decompress(&pZip->abBuffer[0], Hdr.cbData, pZip->u.LZF.abSpill, cbUncompressed);
1189 pZip->u.LZF.pbSpill = &pZip->u.LZF.abSpill[0];
1190 pZip->u.LZF.cbSpill = cbUncompressed;
1202 if (pZip->u.LZF.cbSpill > 0)
1204 unsigned cb = (unsigned)RT_MIN(pZip->u.LZF.cbSpill, cbBuf);
1205 memcpy(pvBuf, pZip->u.LZF.pbSpill, cb);
1206 pZip->u.LZF.pbSpill += cb;
1207 pZip->u.LZF.cbSpill -= cb;
1220 if (pZip->u.LZF.cbInput < sizeof(RTZIPLZFHDR))
1222 if (pZip->u.LZF.cbInput <= 0)
1226 int rc = pZip->pfnIn(pZip->pvUser, &pZip->abBuffer[0],
1227 sizeof(pZip->abBuffer) - RTZIPLZF_MAX_DATA_SIZE, &cb);
1230 pZip->u.LZF.pbInput = &pZip->abBuffer[0];
1231 pZip->u.LZF.cbInput = cb;
1232 pHdr = (PCRTZIPLZFHDR)pZip->u.LZF.pbInput;
1237 size_t cbCur = pZip->u.LZF.cbInput;
1238 memmove(&pZip->abBuffer[0], pZip->u.LZF.pbInput, cbCur);
1239 pZip->u.LZF.pbInput = &pZip->abBuffer[0];
1242 int rc = pZip->pfnIn(pZip->pvUser, &pZip->abBuffer[cbCur],
1243 sizeof(pZip->abBuffer) - RTZIPLZF_MAX_DATA_SIZE - cbCur, &cb);
1246 pHdr = (PCRTZIPLZFHDR)pZip->u.LZF.pbInput;
1247 pZip->u.LZF.cbInput += cb;
1261 pHdr = (PCRTZIPLZFHDR)pZip->u.LZF.pbInput;
1265 if (pHdr->cbData > pZip->u.LZF.cbInput - sizeof(*pHdr))
1268 size_t cbToRead = pHdr->cbData - (pZip->u.LZF.cbInput - sizeof(*pHdr));
1269 Assert(&pZip->u.LZF.pbInput[pZip->u.LZF.cbInput + cbToRead] <= &pZip->u.LZF.pbInput[sizeof(pZip->abBuffer)]);
1270 int rc = pZip->pfnIn(pZip->pvUser, &pZip->u.LZF.pbInput[pZip->u.LZF.cbInput],
1274 pZip->u.LZF.cbInput += cbToRead;
1277 AssertMsgReturn(sizeof(*pHdr) + pHdr->cbData <= pZip->u.LZF.cbInput,
1278 ("cbData=%#x cbInput=%#x\n", pHdr->cbData, pZip->u.LZF.cbInput),
1300 unsigned cbOutput = lzf_decompress(pHdr + 1, pHdr->cbData, pZip->u.LZF.abSpill, cbUncompressed);
1307 pZip->u.LZF.pbSpill = &pZip->u.LZF.abSpill[0];
1308 pZip->u.LZF.cbSpill = cbUncompressed;
1312 pZip->u.LZF.cbInput -= pHdr->cbData + sizeof(*pHdr);
1313 pZip->u.LZF.pbInput += pHdr->cbData + sizeof(*pHdr);
1325 static DECLCALLBACK(int) rtZipLZFDecompDestroy(PRTZIPDECOMP pZip)
1327 NOREF(pZip);
1335 * @param pZip The decompressor instance.
1337 static DECLCALLBACK(int) rtZipLZFDecompInit(PRTZIPDECOMP pZip)
1339 pZip->pfnDecompress = rtZipLZFDecompress;
1340 pZip->pfnDestroy = rtZipLZFDecompDestroy;
1343 pZip->u.LZF.pbInput = NULL;
1344 pZip->u.LZF.cbInput = 0;
1346 pZip->u.LZF.cbSpill = 0;
1347 pZip->u.LZF.pbSpill = NULL;
1378 PRTZIPCOMP pZip = (PRTZIPCOMP)RTMemAlloc(sizeof(RTZIPCOMP));
1379 if (!pZip)
1409 pZip->pfnOut = pfnOut;
1410 pZip->enmType = enmType;
1411 pZip->pvUser = pvUser;
1412 pZip->abBuffer[0] = enmType; /* first byte is the compression type. */
1418 rc = rtZipStoreCompInit(pZip, enmLevel);
1425 rc = rtZipZlibCompInit(pZip, enmLevel, enmType == RTZIPTYPE_ZLIB /*fZlibHeader*/);
1431 rc = rtZipBZlibCompInit(pZip, enmLevel);
1437 rc = rtZipLZFCompInit(pZip, enmLevel);
1450 *ppZip = pZip;
1452 RTMemFree(pZip);
1462 * @param pZip The compressor instance.
1466 RTDECL(int) RTZipCompress(PRTZIPCOMP pZip, const void *pvBuf, size_t cbBuf)
1470 return pZip->pfnCompress(pZip, pvBuf, cbBuf);
1480 * @param pZip The compressor instance.
1482 RTDECL(int) RTZipCompFinish(PRTZIPCOMP pZip)
1484 return pZip->pfnFinish(pZip);
1493 * @param pZip The compressor instance.
1495 RTDECL(int) RTZipCompDestroy(PRTZIPCOMP pZip)
1500 int rc = pZip->pfnDestroy(pZip);
1506 pZip->enmType = RTZIPTYPE_INVALID;
1507 RTMemFree(pZip);
1516 static DECLCALLBACK(int) rtZipStubDecompress(PRTZIPDECOMP pZip, void *pvBuf, size_t cbBuf, size_t *pcbWritten)
1518 NOREF(pZip); NOREF(pvBuf); NOREF(cbBuf); NOREF(pcbWritten);
1526 static DECLCALLBACK(int) rtZipStubDecompDestroy(PRTZIPDECOMP pZip)
1528 NOREF(pZip);
1552 PRTZIPDECOMP pZip = (PRTZIPDECOMP)RTMemAlloc(sizeof(RTZIPDECOMP));
1553 if (!pZip)
1559 pZip->pfnIn = pfnIn;
1560 pZip->enmType = RTZIPTYPE_INVALID;
1561 pZip->pvUser = pvUser;
1562 pZip->pfnDecompress = NULL;
1563 pZip->pfnDestroy = rtZipStubDecompDestroy;
1565 *ppZip = pZip;
1574 * @param pZip The decompressor instance.
1576 static int rtzipDecompInit(PRTZIPDECOMP pZip)
1582 int rc = pZip->pfnIn(pZip->pvUser, &u8Type, sizeof(u8Type), NULL);
1589 pZip->enmType = (RTZIPTYPE)u8Type;
1591 switch (pZip->enmType)
1595 rc = rtZipStoreDecompInit(pZip);
1604 rc = rtZipZlibDecompInit(pZip, pZip->enmType == RTZIPTYPE_ZLIB /*fHeader*/);
1612 rc = rtZipBZlibDecompInit(pZip);
1620 rc = rtZipLZFDecompInit(pZip);
1643 AssertMsgFailed(("Invalid compression type %d (%#x)!\n", pZip->enmType, pZip->enmType));
1649 pZip->pfnDecompress = rtZipStubDecompress;
1650 pZip->pfnDestroy = rtZipStubDecompDestroy;
1661 * @param pZip The decompressor instance.
1668 RTDECL(int) RTZipDecompress(PRTZIPDECOMP pZip, void *pvBuf, size_t cbBuf, size_t *pcbWritten)
1679 if (!pZip->pfnDecompress)
1681 int rc = rtzipDecompInit(pZip);
1689 return pZip->pfnDecompress(pZip, pvBuf, cbBuf, pcbWritten);
1698 * @param pZip The decompressor instance.
1700 RTDECL(int) RTZipDecompDestroy(PRTZIPDECOMP pZip)
1705 int rc = pZip->pfnDestroy(pZip);
1711 pZip->enmType = RTZIPTYPE_INVALID;
1712 RTMemFree(pZip);