lz4io.h File Reference

#include <stddef.h>

Go to the source code of this file.

Macros
#define	stdinmark   "stdin"
#define	stdoutmark   "stdout"
#define	NULL_OUTPUT   "null"
#define	nulmark   "/dev/null"
#define	LZIO_LEGACY_BLOCK_HEADER_SIZE   4

Typedefs
typedef struct LZ4IO_prefs_s	LZ4IO_prefs_t

Enumerations
enum	LZ4IO_blockMode_t { LZ4IO_blockLinked =0 , LZ4IO_blockIndependent }

Functions
LZ4IO_prefs_t *	LZ4IO_defaultPreferences (void)
void	LZ4IO_freePreferences (LZ4IO_prefs_t *prefs)
int	LZ4IO_compressFilename (const char *input_filename, const char *output_filename, int compressionlevel, const LZ4IO_prefs_t *prefs)
int	LZ4IO_decompressFilename (const char *input_filename, const char *output_filename, const LZ4IO_prefs_t *prefs)
int	LZ4IO_compressMultipleFilenames (const char **inFileNamesTable, int ifntSize, const char *suffix, int compressionlevel, const LZ4IO_prefs_t *prefs)
int	LZ4IO_decompressMultipleFilenames (const char **inFileNamesTable, int ifntSize, const char *suffix, const LZ4IO_prefs_t *prefs)
int	LZ4IO_setDictionaryFilename (LZ4IO_prefs_t *const prefs, const char *dictionaryFilename)
int	LZ4IO_setPassThrough (LZ4IO_prefs_t *const prefs, int yes)
int	LZ4IO_setOverwrite (LZ4IO_prefs_t *const prefs, int yes)
int	LZ4IO_setTestMode (LZ4IO_prefs_t *const prefs, int yes)
size_t	LZ4IO_setBlockSizeID (LZ4IO_prefs_t *const prefs, unsigned blockSizeID)
size_t	LZ4IO_setBlockSize (LZ4IO_prefs_t *const prefs, size_t blockSize)
int	LZ4IO_setBlockMode (LZ4IO_prefs_t *const prefs, LZ4IO_blockMode_t blockMode)
int	LZ4IO_setBlockChecksumMode (LZ4IO_prefs_t *const prefs, int xxhash)
int	LZ4IO_setStreamChecksumMode (LZ4IO_prefs_t *const prefs, int xxhash)
int	LZ4IO_setNotificationLevel (int level)
int	LZ4IO_setSparseFile (LZ4IO_prefs_t *const prefs, int enable)
int	LZ4IO_setContentSize (LZ4IO_prefs_t *const prefs, int enable)
void	LZ4IO_setRemoveSrcFile (LZ4IO_prefs_t *const prefs, unsigned flag)
void	LZ4IO_favorDecSpeed (LZ4IO_prefs_t *const prefs, int favor)
int	LZ4IO_displayCompressedFilesInfo (const char **inFileNames, size_t ifnIdx)

Macro Definition Documentation

LZIO_LEGACY_BLOCK_HEADER_SIZE

#define LZIO_LEGACY_BLOCK_HEADER_SIZE   4

Definition at line 61 of file lz4io.h.

NULL_OUTPUT

#define NULL_OUTPUT   "null"

Definition at line 44 of file lz4io.h.

nulmark

#define nulmark   "/dev/null"

Definition at line 48 of file lz4io.h.

stdinmark

#define stdinmark   "stdin"

Definition at line 42 of file lz4io.h.

stdoutmark

#define stdoutmark   "stdout"

Definition at line 43 of file lz4io.h.

Typedef Documentation

LZ4IO_prefs_t

typedef struct LZ4IO_prefs_s LZ4IO_prefs_t

Definition at line 1 of file lz4io.h.

Enumeration Type Documentation

LZ4IO_blockMode_t

enum LZ4IO_blockMode_t

Enumerator
LZ4IO_blockLinked
LZ4IO_blockIndependent

Definition at line 103 of file lz4io.h.

