AuroraMiddleware/lz4
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge pull request #40 from Cyan4973/dev

Browse Source 
minor refactoring
This commit is contained in:
Yann Collet 2014-12-08 13:41:11 +01:00
commit 19fcc54921
6 changed files with 38 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
lib/lz4frame.h
View File

@ -207,6 +207,7 @@ typedef struct {
unsigned reserved[3];
} LZ4F_decompressOptions_t;
/* Resource management */
LZ4F_errorCode_t LZ4F_createDecompressionContext(LZ4F_decompressionContext_t* ctxPtr, unsigned version);
@ -220,6 +221,7 @@ LZ4F_errorCode_t LZ4F_freeDecompressionContext(LZ4F_decompressionContext_t ctx);
* Object can release its memory using LZ4F_freeDecompressionContext();
*/
/* Decompression */
size_t LZ4F_getFrameInfo(LZ4F_decompressionContext_t ctx,
@ -232,7 +234,7 @@ size_t LZ4F_getFrameInfo(LZ4F_decompressionContext_t ctx,
* LZ4F_getFrameInfo() can also be used *after* starting decompression, on a valid LZ4F_decompressionContext_t.
* The number of bytes read from srcBuffer will be provided within *srcSizePtr (necessarily <= original value).
* You are expected to resume decompression from where it stopped (srcBuffer + *srcSizePtr)
* The function result is an hint of the better srcSize to use for next call to LZ4F_decompress,
* The function result is an hint of how many srcSize bytes LZ4F_decompress() expects for next call,
* or an error code which can be tested using LZ4F_isError().
*/
@ -246,20 +248,21 @@ size_t LZ4F_decompress(LZ4F_decompressionContext_t ctx,
*
* The number of bytes regenerated into dstBuffer will be provided within *dstSizePtr (necessarily <= original value).
*
* The number of bytes effectively used from srcBuffer will be provided within *srcSizePtr (necessarily <= original value).
* If the number of bytes read is < number of bytes provided, then the decompression operation is not complete.
* This typically happens when dstBuffer is not large enough to contain all decoded data.
* LZ4F_decompress() will have to be called again, starting from where it stopped (srcBuffer + *srcSizePtr)
* The number of bytes read from srcBuffer will be provided within *srcSizePtr (necessarily <= original value).
* If number of bytes read is < number of bytes provided, then decompression operation is not completed.
* It typically happens when dstBuffer is not large enough to contain all decoded data.
* LZ4F_decompress() must be called again, starting from where it stopped (srcBuffer + *srcSizePtr)
* The function will check this condition, and refuse to continue if it is not respected.
* dstBuffer is supposed to be flushed between calls to the function, since its content will be rewritten.
* Different dst arguments can be used between each calls.
*
* The function result is an hint of the better srcSize to use for next call to LZ4F_decompress.
* Basically, it's the size of the current (or remaining) compressed block + header of next block.
* Respecting the hint provides some boost to performance, since it does not need intermediate buffers.
* dstBuffer is supposed to be flushed between each call to the function, since its content will be overwritten.
* dst arguments can be changed at will with each consecutive call to the function.
*
* The function result is an hint of how many srcSize bytes LZ4F_decompress() expects for next call.
* Schematically, it's the size of the current (or remaining) compressed block + header of next block.
* Respecting the hint provides some boost to performance, since it does skip intermediate buffers.
* This is just a hint, you can always provide any srcSize you want.
* When a frame is fully decoded, the function result will be 0.
* If decompression failed, function result is an error code which can be tested using LZ4F_isError().
* When a frame is fully decoded, the function result will be 0. (no more data expected)
* If decompression failed, function result is an error code, which can be tested using LZ4F_isError().
*/

12
lib/lz4hc.c
View File

@ -36,13 +36,12 @@ You can contact the author at :
/**************************************
Tuning Parameter
**************************************/
#define LZ4HC_DEFAULT_COMPRESSIONLEVEL 8
static const int LZ4HC_compressionLevel_default = 8;
/**************************************
Includes
**************************************/
#include "lz4.h"
#include "lz4hc.h"
@ -82,6 +81,8 @@ You can contact the author at :
#define OPTIMAL_ML (int)((ML_MASK-1)+MINMATCH)
static const int g_maxCompressionLevel = 16;
/**************************************
Local Types
@ -328,7 +329,6 @@ FORCE_INLINE int LZ4HC_encodeSequence (
}
#define MAX_COMPRESSION_LEVEL 16
static int LZ4HC_compress_generic (
void* ctxvoid,
const char* source,
@ -361,9 +361,9 @@ static int LZ4HC_compress_generic (
/* init */
if (compressionLevel > MAX_COMPRESSION_LEVEL) compressionLevel = MAX_COMPRESSION_LEVEL;
if (compressionLevel == 0) compressionLevel = LZ4HC_DEFAULT_COMPRESSIONLEVEL;
maxNbAttempts = 1 << compressionLevel;
if (compressionLevel > g_maxCompressionLevel) compressionLevel = g_maxCompressionLevel;
if (compressionLevel < 1) compressionLevel = LZ4HC_compressionLevel_default;
maxNbAttempts = 1 << (compressionLevel-1);
ctx->end += inputSize;
ip++;

5
programs/bench.c
View File

@ -75,11 +75,6 @@ static int LZ4_compress_local(const char* src, char* dst, int size, int clevel)
# define S_ISREG(x) (((x) & S_IFMT) == S_IFREG)
#endif
// GCC does not support _rotl outside of Windows
#if !defined(_WIN32)
# define _rotl(x,r) ((x << r) | (x >> (32 - r)))
#endif
//**************************************
// Basic Types

5
programs/bench.h
View File

@ -17,8 +17,8 @@
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
You can contact the author at :
- LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html
- LZ4 source repository : http://code.google.com/p/lz4/
- LZ4 public forum : https://group.google.com/forum/#!forum/lz4c
*/
#pragma once
@ -27,9 +27,10 @@ extern "C" {
#endif
/* Main function */
int BMK_benchFile(char** fileNamesTable, int nbFiles, int cLevel);
// Parameters
/* Set Parameters */
void BMK_SetBlocksize(int bsize);
void BMK_SetNbIterations(int nbLoops);
void BMK_SetPause(void);

45
programs/lz4cli.c
View File

@ -1,6 +1,7 @@
/*
LZ4cli.c - LZ4 Command Line Interface
LZ4cli - LZ4 Command Line Interface
Copyright (C) Yann Collet 2011-2014
GPL v2 License
This program is free software; you can redistribute it and/or modify
@ -55,13 +56,9 @@
// Includes
//****************************
#include <stdio.h> // fprintf, fopen, fread, _fileno, stdin, stdout
#include <stdlib.h> // malloc
#include <stdlib.h> // exit, calloc, free
#include <string.h> // strcmp, strlen
#include <time.h> // clock
#include "lz4.h"
#include "lz4hc.h"
#include "xxhash.h"
#include "bench.h"
#include "bench.h" // BMK_benchFile, BMK_SetNbIterations, BMK_SetBlocksize, BMK_SetPause
#include "lz4io.h"
@ -83,30 +80,10 @@
#endif
//**************************************
// Compiler-specific functions
//**************************************
#define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
#if defined(_MSC_VER) // Visual Studio
# define swap32 _byteswap_ulong
#elif (GCC_VERSION >= 403) || defined(__clang__)
# define swap32 __builtin_bswap32
#else
static inline unsigned int swap32(unsigned int x)
{
return ((x << 24) & 0xff000000 ) |
((x << 8) & 0x00ff0000 ) |
((x >> 8) & 0x0000ff00 ) |
((x >> 24) & 0x000000ff );
}
#endif
//****************************
// Constants
//****************************
#define COMPRESSOR_NAME "LZ4 Compression CLI"
#define COMPRESSOR_NAME "LZ4 command line interface"
#ifndef LZ4_VERSION
# define LZ4_VERSION "r125"
#endif
@ -125,15 +102,15 @@
//**************************************
// Macros
//**************************************
#define DISPLAY(...) fprintf(stderr, __VA_ARGS__)
#define DISPLAYLEVEL(l, ...) if (displayLevel>=l) { DISPLAY(__VA_ARGS__); }
#define DISPLAY(...) fprintf(stderr, __VA_ARGS__)
#define DISPLAYLEVEL(l, ...) if (displayLevel>=l) { DISPLAY(__VA_ARGS__); }
static unsigned displayLevel = 2; // 0 : no display // 1: errors // 2 : + result + interaction + warnings ; // 3 : + progression; // 4 : + information
//**************************************
// Local Parameters
// Local Variables
//**************************************
static char* programName;
static int displayLevel = 2; // 0 : no display // 1: errors // 2 : + result + interaction + warnings ; // 3 : + progression; // 4 : + information
//**************************************
@ -196,7 +173,7 @@ int usage_advanced(void)
DISPLAY( " -l : compress using Legacy format (Linux kernel compression)\n");
DISPLAY( " -B# : Block size [4-7](default : 7)\n");
DISPLAY( " -BD : Block dependency (improve compression ratio)\n");
DISPLAY( " -BX : enable block checksum (default:disabled)\n");
//DISPLAY( " -BX : enable block checksum (default:disabled)\n"); // Option currently inactive
DISPLAY( " -Sx : disable stream checksum (default:enabled)\n");
DISPLAY( "Benchmark arguments :\n");
DISPLAY( " -b : benchmark file(s)\n");
@ -508,7 +485,7 @@ int main(int argc, char** argv)
{
if (legacy_format)
{
DISPLAYLEVEL(3, "! Generating compressed LZ4 using Legacy format (deprecated !) ! \n");
DISPLAYLEVEL(3, "! Generating compressed LZ4 using Legacy format (deprecated) ! \n");
LZ4IO_compressFilename_Legacy(input_filename, output_filename, cLevel);
}
else

6
programs/lz4io.c
View File

@ -134,6 +134,7 @@ static int blockIndependence = 1;
static const int minBlockSizeID = 4;
static const int maxBlockSizeID = 7;
//**************************************
// Exceptions
//**************************************
@ -208,9 +209,8 @@ int LZ4IO_setNotificationLevel(int level)
static unsigned LZ4IO_GetMilliSpan(clock_t nPrevious)
{
#define CLOCKS_PER_MSEC (CLOCKS_PER_SEC/1000)
clock_t nCurrent = clock();
unsigned nSpan = (unsigned)((nCurrent - nPrevious) / CLOCKS_PER_MSEC);
unsigned nSpan = (unsigned)(((nCurrent - nPrevious) * 1000) / CLOCKS_PER_SEC);
return nSpan;
}
@ -481,7 +481,6 @@ static unsigned long long decodeLegacyStream(FILE* finput, FILE* foutput)
unsigned long long filesize = 0;
char* in_buff;
char* out_buff;
unsigned int blockSize;
// Allocate Memory
in_buff = (char*)malloc(LZ4_compressBound(LEGACY_BLOCKSIZE));
@ -493,6 +492,7 @@ static unsigned long long decodeLegacyStream(FILE* finput, FILE* foutput)
{
int decodeSize;
size_t sizeCheck;
unsigned int blockSize;
// Block Size
sizeCheck = fread(in_buff, 1, 4, finput);