字符串分成若干个字串进行流压缩

/*

 * 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>     // printf

#include <stdlib.h>    // free

#include <string.h>    // memset, strcat, strlen

#include <zstd.h>      // presumes zstd library is installed

#include "common.h"    // Helper functions, CHECK(), and CHECK_ZSTD()

 

static void compressFile_orDie(const char* fname, const char* outName, int cLevel)

{

    /* Open the input and output files. */

    //FILE* const fin  = fopen_orDie(fname, "rb");

 

    char *fin="123456789_1234567890_public and private log test is: 6111, 1.000010, 2.33, sse, a";

    FILE* const fout = fopen_orDie(outName, "wb");

    /* Create the input and output buffers.

     * They may be any size, but we recommend using these functions to size them.

     * Performance will only suffer significantly for very tiny buffers.

     */

    #define buffIntest 1

 

    #define ZSTD_BLOCKHEADERSIZE 3   /* C standard doesn't allow `static const` variable to be init using another `static const` variable */

    static const size_t ZSTD_blockHeaderSize = ZSTD_BLOCKHEADERSIZE;

 

    size_t const buffInSize = buffIntest;

 

    //开辟一块小buffer内存

    void*  const buffIn  = malloc_orDie(buffInSize);

    

    size_t const buffOutSize = ZSTD_compressBound(ZSTD_BLOCKSIZE_MAX) + ZSTD_blockHeaderSize + 4 ;

 

    //开辟buffer大内存

    void*  const buffOut = malloc_orDie(buffOutSize);

 

    /* Create the context. */

    ZSTD_CCtx* const cctx = ZSTD_createCCtx();

    CHECK(cctx != NULL, "ZSTD_createCCtx() failed!");

 

    /* Set any parameters you want.

     * Here we set the compression level, and enable the checksum.

     */

    CHECK_ZSTD( ZSTD_CCtx_setParameter(cctx, ZSTD_c_compressionLevel, cLevel) );

    CHECK_ZSTD( ZSTD_CCtx_setParameter(cctx, ZSTD_c_checksumFlag, 1) );

    ZSTD_CCtx_setParameter(cctx, ZSTD_c_nbWorkers, 4);

 

    /* This loop read from the input file, compresses that entire chunk,

     * and writes all output produced to the output file.

     */

    size_t const toRead = buffInSize;

    static int cnt = 0;

    size_t SIZE = strlen(fin);

 

    for (;;) {

        char *buffIn = fin;

        //memccpy(buffIn,)

        fin += buffIntest;

        size_t read;

 

        if(*(fin -1)== NULL){

            read = 0;

            //cnt = 0;

        }

        else{

            read = 1 ;

        }

 

        

        //size_t read = fread_orDie(buffIn, toRead, fin);

        printf("read%d", read);

 

        printf("toRead%d", toRead);

        /* Select the flush mode.

         * If the read may not be finished (read == toRead) we use

         * ZSTD_e_continue. If this is the last chunk, we use ZSTD_e_end.

         * Zstd optimizes the case where the first flush mode is ZSTD_e_end,

         * since it knows it is compressing the entire source in one pass.

         */

        int const lastChunk = (read < toRead);

        ZSTD_EndDirective const mode = lastChunk ? ZSTD_e_end : ZSTD_e_continue;

        /* Set the input buffer to what we just read.

         * We compress until the input buffer is empty, each time flushing the

         * output.

         */

        ZSTD_inBuffer input = { buffIn, read, 0 };

        int finished;

        do {

            /* Compress into the output buffer and write all of the output to

             * the file so we can reuse the buffer next iteration.

             */

            ZSTD_outBuffer output = { buffOut, buffOutSize, 0 };

            size_t const remaining = ZSTD_compressStream2(cctx, &output , &input, mode);

            CHECK_ZSTD(remaining);

            fwrite_orDie(buffOut, output.pos, fout);

            /* If we're on the last chunk we're finished when zstd returns 0,

             * which means its consumed all the input AND finished the frame.

             * Otherwise, we're finished when we've consumed all the input.

             */

            finished = lastChunk ? (remaining == 0) : (input.pos == input.size);

        } while (!finished);

        CHECK(input.pos == input.size,

              "Impossible: zstd only returns 0 when the input is completely consumed!");

 

        if (lastChunk) {

            break;

        }

    }

 

    ZSTD_freeCCtx(cctx);

    fclose_orDie(fout);

 

    free(buffIn);

    free(buffOut);

}

 

static char* createOutFilename_orDie(const char* filename)

{

    size_t const inL = strlen(filename);

    size_t const outL = inL + 5;

    void* const outSpace = malloc_orDie(outL);

    memset(outSpace, 0, outL);

    strcat(outSpace, filename);

    strcat(outSpace, ".zst");

    return (char*)outSpace;

}

 

int main(int argc, const char** argv)

{

    const char* const exeName = argv[0];

 

    if (argc!=2) {

        printf("wrong arguments\n");

        printf("usage:\n");

        printf("%s FILE\n", exeName);

        return 1;

    }

 

    const char* const inFilename = argv[1];

 

    char* const outFilename = createOutFilename_orDie(inFilename);

    compressFile_orDie(inFilename, outFilename, 1);

 

    free(outFilename);   /* not strictly required, since program execution stops there,

                          * but some static analyzer main complain otherwise */

    return 0;

}