{ LZ4IO_blockLinked=0, LZ4IO_blockIndependent} LZ4IO_blockMode_t;

Function Documentation

LZ4IO_compressFilename()

int LZ4IO_compressFilename	(	const char *	input_filename,
		const char *	output_filename,
		int	compressionlevel,
		const LZ4IO_prefs_t *	prefs
	)

Definition at line 774 of file lz4io.c.

{
    UTIL_time_t const timeStart = UTIL_getTime();
    clock_t const cpuStart = clock();
    cRess_t const ress = LZ4IO_createCResources(prefs);
 
    int const result = LZ4IO_compressFilename_extRess(ress, srcFileName, dstFileName, compressionLevel, prefs);
 
    /* Free resources */
    LZ4IO_freeCResources(ress);
 
    /* Final Status */
    {   clock_t const cpuEnd = clock();
        double const cpuLoad_s = (double)(cpuEnd - cpuStart) / CLOCKS_PER_SEC;
        U64 const timeLength_ns = UTIL_clockSpanNano(timeStart);
        double const timeLength_s = (double)timeLength_ns / 1000000000;
        DISPLAYLEVEL(4, "Completed in %.2f sec  (cpu load : %.0f%%)\n",
                        timeLength_s, (cpuLoad_s / timeLength_s) * 100);
    }
 
    return result;
}

References compressionLevel, DISPLAYLEVEL, LZ4IO_compressFilename_extRess(), LZ4IO_createCResources(), LZ4IO_freeCResources(), UTIL_clockSpanNano(), and UTIL_getTime().

LZ4IO_compressMultipleFilenames()

int LZ4IO_compressMultipleFilenames	(	const char **	inFileNamesTable,
		int	ifntSize,
		const char *	suffix,
		int	compressionlevel,
		const LZ4IO_prefs_t *	prefs
	)

Definition at line 798 of file lz4io.c.

{
    int i;
    int missed_files = 0;
    char* dstFileName = (char*)malloc(FNSPACE);
    size_t ofnSize = FNSPACE;
    const size_t suffixSize = strlen(suffix);
    cRess_t ress;
 
    if (dstFileName == NULL) return ifntSize;   /* not enough memory */
    ress = LZ4IO_createCResources(prefs);
 
    /* loop on each file */
    for (i=0; i<ifntSize; i++) {
        size_t const ifnSize = strlen(inFileNamesTable[i]);
        if (!strcmp(suffix, stdoutmark)) {
            missed_files += LZ4IO_compressFilename_extRess(ress,
                                    inFileNamesTable[i], stdoutmark,
                                    compressionLevel, prefs);
            continue;
        }
        if (ofnSize <= ifnSize+suffixSize+1) {
            free(dstFileName);
            ofnSize = ifnSize + 20;
            dstFileName = (char*)malloc(ofnSize);
            if (dstFileName==NULL) {
                LZ4IO_freeCResources(ress);
                return ifntSize;
        }   }
        strcpy(dstFileName, inFileNamesTable[i]);
        strcat(dstFileName, suffix);
 
        missed_files += LZ4IO_compressFilename_extRess(ress,
                                inFileNamesTable[i], dstFileName,
                                compressionLevel, prefs);
    }
 
    /* Close & Free */
    LZ4IO_freeCResources(ress);
    free(dstFileName);
 
    return missed_files;
}

References compressionLevel, FNSPACE, free(), i, LZ4IO_compressFilename_extRess(), LZ4IO_createCResources(), LZ4IO_freeCResources(), malloc(), NULL, stdoutmark, and suffix.

Referenced by main().

LZ4IO_decompressFilename()

int LZ4IO_decompressFilename	(	const char *	input_filename,
		const char *	output_filename,
		const LZ4IO_prefs_t *	prefs
	)

Definition at line 1292 of file lz4io.c.

