FreeBSD/Linux Kernel Cross Reference
sys/contrib/zstd/examples/streaming_decompression.c

     /*
      * Copyright (c) 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;
   }

Cache object: 1cad3c408e8bf7a9e015110b6fb3df0e