/* * Copyright (c) 2016-2020, Yann Collet, Facebook, Inc. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * You may select, at your option, one of the above-listed licenses. */ #include <stdio.h> // fprintf #include <stdlib.h> // free #include <zstd.h> // presumes zstd library is installed #include "common.h" // Helper functions, CHECK(), and CHECK_ZSTD() static void decompressFile_orDie(const char* fname) { FILE* const fin = fopen_orDie(fname, "rb"); size_t const buffInSize = ZSTD_DStreamInSize(); void* const buffIn = malloc_orDie(buffInSize); FILE* const fout = stdout; size_t const buffOutSize = ZSTD_DStreamOutSize(); /* Guarantee to successfully flush at least one complete compressed block in all circumstances. */ void* const buffOut = malloc_orDie(buffOutSize); ZSTD_DCtx* const dctx = ZSTD_createDCtx(); CHECK(dctx != NULL, "ZSTD_createDCtx() failed!"); /* This loop assumes that the input file is one or more concatenated zstd * streams. This example won't work if there is trailing non-zstd data at * the end, but streaming decompression in general handles this case. * ZSTD_decompressStream() returns 0 exactly when the frame is completed, * and doesn't consume input after the frame. */ size_t const toRead = buffInSize; size_t read; size_t lastRet = 0; int isEmpty = 1; while ( (read = fread_orDie(buffIn, toRead, fin)) ) { isEmpty = 0; ZSTD_inBuffer input = { buffIn, read, 0 }; /* Given a valid frame, zstd won't consume the last byte of the frame * until it has flushed all of the decompressed data of the frame. * Therefore, instead of checking if the return code is 0, we can * decompress just check if input.pos < input.size. */ while (input.pos < input.size) { ZSTD_outBuffer output = { buffOut, buffOutSize, 0 }; /* The return code is zero if the frame is complete, but there may * be multiple frames concatenated together. Zstd will automatically * reset the context when a frame is complete. Still, calling * ZSTD_DCtx_reset() can be useful to reset the context to a clean * state, for instance if the last decompression call returned an * error. */ size_t const ret = ZSTD_decompressStream(dctx, &output , &input); CHECK_ZSTD(ret); fwrite_orDie(buffOut, output.pos, fout); lastRet = ret; } } if (isEmpty) { fprintf(stderr, "input is empty\n"); exit(1); } if (lastRet != 0) { /* The last return value from ZSTD_decompressStream did not end on a * frame, but we reached the end of the file! We assume this is an * error, and the input was truncated. */ fprintf(stderr, "EOF before end of stream: %zu\n", lastRet); exit(1); } ZSTD_freeDCtx(dctx); fclose_orDie(fin); fclose_orDie(fout); free(buffIn); free(buffOut); } int main(int argc, const char** argv) { const char* const exeName = argv[0]; if (argc!=2) { fprintf(stderr, "wrong arguments\n"); fprintf(stderr, "usage:\n"); fprintf(stderr, "%s FILE\n", exeName); return 1; } const char* const inFilename = argv[1]; decompressFile_orDie(inFilename); return 0; } |