{
    dRess_t const ress = LZ4IO_createDResources(prefs);
    clock_t const start = clock();
 
    int const missingFiles = LZ4IO_decompressDstFile(ress, input_filename, output_filename, prefs);
 
    clock_t const end = clock();
    double const seconds = (double)(end - start) / CLOCKS_PER_SEC;
    DISPLAYLEVEL(4, "Done in %.2f sec  \n", seconds);
 
    LZ4IO_freeDResources(ress);
    return missingFiles;
}

References DISPLAYLEVEL, test_evm::end, LZ4IO_createDResources(), LZ4IO_decompressDstFile(), LZ4IO_freeDResources(), and start.

LZ4IO_decompressMultipleFilenames()

int LZ4IO_decompressMultipleFilenames	(	const char **	inFileNamesTable,
		int	ifntSize,
		const char *	suffix,
		const LZ4IO_prefs_t *	prefs
	)

Definition at line 1308 of file lz4io.c.

{
    int i;
    int skippedFiles = 0;
    int missingFiles = 0;
    char* outFileName = (char*)malloc(FNSPACE);
    size_t ofnSize = FNSPACE;
    size_t const suffixSize = strlen(suffix);
    dRess_t ress = LZ4IO_createDResources(prefs);
 
    if (outFileName==NULL) EXM_THROW(70, "Memory allocation error");
    ress.dstFile = LZ4IO_openDstFile(stdoutmark, prefs);
 
    for (i=0; i<ifntSize; i++) {
        size_t const ifnSize = strlen(inFileNamesTable[i]);
        const char* const suffixPtr = inFileNamesTable[i] + ifnSize - suffixSize;
        if (!strcmp(suffix, stdoutmark)) {
            missingFiles += LZ4IO_decompressSrcFile(ress, inFileNamesTable[i], stdoutmark, prefs);
            continue;
        }
        if (ofnSize <= ifnSize-suffixSize+1) {
            free(outFileName);
            ofnSize = ifnSize + 20;
            outFileName = (char*)malloc(ofnSize);
            if (outFileName==NULL) EXM_THROW(71, "Memory allocation error");
        }
        if (ifnSize <= suffixSize  ||  strcmp(suffixPtr, suffix) != 0) {
            DISPLAYLEVEL(1, "File extension doesn't match expected LZ4_EXTENSION (%4s); will not process file: %s\n", suffix, inFileNamesTable[i]);
            skippedFiles++;
            continue;
        }
        memcpy(outFileName, inFileNamesTable[i], ifnSize - suffixSize);
        outFileName[ifnSize-suffixSize] = '\0';
        missingFiles += LZ4IO_decompressDstFile(ress, inFileNamesTable[i], outFileName, prefs);
    }
 
    LZ4IO_freeDResources(ress);
    free(outFileName);
    return missingFiles + skippedFiles;
}

References DISPLAYLEVEL, dRess_t::dstFile, EXM_THROW, FNSPACE, free(), i, LZ4IO_createDResources(), LZ4IO_decompressDstFile(), LZ4IO_decompressSrcFile(), LZ4IO_freeDResources(), LZ4IO_openDstFile(), malloc(), memcpy(), NULL, stdoutmark, and suffix.

Referenced by main().

LZ4IO_defaultPreferences()

LZ4IO_prefs_t* LZ4IO_defaultPreferences

(

void

)

Definition at line 160 of file lz4io.c.

{
    LZ4IO_prefs_t* const ret = (LZ4IO_prefs_t*)malloc(sizeof(*ret));
    if (!ret) EXM_THROW(21, "Allocation error : not enough memory");
    ret->passThrough = 0;
    ret->overwrite = 1;
    ret->testMode = 0;
    ret->blockSizeId = LZ4IO_BLOCKSIZEID_DEFAULT;
    ret->blockSize = 0;
    ret->blockChecksum = 0;
    ret->streamChecksum = 1;
    ret->blockIndependence = 1;
    ret->sparseFileSupport = 1;
    ret->contentSizeFlag = 0;
    ret->useDictionary = 0;
    ret->favorDecSpeed = 0;
    ret->dictionaryFilename = NULL;
    ret->removeSrcFile = 0;
    return ret;
}

