Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
2dot5
ClickHouse
提交
6b9fbd20
C
ClickHouse
项目概览
2dot5
/
ClickHouse
通知
3
Star
0
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
DevOps
流水线
流水线任务
计划
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
C
ClickHouse
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
DevOps
DevOps
流水线
流水线任务
计划
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
流水线任务
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
6b9fbd20
编写于
5月 06, 2017
作者:
K
kmeaw
提交者:
alexey-milovidov
5月 06, 2017
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
Update lz4 library to the latest stable version (1.7.5, 2016-11-28)
上级
11ec4c62
变更
4
展开全部
隐藏空白更改
内联
并排
Showing
4 changed file
with
957 addition
and
879 deletion
+957
-879
contrib/liblz4/include/lz4/lz4.h
contrib/liblz4/include/lz4/lz4.h
+242
-139
contrib/liblz4/include/lz4/lz4hc.h
contrib/liblz4/include/lz4/lz4hc.h
+148
-109
contrib/liblz4/src/lz4.c
contrib/liblz4/src/lz4.c
+382
-435
contrib/liblz4/src/lz4hc.c
contrib/liblz4/src/lz4hc.c
+185
-196
未找到文件。
contrib/liblz4/include/lz4/lz4.h
浏览文件 @
6b9fbd20
此差异已折叠。
点击以展开。
contrib/liblz4/include/lz4/lz4hc.h
浏览文件 @
6b9fbd20
/*
/*
LZ4 HC - High Compression Mode of LZ4
LZ4 HC - High Compression Mode of LZ4
Header File
Header File
Copyright (C) 2011-201
5
, Yann Collet.
Copyright (C) 2011-201
6
, Yann Collet.
BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
Redistribution and use in source and binary forms, with or without
Redistribution and use in source and binary forms, with or without
...
@@ -28,107 +28,92 @@
...
@@ -28,107 +28,92 @@
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
You can contact the author at :
You can contact the author at :
- LZ4 source repository : https://github.com/
Cyan4973
/lz4
- LZ4 source repository : https://github.com/
lz4
/lz4
- LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c
- LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c
*/
*/
#
pragma once
#
ifndef LZ4_HC_H_19834876238432
#define LZ4_HC_H_19834876238432
#if defined (__cplusplus)
#if defined (__cplusplus)
extern
"C"
{
extern
"C"
{
#endif
#endif
/*****************************
/* --- Dependency --- */
* Includes
/* note : lz4hc is not an independent module, it requires lz4.h/lz4.c for proper compilation */
*****************************/
#include "lz4.h"
/* stddef, LZ4LIB_API, LZ4_DEPRECATED */
#include <stddef.h>
/* size_t */
/**************************************
/* --- Useful constants --- */
* Block Compression
#define LZ4HC_CLEVEL_MIN 3
**************************************/
#define LZ4HC_CLEVEL_DEFAULT 9
int
LZ4_compress_HC
(
const
char
*
src
,
char
*
dst
,
int
srcSize
,
int
maxDstSize
,
int
compressionLevel
);
#define LZ4HC_CLEVEL_OPT_MIN 11
/*
#define LZ4HC_CLEVEL_MAX 12
LZ4_compress_HC :
Destination buffer 'dst' must be already allocated.
Compression completion is guaranteed if 'dst' buffer is sized to handle worst circumstances (data not compressible)
Worst size evaluation is provided by function LZ4_compressBound() (see "lz4.h")
srcSize : Max supported value is LZ4_MAX_INPUT_SIZE (see "lz4.h")
compressionLevel : Recommended values are between 4 and 9, although any value between 0 and 16 will work.
0 means "use default value" (see lz4hc.c).
Values >16 behave the same as 16.
return : the number of bytes written into buffer 'dst'
or 0 if compression fails.
*/
/* Note :
Decompression functions are provided within LZ4 source code (see "lz4.h") (BSD license)
*/
int
LZ4_sizeofStateHC
(
void
);
/*-************************************
int
LZ4_compress_HC_extStateHC
(
void
*
state
,
const
char
*
src
,
char
*
dst
,
int
srcSize
,
int
maxDstSize
,
int
compressionLevel
);
* Block Compression
/*
**************************************/
LZ4_compress_HC_extStateHC() :
/*! LZ4_compress_HC() :
Use this function if you prefer to manually allocate memory for compression tables.
* Compress data from `src` into `dst`, using the more powerful but slower "HC" algorithm.
To know how much memory must be allocated for the compression tables, use :
* `dst` must be already allocated.
int LZ4_sizeofStateHC();
* Compression is guaranteed to succeed if `dstCapacity >= LZ4_compressBound(srcSize)` (see "lz4.h")
* Max supported `srcSize` value is LZ4_MAX_INPUT_SIZE (see "lz4.h")
* `compressionLevel` : Recommended values are between 4 and 9, although any value between 1 and LZ4HC_MAX_CLEVEL will work.
* Values >LZ4HC_MAX_CLEVEL behave the same as LZ4HC_MAX_CLEVEL.
* @return : the number of bytes written into 'dst'
* or 0 if compression fails.
*/
LZ4LIB_API
int
LZ4_compress_HC
(
const
char
*
src
,
char
*
dst
,
int
srcSize
,
int
dstCapacity
,
int
compressionLevel
);
Allocated memory must be aligned on 8-bytes boundaries (which a normal malloc() will do properly).
The allocated memory can then be provided to the compression functions using 'void* state' parameter.
/* Note :
LZ4_compress_HC_extStateHC() is equivalent to previously described function.
* Decompression functions are provided within "lz4.h" (BSD license)
It just uses externally allocated memory for stateHC.
*/
*/
/**************************************
/*! LZ4_compress_HC_extStateHC() :
* Streaming Compression
* Same as LZ4_compress_HC(), but using an externally allocated memory segment for `state`.
**************************************/
* `state` size is provided by LZ4_sizeofStateHC().
#define LZ4_STREAMHCSIZE 262192
* Memory segment must be aligned on 8-bytes boundaries (which a normal malloc() will do properly).
#define LZ4_STREAMHCSIZE_SIZET (LZ4_STREAMHCSIZE / sizeof(size_t))
*/
typedef
struct
{
size_t
table
[
LZ4_STREAMHCSIZE_SIZET
];
}
LZ4_streamHC_t
;
LZ4LIB_API
int
LZ4_compress_HC_extStateHC
(
void
*
state
,
const
char
*
src
,
char
*
dst
,
int
srcSize
,
int
maxDstSize
,
int
compressionLevel
);
/*
LZ4LIB_API
int
LZ4_sizeofStateHC
(
void
);
LZ4_streamHC_t
This structure allows static allocation of LZ4 HC streaming state.
State must then be initialized using LZ4_resetStreamHC() before first use.
Static allocation should only be used in combination with static linking.
If you want to use LZ4 as a DLL, please use construction functions below, which are future-proof.
*/
/*-************************************
* Streaming Compression
* Bufferless synchronous API
**************************************/
typedef
union
LZ4_streamHC_u
LZ4_streamHC_t
;
/* incomplete type (defined later) */
LZ4_streamHC_t
*
LZ4_createStreamHC
(
void
);
/*! LZ4_createStreamHC() and LZ4_freeStreamHC() :
int
LZ4_freeStreamHC
(
LZ4_streamHC_t
*
streamHCPtr
);
* These functions create and release memory for LZ4 HC streaming state.
/*
* Newly created states are automatically initialized.
These functions create and release memory for LZ4 HC streaming state.
* Existing states can be re-used several times, using LZ4_resetStreamHC().
Newly created states are already initialized.
* These methods are API and ABI stable, they can be used in combination with a DLL.
Existing state space can be re-used anytime using LZ4_resetStreamHC().
*/
If you use LZ4 as a DLL, use these functions instead of static structure allocation,
LZ4LIB_API
LZ4_streamHC_t
*
LZ4_createStreamHC
(
void
);
to avoid size mismatch between different versions.
LZ4LIB_API
int
LZ4_freeStreamHC
(
LZ4_streamHC_t
*
streamHCPtr
);
*/
void
LZ4_resetStreamHC
(
LZ4_streamHC_t
*
streamHCPtr
,
int
compressionLevel
);
LZ4LIB_API
void
LZ4_resetStreamHC
(
LZ4_streamHC_t
*
streamHCPtr
,
int
compressionLevel
);
int
LZ4_loadDictHC
(
LZ4_streamHC_t
*
streamHCPtr
,
const
char
*
dictionary
,
int
dictSize
);
LZ4LIB_API
int
LZ4_loadDictHC
(
LZ4_streamHC_t
*
streamHCPtr
,
const
char
*
dictionary
,
int
dictSize
);
int
LZ4_compress_HC_continue
(
LZ4_streamHC_t
*
streamHCPtr
,
const
char
*
src
,
char
*
dst
,
int
srcSize
,
int
maxDstSize
);
LZ4LIB_API
int
LZ4_compress_HC_continue
(
LZ4_streamHC_t
*
streamHCPtr
,
const
char
*
src
,
char
*
dst
,
int
srcSize
,
int
maxDstSize
);
int
LZ4_saveDictHC
(
LZ4_streamHC_t
*
streamHCPtr
,
char
*
safeBuffer
,
int
maxDictSize
);
LZ4LIB_API
int
LZ4_saveDictHC
(
LZ4_streamHC_t
*
streamHCPtr
,
char
*
safeBuffer
,
int
maxDictSize
);
/*
/*
These functions compress data in successive blocks of any size, using previous blocks as dictionary.
These functions compress data in successive blocks of any size, using previous blocks as dictionary.
One key assumption is that previous blocks (up to 64 KB) remain read-accessible while compressing next blocks.
One key assumption is that previous blocks (up to 64 KB) remain read-accessible while compressing next blocks.
There is an exception for ring buffers, which can be smaller 64 KB.
There is an exception for ring buffers, which can be smaller
than
64 KB.
Such case is automatically detected and correctly
handled by LZ4_compress_HC_continue().
Ring buffers scenario is automatically detected and
handled by LZ4_compress_HC_continue().
Before starting compression, state must be properly initialized, using LZ4_resetStreamHC().
Before starting compression, state must be properly initialized, using LZ4_resetStreamHC().
A first "fictional block" can then be designated as initial dictionary, using LZ4_loadDictHC() (Optional).
A first "fictional block" can then be designated as initial dictionary, using LZ4_loadDictHC() (Optional).
Then, use LZ4_compress_HC_continue() to compress each successive block.
Then, use LZ4_compress_HC_continue() to compress each successive block.
It works like LZ4_compress_HC(), but use previous memory blocks as dictionary to improve compression.
Previous memory blocks (including initial dictionary when present) must remain accessible and unmodified during compression.
Previous memory blocks (including initial dictionary when present) must remain accessible and unmodified during compression.
As a reminder, size 'dst' buffer to handle worst cases, using LZ4_compressBound(), to ensure success of compression operation
.
'dst' buffer should be sized to handle worst case scenarios, using LZ4_compressBound(), to ensure operation success
.
If, for any reason, previous data blocks can't be preserved unmodified in memory during next compression block,
If, for any reason, previous data blocks can't be preserved unmodified in memory during next compression block,
you must save it to a safer memory space, using LZ4_saveDictHC().
you must save it to a safer memory space, using LZ4_saveDictHC().
...
@@ -136,50 +121,102 @@ int LZ4_saveDictHC (LZ4_streamHC_t* streamHCPtr, char* safeBuffer, int maxDictSi
...
@@ -136,50 +121,102 @@ int LZ4_saveDictHC (LZ4_streamHC_t* streamHCPtr, char* safeBuffer, int maxDictSi
*/
*/
/*-******************************************
* !!!!! STATIC LINKING ONLY !!!!!
*******************************************/
/*-*************************************
* PRIVATE DEFINITIONS :
* Do not use these definitions.
* They are exposed to allow static allocation of `LZ4_streamHC_t`.
* Using these definitions makes the code vulnerable to potential API break when upgrading LZ4
**************************************/
#define LZ4HC_DICTIONARY_LOGSIZE 17
#define LZ4HC_MAXD (1<<LZ4HC_DICTIONARY_LOGSIZE)
#define LZ4HC_MAXD_MASK (LZ4HC_MAXD - 1)
#define LZ4HC_HASH_LOG 15
#define LZ4HC_HASHTABLESIZE (1 << LZ4HC_HASH_LOG)
#define LZ4HC_HASH_MASK (LZ4HC_HASHTABLESIZE - 1)
#if defined(__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
/* C99 */
)
#include <stdint.h>
typedef
struct
{
uint32_t
hashTable
[
LZ4HC_HASHTABLESIZE
];
uint16_t
chainTable
[
LZ4HC_MAXD
];
const
uint8_t
*
end
;
/* next block here to continue on current prefix */
const
uint8_t
*
base
;
/* All index relative to this position */
const
uint8_t
*
dictBase
;
/* alternate base for extDict */
uint8_t
*
inputBuffer
;
/* deprecated */
uint32_t
dictLimit
;
/* below that point, need extDict */
uint32_t
lowLimit
;
/* below that point, no more dict */
uint32_t
nextToUpdate
;
/* index from which to continue dictionary update */
uint32_t
searchNum
;
/* only for optimal parser */
uint32_t
compressionLevel
;
}
LZ4HC_CCtx_internal
;
#else
typedef
struct
{
unsigned
int
hashTable
[
LZ4HC_HASHTABLESIZE
];
unsigned
short
chainTable
[
LZ4HC_MAXD
];
const
unsigned
char
*
end
;
/* next block here to continue on current prefix */
const
unsigned
char
*
base
;
/* All index relative to this position */
const
unsigned
char
*
dictBase
;
/* alternate base for extDict */
unsigned
char
*
inputBuffer
;
/* deprecated */
unsigned
int
dictLimit
;
/* below that point, need extDict */
unsigned
int
lowLimit
;
/* below that point, no more dict */
unsigned
int
nextToUpdate
;
/* index from which to continue dictionary update */
unsigned
int
searchNum
;
/* only for optimal parser */
unsigned
int
compressionLevel
;
}
LZ4HC_CCtx_internal
;
#endif
#define LZ4_STREAMHCSIZE (4*LZ4HC_HASHTABLESIZE + 2*LZ4HC_MAXD + 56)
/* 393268 */
#define LZ4_STREAMHCSIZE_SIZET (LZ4_STREAMHCSIZE / sizeof(size_t))
union
LZ4_streamHC_u
{
size_t
table
[
LZ4_STREAMHCSIZE_SIZET
];
LZ4HC_CCtx_internal
internal_donotuse
;
};
/* previously typedef'd to LZ4_streamHC_t */
/*
LZ4_streamHC_t :
This structure allows static allocation of LZ4 HC streaming state.
State must be initialized using LZ4_resetStreamHC() before first use.
Static allocation shall only be used in combination with static linking.
When invoking LZ4 from a DLL, use create/free functions instead, which are API and ABI stable.
*/
/*
*
************************************
/*
-
************************************
* Deprecated Functions
* Deprecated Functions
**************************************/
**************************************/
/* Deprecate Warnings */
/* see lz4.h LZ4_DISABLE_DEPRECATE_WARNINGS to turn off deprecation warnings */
/* Should these warnings messages be a problem,
it is generally possible to disable them,
/* deprecated compression functions */
with -Wno-deprecated-declarations for gcc
/* these functions will trigger warning messages in future releases */
or _CRT_SECURE_NO_WARNINGS in Visual for example.
LZ4_DEPRECATED
(
"use LZ4_compress_HC() instead"
)
int
LZ4_compressHC
(
const
char
*
source
,
char
*
dest
,
int
inputSize
);
You can also define LZ4_DEPRECATE_WARNING_DEFBLOCK. */
LZ4_DEPRECATED
(
"use LZ4_compress_HC() instead"
)
int
LZ4_compressHC_limitedOutput
(
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
maxOutputSize
);
#ifndef LZ4_DEPRECATE_WARNING_DEFBLOCK
LZ4_DEPRECATED
(
"use LZ4_compress_HC() instead"
)
int
LZ4_compressHC2
(
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
compressionLevel
);
# define LZ4_DEPRECATE_WARNING_DEFBLOCK
LZ4_DEPRECATED
(
"use LZ4_compress_HC() instead"
)
int
LZ4_compressHC2_limitedOutput
(
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
maxOutputSize
,
int
compressionLevel
);
# define LZ4_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
LZ4_DEPRECATED
(
"use LZ4_compress_HC_extStateHC() instead"
)
int
LZ4_compressHC_withStateHC
(
void
*
state
,
const
char
*
source
,
char
*
dest
,
int
inputSize
);
# if (LZ4_GCC_VERSION >= 405) || defined(__clang__)
LZ4_DEPRECATED
(
"use LZ4_compress_HC_extStateHC() instead"
)
int
LZ4_compressHC_limitedOutput_withStateHC
(
void
*
state
,
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
maxOutputSize
);
# define LZ4_DEPRECATED(message) __attribute__((deprecated(message)))
LZ4_DEPRECATED
(
"use LZ4_compress_HC_extStateHC() instead"
)
int
LZ4_compressHC2_withStateHC
(
void
*
state
,
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
compressionLevel
);
# elif (LZ4_GCC_VERSION >= 301)
LZ4_DEPRECATED
(
"use LZ4_compress_HC_extStateHC() instead"
)
int
LZ4_compressHC2_limitedOutput_withStateHC
(
void
*
state
,
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
maxOutputSize
,
int
compressionLevel
);
# define LZ4_DEPRECATED(message) __attribute__((deprecated))
LZ4_DEPRECATED
(
"use LZ4_compress_HC_continue() instead"
)
int
LZ4_compressHC_continue
(
LZ4_streamHC_t
*
LZ4_streamHCPtr
,
const
char
*
source
,
char
*
dest
,
int
inputSize
);
# elif defined(_MSC_VER)
LZ4_DEPRECATED
(
"use LZ4_compress_HC_continue() instead"
)
int
LZ4_compressHC_limitedOutput_continue
(
LZ4_streamHC_t
*
LZ4_streamHCPtr
,
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
maxOutputSize
);
# define LZ4_DEPRECATED(message) __declspec(deprecated(message))
# else
/* Deprecated Streaming functions using older model; should no longer be used */
# pragma message("WARNING: You need to implement LZ4_DEPRECATED for this compiler")
# define LZ4_DEPRECATED(message)
# endif
#endif // LZ4_DEPRECATE_WARNING_DEFBLOCK
/* compression functions */
/* these functions are planned to trigger warning messages by r131 approximately */
int
LZ4_compressHC
(
const
char
*
source
,
char
*
dest
,
int
inputSize
);
int
LZ4_compressHC_limitedOutput
(
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
maxOutputSize
);
int
LZ4_compressHC2
(
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
compressionLevel
);
int
LZ4_compressHC2_limitedOutput
(
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
maxOutputSize
,
int
compressionLevel
);
int
LZ4_compressHC_withStateHC
(
void
*
state
,
const
char
*
source
,
char
*
dest
,
int
inputSize
);
int
LZ4_compressHC_limitedOutput_withStateHC
(
void
*
state
,
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
maxOutputSize
);
int
LZ4_compressHC2_withStateHC
(
void
*
state
,
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
compressionLevel
);
int
LZ4_compressHC2_limitedOutput_withStateHC
(
void
*
state
,
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
maxOutputSize
,
int
compressionLevel
);
int
LZ4_compressHC_continue
(
LZ4_streamHC_t
*
LZ4_streamHCPtr
,
const
char
*
source
,
char
*
dest
,
int
inputSize
);
int
LZ4_compressHC_limitedOutput_continue
(
LZ4_streamHC_t
*
LZ4_streamHCPtr
,
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
maxOutputSize
);
/* Streaming functions following the older model; should no longer be used */
LZ4_DEPRECATED
(
"use LZ4_createStreamHC() instead"
)
void
*
LZ4_createHC
(
char
*
inputBuffer
);
LZ4_DEPRECATED
(
"use LZ4_createStreamHC() instead"
)
void
*
LZ4_createHC
(
char
*
inputBuffer
);
LZ4_DEPRECATED
(
"use LZ4_saveDictHC() instead"
)
char
*
LZ4_slideInputBufferHC
(
void
*
LZ4HC_Data
);
LZ4_DEPRECATED
(
"use LZ4_saveDictHC() instead"
)
char
*
LZ4_slideInputBufferHC
(
void
*
LZ4HC_Data
);
LZ4_DEPRECATED
(
"use LZ4_freeStreamHC() instead"
)
int
LZ4_freeHC
(
void
*
LZ4HC_Data
);
LZ4_DEPRECATED
(
"use LZ4_freeStreamHC() instead"
)
int
LZ4_freeHC
(
void
*
LZ4HC_Data
);
LZ4_DEPRECATED
(
"use LZ4_compress_HC_continue() instead"
)
int
LZ4_compressHC2_continue
(
void
*
LZ4HC_Data
,
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
compressionLevel
);
LZ4_DEPRECATED
(
"use LZ4_compress_HC_continue() instead"
)
int
LZ4_compressHC2_continue
(
void
*
LZ4HC_Data
,
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
compressionLevel
);
LZ4_DEPRECATED
(
"use LZ4_compress_HC_continue() instead"
)
int
LZ4_compressHC2_limitedOutput_continue
(
void
*
LZ4HC_Data
,
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
maxOutputSize
,
int
compressionLevel
);
LZ4_DEPRECATED
(
"use LZ4_compress_HC_continue() instead"
)
int
LZ4_compressHC2_limitedOutput_continue
(
void
*
LZ4HC_Data
,
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
maxOutputSize
,
int
compressionLevel
);
LZ4_DEPRECATED
(
"use LZ4_createStreamHC() instead"
)
int
LZ4_sizeofStreamStateHC
(
void
);
LZ4_DEPRECATED
(
"use LZ4_createStreamHC() instead"
)
int
LZ4_sizeofStreamStateHC
(
void
);
LZ4_DEPRECATED
(
"use LZ4_resetStreamHC() instead"
)
int
LZ4_resetStreamStateHC
(
void
*
state
,
char
*
inputBuffer
);
LZ4_DEPRECATED
(
"use LZ4_resetStreamHC() instead"
)
int
LZ4_resetStreamStateHC
(
void
*
state
,
char
*
inputBuffer
);
...
@@ -187,3 +224,5 @@ LZ4_DEPRECATED("use LZ4_resetStreamHC() instead") int LZ4_resetStreamStateHC(
...
@@ -187,3 +224,5 @@ LZ4_DEPRECATED("use LZ4_resetStreamHC() instead") int LZ4_resetStreamStateHC(
#if defined (__cplusplus)
#if defined (__cplusplus)
}
}
#endif
#endif
#endif
/* LZ4_HC_H_19834876238432 */
contrib/liblz4/src/lz4.c
浏览文件 @
6b9fbd20
此差异已折叠。
点击以展开。
contrib/liblz4/src/lz4hc.c
浏览文件 @
6b9fbd20
此差异已折叠。
点击以展开。
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录