117 lines
4.0 KiB
C
117 lines
4.0 KiB
C
|
// LZ4frame API example : compress a file
|
||
|
// Based on sample code from Zbigniew Jędrzejewski-Szmek
|
||
|
|
||
|
#include <stdio.h>
|
||
|
#include <stdlib.h>
|
||
|
#include <string.h>
|
||
|
#include <errno.h>
|
||
|
|
||
|
#include <lz4frame.h>
|
||
|
|
||
|
#define BUF_SIZE 16*1024
|
||
|
#define LZ4_HEADER_SIZE 19
|
||
|
#define LZ4_FOOTER_SIZE 4
|
||
|
|
||
|
static size_t get_block_size(const LZ4F_frameInfo_t* info) {
|
||
|
switch (info->blockSizeID) {
|
||
|
case LZ4F_default:
|
||
|
case LZ4F_max64KB: return 1 << 16;
|
||
|
case LZ4F_max256KB: return 1 << 18;
|
||
|
case LZ4F_max1MB: return 1 << 20;
|
||
|
case LZ4F_max4MB: return 1 << 22;
|
||
|
default:
|
||
|
printf("Impossible unless more block sizes are allowed\n");
|
||
|
exit(1);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
size_t decompress_file_to_mem(FILE *in, char **outMem) {
|
||
|
void* const src = malloc(BUF_SIZE);
|
||
|
void* dst = NULL;
|
||
|
size_t dstCapacity = 0;
|
||
|
LZ4F_dctx *dctx = NULL;
|
||
|
size_t ret;
|
||
|
|
||
|
/* Initialization */
|
||
|
if (!src) { perror("decompress_file(src)"); goto cleanup; }
|
||
|
ret = LZ4F_createDecompressionContext(&dctx, LZ4F_VERSION);
|
||
|
if (LZ4F_isError(ret)) {
|
||
|
printf("LZ4F_dctx creation error: %s\n", LZ4F_getErrorName(ret));
|
||
|
goto cleanup;
|
||
|
}
|
||
|
|
||
|
/* Decompression */
|
||
|
ret = 1;
|
||
|
while (ret != 0) {
|
||
|
/* Load more input */
|
||
|
size_t srcSize = fread(src, 1, BUF_SIZE, in);
|
||
|
void* srcPtr = src;
|
||
|
void* srcEnd = srcPtr + srcSize;
|
||
|
if (srcSize == 0 || ferror(in)) {
|
||
|
printf("Decompress: not enough input or error reading file\n");
|
||
|
goto cleanup;
|
||
|
}
|
||
|
/* Allocate destination buffer if it isn't already */
|
||
|
if (!dst) {
|
||
|
LZ4F_frameInfo_t info;
|
||
|
ret = LZ4F_getFrameInfo(dctx, &info, src, &srcSize);
|
||
|
if (LZ4F_isError(ret)) {
|
||
|
printf("LZ4F_getFrameInfo error: %s\n", LZ4F_getErrorName(ret));
|
||
|
goto cleanup;
|
||
|
}
|
||
|
/* Allocating enough space for an entire block isn't necessary for
|
||
|
* correctness, but it allows some memcpy's to be elided.
|
||
|
*/
|
||
|
dstCapacity = get_block_size(&info);
|
||
|
dst = malloc(dstCapacity);
|
||
|
if (!dst) { perror("decompress_file(dst)"); goto cleanup; }
|
||
|
srcPtr += srcSize;
|
||
|
srcSize = srcEnd - srcPtr;
|
||
|
}
|
||
|
/* Decompress:
|
||
|
* Continue while there is more input to read and the frame isn't over.
|
||
|
* If srcPtr == srcEnd then we know that there is no more output left in the
|
||
|
* internal buffer left to flush.
|
||
|
*/
|
||
|
while (srcPtr != srcEnd && ret != 0) {
|
||
|
/* INVARIANT: Any data left in dst has already been written */
|
||
|
size_t dstSize = dstCapacity;
|
||
|
ret = LZ4F_decompress(dctx, dst, &dstSize, srcPtr, &srcSize, /* LZ4F_decompressOptions_t */ NULL);
|
||
|
if (LZ4F_isError(ret)) {
|
||
|
printf("Decompression error: %s\n", LZ4F_getErrorName(ret));
|
||
|
goto cleanup;
|
||
|
}
|
||
|
/* Flush output */
|
||
|
if (dstSize != 0){
|
||
|
/* size_t written = fwrite(dst, 1, dstSize, out); */
|
||
|
/* printf("Writing %zu bytes\n", dstSize); */
|
||
|
/* if (written != dstSize) { */
|
||
|
/* printf("Decompress: Failed to write to file\n"); */
|
||
|
/* goto cleanup; */
|
||
|
/* } */
|
||
|
*outMem = malloc(dstSize);
|
||
|
memcpy(*outMem, dst, dstSize);
|
||
|
printf("Copying %zu bytes\n", dstSize);
|
||
|
}
|
||
|
/* Update input */
|
||
|
srcPtr += srcSize;
|
||
|
srcSize = srcEnd - srcPtr;
|
||
|
}
|
||
|
}
|
||
|
/* Check that there isn't trailing input data after the frame.
|
||
|
* It is valid to have multiple frames in the same file, but this example
|
||
|
* doesn't support it.
|
||
|
*/
|
||
|
ret = fread(src, 1, 1, in);
|
||
|
if (ret != 0 || !feof(in)) {
|
||
|
printf("Decompress: Trailing data left in file after frame\n");
|
||
|
goto cleanup;
|
||
|
}
|
||
|
|
||
|
cleanup:
|
||
|
free(src);
|
||
|
free(dst);
|
||
|
return LZ4F_freeDecompressionContext(dctx); /* note : free works on NULL */
|
||
|
}
|
||
|
|