References LZ4IO_prefs_s::blockChecksum, LZ4IO_prefs_s::blockIndependence, LZ4IO_prefs_s::blockSize, LZ4IO_prefs_s::blockSizeId, LZ4IO_prefs_s::contentSizeFlag, LZ4IO_prefs_s::dictionaryFilename, EXM_THROW, LZ4IO_prefs_s::favorDecSpeed, LZ4IO_BLOCKSIZEID_DEFAULT, malloc(), NULL, LZ4IO_prefs_s::overwrite, LZ4IO_prefs_s::passThrough, LZ4IO_prefs_s::removeSrcFile, LZ4IO_prefs_s::sparseFileSupport, LZ4IO_prefs_s::streamChecksum, LZ4IO_prefs_s::testMode, and LZ4IO_prefs_s::useDictionary.

Referenced by main().

LZ4IO_displayCompressedFilesInfo()

int LZ4IO_displayCompressedFilesInfo	(	const char **	inFileNames,
		size_t	ifnIdx
	)

Definition at line 1630 of file lz4io.c.

{
    int result = 0;
    size_t idx = 0;
    if (g_displayLevel < 3) {
        DISPLAYOUT("%10s %14s %5s %11s %13s %9s   %s\n",
                "Frames", "Type", "Block", "Compressed", "Uncompressed", "Ratio", "Filename");
    }
    for (; idx < ifnIdx; idx++) {
        /* Get file info */
        LZ4IO_cFileInfo_t cfinfo = LZ4IO_INIT_CFILEINFO;
        cfinfo.fileName = LZ4IO_baseName(inFileNames[idx]);
        if (!UTIL_isRegFile(inFileNames[idx])) {
            DISPLAYLEVEL(1, "lz4: %s is not a regular file \n", inFileNames[idx]);
            return 0;
        }
        DISPLAYLEVEL(3, "%s(%llu/%llu)\n", cfinfo.fileName, (unsigned long long)idx + 1, (unsigned  long long)ifnIdx);
        DISPLAYLEVEL(3, "    %6s %14s %5s %8s %20s %20s %9s\n",
                     "Frame", "Type", "Block", "Checksum", "Compressed", "Uncompressed", "Ratio")
        {   LZ4IO_infoResult const op_result = LZ4IO_getCompressedFileInfo(&cfinfo, inFileNames[idx]);
            if (op_result != LZ4IO_LZ4F_OK) {
                assert(op_result == LZ4IO_format_not_known);
                DISPLAYLEVEL(1, "lz4: %s: File format not recognized \n", inFileNames[idx]);
                return 0;
        }   }
        DISPLAYLEVEL(3, "\n");
        if (g_displayLevel < 3) {
            /* Display Summary */
            {   char buffers[3][10];
                DISPLAYOUT("%10llu %14s %5s %11s %13s ",
                        cfinfo.frameCount,
                        cfinfo.eqFrameTypes ? LZ4IO_frameTypeNames[cfinfo.frameSummary.frameType] : "-" ,
                        cfinfo.eqBlockTypes ? LZ4IO_blockTypeID(cfinfo.frameSummary.lz4FrameInfo.blockSizeID,
                                                                cfinfo.frameSummary.lz4FrameInfo.blockMode, buffers[0]) : "-",
                        LZ4IO_toHuman((long double)cfinfo.fileSize, buffers[1]),
                        cfinfo.allContentSize ? LZ4IO_toHuman((long double)cfinfo.frameSummary.lz4FrameInfo.contentSize, buffers[2]) : "-");
                if (cfinfo.allContentSize) {
                    double const ratio = (double)cfinfo.fileSize / cfinfo.frameSummary.lz4FrameInfo.contentSize * 100;
                    DISPLAYOUT("%9.2f%%  %s \n", ratio, cfinfo.fileName);
                } else {
                    DISPLAYOUT("%9s   %s\n",
                            "-",
                            cfinfo.fileName);
        }   }   }  /* if (g_displayLevel < 3) */
    }  /* for (; idx < ifnIdx; idx++) */
 
    return result;
}

References LZ4IO_cFileInfo_t::allContentSize, assert(), LZ4F_frameInfo_t::blockMode, LZ4F_frameInfo_t::blockSizeID, LZ4F_frameInfo_t::contentSize, DISPLAYLEVEL, DISPLAYOUT, LZ4IO_cFileInfo_t::eqBlockTypes, LZ4IO_cFileInfo_t::eqFrameTypes, LZ4IO_cFileInfo_t::fileName, LZ4IO_cFileInfo_t::fileSize, LZ4IO_cFileInfo_t::frameCount, LZ4IO_cFileInfo_t::frameSummary, LZ4IO_frameInfo_t::frameType, g_displayLevel, setup::idx, LZ4IO_frameInfo_t::lz4FrameInfo, LZ4IO_baseName(), LZ4IO_blockTypeID(), LZ4IO_format_not_known, LZ4IO_frameTypeNames, LZ4IO_getCompressedFileInfo(), LZ4IO_INIT_CFILEINFO, LZ4IO_LZ4F_OK, LZ4IO_toHuman(), and UTIL_isRegFile().

Referenced by main().

LZ4IO_favorDecSpeed()

void LZ4IO_favorDecSpeed	(	LZ4IO_prefs_t *const	prefs,
		int	favor
	)

Definition at line 288 of file lz4io.c.

{
    prefs->favorDecSpeed = (favor!=0);
}

References LZ4IO_prefs_s::favorDecSpeed.

Referenced by main().

LZ4IO_freePreferences()

void LZ4IO_freePreferences

(

LZ4IO_prefs_t *

prefs

)

Definition at line 181 of file lz4io.c.

{
    free(prefs);
}

References free().

Referenced by main().

LZ4IO_setBlockChecksumMode()

int LZ4IO_setBlockChecksumMode	(	LZ4IO_prefs_t *const	prefs,
		int	xxhash
	)

Definition at line 253 of file lz4io.c.

{
    prefs->blockChecksum = (enable != 0);
    return prefs->blockChecksum;
}

References LZ4IO_prefs_s::blockChecksum.

Referenced by main().

LZ4IO_setBlockMode()

int LZ4IO_setBlockMode	(	LZ4IO_prefs_t *const	prefs,
		LZ4IO_blockMode_t	blockMode
	)

Definition at line 246 of file lz4io.c.

{
    prefs->blockIndependence = (blockMode == LZ4IO_blockIndependent);
    return prefs->blockIndependence;
}

References LZ4IO_prefs_s::blockIndependence, and LZ4IO_blockIndependent.

Referenced by main().

LZ4IO_setBlockSize()

size_t LZ4IO_setBlockSize	(	LZ4IO_prefs_t *const	prefs,
		size_t	blockSize
	)

Definition at line 228 of file lz4io.c.

{
    static const size_t minBlockSize = 32;
    static const size_t maxBlockSize = 4 MB;
    unsigned bsid = 0;
    if (blockSize < minBlockSize) blockSize = minBlockSize;
    if (blockSize > maxBlockSize) blockSize = maxBlockSize;
    prefs->blockSize = blockSize;
    blockSize--;
    /* find which of { 64k, 256k, 1MB, 4MB } is closest to blockSize */
    while (blockSize >>= 2)
        bsid++;
    if (bsid < 7) bsid = 7;
    prefs->blockSizeId = (int)(bsid-3);
    return prefs->blockSize;
}

References LZ4IO_prefs_s::blockSize, LZ4IO_prefs_s::blockSizeId, int, and MB.

Referenced by main().

LZ4IO_setBlockSizeID()

size_t LZ4IO_setBlockSizeID	(	LZ4IO_prefs_t *const	prefs,
		unsigned	blockSizeID
	)

Definition at line 217 of file lz4io.c.

{
    static const size_t blockSizeTable[] = { 64 KB, 256 KB, 1 MB, 4 MB };
    static const unsigned minBlockSizeID = 4;
    static const unsigned maxBlockSizeID = 7;
    if ((bsid < minBlockSizeID) || (bsid > maxBlockSizeID)) return 0;
    prefs->blockSizeId = (int)bsid;
    prefs->blockSize = blockSizeTable[(unsigned)prefs->blockSizeId-minBlockSizeID];
    return prefs->blockSize;
}

References LZ4IO_prefs_s::blockSize, LZ4IO_prefs_s::blockSizeId, int, KB, MB, and unsigned.

Referenced by main().

LZ4IO_setContentSize()

int LZ4IO_setContentSize	(	LZ4IO_prefs_t *const	prefs,
		int	enable
	)

Definition at line 281 of file lz4io.c.

{
    prefs->contentSizeFlag = (enable!=0);
    return prefs->contentSizeFlag;
}

References LZ4IO_prefs_s::contentSizeFlag.

Referenced by main().

LZ4IO_setDictionaryFilename()

int LZ4IO_setDictionaryFilename	(	LZ4IO_prefs_t *const	prefs,
		const char *	dictionaryFilename
	)

Definition at line 187 of file lz4io.c.

{
    prefs->dictionaryFilename = dictionaryFilename;
    prefs->useDictionary = dictionaryFilename != NULL;
    return prefs->useDictionary;
}

References LZ4IO_prefs_s::dictionaryFilename, NULL, and LZ4IO_prefs_s::useDictionary.

Referenced by main().

LZ4IO_setNotificationLevel()

int LZ4IO_setNotificationLevel

(

int

level

)

Definition at line 267 of file lz4io.c.

{
    g_displayLevel = level;
    return g_displayLevel;
}

References g_displayLevel, and level.

Referenced by main().

LZ4IO_setOverwrite()

int LZ4IO_setOverwrite	(	LZ4IO_prefs_t *const	prefs,
		int	yes
	)

Definition at line 203 of file lz4io.c.

{
   prefs->overwrite = (yes!=0);
   return prefs->overwrite;
}

References LZ4IO_prefs_s::overwrite.

Referenced by main().

LZ4IO_setPassThrough()

int LZ4IO_setPassThrough	(	LZ4IO_prefs_t *const	prefs,
		int	yes
	)

Definition at line 195 of file lz4io.c.

{
   prefs->passThrough = (yes!=0);
   return prefs->passThrough;
}

References LZ4IO_prefs_s::passThrough.

Referenced by main().

LZ4IO_setRemoveSrcFile()

void LZ4IO_setRemoveSrcFile	(	LZ4IO_prefs_t *const	prefs,
		unsigned	flag
	)

Definition at line 293 of file lz4io.c.

{
  prefs->removeSrcFile = (flag>0);
}

References LZ4IO_prefs_s::removeSrcFile.

Referenced by main().

LZ4IO_setSparseFile()

int LZ4IO_setSparseFile	(	LZ4IO_prefs_t *const	prefs,
		int	enable
	)

Definition at line 274 of file lz4io.c.

{
    prefs->sparseFileSupport = 2*(enable!=0);  /* 2==force enable */
    return prefs->sparseFileSupport;
}

References LZ4IO_prefs_s::sparseFileSupport.

Referenced by main().

LZ4IO_setStreamChecksumMode()

int LZ4IO_setStreamChecksumMode	(	LZ4IO_prefs_t *const	prefs,
		int	xxhash
	)

Definition at line 260 of file lz4io.c.

{
    prefs->streamChecksum = (enable != 0);
    return prefs->streamChecksum;
}

References LZ4IO_prefs_s::streamChecksum.

Referenced by main().

LZ4IO_setTestMode()

int LZ4IO_setTestMode	(	LZ4IO_prefs_t *const	prefs,
		int	yes
	)

Definition at line 210 of file lz4io.c.

{
   prefs->testMode = (yes!=0);
   return prefs->testMode;
}

References LZ4IO_prefs_s::testMode.

Referenced by main().