Skip to content
Projects
Groups
Snippets
Help
Loading...
Sign in
Toggle navigation
B
beego
Project
Project
Details
Activity
Cycle Analytics
Repository
Repository
Files
Commits
Branches
Tags
Contributors
Graph
Compare
Charts
Issues
0
Issues
0
List
Board
Labels
Milestones
Merge Requests
0
Merge Requests
0
Wiki
Wiki
Snippets
Snippets
Members
Members
Collapse sidebar
Close sidebar
Activity
Graph
Charts
Create a new issue
Commits
Issue Boards
Open sidebar
go
beego
Commits
d0d28566
Commit
d0d28566
authored
Nov 10, 2018
by
Viktor Vassilyev
Browse files
Options
Browse Files
Download
Email Patches
Plain Diff
chore(GoMod): add dependency go-bindata-assetfs in vendor dir
parent
872b787e
Hide whitespace changes
Inline
Side-by-side
Showing
9 changed files
with
2857 additions
and
0 deletions
+2857
-0
go.sum
go.sum
+1
-0
lz4.c
vendor/github.com/cloudflare/golz4/src/lz4.c
+1367
-0
lz4.h
vendor/github.com/cloudflare/golz4/src/lz4.h
+315
-0
lz4hc.c
vendor/github.com/cloudflare/golz4/src/lz4hc.c
+751
-0
lz4hc.h
vendor/github.com/cloudflare/golz4/src/lz4hc.h
+174
-0
LICENSE
vendor/github.com/elazarl/go-bindata-assetfs/LICENSE
+23
-0
README.md
vendor/github.com/elazarl/go-bindata-assetfs/README.md
+46
-0
assetfs.go
vendor/github.com/elazarl/go-bindata-assetfs/assetfs.go
+167
-0
doc.go
vendor/github.com/elazarl/go-bindata-assetfs/doc.go
+13
-0
No files found.
go.sum
View file @
d0d28566
...
@@ -26,6 +26,7 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
...
@@ -26,6 +26,7 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/edsrzf/mmap-go v0.0.0-20170320065105-0bce6a688712 h1:aaQcKT9WumO6JEJcRyTqFVq4XUZiUcKR2/GI31TOcz8=
github.com/edsrzf/mmap-go v0.0.0-20170320065105-0bce6a688712 h1:aaQcKT9WumO6JEJcRyTqFVq4XUZiUcKR2/GI31TOcz8=
github.com/edsrzf/mmap-go v0.0.0-20170320065105-0bce6a688712/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M=
github.com/edsrzf/mmap-go v0.0.0-20170320065105-0bce6a688712/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M=
github.com/elazarl/go-bindata-assetfs v0.0.0-20180223110309-38087fe4dafb h1:T6FhFH6fLQPEu7n7PauDhb4mhpxhlfaL7a7MZEpIgDc=
github.com/elazarl/go-bindata-assetfs v0.0.0-20180223110309-38087fe4dafb/go.mod h1:v+YaWX3bdea5J/mo8dSETolEo7R71Vk1u8bnjau5yw4=
github.com/elazarl/go-bindata-assetfs v0.0.0-20180223110309-38087fe4dafb/go.mod h1:v+YaWX3bdea5J/mo8dSETolEo7R71Vk1u8bnjau5yw4=
github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
...
...
vendor/github.com/cloudflare/golz4/src/lz4.c
0 → 100644
View file @
d0d28566
/*
LZ4 - Fast LZ compression algorithm
Copyright (C) 2011-2015, Yann Collet.
BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following disclaimer
in the documentation and/or other materials provided with the
distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
You can contact the author at :
- LZ4 source repository : http://code.google.com/p/lz4
- LZ4 source mirror : https://github.com/Cyan4973/lz4
- LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c
*/
/**************************************
Tuning parameters
**************************************/
/*
* HEAPMODE :
* Select how default compression functions will allocate memory for their hash table,
* in memory stack (0:default, fastest), or in memory heap (1:requires malloc()).
*/
#define HEAPMODE 0
/*
* CPU_HAS_EFFICIENT_UNALIGNED_MEMORY_ACCESS :
* By default, the source code expects the compiler to correctly optimize
* 4-bytes and 8-bytes read on architectures able to handle it efficiently.
* This is not always the case. In some circumstances (ARM notably),
* the compiler will issue cautious code even when target is able to correctly handle unaligned memory accesses.
*
* You can force the compiler to use unaligned memory access by uncommenting the line below.
* One of the below scenarios will happen :
* 1 - Your target CPU correctly handle unaligned access, and was not well optimized by compiler (good case).
* You will witness large performance improvements (+50% and up).
* Keep the line uncommented and send a word to upstream (https://groups.google.com/forum/#!forum/lz4c)
* The goal is to automatically detect such situations by adding your target CPU within an exception list.
* 2 - Your target CPU correctly handle unaligned access, and was already already optimized by compiler
* No change will be experienced.
* 3 - Your target CPU inefficiently handle unaligned access.
* You will experience a performance loss. Comment back the line.
* 4 - Your target CPU does not handle unaligned access.
* Program will crash.
* If uncommenting results in better performance (case 1)
* please report your configuration to upstream (https://groups.google.com/forum/#!forum/lz4c)
* An automatic detection macro will be added to match your case within future versions of the library.
*/
/* #define CPU_HAS_EFFICIENT_UNALIGNED_MEMORY_ACCESS 1 */
/**************************************
CPU Feature Detection
**************************************/
/*
* Automated efficient unaligned memory access detection
* Based on known hardware architectures
* This list will be updated thanks to feedbacks
*/
#if defined(CPU_HAS_EFFICIENT_UNALIGNED_MEMORY_ACCESS) \
|| defined(__ARM_FEATURE_UNALIGNED) \
|| defined(__i386__) || defined(__x86_64__) \
|| defined(_M_IX86) || defined(_M_X64) \
|| defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_8__) \
|| (defined(_M_ARM) && (_M_ARM >= 7))
# define LZ4_UNALIGNED_ACCESS 1
#else
# define LZ4_UNALIGNED_ACCESS 0
#endif
/*
* LZ4_FORCE_SW_BITCOUNT
* Define this parameter if your target system or compiler does not support hardware bit count
*/
#if defined(_MSC_VER) && defined(_WIN32_WCE)
/* Visual Studio for Windows CE does not support Hardware bit count */
# define LZ4_FORCE_SW_BITCOUNT
#endif
/**************************************
Compiler Options
**************************************/
#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
/* C99 */
/* "restrict" is a known keyword */
#else
# define restrict
/* Disable restrict */
#endif
#ifdef _MSC_VER
/* Visual Studio */
# define FORCE_INLINE static __forceinline
# include <intrin.h>
# pragma warning(disable : 4127)
/* disable: C4127: conditional expression is constant */
# pragma warning(disable : 4293)
/* disable: C4293: too large shift (32-bits) */
#else
# if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
/* C99 */
# ifdef __GNUC__
# define FORCE_INLINE static inline __attribute__((always_inline))
# else
# define FORCE_INLINE static inline
# endif
# else
# define FORCE_INLINE static
# endif
/* __STDC_VERSION__ */
#endif
/* _MSC_VER */
#define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
#if (GCC_VERSION >= 302) || (__INTEL_COMPILER >= 800) || defined(__clang__)
# define expect(expr,value) (__builtin_expect ((expr),(value)) )
#else
# define expect(expr,value) (expr)
#endif
#define likely(expr) expect((expr) != 0, 1)
#define unlikely(expr) expect((expr) != 0, 0)
/**************************************
Memory routines
**************************************/
#include <stdlib.h>
/* malloc, calloc, free */
#define ALLOCATOR(n,s) calloc(n,s)
#define FREEMEM free
#include <string.h>
/* memset, memcpy */
#define MEM_INIT memset
/**************************************
Includes
**************************************/
#include "lz4.h"
/**************************************
Basic Types
**************************************/
#if defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
/* C99 */
# include <stdint.h>
typedef
uint8_t
BYTE
;
typedef
uint16_t
U16
;
typedef
uint32_t
U32
;
typedef
int32_t
S32
;
typedef
uint64_t
U64
;
#else
typedef
unsigned
char
BYTE
;
typedef
unsigned
short
U16
;
typedef
unsigned
int
U32
;
typedef
signed
int
S32
;
typedef
unsigned
long
long
U64
;
#endif
/**************************************
Reading and writing into memory
**************************************/
#define STEPSIZE sizeof(size_t)
static
unsigned
LZ4_64bits
(
void
)
{
return
sizeof
(
void
*
)
==
8
;
}
static
unsigned
LZ4_isLittleEndian
(
void
)
{
const
union
{
U32
i
;
BYTE
c
[
4
];
}
one
=
{
1
};
/* don't use static : performance detrimental */
return
one
.
c
[
0
];
}
static
U16
LZ4_readLE16
(
const
void
*
memPtr
)
{
if
((
LZ4_UNALIGNED_ACCESS
)
&&
(
LZ4_isLittleEndian
()))
return
*
(
U16
*
)
memPtr
;
else
{
const
BYTE
*
p
=
memPtr
;
return
(
U16
)((
U16
)
p
[
0
]
+
(
p
[
1
]
<<
8
));
}
}
static
void
LZ4_writeLE16
(
void
*
memPtr
,
U16
value
)
{
if
((
LZ4_UNALIGNED_ACCESS
)
&&
(
LZ4_isLittleEndian
()))
{
*
(
U16
*
)
memPtr
=
value
;
return
;
}
else
{
BYTE
*
p
=
memPtr
;
p
[
0
]
=
(
BYTE
)
value
;
p
[
1
]
=
(
BYTE
)(
value
>>
8
);
}
}
static
U16
LZ4_read16
(
const
void
*
memPtr
)
{
if
(
LZ4_UNALIGNED_ACCESS
)
return
*
(
U16
*
)
memPtr
;
else
{
U16
val16
;
memcpy
(
&
val16
,
memPtr
,
2
);
return
val16
;
}
}
static
U32
LZ4_read32
(
const
void
*
memPtr
)
{
if
(
LZ4_UNALIGNED_ACCESS
)
return
*
(
U32
*
)
memPtr
;
else
{
U32
val32
;
memcpy
(
&
val32
,
memPtr
,
4
);
return
val32
;
}
}
static
U64
LZ4_read64
(
const
void
*
memPtr
)
{
if
(
LZ4_UNALIGNED_ACCESS
)
return
*
(
U64
*
)
memPtr
;
else
{
U64
val64
;
memcpy
(
&
val64
,
memPtr
,
8
);
return
val64
;
}
}
static
size_t
LZ4_read_ARCH
(
const
void
*
p
)
{
if
(
LZ4_64bits
())
return
(
size_t
)
LZ4_read64
(
p
);
else
return
(
size_t
)
LZ4_read32
(
p
);
}
static
void
LZ4_copy4
(
void
*
dstPtr
,
const
void
*
srcPtr
)
{
if
(
LZ4_UNALIGNED_ACCESS
)
{
*
(
U32
*
)
dstPtr
=
*
(
U32
*
)
srcPtr
;
return
;
}
memcpy
(
dstPtr
,
srcPtr
,
4
);
}
static
void
LZ4_copy8
(
void
*
dstPtr
,
const
void
*
srcPtr
)
{
#if GCC_VERSION!=409
/* disabled on GCC 4.9, as it generates invalid opcode (crash) */
if
(
LZ4_UNALIGNED_ACCESS
)
{
if
(
LZ4_64bits
())
*
(
U64
*
)
dstPtr
=
*
(
U64
*
)
srcPtr
;
else
((
U32
*
)
dstPtr
)[
0
]
=
((
U32
*
)
srcPtr
)[
0
],
((
U32
*
)
dstPtr
)[
1
]
=
((
U32
*
)
srcPtr
)[
1
];
return
;
}
#endif
memcpy
(
dstPtr
,
srcPtr
,
8
);
}
/* customized version of memcpy, which may overwrite up to 7 bytes beyond dstEnd */
static
void
LZ4_wildCopy
(
void
*
dstPtr
,
const
void
*
srcPtr
,
void
*
dstEnd
)
{
BYTE
*
d
=
dstPtr
;
const
BYTE
*
s
=
srcPtr
;
BYTE
*
e
=
dstEnd
;
do
{
LZ4_copy8
(
d
,
s
);
d
+=
8
;
s
+=
8
;
}
while
(
d
<
e
);
}
/**************************************
Common Constants
**************************************/
#define MINMATCH 4
#define COPYLENGTH 8
#define LASTLITERALS 5
#define MFLIMIT (COPYLENGTH+MINMATCH)
static
const
int
LZ4_minLength
=
(
MFLIMIT
+
1
);
#define KB *(1 <<10)
#define MB *(1 <<20)
#define GB *(1U<<30)
#define MAXD_LOG 16
#define MAX_DISTANCE ((1 << MAXD_LOG) - 1)
#define ML_BITS 4
#define ML_MASK ((1U<<ML_BITS)-1)
#define RUN_BITS (8-ML_BITS)
#define RUN_MASK ((1U<<RUN_BITS)-1)
/**************************************
Common Utils
**************************************/
#define LZ4_STATIC_ASSERT(c) { enum { LZ4_static_assert = 1/(int)(!!(c)) }; }
/* use only *after* variable declarations */
/********************************
Common functions
********************************/
static
unsigned
LZ4_NbCommonBytes
(
register
size_t
val
)
{
if
(
LZ4_isLittleEndian
())
{
if
(
LZ4_64bits
())
{
# if defined(_MSC_VER) && defined(_WIN64) && !defined(LZ4_FORCE_SW_BITCOUNT)
unsigned
long
r
=
0
;
_BitScanForward64
(
&
r
,
(
U64
)
val
);
return
(
int
)(
r
>>
3
);
# elif defined(__GNUC__) && (GCC_VERSION >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT)
return
(
__builtin_ctzll
((
U64
)
val
)
>>
3
);
# else
static
const
int
DeBruijnBytePos
[
64
]
=
{
0
,
0
,
0
,
0
,
0
,
1
,
1
,
2
,
0
,
3
,
1
,
3
,
1
,
4
,
2
,
7
,
0
,
2
,
3
,
6
,
1
,
5
,
3
,
5
,
1
,
3
,
4
,
4
,
2
,
5
,
6
,
7
,
7
,
0
,
1
,
2
,
3
,
3
,
4
,
6
,
2
,
6
,
5
,
5
,
3
,
4
,
5
,
6
,
7
,
1
,
2
,
4
,
6
,
4
,
4
,
5
,
7
,
2
,
6
,
5
,
7
,
6
,
7
,
7
};
return
DeBruijnBytePos
[((
U64
)((
val
&
-
(
long
long
)
val
)
*
0x0218A392CDABBD3FULL
))
>>
58
];
# endif
}
else
/* 32 bits */
{
# if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT)
unsigned
long
r
;
_BitScanForward
(
&
r
,
(
U32
)
val
);
return
(
int
)(
r
>>
3
);
# elif defined(__GNUC__) && (GCC_VERSION >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT)
return
(
__builtin_ctz
((
U32
)
val
)
>>
3
);
# else
static
const
int
DeBruijnBytePos
[
32
]
=
{
0
,
0
,
3
,
0
,
3
,
1
,
3
,
0
,
3
,
2
,
2
,
1
,
3
,
2
,
0
,
1
,
3
,
3
,
1
,
2
,
2
,
2
,
2
,
0
,
3
,
1
,
2
,
0
,
1
,
0
,
1
,
1
};
return
DeBruijnBytePos
[((
U32
)((
val
&
-
(
S32
)
val
)
*
0x077CB531U
))
>>
27
];
# endif
}
}
else
/* Big Endian CPU */
{
if
(
LZ4_64bits
())
{
# if defined(_MSC_VER) && defined(_WIN64) && !defined(LZ4_FORCE_SW_BITCOUNT)
unsigned
long
r
=
0
;
_BitScanReverse64
(
&
r
,
val
);
return
(
unsigned
)(
r
>>
3
);
# elif defined(__GNUC__) && (GCC_VERSION >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT)
return
(
__builtin_clzll
(
val
)
>>
3
);
# else
unsigned
r
;
if
(
!
(
val
>>
32
))
{
r
=
4
;
}
else
{
r
=
0
;
val
>>=
32
;
}
if
(
!
(
val
>>
16
))
{
r
+=
2
;
val
>>=
8
;
}
else
{
val
>>=
24
;
}
r
+=
(
!
val
);
return
r
;
# endif
}
else
/* 32 bits */
{
# if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT)
unsigned
long
r
=
0
;
_BitScanReverse
(
&
r
,
(
unsigned
long
)
val
);
return
(
unsigned
)(
r
>>
3
);
# elif defined(__GNUC__) && (GCC_VERSION >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT)
return
(
__builtin_clz
(
val
)
>>
3
);
# else
unsigned
r
;
if
(
!
(
val
>>
16
))
{
r
=
2
;
val
>>=
8
;
}
else
{
r
=
0
;
val
>>=
24
;
}
r
+=
(
!
val
);
return
r
;
# endif
}
}
}
static
unsigned
LZ4_count
(
const
BYTE
*
pIn
,
const
BYTE
*
pMatch
,
const
BYTE
*
pInLimit
)
{
const
BYTE
*
const
pStart
=
pIn
;
while
(
likely
(
pIn
<
pInLimit
-
(
STEPSIZE
-
1
)))
{
size_t
diff
=
LZ4_read_ARCH
(
pMatch
)
^
LZ4_read_ARCH
(
pIn
);
if
(
!
diff
)
{
pIn
+=
STEPSIZE
;
pMatch
+=
STEPSIZE
;
continue
;
}
pIn
+=
LZ4_NbCommonBytes
(
diff
);
return
(
unsigned
)(
pIn
-
pStart
);
}
if
(
LZ4_64bits
())
if
((
pIn
<
(
pInLimit
-
3
))
&&
(
LZ4_read32
(
pMatch
)
==
LZ4_read32
(
pIn
)))
{
pIn
+=
4
;
pMatch
+=
4
;
}
if
((
pIn
<
(
pInLimit
-
1
))
&&
(
LZ4_read16
(
pMatch
)
==
LZ4_read16
(
pIn
)))
{
pIn
+=
2
;
pMatch
+=
2
;
}
if
((
pIn
<
pInLimit
)
&&
(
*
pMatch
==
*
pIn
))
pIn
++
;
return
(
unsigned
)(
pIn
-
pStart
);
}
#ifndef LZ4_COMMONDEFS_ONLY
/**************************************
Local Constants
**************************************/
#define LZ4_HASHLOG (LZ4_MEMORY_USAGE-2)
#define HASHTABLESIZE (1 << LZ4_MEMORY_USAGE)
#define HASH_SIZE_U32 (1 << LZ4_HASHLOG)
/* required as macro for static allocation */
static
const
int
LZ4_64Klimit
=
((
64
KB
)
+
(
MFLIMIT
-
1
));
static
const
U32
LZ4_skipTrigger
=
6
;
/* Increase this value ==> compression run slower on incompressible data */
/**************************************
Local Utils
**************************************/
int
LZ4_versionNumber
(
void
)
{
return
LZ4_VERSION_NUMBER
;
}
int
LZ4_compressBound
(
int
isize
)
{
return
LZ4_COMPRESSBOUND
(
isize
);
}
/**************************************
Local Structures and types
**************************************/
typedef
struct
{
U32
hashTable
[
HASH_SIZE_U32
];
U32
currentOffset
;
U32
initCheck
;
const
BYTE
*
dictionary
;
const
BYTE
*
bufferStart
;
U32
dictSize
;
}
LZ4_stream_t_internal
;
typedef
enum
{
notLimited
=
0
,
limitedOutput
=
1
}
limitedOutput_directive
;
typedef
enum
{
byPtr
,
byU32
,
byU16
}
tableType_t
;
typedef
enum
{
noDict
=
0
,
withPrefix64k
,
usingExtDict
}
dict_directive
;
typedef
enum
{
noDictIssue
=
0
,
dictSmall
}
dictIssue_directive
;
typedef
enum
{
endOnOutputSize
=
0
,
endOnInputSize
=
1
}
endCondition_directive
;
typedef
enum
{
full
=
0
,
partial
=
1
}
earlyEnd_directive
;
/********************************
Compression functions
********************************/
static
U32
LZ4_hashSequence
(
U32
sequence
,
tableType_t
tableType
)
{
if
(
tableType
==
byU16
)
return
(((
sequence
)
*
2654435761U
)
>>
((
MINMATCH
*
8
)
-
(
LZ4_HASHLOG
+
1
)));
else
return
(((
sequence
)
*
2654435761U
)
>>
((
MINMATCH
*
8
)
-
LZ4_HASHLOG
));
}
static
U32
LZ4_hashPosition
(
const
BYTE
*
p
,
tableType_t
tableType
)
{
return
LZ4_hashSequence
(
LZ4_read32
(
p
),
tableType
);
}
static
void
LZ4_putPositionOnHash
(
const
BYTE
*
p
,
U32
h
,
void
*
tableBase
,
tableType_t
tableType
,
const
BYTE
*
srcBase
)
{
switch
(
tableType
)
{
case
byPtr
:
{
const
BYTE
**
hashTable
=
(
const
BYTE
**
)
tableBase
;
hashTable
[
h
]
=
p
;
return
;
}
case
byU32
:
{
U32
*
hashTable
=
(
U32
*
)
tableBase
;
hashTable
[
h
]
=
(
U32
)(
p
-
srcBase
);
return
;
}
case
byU16
:
{
U16
*
hashTable
=
(
U16
*
)
tableBase
;
hashTable
[
h
]
=
(
U16
)(
p
-
srcBase
);
return
;
}
}
}
static
void
LZ4_putPosition
(
const
BYTE
*
p
,
void
*
tableBase
,
tableType_t
tableType
,
const
BYTE
*
srcBase
)
{
U32
h
=
LZ4_hashPosition
(
p
,
tableType
);
LZ4_putPositionOnHash
(
p
,
h
,
tableBase
,
tableType
,
srcBase
);
}
static
const
BYTE
*
LZ4_getPositionOnHash
(
U32
h
,
void
*
tableBase
,
tableType_t
tableType
,
const
BYTE
*
srcBase
)
{
if
(
tableType
==
byPtr
)
{
const
BYTE
**
hashTable
=
(
const
BYTE
**
)
tableBase
;
return
hashTable
[
h
];
}
if
(
tableType
==
byU32
)
{
U32
*
hashTable
=
(
U32
*
)
tableBase
;
return
hashTable
[
h
]
+
srcBase
;
}
{
U16
*
hashTable
=
(
U16
*
)
tableBase
;
return
hashTable
[
h
]
+
srcBase
;
}
/* default, to ensure a return */
}
static
const
BYTE
*
LZ4_getPosition
(
const
BYTE
*
p
,
void
*
tableBase
,
tableType_t
tableType
,
const
BYTE
*
srcBase
)
{
U32
h
=
LZ4_hashPosition
(
p
,
tableType
);
return
LZ4_getPositionOnHash
(
h
,
tableBase
,
tableType
,
srcBase
);
}
static
int
LZ4_compress_generic
(
void
*
ctx
,
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
maxOutputSize
,
limitedOutput_directive
outputLimited
,
tableType_t
tableType
,
dict_directive
dict
,
dictIssue_directive
dictIssue
)
{
LZ4_stream_t_internal
*
const
dictPtr
=
(
LZ4_stream_t_internal
*
)
ctx
;
const
BYTE
*
ip
=
(
const
BYTE
*
)
source
;
const
BYTE
*
base
;
const
BYTE
*
lowLimit
;
const
BYTE
*
const
lowRefLimit
=
ip
-
dictPtr
->
dictSize
;
const
BYTE
*
const
dictionary
=
dictPtr
->
dictionary
;
const
BYTE
*
const
dictEnd
=
dictionary
+
dictPtr
->
dictSize
;
const
size_t
dictDelta
=
dictEnd
-
(
const
BYTE
*
)
source
;
const
BYTE
*
anchor
=
(
const
BYTE
*
)
source
;
const
BYTE
*
const
iend
=
ip
+
inputSize
;
const
BYTE
*
const
mflimit
=
iend
-
MFLIMIT
;
const
BYTE
*
const
matchlimit
=
iend
-
LASTLITERALS
;
BYTE
*
op
=
(
BYTE
*
)
dest
;
BYTE
*
const
olimit
=
op
+
maxOutputSize
;
U32
forwardH
;
size_t
refDelta
=
0
;
/* Init conditions */
if
((
U32
)
inputSize
>
(
U32
)
LZ4_MAX_INPUT_SIZE
)
return
0
;
/* Unsupported input size, too large (or negative) */
switch
(
dict
)
{
case
noDict
:
default:
base
=
(
const
BYTE
*
)
source
;
lowLimit
=
(
const
BYTE
*
)
source
;
break
;
case
withPrefix64k
:
base
=
(
const
BYTE
*
)
source
-
dictPtr
->
currentOffset
;
lowLimit
=
(
const
BYTE
*
)
source
-
dictPtr
->
dictSize
;
break
;
case
usingExtDict
:
base
=
(
const
BYTE
*
)
source
-
dictPtr
->
currentOffset
;
lowLimit
=
(
const
BYTE
*
)
source
;
break
;
}
if
((
tableType
==
byU16
)
&&
(
inputSize
>=
LZ4_64Klimit
))
return
0
;
/* Size too large (not within 64K limit) */
if
(
inputSize
<
LZ4_minLength
)
goto
_last_literals
;
/* Input too small, no compression (all literals) */
/* First Byte */
LZ4_putPosition
(
ip
,
ctx
,
tableType
,
base
);
ip
++
;
forwardH
=
LZ4_hashPosition
(
ip
,
tableType
);
/* Main Loop */
for
(
;
;
)
{
const
BYTE
*
match
;
BYTE
*
token
;
{
const
BYTE
*
forwardIp
=
ip
;
unsigned
step
=
1
;
unsigned
searchMatchNb
=
(
1U
<<
LZ4_skipTrigger
);
/* Find a match */
do
{
U32
h
=
forwardH
;
ip
=
forwardIp
;
forwardIp
+=
step
;
step
=
searchMatchNb
++
>>
LZ4_skipTrigger
;
if
(
unlikely
(
forwardIp
>
mflimit
))
goto
_last_literals
;
match
=
LZ4_getPositionOnHash
(
h
,
ctx
,
tableType
,
base
);
if
(
dict
==
usingExtDict
)
{
if
(
match
<
(
const
BYTE
*
)
source
)
{
refDelta
=
dictDelta
;
lowLimit
=
dictionary
;
}
else
{
refDelta
=
0
;
lowLimit
=
(
const
BYTE
*
)
source
;
}
}
forwardH
=
LZ4_hashPosition
(
forwardIp
,
tableType
);
LZ4_putPositionOnHash
(
ip
,
h
,
ctx
,
tableType
,
base
);
}
while
(
((
dictIssue
==
dictSmall
)
?
(
match
<
lowRefLimit
)
:
0
)
||
((
tableType
==
byU16
)
?
0
:
(
match
+
MAX_DISTANCE
<
ip
))
||
(
LZ4_read32
(
match
+
refDelta
)
!=
LZ4_read32
(
ip
))
);
}
/* Catch up */
while
((
ip
>
anchor
)
&&
(
match
+
refDelta
>
lowLimit
)
&&
(
unlikely
(
ip
[
-
1
]
==
match
[
refDelta
-
1
])))
{
ip
--
;
match
--
;
}
{
/* Encode Literal length */
unsigned
litLength
=
(
unsigned
)(
ip
-
anchor
);
token
=
op
++
;
if
((
outputLimited
)
&&
(
unlikely
(
op
+
litLength
+
(
2
+
1
+
LASTLITERALS
)
+
(
litLength
/
255
)
>
olimit
)))
return
0
;
/* Check output limit */
if
(
litLength
>=
RUN_MASK
)
{
int
len
=
(
int
)
litLength
-
RUN_MASK
;
*
token
=
(
RUN_MASK
<<
ML_BITS
);
for
(;
len
>=
255
;
len
-=
255
)
*
op
++
=
255
;
*
op
++
=
(
BYTE
)
len
;
}
else
*
token
=
(
BYTE
)(
litLength
<<
ML_BITS
);
/* Copy Literals */
LZ4_wildCopy
(
op
,
anchor
,
op
+
litLength
);
op
+=
litLength
;
}
_next_match:
/* Encode Offset */
LZ4_writeLE16
(
op
,
(
U16
)(
ip
-
match
));
op
+=
2
;
/* Encode MatchLength */
{
unsigned
matchLength
;
if
((
dict
==
usingExtDict
)
&&
(
lowLimit
==
dictionary
))
{
const
BYTE
*
limit
;
match
+=
refDelta
;
limit
=
ip
+
(
dictEnd
-
match
);
if
(
limit
>
matchlimit
)
limit
=
matchlimit
;
matchLength
=
LZ4_count
(
ip
+
MINMATCH
,
match
+
MINMATCH
,
limit
);
ip
+=
MINMATCH
+
matchLength
;
if
(
ip
==
limit
)
{
unsigned
more
=
LZ4_count
(
ip
,
(
const
BYTE
*
)
source
,
matchlimit
);
matchLength
+=
more
;
ip
+=
more
;
}
}
else
{
matchLength
=
LZ4_count
(
ip
+
MINMATCH
,
match
+
MINMATCH
,
matchlimit
);
ip
+=
MINMATCH
+
matchLength
;
}
if
((
outputLimited
)
&&
(
unlikely
(
op
+
(
1
+
LASTLITERALS
)
+
(
matchLength
>>
8
)
>
olimit
)))
return
0
;
/* Check output limit */
if
(
matchLength
>=
ML_MASK
)
{
*
token
+=
ML_MASK
;
matchLength
-=
ML_MASK
;
for
(;
matchLength
>=
510
;
matchLength
-=
510
)
{
*
op
++
=
255
;
*
op
++
=
255
;
}
if
(
matchLength
>=
255
)
{
matchLength
-=
255
;
*
op
++
=
255
;
}
*
op
++
=
(
BYTE
)
matchLength
;
}
else
*
token
+=
(
BYTE
)(
matchLength
);
}
anchor
=
ip
;
/* Test end of chunk */
if
(
ip
>
mflimit
)
break
;
/* Fill table */
LZ4_putPosition
(
ip
-
2
,
ctx
,
tableType
,
base
);
/* Test next position */
match
=
LZ4_getPosition
(
ip
,
ctx
,
tableType
,
base
);
if
(
dict
==
usingExtDict
)
{
if
(
match
<
(
const
BYTE
*
)
source
)
{
refDelta
=
dictDelta
;
lowLimit
=
dictionary
;
}
else
{
refDelta
=
0
;
lowLimit
=
(
const
BYTE
*
)
source
;
}
}
LZ4_putPosition
(
ip
,
ctx
,
tableType
,
base
);
if
(
((
dictIssue
==
dictSmall
)
?
(
match
>=
lowRefLimit
)
:
1
)
&&
(
match
+
MAX_DISTANCE
>=
ip
)
&&
(
LZ4_read32
(
match
+
refDelta
)
==
LZ4_read32
(
ip
))
)
{
token
=
op
++
;
*
token
=
0
;
goto
_next_match
;
}
/* Prepare next loop */
forwardH
=
LZ4_hashPosition
(
++
ip
,
tableType
);
}
_last_literals:
/* Encode Last Literals */
{
int
lastRun
=
(
int
)(
iend
-
anchor
);
if
((
outputLimited
)
&&
(((
char
*
)
op
-
dest
)
+
lastRun
+
1
+
((
lastRun
+
255
-
RUN_MASK
)
/
255
)
>
(
U32
)
maxOutputSize
))
return
0
;
/* Check output limit */
if
(
lastRun
>=
(
int
)
RUN_MASK
)
{
*
op
++=
(
RUN_MASK
<<
ML_BITS
);
lastRun
-=
RUN_MASK
;
for
(;
lastRun
>=
255
;
lastRun
-=
255
)
*
op
++
=
255
;
*
op
++
=
(
BYTE
)
lastRun
;
}
else
*
op
++
=
(
BYTE
)(
lastRun
<<
ML_BITS
);
memcpy
(
op
,
anchor
,
iend
-
anchor
);
op
+=
iend
-
anchor
;
}
/* End */
return
(
int
)
(((
char
*
)
op
)
-
dest
);
}
int
LZ4_compress
(
const
char
*
source
,
char
*
dest
,
int
inputSize
)
{
#if (HEAPMODE)
void
*
ctx
=
ALLOCATOR
(
LZ4_STREAMSIZE_U64
,
8
);
/* Aligned on 8-bytes boundaries */
#else
U64
ctx
[
LZ4_STREAMSIZE_U64
]
=
{
0
};
/* Ensure data is aligned on 8-bytes boundaries */
#endif
int
result
;
if
(
inputSize
<
LZ4_64Klimit
)
result
=
LZ4_compress_generic
((
void
*
)
ctx
,
source
,
dest
,
inputSize
,
0
,
notLimited
,
byU16
,
noDict
,
noDictIssue
);
else
result
=
LZ4_compress_generic
((
void
*
)
ctx
,
source
,
dest
,
inputSize
,
0
,
notLimited
,
LZ4_64bits
()
?
byU32
:
byPtr
,
noDict
,
noDictIssue
);
#if (HEAPMODE)
FREEMEM
(
ctx
);
#endif
return
result
;
}
int
LZ4_compress_limitedOutput
(
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
maxOutputSize
)
{
#if (HEAPMODE)
void
*
ctx
=
ALLOCATOR
(
LZ4_STREAMSIZE_U64
,
8
);
/* Aligned on 8-bytes boundaries */
#else
U64
ctx
[
LZ4_STREAMSIZE_U64
]
=
{
0
};
/* Ensure data is aligned on 8-bytes boundaries */
#endif
int
result
;
if
(
inputSize
<
LZ4_64Klimit
)
result
=
LZ4_compress_generic
((
void
*
)
ctx
,
source
,
dest
,
inputSize
,
maxOutputSize
,
limitedOutput
,
byU16
,
noDict
,
noDictIssue
);
else
result
=
LZ4_compress_generic
((
void
*
)
ctx
,
source
,
dest
,
inputSize
,
maxOutputSize
,
limitedOutput
,
LZ4_64bits
()
?
byU32
:
byPtr
,
noDict
,
noDictIssue
);
#if (HEAPMODE)
FREEMEM
(
ctx
);
#endif
return
result
;
}
/*****************************************
Experimental : Streaming functions
*****************************************/
/*
* LZ4_initStream
* Use this function once, to init a newly allocated LZ4_stream_t structure
* Return : 1 if OK, 0 if error
*/
void
LZ4_resetStream
(
LZ4_stream_t
*
LZ4_stream
)
{
MEM_INIT
(
LZ4_stream
,
0
,
sizeof
(
LZ4_stream_t
));
}
LZ4_stream_t
*
LZ4_createStream
(
void
)
{
LZ4_stream_t
*
lz4s
=
(
LZ4_stream_t
*
)
ALLOCATOR
(
8
,
LZ4_STREAMSIZE_U64
);
LZ4_STATIC_ASSERT
(
LZ4_STREAMSIZE
>=
sizeof
(
LZ4_stream_t_internal
));
/* A compilation error here means LZ4_STREAMSIZE is not large enough */
LZ4_resetStream
(
lz4s
);
return
lz4s
;
}
int
LZ4_freeStream
(
LZ4_stream_t
*
LZ4_stream
)
{
FREEMEM
(
LZ4_stream
);
return
(
0
);
}
int
LZ4_loadDict
(
LZ4_stream_t
*
LZ4_dict
,
const
char
*
dictionary
,
int
dictSize
)
{
LZ4_stream_t_internal
*
dict
=
(
LZ4_stream_t_internal
*
)
LZ4_dict
;
const
BYTE
*
p
=
(
const
BYTE
*
)
dictionary
;
const
BYTE
*
const
dictEnd
=
p
+
dictSize
;
const
BYTE
*
base
;
if
(
dict
->
initCheck
)
LZ4_resetStream
(
LZ4_dict
);
/* Uninitialized structure detected */
if
(
dictSize
<
MINMATCH
)
{
dict
->
dictionary
=
NULL
;
dict
->
dictSize
=
0
;
return
0
;
}
if
(
p
<=
dictEnd
-
64
KB
)
p
=
dictEnd
-
64
KB
;
base
=
p
-
dict
->
currentOffset
;
dict
->
dictionary
=
p
;
dict
->
dictSize
=
(
U32
)(
dictEnd
-
p
);
dict
->
currentOffset
+=
dict
->
dictSize
;
while
(
p
<=
dictEnd
-
MINMATCH
)
{
LZ4_putPosition
(
p
,
dict
,
byU32
,
base
);
p
+=
3
;
}
return
dict
->
dictSize
;
}
static
void
LZ4_renormDictT
(
LZ4_stream_t_internal
*
LZ4_dict
,
const
BYTE
*
src
)
{
if
((
LZ4_dict
->
currentOffset
>
0x80000000
)
||
((
size_t
)
LZ4_dict
->
currentOffset
>
(
size_t
)
src
))
/* address space overflow */
{
/* rescale hash table */
U32
delta
=
LZ4_dict
->
currentOffset
-
64
KB
;
const
BYTE
*
dictEnd
=
LZ4_dict
->
dictionary
+
LZ4_dict
->
dictSize
;
int
i
;
for
(
i
=
0
;
i
<
HASH_SIZE_U32
;
i
++
)
{
if
(
LZ4_dict
->
hashTable
[
i
]
<
delta
)
LZ4_dict
->
hashTable
[
i
]
=
0
;
else
LZ4_dict
->
hashTable
[
i
]
-=
delta
;
}
LZ4_dict
->
currentOffset
=
64
KB
;
if
(
LZ4_dict
->
dictSize
>
64
KB
)
LZ4_dict
->
dictSize
=
64
KB
;
LZ4_dict
->
dictionary
=
dictEnd
-
LZ4_dict
->
dictSize
;
}
}
FORCE_INLINE
int
LZ4_compress_continue_generic
(
void
*
LZ4_stream
,
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
maxOutputSize
,
limitedOutput_directive
limit
)
{
LZ4_stream_t_internal
*
streamPtr
=
(
LZ4_stream_t_internal
*
)
LZ4_stream
;
const
BYTE
*
const
dictEnd
=
streamPtr
->
dictionary
+
streamPtr
->
dictSize
;
const
BYTE
*
smallest
=
(
const
BYTE
*
)
source
;
if
(
streamPtr
->
initCheck
)
return
0
;
/* Uninitialized structure detected */
if
((
streamPtr
->
dictSize
>
0
)
&&
(
smallest
>
dictEnd
))
smallest
=
dictEnd
;
LZ4_renormDictT
(
streamPtr
,
smallest
);
/* Check overlapping input/dictionary space */
{
const
BYTE
*
sourceEnd
=
(
const
BYTE
*
)
source
+
inputSize
;
if
((
sourceEnd
>
streamPtr
->
dictionary
)
&&
(
sourceEnd
<
dictEnd
))
{
streamPtr
->
dictSize
=
(
U32
)(
dictEnd
-
sourceEnd
);
if
(
streamPtr
->
dictSize
>
64
KB
)
streamPtr
->
dictSize
=
64
KB
;
if
(
streamPtr
->
dictSize
<
4
)
streamPtr
->
dictSize
=
0
;
streamPtr
->
dictionary
=
dictEnd
-
streamPtr
->
dictSize
;
}
}
/* prefix mode : source data follows dictionary */
if
(
dictEnd
==
(
const
BYTE
*
)
source
)
{
int
result
;
if
((
streamPtr
->
dictSize
<
64
KB
)
&&
(
streamPtr
->
dictSize
<
streamPtr
->
currentOffset
))
result
=
LZ4_compress_generic
(
LZ4_stream
,
source
,
dest
,
inputSize
,
maxOutputSize
,
limit
,
byU32
,
withPrefix64k
,
dictSmall
);
else
result
=
LZ4_compress_generic
(
LZ4_stream
,
source
,
dest
,
inputSize
,
maxOutputSize
,
limit
,
byU32
,
withPrefix64k
,
noDictIssue
);
streamPtr
->
dictSize
+=
(
U32
)
inputSize
;
streamPtr
->
currentOffset
+=
(
U32
)
inputSize
;
return
result
;
}
/* external dictionary mode */
{
int
result
;
if
((
streamPtr
->
dictSize
<
64
KB
)
&&
(
streamPtr
->
dictSize
<
streamPtr
->
currentOffset
))
result
=
LZ4_compress_generic
(
LZ4_stream
,
source
,
dest
,
inputSize
,
maxOutputSize
,
limit
,
byU32
,
usingExtDict
,
dictSmall
);
else
result
=
LZ4_compress_generic
(
LZ4_stream
,
source
,
dest
,
inputSize
,
maxOutputSize
,
limit
,
byU32
,
usingExtDict
,
noDictIssue
);
streamPtr
->
dictionary
=
(
const
BYTE
*
)
source
;
streamPtr
->
dictSize
=
(
U32
)
inputSize
;
streamPtr
->
currentOffset
+=
(
U32
)
inputSize
;
return
result
;
}
}
int
LZ4_compress_continue
(
LZ4_stream_t
*
LZ4_stream
,
const
char
*
source
,
char
*
dest
,
int
inputSize
)
{
return
LZ4_compress_continue_generic
(
LZ4_stream
,
source
,
dest
,
inputSize
,
0
,
notLimited
);
}
int
LZ4_compress_limitedOutput_continue
(
LZ4_stream_t
*
LZ4_stream
,
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
maxOutputSize
)
{
return
LZ4_compress_continue_generic
(
LZ4_stream
,
source
,
dest
,
inputSize
,
maxOutputSize
,
limitedOutput
);
}
/* Hidden debug function, to force separate dictionary mode */
int
LZ4_compress_forceExtDict
(
LZ4_stream_t
*
LZ4_dict
,
const
char
*
source
,
char
*
dest
,
int
inputSize
)
{
LZ4_stream_t_internal
*
streamPtr
=
(
LZ4_stream_t_internal
*
)
LZ4_dict
;
int
result
;
const
BYTE
*
const
dictEnd
=
streamPtr
->
dictionary
+
streamPtr
->
dictSize
;
const
BYTE
*
smallest
=
dictEnd
;
if
(
smallest
>
(
const
BYTE
*
)
source
)
smallest
=
(
const
BYTE
*
)
source
;
LZ4_renormDictT
((
LZ4_stream_t_internal
*
)
LZ4_dict
,
smallest
);
result
=
LZ4_compress_generic
(
LZ4_dict
,
source
,
dest
,
inputSize
,
0
,
notLimited
,
byU32
,
usingExtDict
,
noDictIssue
);
streamPtr
->
dictionary
=
(
const
BYTE
*
)
source
;
streamPtr
->
dictSize
=
(
U32
)
inputSize
;
streamPtr
->
currentOffset
+=
(
U32
)
inputSize
;
return
result
;
}
int
LZ4_saveDict
(
LZ4_stream_t
*
LZ4_dict
,
char
*
safeBuffer
,
int
dictSize
)
{
LZ4_stream_t_internal
*
dict
=
(
LZ4_stream_t_internal
*
)
LZ4_dict
;
const
BYTE
*
previousDictEnd
=
dict
->
dictionary
+
dict
->
dictSize
;
if
((
U32
)
dictSize
>
64
KB
)
dictSize
=
64
KB
;
/* useless to define a dictionary > 64 KB */
if
((
U32
)
dictSize
>
dict
->
dictSize
)
dictSize
=
dict
->
dictSize
;
memmove
(
safeBuffer
,
previousDictEnd
-
dictSize
,
dictSize
);
dict
->
dictionary
=
(
const
BYTE
*
)
safeBuffer
;
dict
->
dictSize
=
(
U32
)
dictSize
;
return
dictSize
;
}
/****************************
Decompression functions
****************************/
/*
* This generic decompression function cover all use cases.
* It shall be instantiated several times, using different sets of directives
* Note that it is essential this generic function is really inlined,
* in order to remove useless branches during compilation optimization.
*/
FORCE_INLINE
int
LZ4_decompress_generic
(
const
char
*
const
source
,
char
*
const
dest
,
int
inputSize
,
int
outputSize
,
/* If endOnInput==endOnInputSize, this value is the max size of Output Buffer. */
int
endOnInput
,
/* endOnOutputSize, endOnInputSize */
int
partialDecoding
,
/* full, partial */
int
targetOutputSize
,
/* only used if partialDecoding==partial */
int
dict
,
/* noDict, withPrefix64k, usingExtDict */
const
BYTE
*
const
lowPrefix
,
/* == dest if dict == noDict */
const
BYTE
*
const
dictStart
,
/* only if dict==usingExtDict */
const
size_t
dictSize
/* note : = 0 if noDict */
)
{
/* Local Variables */
const
BYTE
*
restrict
ip
=
(
const
BYTE
*
)
source
;
const
BYTE
*
const
iend
=
ip
+
inputSize
;
BYTE
*
op
=
(
BYTE
*
)
dest
;
BYTE
*
const
oend
=
op
+
outputSize
;
BYTE
*
cpy
;
BYTE
*
oexit
=
op
+
targetOutputSize
;
const
BYTE
*
const
lowLimit
=
lowPrefix
-
dictSize
;
const
BYTE
*
const
dictEnd
=
(
const
BYTE
*
)
dictStart
+
dictSize
;
const
size_t
dec32table
[]
=
{
4
,
1
,
2
,
1
,
4
,
4
,
4
,
4
};
const
size_t
dec64table
[]
=
{
0
,
0
,
0
,
(
size_t
)
-
1
,
0
,
1
,
2
,
3
};
const
int
safeDecode
=
(
endOnInput
==
endOnInputSize
);
const
int
checkOffset
=
((
safeDecode
)
&&
(
dictSize
<
(
int
)(
64
KB
)));
/* Special cases */
if
((
partialDecoding
)
&&
(
oexit
>
oend
-
MFLIMIT
))
oexit
=
oend
-
MFLIMIT
;
/* targetOutputSize too high => decode everything */
if
((
endOnInput
)
&&
(
unlikely
(
outputSize
==
0
)))
return
((
inputSize
==
1
)
&&
(
*
ip
==
0
))
?
0
:
-
1
;
/* Empty output buffer */
if
((
!
endOnInput
)
&&
(
unlikely
(
outputSize
==
0
)))
return
(
*
ip
==
0
?
1
:-
1
);
/* Main Loop */
while
(
1
)
{
unsigned
token
;
size_t
length
;
const
BYTE
*
match
;
/* get literal length */
token
=
*
ip
++
;
if
((
length
=
(
token
>>
ML_BITS
))
==
RUN_MASK
)
{
unsigned
s
;
do
{
s
=
*
ip
++
;
length
+=
s
;
}
while
(
likely
((
endOnInput
)
?
ip
<
iend
-
RUN_MASK
:
1
)
&&
(
s
==
255
));
if
((
safeDecode
)
&&
unlikely
((
size_t
)(
op
+
length
)
<
(
size_t
)(
op
)))
goto
_output_error
;
/* overflow detection */
if
((
safeDecode
)
&&
unlikely
((
size_t
)(
ip
+
length
)
<
(
size_t
)(
ip
)))
goto
_output_error
;
/* overflow detection */
}
/* copy literals */
cpy
=
op
+
length
;
if
(((
endOnInput
)
&&
((
cpy
>
(
partialDecoding
?
oexit
:
oend
-
MFLIMIT
))
||
(
ip
+
length
>
iend
-
(
2
+
1
+
LASTLITERALS
)))
)
||
((
!
endOnInput
)
&&
(
cpy
>
oend
-
COPYLENGTH
)))
{
if
(
partialDecoding
)
{
if
(
cpy
>
oend
)
goto
_output_error
;
/* Error : write attempt beyond end of output buffer */
if
((
endOnInput
)
&&
(
ip
+
length
>
iend
))
goto
_output_error
;
/* Error : read attempt beyond end of input buffer */
}
else
{
if
((
!
endOnInput
)
&&
(
cpy
!=
oend
))
goto
_output_error
;
/* Error : block decoding must stop exactly there */
if
((
endOnInput
)
&&
((
ip
+
length
!=
iend
)
||
(
cpy
>
oend
)))
goto
_output_error
;
/* Error : input must be consumed */
}
memcpy
(
op
,
ip
,
length
);
ip
+=
length
;
op
+=
length
;
break
;
/* Necessarily EOF, due to parsing restrictions */
}
LZ4_wildCopy
(
op
,
ip
,
cpy
);
ip
+=
length
;
op
=
cpy
;
/* get offset */
match
=
cpy
-
LZ4_readLE16
(
ip
);
ip
+=
2
;
if
((
checkOffset
)
&&
(
unlikely
(
match
<
lowLimit
)))
goto
_output_error
;
/* Error : offset outside destination buffer */
/* get matchlength */
length
=
token
&
ML_MASK
;
if
(
length
==
ML_MASK
)
{
unsigned
s
;
do
{
if
((
endOnInput
)
&&
(
ip
>
iend
-
LASTLITERALS
))
goto
_output_error
;
s
=
*
ip
++
;
length
+=
s
;
}
while
(
s
==
255
);
if
((
safeDecode
)
&&
unlikely
((
size_t
)(
op
+
length
)
<
(
size_t
)
op
))
goto
_output_error
;
/* overflow detection */
}
length
+=
MINMATCH
;
/* check external dictionary */
if
((
dict
==
usingExtDict
)
&&
(
match
<
lowPrefix
))
{
if
(
unlikely
(
op
+
length
>
oend
-
LASTLITERALS
))
goto
_output_error
;
/* doesn't respect parsing restriction */
if
(
length
<=
(
size_t
)(
lowPrefix
-
match
))
{
/* match can be copied as a single segment from external dictionary */
match
=
dictEnd
-
(
lowPrefix
-
match
);
memcpy
(
op
,
match
,
length
);
op
+=
length
;
}
else
{
/* match encompass external dictionary and current segment */
size_t
copySize
=
(
size_t
)(
lowPrefix
-
match
);
memcpy
(
op
,
dictEnd
-
copySize
,
copySize
);
op
+=
copySize
;
copySize
=
length
-
copySize
;
if
(
copySize
>
(
size_t
)(
op
-
lowPrefix
))
/* overlap within current segment */
{
BYTE
*
const
endOfMatch
=
op
+
copySize
;
const
BYTE
*
copyFrom
=
lowPrefix
;
while
(
op
<
endOfMatch
)
*
op
++
=
*
copyFrom
++
;
}
else
{
memcpy
(
op
,
lowPrefix
,
copySize
);
op
+=
copySize
;
}
}
continue
;
}
/* copy repeated sequence */
cpy
=
op
+
length
;
if
(
unlikely
((
op
-
match
)
<
8
))
{
const
size_t
dec64
=
dec64table
[
op
-
match
];
op
[
0
]
=
match
[
0
];
op
[
1
]
=
match
[
1
];
op
[
2
]
=
match
[
2
];
op
[
3
]
=
match
[
3
];
match
+=
dec32table
[
op
-
match
];
LZ4_copy4
(
op
+
4
,
match
);
op
+=
8
;
match
-=
dec64
;
}
else
{
LZ4_copy8
(
op
,
match
);
op
+=
8
;
match
+=
8
;
}
if
(
unlikely
(
cpy
>
oend
-
12
))
{
if
(
cpy
>
oend
-
LASTLITERALS
)
goto
_output_error
;
/* Error : last LASTLITERALS bytes must be literals */
if
(
op
<
oend
-
8
)
{
LZ4_wildCopy
(
op
,
match
,
oend
-
8
);
match
+=
(
oend
-
8
)
-
op
;
op
=
oend
-
8
;
}
while
(
op
<
cpy
)
*
op
++
=
*
match
++
;
}
else
LZ4_wildCopy
(
op
,
match
,
cpy
);
op
=
cpy
;
/* correction */
}
/* end of decoding */
if
(
endOnInput
)
return
(
int
)
(((
char
*
)
op
)
-
dest
);
/* Nb of output bytes decoded */
else
return
(
int
)
(((
char
*
)
ip
)
-
source
);
/* Nb of input bytes read */
/* Overflow error detected */
_output_error:
return
(
int
)
(
-
(((
char
*
)
ip
)
-
source
))
-
1
;
}
int
LZ4_decompress_safe
(
const
char
*
source
,
char
*
dest
,
int
compressedSize
,
int
maxDecompressedSize
)
{
return
LZ4_decompress_generic
(
source
,
dest
,
compressedSize
,
maxDecompressedSize
,
endOnInputSize
,
full
,
0
,
noDict
,
(
BYTE
*
)
dest
,
NULL
,
0
);
}
int
LZ4_decompress_safe_partial
(
const
char
*
source
,
char
*
dest
,
int
compressedSize
,
int
targetOutputSize
,
int
maxDecompressedSize
)
{
return
LZ4_decompress_generic
(
source
,
dest
,
compressedSize
,
maxDecompressedSize
,
endOnInputSize
,
partial
,
targetOutputSize
,
noDict
,
(
BYTE
*
)
dest
,
NULL
,
0
);
}
int
LZ4_decompress_fast
(
const
char
*
source
,
char
*
dest
,
int
originalSize
)
{
return
LZ4_decompress_generic
(
source
,
dest
,
0
,
originalSize
,
endOnOutputSize
,
full
,
0
,
withPrefix64k
,
(
BYTE
*
)(
dest
-
64
KB
),
NULL
,
64
KB
);
}
/* streaming decompression functions */
typedef
struct
{
BYTE
*
externalDict
;
size_t
extDictSize
;
BYTE
*
prefixEnd
;
size_t
prefixSize
;
}
LZ4_streamDecode_t_internal
;
/*
* If you prefer dynamic allocation methods,
* LZ4_createStreamDecode()
* provides a pointer (void*) towards an initialized LZ4_streamDecode_t structure.
*/
LZ4_streamDecode_t
*
LZ4_createStreamDecode
(
void
)
{
LZ4_streamDecode_t
*
lz4s
=
(
LZ4_streamDecode_t
*
)
ALLOCATOR
(
sizeof
(
U64
),
LZ4_STREAMDECODESIZE_U64
);
return
lz4s
;
}
int
LZ4_freeStreamDecode
(
LZ4_streamDecode_t
*
LZ4_stream
)
{
FREEMEM
(
LZ4_stream
);
return
0
;
}
/*
* LZ4_setStreamDecode
* Use this function to instruct where to find the dictionary
* This function is not necessary if previous data is still available where it was decoded.
* Loading a size of 0 is allowed (same effect as no dictionary).
* Return : 1 if OK, 0 if error
*/
int
LZ4_setStreamDecode
(
LZ4_streamDecode_t
*
LZ4_streamDecode
,
const
char
*
dictionary
,
int
dictSize
)
{
LZ4_streamDecode_t_internal
*
lz4sd
=
(
LZ4_streamDecode_t_internal
*
)
LZ4_streamDecode
;
lz4sd
->
prefixSize
=
(
size_t
)
dictSize
;
lz4sd
->
prefixEnd
=
(
BYTE
*
)
dictionary
+
dictSize
;
lz4sd
->
externalDict
=
NULL
;
lz4sd
->
extDictSize
=
0
;
return
1
;
}
/*
*_continue() :
These decoding functions allow decompression of multiple blocks in "streaming" mode.
Previously decoded blocks must still be available at the memory position where they were decoded.
If it's not possible, save the relevant part of decoded data into a safe buffer,
and indicate where it stands using LZ4_setStreamDecode()
*/
int
LZ4_decompress_safe_continue
(
LZ4_streamDecode_t
*
LZ4_streamDecode
,
const
char
*
source
,
char
*
dest
,
int
compressedSize
,
int
maxOutputSize
)
{
LZ4_streamDecode_t_internal
*
lz4sd
=
(
LZ4_streamDecode_t_internal
*
)
LZ4_streamDecode
;
int
result
;
if
(
lz4sd
->
prefixEnd
==
(
BYTE
*
)
dest
)
{
result
=
LZ4_decompress_generic
(
source
,
dest
,
compressedSize
,
maxOutputSize
,
endOnInputSize
,
full
,
0
,
usingExtDict
,
lz4sd
->
prefixEnd
-
lz4sd
->
prefixSize
,
lz4sd
->
externalDict
,
lz4sd
->
extDictSize
);
if
(
result
<=
0
)
return
result
;
lz4sd
->
prefixSize
+=
result
;
lz4sd
->
prefixEnd
+=
result
;
}
else
{
lz4sd
->
extDictSize
=
lz4sd
->
prefixSize
;
lz4sd
->
externalDict
=
lz4sd
->
prefixEnd
-
lz4sd
->
extDictSize
;
result
=
LZ4_decompress_generic
(
source
,
dest
,
compressedSize
,
maxOutputSize
,
endOnInputSize
,
full
,
0
,
usingExtDict
,
(
BYTE
*
)
dest
,
lz4sd
->
externalDict
,
lz4sd
->
extDictSize
);
if
(
result
<=
0
)
return
result
;
lz4sd
->
prefixSize
=
result
;
lz4sd
->
prefixEnd
=
(
BYTE
*
)
dest
+
result
;
}
return
result
;
}
int
LZ4_decompress_fast_continue
(
LZ4_streamDecode_t
*
LZ4_streamDecode
,
const
char
*
source
,
char
*
dest
,
int
originalSize
)
{
LZ4_streamDecode_t_internal
*
lz4sd
=
(
LZ4_streamDecode_t_internal
*
)
LZ4_streamDecode
;
int
result
;
if
(
lz4sd
->
prefixEnd
==
(
BYTE
*
)
dest
)
{
result
=
LZ4_decompress_generic
(
source
,
dest
,
0
,
originalSize
,
endOnOutputSize
,
full
,
0
,
usingExtDict
,
lz4sd
->
prefixEnd
-
lz4sd
->
prefixSize
,
lz4sd
->
externalDict
,
lz4sd
->
extDictSize
);
if
(
result
<=
0
)
return
result
;
lz4sd
->
prefixSize
+=
originalSize
;
lz4sd
->
prefixEnd
+=
originalSize
;
}
else
{
lz4sd
->
extDictSize
=
lz4sd
->
prefixSize
;
lz4sd
->
externalDict
=
(
BYTE
*
)
dest
-
lz4sd
->
extDictSize
;
result
=
LZ4_decompress_generic
(
source
,
dest
,
0
,
originalSize
,
endOnOutputSize
,
full
,
0
,
usingExtDict
,
(
BYTE
*
)
dest
,
lz4sd
->
externalDict
,
lz4sd
->
extDictSize
);
if
(
result
<=
0
)
return
result
;
lz4sd
->
prefixSize
=
originalSize
;
lz4sd
->
prefixEnd
=
(
BYTE
*
)
dest
+
originalSize
;
}
return
result
;
}
/*
Advanced decoding functions :
*_usingDict() :
These decoding functions work the same as "_continue" ones,
the dictionary must be explicitly provided within parameters
*/
FORCE_INLINE
int
LZ4_decompress_usingDict_generic
(
const
char
*
source
,
char
*
dest
,
int
compressedSize
,
int
maxOutputSize
,
int
safe
,
const
char
*
dictStart
,
int
dictSize
)
{
if
(
dictSize
==
0
)
return
LZ4_decompress_generic
(
source
,
dest
,
compressedSize
,
maxOutputSize
,
safe
,
full
,
0
,
noDict
,
(
BYTE
*
)
dest
,
NULL
,
0
);
if
(
dictStart
+
dictSize
==
dest
)
{
if
(
dictSize
>=
(
int
)(
64
KB
-
1
))
return
LZ4_decompress_generic
(
source
,
dest
,
compressedSize
,
maxOutputSize
,
safe
,
full
,
0
,
withPrefix64k
,
(
BYTE
*
)
dest
-
64
KB
,
NULL
,
0
);
return
LZ4_decompress_generic
(
source
,
dest
,
compressedSize
,
maxOutputSize
,
safe
,
full
,
0
,
noDict
,
(
BYTE
*
)
dest
-
dictSize
,
NULL
,
0
);
}
return
LZ4_decompress_generic
(
source
,
dest
,
compressedSize
,
maxOutputSize
,
safe
,
full
,
0
,
usingExtDict
,
(
BYTE
*
)
dest
,
(
BYTE
*
)
dictStart
,
dictSize
);
}
int
LZ4_decompress_safe_usingDict
(
const
char
*
source
,
char
*
dest
,
int
compressedSize
,
int
maxOutputSize
,
const
char
*
dictStart
,
int
dictSize
)
{
return
LZ4_decompress_usingDict_generic
(
source
,
dest
,
compressedSize
,
maxOutputSize
,
1
,
dictStart
,
dictSize
);
}
int
LZ4_decompress_fast_usingDict
(
const
char
*
source
,
char
*
dest
,
int
originalSize
,
const
char
*
dictStart
,
int
dictSize
)
{
return
LZ4_decompress_usingDict_generic
(
source
,
dest
,
0
,
originalSize
,
0
,
dictStart
,
dictSize
);
}
/* debug function */
int
LZ4_decompress_safe_forceExtDict
(
const
char
*
source
,
char
*
dest
,
int
compressedSize
,
int
maxOutputSize
,
const
char
*
dictStart
,
int
dictSize
)
{
return
LZ4_decompress_generic
(
source
,
dest
,
compressedSize
,
maxOutputSize
,
endOnInputSize
,
full
,
0
,
usingExtDict
,
(
BYTE
*
)
dest
,
(
BYTE
*
)
dictStart
,
dictSize
);
}
/***************************************************
Obsolete Functions
***************************************************/
/*
These function names are deprecated and should no longer be used.
They are only provided here for compatibility with older user programs.
- LZ4_uncompress is totally equivalent to LZ4_decompress_fast
- LZ4_uncompress_unknownOutputSize is totally equivalent to LZ4_decompress_safe
*/
int
LZ4_uncompress
(
const
char
*
source
,
char
*
dest
,
int
outputSize
)
{
return
LZ4_decompress_fast
(
source
,
dest
,
outputSize
);
}
int
LZ4_uncompress_unknownOutputSize
(
const
char
*
source
,
char
*
dest
,
int
isize
,
int
maxOutputSize
)
{
return
LZ4_decompress_safe
(
source
,
dest
,
isize
,
maxOutputSize
);
}
/* Obsolete Streaming functions */
int
LZ4_sizeofStreamState
()
{
return
LZ4_STREAMSIZE
;
}
static
void
LZ4_init
(
LZ4_stream_t_internal
*
lz4ds
,
const
BYTE
*
base
)
{
MEM_INIT
(
lz4ds
,
0
,
LZ4_STREAMSIZE
);
lz4ds
->
bufferStart
=
base
;
}
int
LZ4_resetStreamState
(
void
*
state
,
const
char
*
inputBuffer
)
{
if
((((
size_t
)
state
)
&
3
)
!=
0
)
return
1
;
/* Error : pointer is not aligned on 4-bytes boundary */
LZ4_init
((
LZ4_stream_t_internal
*
)
state
,
(
const
BYTE
*
)
inputBuffer
);
return
0
;
}
void
*
LZ4_create
(
const
char
*
inputBuffer
)
{
void
*
lz4ds
=
ALLOCATOR
(
8
,
LZ4_STREAMSIZE_U64
);
LZ4_init
((
LZ4_stream_t_internal
*
)
lz4ds
,
(
const
BYTE
*
)
inputBuffer
);
return
lz4ds
;
}
char
*
LZ4_slideInputBuffer
(
void
*
LZ4_Data
)
{
LZ4_stream_t_internal
*
ctx
=
(
LZ4_stream_t_internal
*
)
LZ4_Data
;
int
dictSize
=
LZ4_saveDict
((
LZ4_stream_t
*
)
ctx
,
(
char
*
)
ctx
->
bufferStart
,
64
KB
);
return
(
char
*
)(
ctx
->
bufferStart
+
dictSize
);
}
/* Obsolete compresson functions using User-allocated state */
int
LZ4_sizeofState
()
{
return
LZ4_STREAMSIZE
;
}
int
LZ4_compress_withState
(
void
*
state
,
const
char
*
source
,
char
*
dest
,
int
inputSize
)
{
if
(((
size_t
)(
state
)
&
3
)
!=
0
)
return
0
;
/* Error : state is not aligned on 4-bytes boundary */
MEM_INIT
(
state
,
0
,
LZ4_STREAMSIZE
);
if
(
inputSize
<
LZ4_64Klimit
)
return
LZ4_compress_generic
(
state
,
source
,
dest
,
inputSize
,
0
,
notLimited
,
byU16
,
noDict
,
noDictIssue
);
else
return
LZ4_compress_generic
(
state
,
source
,
dest
,
inputSize
,
0
,
notLimited
,
LZ4_64bits
()
?
byU32
:
byPtr
,
noDict
,
noDictIssue
);
}
int
LZ4_compress_limitedOutput_withState
(
void
*
state
,
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
maxOutputSize
)
{
if
(((
size_t
)(
state
)
&
3
)
!=
0
)
return
0
;
/* Error : state is not aligned on 4-bytes boundary */
MEM_INIT
(
state
,
0
,
LZ4_STREAMSIZE
);
if
(
inputSize
<
LZ4_64Klimit
)
return
LZ4_compress_generic
(
state
,
source
,
dest
,
inputSize
,
maxOutputSize
,
limitedOutput
,
byU16
,
noDict
,
noDictIssue
);
else
return
LZ4_compress_generic
(
state
,
source
,
dest
,
inputSize
,
maxOutputSize
,
limitedOutput
,
LZ4_64bits
()
?
byU32
:
byPtr
,
noDict
,
noDictIssue
);
}
/* Obsolete streaming decompression functions */
int
LZ4_decompress_safe_withPrefix64k
(
const
char
*
source
,
char
*
dest
,
int
compressedSize
,
int
maxOutputSize
)
{
return
LZ4_decompress_generic
(
source
,
dest
,
compressedSize
,
maxOutputSize
,
endOnInputSize
,
full
,
0
,
withPrefix64k
,
(
BYTE
*
)
dest
-
64
KB
,
NULL
,
64
KB
);
}
int
LZ4_decompress_fast_withPrefix64k
(
const
char
*
source
,
char
*
dest
,
int
originalSize
)
{
return
LZ4_decompress_generic
(
source
,
dest
,
0
,
originalSize
,
endOnOutputSize
,
full
,
0
,
withPrefix64k
,
(
BYTE
*
)
dest
-
64
KB
,
NULL
,
64
KB
);
}
#endif
/* LZ4_COMMONDEFS_ONLY */
vendor/github.com/cloudflare/golz4/src/lz4.h
0 → 100644
View file @
d0d28566
/*
LZ4 - Fast LZ compression algorithm
Header File
Copyright (C) 2011-2014, Yann Collet.
BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following disclaimer
in the documentation and/or other materials provided with the
distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
You can contact the author at :
- LZ4 source repository : http://code.google.com/p/lz4/
- LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c
*/
#pragma once
#if defined (__cplusplus)
extern
"C"
{
#endif
/*
* lz4.h provides raw compression format functions, for optimal performance and integration into programs.
* If you need to generate data using an inter-operable format (respecting the framing specification),
* please use lz4frame.h instead.
*/
/**************************************
Version
**************************************/
#define LZ4_VERSION_MAJOR 1
/* for breaking interface changes */
#define LZ4_VERSION_MINOR 5
/* for new (non-breaking) interface capabilities */
#define LZ4_VERSION_RELEASE 0
/* for tweaks, bug-fixes, or development */
#define LZ4_VERSION_NUMBER (LZ4_VERSION_MAJOR *100*100 + LZ4_VERSION_MINOR *100 + LZ4_VERSION_RELEASE)
int
LZ4_versionNumber
(
void
);
/**************************************
Tuning parameter
**************************************/
/*
* LZ4_MEMORY_USAGE :
* Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)
* Increasing memory usage improves compression ratio
* Reduced memory usage can improve speed, due to cache effect
* Default value is 14, for 16KB, which nicely fits into Intel x86 L1 cache
*/
#define LZ4_MEMORY_USAGE 14
/**************************************
Simple Functions
**************************************/
int
LZ4_compress
(
const
char
*
source
,
char
*
dest
,
int
sourceSize
);
int
LZ4_decompress_safe
(
const
char
*
source
,
char
*
dest
,
int
compressedSize
,
int
maxDecompressedSize
);
/*
LZ4_compress() :
Compresses 'sourceSize' bytes from 'source' into 'dest'.
Destination buffer must be already allocated,
and must be sized to handle worst cases situations (input data not compressible)
Worst case size evaluation is provided by function LZ4_compressBound()
inputSize : Max supported value is LZ4_MAX_INPUT_SIZE
return : the number of bytes written in buffer dest
or 0 if the compression fails
LZ4_decompress_safe() :
compressedSize : is obviously the source size
maxDecompressedSize : is the size of the destination buffer, which must be already allocated.
return : the number of bytes decompressed into the destination buffer (necessarily <= maxDecompressedSize)
If the destination buffer is not large enough, decoding will stop and output an error code (<0).
If the source stream is detected malformed, the function will stop decoding and return a negative result.
This function is protected against buffer overflow exploits,
and never writes outside of output buffer, nor reads outside of input buffer.
It is also protected against malicious data packets.
*/
/**************************************
Advanced Functions
**************************************/
#define LZ4_MAX_INPUT_SIZE 0x7E000000
/* 2 113 929 216 bytes */
#define LZ4_COMPRESSBOUND(isize) ((unsigned int)(isize) > (unsigned int)LZ4_MAX_INPUT_SIZE ? 0 : (isize) + ((isize)/255) + 16)
/*
LZ4_compressBound() :
Provides the maximum size that LZ4 compression may output in a "worst case" scenario (input data not compressible)
This function is primarily useful for memory allocation purposes (output buffer size).
Macro LZ4_COMPRESSBOUND() is also provided for compilation-time evaluation (stack memory allocation for example).
isize : is the input size. Max supported value is LZ4_MAX_INPUT_SIZE
return : maximum output size in a "worst case" scenario
or 0, if input size is too large ( > LZ4_MAX_INPUT_SIZE)
*/
int
LZ4_compressBound
(
int
isize
);
/*
LZ4_compress_limitedOutput() :
Compress 'sourceSize' bytes from 'source' into an output buffer 'dest' of maximum size 'maxOutputSize'.
If it cannot achieve it, compression will stop, and result of the function will be zero.
This saves time and memory on detecting non-compressible (or barely compressible) data.
This function never writes outside of provided output buffer.
sourceSize : Max supported value is LZ4_MAX_INPUT_VALUE
maxOutputSize : is the size of the destination buffer (which must be already allocated)
return : the number of bytes written in buffer 'dest'
or 0 if compression fails
*/
int
LZ4_compress_limitedOutput
(
const
char
*
source
,
char
*
dest
,
int
sourceSize
,
int
maxOutputSize
);
/*
LZ4_compress_withState() :
Same compression functions, but using an externally allocated memory space to store compression state.
Use LZ4_sizeofState() to know how much memory must be allocated,
and then, provide it as 'void* state' to compression functions.
*/
int
LZ4_sizeofState
(
void
);
int
LZ4_compress_withState
(
void
*
state
,
const
char
*
source
,
char
*
dest
,
int
inputSize
);
int
LZ4_compress_limitedOutput_withState
(
void
*
state
,
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
maxOutputSize
);
/*
LZ4_decompress_fast() :
originalSize : is the original and therefore uncompressed size
return : the number of bytes read from the source buffer (in other words, the compressed size)
If the source stream is detected malformed, the function will stop decoding and return a negative result.
Destination buffer must be already allocated. Its size must be a minimum of 'originalSize' bytes.
note : This function fully respect memory boundaries for properly formed compressed data.
It is a bit faster than LZ4_decompress_safe().
However, it does not provide any protection against intentionally modified data stream (malicious input).
Use this function in trusted environment only (data to decode comes from a trusted source).
*/
int
LZ4_decompress_fast
(
const
char
*
source
,
char
*
dest
,
int
originalSize
);
/*
LZ4_decompress_safe_partial() :
This function decompress a compressed block of size 'compressedSize' at position 'source'
into destination buffer 'dest' of size 'maxDecompressedSize'.
The function tries to stop decompressing operation as soon as 'targetOutputSize' has been reached,
reducing decompression time.
return : the number of bytes decoded in the destination buffer (necessarily <= maxDecompressedSize)
Note : this number can be < 'targetOutputSize' should the compressed block to decode be smaller.
Always control how many bytes were decoded.
If the source stream is detected malformed, the function will stop decoding and return a negative result.
This function never writes outside of output buffer, and never reads outside of input buffer. It is therefore protected against malicious data packets
*/
int
LZ4_decompress_safe_partial
(
const
char
*
source
,
char
*
dest
,
int
compressedSize
,
int
targetOutputSize
,
int
maxDecompressedSize
);
/***********************************************
Streaming Compression Functions
***********************************************/
#define LZ4_STREAMSIZE_U64 ((1 << (LZ4_MEMORY_USAGE-3)) + 4)
#define LZ4_STREAMSIZE (LZ4_STREAMSIZE_U64 * sizeof(long long))
/*
* LZ4_stream_t
* information structure to track an LZ4 stream.
* important : init this structure content before first use !
* note : only allocated directly the structure if you are statically linking LZ4
* If you are using liblz4 as a DLL, please use below construction methods instead.
*/
typedef
struct
{
long
long
table
[
LZ4_STREAMSIZE_U64
];
}
LZ4_stream_t
;
/*
* LZ4_resetStream
* Use this function to init an allocated LZ4_stream_t structure
*/
void
LZ4_resetStream
(
LZ4_stream_t
*
LZ4_streamPtr
);
/*
* LZ4_createStream will allocate and initialize an LZ4_stream_t structure
* LZ4_freeStream releases its memory.
* In the context of a DLL (liblz4), please use these methods rather than the static struct.
* They are more future proof, in case of a change of LZ4_stream_t size.
*/
LZ4_stream_t
*
LZ4_createStream
(
void
);
int
LZ4_freeStream
(
LZ4_stream_t
*
LZ4_streamPtr
);
/*
* LZ4_loadDict
* Use this function to load a static dictionary into LZ4_stream.
* Any previous data will be forgotten, only 'dictionary' will remain in memory.
* Loading a size of 0 is allowed.
* Return : dictionary size, in bytes (necessarily <= 64 KB)
*/
int
LZ4_loadDict
(
LZ4_stream_t
*
LZ4_streamPtr
,
const
char
*
dictionary
,
int
dictSize
);
/*
* LZ4_compress_continue
* Compress data block 'source', using blocks compressed before as dictionary to improve compression ratio
* Previous data blocks are assumed to still be present at their previous location.
*/
int
LZ4_compress_continue
(
LZ4_stream_t
*
LZ4_streamPtr
,
const
char
*
source
,
char
*
dest
,
int
inputSize
);
/*
* LZ4_compress_limitedOutput_continue
* Same as before, but also specify a maximum target compressed size (maxOutputSize)
* If objective cannot be met, compression exits, and returns a zero.
*/
int
LZ4_compress_limitedOutput_continue
(
LZ4_stream_t
*
LZ4_streamPtr
,
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
maxOutputSize
);
/*
* LZ4_saveDict
* If previously compressed data block is not guaranteed to remain available at its memory location
* save it into a safer place (char* safeBuffer)
* Note : you don't need to call LZ4_loadDict() afterwards,
* dictionary is immediately usable, you can therefore call again LZ4_compress_continue()
* Return : dictionary size in bytes, or 0 if error
* Note : any dictSize > 64 KB will be interpreted as 64KB.
*/
int
LZ4_saveDict
(
LZ4_stream_t
*
LZ4_streamPtr
,
char
*
safeBuffer
,
int
dictSize
);
/************************************************
Streaming Decompression Functions
************************************************/
#define LZ4_STREAMDECODESIZE_U64 4
#define LZ4_STREAMDECODESIZE (LZ4_STREAMDECODESIZE_U64 * sizeof(unsigned long long))
typedef
struct
{
unsigned
long
long
table
[
LZ4_STREAMDECODESIZE_U64
];
}
LZ4_streamDecode_t
;
/*
* LZ4_streamDecode_t
* information structure to track an LZ4 stream.
* init this structure content using LZ4_setStreamDecode or memset() before first use !
*
* In the context of a DLL (liblz4) please prefer usage of construction methods below.
* They are more future proof, in case of a change of LZ4_streamDecode_t size in the future.
* LZ4_createStreamDecode will allocate and initialize an LZ4_streamDecode_t structure
* LZ4_freeStreamDecode releases its memory.
*/
LZ4_streamDecode_t
*
LZ4_createStreamDecode
(
void
);
int
LZ4_freeStreamDecode
(
LZ4_streamDecode_t
*
LZ4_stream
);
/*
* LZ4_setStreamDecode
* Use this function to instruct where to find the dictionary.
* Setting a size of 0 is allowed (same effect as reset).
* Return : 1 if OK, 0 if error
*/
int
LZ4_setStreamDecode
(
LZ4_streamDecode_t
*
LZ4_streamDecode
,
const
char
*
dictionary
,
int
dictSize
);
/*
*_continue() :
These decoding functions allow decompression of multiple blocks in "streaming" mode.
Previously decoded blocks *must* remain available at the memory position where they were decoded (up to 64 KB)
If this condition is not possible, save the relevant part of decoded data into a safe buffer,
and indicate where is its new address using LZ4_setStreamDecode()
*/
int
LZ4_decompress_safe_continue
(
LZ4_streamDecode_t
*
LZ4_streamDecode
,
const
char
*
source
,
char
*
dest
,
int
compressedSize
,
int
maxDecompressedSize
);
int
LZ4_decompress_fast_continue
(
LZ4_streamDecode_t
*
LZ4_streamDecode
,
const
char
*
source
,
char
*
dest
,
int
originalSize
);
/*
Advanced decoding functions :
*_usingDict() :
These decoding functions work the same as
a combination of LZ4_setDictDecode() followed by LZ4_decompress_x_continue()
They are stand-alone and don't use nor update an LZ4_streamDecode_t structure.
*/
int
LZ4_decompress_safe_usingDict
(
const
char
*
source
,
char
*
dest
,
int
compressedSize
,
int
maxDecompressedSize
,
const
char
*
dictStart
,
int
dictSize
);
int
LZ4_decompress_fast_usingDict
(
const
char
*
source
,
char
*
dest
,
int
originalSize
,
const
char
*
dictStart
,
int
dictSize
);
/**************************************
Obsolete Functions
**************************************/
/*
Obsolete decompression functions
These function names are deprecated and should no longer be used.
They are only provided here for compatibility with older user programs.
- LZ4_uncompress is the same as LZ4_decompress_fast
- LZ4_uncompress_unknownOutputSize is the same as LZ4_decompress_safe
These function prototypes are now disabled; uncomment them if you really need them.
It is highly recommended to stop using these functions and migrate to newer ones */
/* int LZ4_uncompress (const char* source, char* dest, int outputSize); */
/* int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize); */
/* Obsolete streaming functions; use new streaming interface whenever possible */
void
*
LZ4_create
(
const
char
*
inputBuffer
);
int
LZ4_sizeofStreamState
(
void
);
int
LZ4_resetStreamState
(
void
*
state
,
const
char
*
inputBuffer
);
char
*
LZ4_slideInputBuffer
(
void
*
state
);
/* Obsolete streaming decoding functions */
int
LZ4_decompress_safe_withPrefix64k
(
const
char
*
source
,
char
*
dest
,
int
compressedSize
,
int
maxOutputSize
);
int
LZ4_decompress_fast_withPrefix64k
(
const
char
*
source
,
char
*
dest
,
int
originalSize
);
#if defined (__cplusplus)
}
#endif
vendor/github.com/cloudflare/golz4/src/lz4hc.c
0 → 100644
View file @
d0d28566
/*
LZ4 HC - High Compression Mode of LZ4
Copyright (C) 2011-2014, Yann Collet.
BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following disclaimer
in the documentation and/or other materials provided with the
distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
You can contact the author at :
- LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html
- LZ4 source repository : http://code.google.com/p/lz4/
*/
/**************************************
Tuning Parameter
**************************************/
static
const
int
LZ4HC_compressionLevel_default
=
8
;
/**************************************
Includes
**************************************/
#include "lz4hc.h"
/**************************************
Local Compiler Options
**************************************/
#if defined(__GNUC__)
# pragma GCC diagnostic ignored "-Wunused-function"
#endif
#if defined (__clang__)
# pragma clang diagnostic ignored "-Wunused-function"
#endif
/**************************************
Common LZ4 definition
**************************************/
#define LZ4_COMMONDEFS_ONLY
#include "lz4.c"
/**************************************
Local Constants
**************************************/
#define DICTIONARY_LOGSIZE 16
#define MAXD (1<<DICTIONARY_LOGSIZE)
#define MAXD_MASK ((U32)(MAXD - 1))
#define HASH_LOG (DICTIONARY_LOGSIZE-1)
#define HASHTABLESIZE (1 << HASH_LOG)
#define HASH_MASK (HASHTABLESIZE - 1)
#define OPTIMAL_ML (int)((ML_MASK-1)+MINMATCH)
static
const
int
g_maxCompressionLevel
=
16
;
/**************************************
Local Types
**************************************/
typedef
struct
{
U32
hashTable
[
HASHTABLESIZE
];
U16
chainTable
[
MAXD
];
const
BYTE
*
end
;
/* next block here to continue on current prefix */
const
BYTE
*
base
;
/* All index relative to this position */
const
BYTE
*
dictBase
;
/* alternate base for extDict */
const
BYTE
*
inputBuffer
;
/* deprecated */
U32
dictLimit
;
/* below that point, need extDict */
U32
lowLimit
;
/* below that point, no more dict */
U32
nextToUpdate
;
U32
compressionLevel
;
}
LZ4HC_Data_Structure
;
/**************************************
Local Macros
**************************************/
#define HASH_FUNCTION(i) (((i) * 2654435761U) >> ((MINMATCH*8)-HASH_LOG))
#define DELTANEXT(p) chainTable[(size_t)(p) & MAXD_MASK]
#define GETNEXT(p) ((p) - (size_t)DELTANEXT(p))
static
U32
LZ4HC_hashPtr
(
const
void
*
ptr
)
{
return
HASH_FUNCTION
(
LZ4_read32
(
ptr
));
}
/**************************************
HC Compression
**************************************/
static
void
LZ4HC_init
(
LZ4HC_Data_Structure
*
hc4
,
const
BYTE
*
start
)
{
MEM_INIT
((
void
*
)
hc4
->
hashTable
,
0
,
sizeof
(
hc4
->
hashTable
));
MEM_INIT
(
hc4
->
chainTable
,
0xFF
,
sizeof
(
hc4
->
chainTable
));
hc4
->
nextToUpdate
=
64
KB
;
hc4
->
base
=
start
-
64
KB
;
hc4
->
inputBuffer
=
start
;
hc4
->
end
=
start
;
hc4
->
dictBase
=
start
-
64
KB
;
hc4
->
dictLimit
=
64
KB
;
hc4
->
lowLimit
=
64
KB
;
}
/* Update chains up to ip (excluded) */
FORCE_INLINE
void
LZ4HC_Insert
(
LZ4HC_Data_Structure
*
hc4
,
const
BYTE
*
ip
)
{
U16
*
chainTable
=
hc4
->
chainTable
;
U32
*
HashTable
=
hc4
->
hashTable
;
const
BYTE
*
const
base
=
hc4
->
base
;
const
U32
target
=
(
U32
)(
ip
-
base
);
U32
idx
=
hc4
->
nextToUpdate
;
while
(
idx
<
target
)
{
U32
h
=
LZ4HC_hashPtr
(
base
+
idx
);
size_t
delta
=
idx
-
HashTable
[
h
];
if
(
delta
>
MAX_DISTANCE
)
delta
=
MAX_DISTANCE
;
chainTable
[
idx
&
0xFFFF
]
=
(
U16
)
delta
;
HashTable
[
h
]
=
idx
;
idx
++
;
}
hc4
->
nextToUpdate
=
target
;
}
FORCE_INLINE
int
LZ4HC_InsertAndFindBestMatch
(
LZ4HC_Data_Structure
*
hc4
,
/* Index table will be updated */
const
BYTE
*
ip
,
const
BYTE
*
const
iLimit
,
const
BYTE
**
matchpos
,
const
int
maxNbAttempts
)
{
U16
*
const
chainTable
=
hc4
->
chainTable
;
U32
*
const
HashTable
=
hc4
->
hashTable
;
const
BYTE
*
const
base
=
hc4
->
base
;
const
BYTE
*
const
dictBase
=
hc4
->
dictBase
;
const
U32
dictLimit
=
hc4
->
dictLimit
;
const
U32
lowLimit
=
(
hc4
->
lowLimit
+
64
KB
>
(
U32
)(
ip
-
base
))
?
hc4
->
lowLimit
:
(
U32
)(
ip
-
base
)
-
(
64
KB
-
1
);
U32
matchIndex
;
const
BYTE
*
match
;
int
nbAttempts
=
maxNbAttempts
;
size_t
ml
=
0
;
/* HC4 match finder */
LZ4HC_Insert
(
hc4
,
ip
);
matchIndex
=
HashTable
[
LZ4HC_hashPtr
(
ip
)];
while
((
matchIndex
>=
lowLimit
)
&&
(
nbAttempts
))
{
nbAttempts
--
;
if
(
matchIndex
>=
dictLimit
)
{
match
=
base
+
matchIndex
;
if
(
*
(
match
+
ml
)
==
*
(
ip
+
ml
)
&&
(
LZ4_read32
(
match
)
==
LZ4_read32
(
ip
)))
{
size_t
mlt
=
LZ4_count
(
ip
+
MINMATCH
,
match
+
MINMATCH
,
iLimit
)
+
MINMATCH
;
if
(
mlt
>
ml
)
{
ml
=
mlt
;
*
matchpos
=
match
;
}
}
}
else
{
match
=
dictBase
+
matchIndex
;
if
(
LZ4_read32
(
match
)
==
LZ4_read32
(
ip
))
{
size_t
mlt
;
const
BYTE
*
vLimit
=
ip
+
(
dictLimit
-
matchIndex
);
if
(
vLimit
>
iLimit
)
vLimit
=
iLimit
;
mlt
=
LZ4_count
(
ip
+
MINMATCH
,
match
+
MINMATCH
,
vLimit
)
+
MINMATCH
;
if
((
ip
+
mlt
==
vLimit
)
&&
(
vLimit
<
iLimit
))
mlt
+=
LZ4_count
(
ip
+
mlt
,
base
+
dictLimit
,
iLimit
);
if
(
mlt
>
ml
)
{
ml
=
mlt
;
*
matchpos
=
base
+
matchIndex
;
}
/* virtual matchpos */
}
}
matchIndex
-=
chainTable
[
matchIndex
&
0xFFFF
];
}
return
(
int
)
ml
;
}
FORCE_INLINE
int
LZ4HC_InsertAndGetWiderMatch
(
LZ4HC_Data_Structure
*
hc4
,
const
BYTE
*
ip
,
const
BYTE
*
iLowLimit
,
const
BYTE
*
iHighLimit
,
int
longest
,
const
BYTE
**
matchpos
,
const
BYTE
**
startpos
,
const
int
maxNbAttempts
)
{
U16
*
const
chainTable
=
hc4
->
chainTable
;
U32
*
const
HashTable
=
hc4
->
hashTable
;
const
BYTE
*
const
base
=
hc4
->
base
;
const
U32
dictLimit
=
hc4
->
dictLimit
;
const
U32
lowLimit
=
(
hc4
->
lowLimit
+
64
KB
>
(
U32
)(
ip
-
base
))
?
hc4
->
lowLimit
:
(
U32
)(
ip
-
base
)
-
(
64
KB
-
1
);
const
BYTE
*
const
dictBase
=
hc4
->
dictBase
;
const
BYTE
*
match
;
U32
matchIndex
;
int
nbAttempts
=
maxNbAttempts
;
int
delta
=
(
int
)(
ip
-
iLowLimit
);
/* First Match */
LZ4HC_Insert
(
hc4
,
ip
);
matchIndex
=
HashTable
[
LZ4HC_hashPtr
(
ip
)];
while
((
matchIndex
>=
lowLimit
)
&&
(
nbAttempts
))
{
nbAttempts
--
;
if
(
matchIndex
>=
dictLimit
)
{
match
=
base
+
matchIndex
;
if
(
*
(
iLowLimit
+
longest
)
==
*
(
match
-
delta
+
longest
))
if
(
LZ4_read32
(
match
)
==
LZ4_read32
(
ip
))
{
const
BYTE
*
startt
=
ip
;
const
BYTE
*
tmpMatch
=
match
;
const
BYTE
*
const
matchEnd
=
ip
+
MINMATCH
+
LZ4_count
(
ip
+
MINMATCH
,
match
+
MINMATCH
,
iHighLimit
);
while
((
startt
>
iLowLimit
)
&&
(
tmpMatch
>
iLowLimit
)
&&
(
startt
[
-
1
]
==
tmpMatch
[
-
1
]))
{
startt
--
;
tmpMatch
--
;}
if
((
matchEnd
-
startt
)
>
longest
)
{
longest
=
(
int
)(
matchEnd
-
startt
);
*
matchpos
=
tmpMatch
;
*
startpos
=
startt
;
}
}
}
else
{
match
=
dictBase
+
matchIndex
;
if
(
LZ4_read32
(
match
)
==
LZ4_read32
(
ip
))
{
size_t
mlt
;
int
back
=
0
;
const
BYTE
*
vLimit
=
ip
+
(
dictLimit
-
matchIndex
);
if
(
vLimit
>
iHighLimit
)
vLimit
=
iHighLimit
;
mlt
=
LZ4_count
(
ip
+
MINMATCH
,
match
+
MINMATCH
,
vLimit
)
+
MINMATCH
;
if
((
ip
+
mlt
==
vLimit
)
&&
(
vLimit
<
iHighLimit
))
mlt
+=
LZ4_count
(
ip
+
mlt
,
base
+
dictLimit
,
iHighLimit
);
while
((
ip
+
back
>
iLowLimit
)
&&
(
matchIndex
+
back
>
lowLimit
)
&&
(
ip
[
back
-
1
]
==
match
[
back
-
1
]))
back
--
;
mlt
-=
back
;
if
((
int
)
mlt
>
longest
)
{
longest
=
(
int
)
mlt
;
*
matchpos
=
base
+
matchIndex
+
back
;
*
startpos
=
ip
+
back
;
}
}
}
matchIndex
-=
chainTable
[
matchIndex
&
0xFFFF
];
}
return
longest
;
}
typedef
enum
{
noLimit
=
0
,
limitedOutput
=
1
}
limitedOutput_directive
;
#define LZ4HC_DEBUG 0
#if LZ4HC_DEBUG
static
unsigned
debug
=
0
;
#endif
FORCE_INLINE
int
LZ4HC_encodeSequence
(
const
BYTE
**
ip
,
BYTE
**
op
,
const
BYTE
**
anchor
,
int
matchLength
,
const
BYTE
*
const
match
,
limitedOutput_directive
limitedOutputBuffer
,
BYTE
*
oend
)
{
int
length
;
BYTE
*
token
;
#if LZ4HC_DEBUG
if
(
debug
)
printf
(
"literal : %u -- match : %u -- offset : %u
\n
"
,
(
U32
)(
*
ip
-
*
anchor
),
(
U32
)
matchLength
,
(
U32
)(
*
ip
-
match
));
#endif
/* Encode Literal length */
length
=
(
int
)(
*
ip
-
*
anchor
);
token
=
(
*
op
)
++
;
if
((
limitedOutputBuffer
)
&&
((
*
op
+
(
length
>>
8
)
+
length
+
(
2
+
1
+
LASTLITERALS
))
>
oend
))
return
1
;
/* Check output limit */
if
(
length
>=
(
int
)
RUN_MASK
)
{
int
len
;
*
token
=
(
RUN_MASK
<<
ML_BITS
);
len
=
length
-
RUN_MASK
;
for
(;
len
>
254
;
len
-=
255
)
*
(
*
op
)
++
=
255
;
*
(
*
op
)
++
=
(
BYTE
)
len
;
}
else
*
token
=
(
BYTE
)(
length
<<
ML_BITS
);
/* Copy Literals */
LZ4_wildCopy
(
*
op
,
*
anchor
,
(
*
op
)
+
length
);
*
op
+=
length
;
/* Encode Offset */
LZ4_writeLE16
(
*
op
,
(
U16
)(
*
ip
-
match
));
*
op
+=
2
;
/* Encode MatchLength */
length
=
(
int
)(
matchLength
-
MINMATCH
);
if
((
limitedOutputBuffer
)
&&
(
*
op
+
(
length
>>
8
)
+
(
1
+
LASTLITERALS
)
>
oend
))
return
1
;
/* Check output limit */
if
(
length
>=
(
int
)
ML_MASK
)
{
*
token
+=
ML_MASK
;
length
-=
ML_MASK
;
for
(;
length
>
509
;
length
-=
510
)
{
*
(
*
op
)
++
=
255
;
*
(
*
op
)
++
=
255
;
}
if
(
length
>
254
)
{
length
-=
255
;
*
(
*
op
)
++
=
255
;
}
*
(
*
op
)
++
=
(
BYTE
)
length
;
}
else
*
token
+=
(
BYTE
)(
length
);
/* Prepare next loop */
*
ip
+=
matchLength
;
*
anchor
=
*
ip
;
return
0
;
}
static
int
LZ4HC_compress_generic
(
void
*
ctxvoid
,
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
maxOutputSize
,
int
compressionLevel
,
limitedOutput_directive
limit
)
{
LZ4HC_Data_Structure
*
ctx
=
(
LZ4HC_Data_Structure
*
)
ctxvoid
;
const
BYTE
*
ip
=
(
const
BYTE
*
)
source
;
const
BYTE
*
anchor
=
ip
;
const
BYTE
*
const
iend
=
ip
+
inputSize
;
const
BYTE
*
const
mflimit
=
iend
-
MFLIMIT
;
const
BYTE
*
const
matchlimit
=
(
iend
-
LASTLITERALS
);
BYTE
*
op
=
(
BYTE
*
)
dest
;
BYTE
*
const
oend
=
op
+
maxOutputSize
;
unsigned
maxNbAttempts
;
int
ml
,
ml2
,
ml3
,
ml0
;
const
BYTE
*
ref
=
NULL
;
const
BYTE
*
start2
=
NULL
;
const
BYTE
*
ref2
=
NULL
;
const
BYTE
*
start3
=
NULL
;
const
BYTE
*
ref3
=
NULL
;
const
BYTE
*
start0
;
const
BYTE
*
ref0
;
/* init */
if
(
compressionLevel
>
g_maxCompressionLevel
)
compressionLevel
=
g_maxCompressionLevel
;
if
(
compressionLevel
<
1
)
compressionLevel
=
LZ4HC_compressionLevel_default
;
maxNbAttempts
=
1
<<
(
compressionLevel
-
1
);
ctx
->
end
+=
inputSize
;
ip
++
;
/* Main Loop */
while
(
ip
<
mflimit
)
{
ml
=
LZ4HC_InsertAndFindBestMatch
(
ctx
,
ip
,
matchlimit
,
(
&
ref
),
maxNbAttempts
);
if
(
!
ml
)
{
ip
++
;
continue
;
}
/* saved, in case we would skip too much */
start0
=
ip
;
ref0
=
ref
;
ml0
=
ml
;
_Search2:
if
(
ip
+
ml
<
mflimit
)
ml2
=
LZ4HC_InsertAndGetWiderMatch
(
ctx
,
ip
+
ml
-
2
,
ip
+
1
,
matchlimit
,
ml
,
&
ref2
,
&
start2
,
maxNbAttempts
);
else
ml2
=
ml
;
if
(
ml2
==
ml
)
/* No better match */
{
if
(
LZ4HC_encodeSequence
(
&
ip
,
&
op
,
&
anchor
,
ml
,
ref
,
limit
,
oend
))
return
0
;
continue
;
}
if
(
start0
<
ip
)
{
if
(
start2
<
ip
+
ml0
)
/* empirical */
{
ip
=
start0
;
ref
=
ref0
;
ml
=
ml0
;
}
}
/* Here, start0==ip */
if
((
start2
-
ip
)
<
3
)
/* First Match too small : removed */
{
ml
=
ml2
;
ip
=
start2
;
ref
=
ref2
;
goto
_Search2
;
}
_Search3:
/*
* Currently we have :
* ml2 > ml1, and
* ip1+3 <= ip2 (usually < ip1+ml1)
*/
if
((
start2
-
ip
)
<
OPTIMAL_ML
)
{
int
correction
;
int
new_ml
=
ml
;
if
(
new_ml
>
OPTIMAL_ML
)
new_ml
=
OPTIMAL_ML
;
if
(
ip
+
new_ml
>
start2
+
ml2
-
MINMATCH
)
new_ml
=
(
int
)(
start2
-
ip
)
+
ml2
-
MINMATCH
;
correction
=
new_ml
-
(
int
)(
start2
-
ip
);
if
(
correction
>
0
)
{
start2
+=
correction
;
ref2
+=
correction
;
ml2
-=
correction
;
}
}
/* Now, we have start2 = ip+new_ml, with new_ml = min(ml, OPTIMAL_ML=18) */
if
(
start2
+
ml2
<
mflimit
)
ml3
=
LZ4HC_InsertAndGetWiderMatch
(
ctx
,
start2
+
ml2
-
3
,
start2
,
matchlimit
,
ml2
,
&
ref3
,
&
start3
,
maxNbAttempts
);
else
ml3
=
ml2
;
if
(
ml3
==
ml2
)
/* No better match : 2 sequences to encode */
{
/* ip & ref are known; Now for ml */
if
(
start2
<
ip
+
ml
)
ml
=
(
int
)(
start2
-
ip
);
/* Now, encode 2 sequences */
if
(
LZ4HC_encodeSequence
(
&
ip
,
&
op
,
&
anchor
,
ml
,
ref
,
limit
,
oend
))
return
0
;
ip
=
start2
;
if
(
LZ4HC_encodeSequence
(
&
ip
,
&
op
,
&
anchor
,
ml2
,
ref2
,
limit
,
oend
))
return
0
;
continue
;
}
if
(
start3
<
ip
+
ml
+
3
)
/* Not enough space for match 2 : remove it */
{
if
(
start3
>=
(
ip
+
ml
))
/* can write Seq1 immediately ==> Seq2 is removed, so Seq3 becomes Seq1 */
{
if
(
start2
<
ip
+
ml
)
{
int
correction
=
(
int
)(
ip
+
ml
-
start2
);
start2
+=
correction
;
ref2
+=
correction
;
ml2
-=
correction
;
if
(
ml2
<
MINMATCH
)
{
start2
=
start3
;
ref2
=
ref3
;
ml2
=
ml3
;
}
}
if
(
LZ4HC_encodeSequence
(
&
ip
,
&
op
,
&
anchor
,
ml
,
ref
,
limit
,
oend
))
return
0
;
ip
=
start3
;
ref
=
ref3
;
ml
=
ml3
;
start0
=
start2
;
ref0
=
ref2
;
ml0
=
ml2
;
goto
_Search2
;
}
start2
=
start3
;
ref2
=
ref3
;
ml2
=
ml3
;
goto
_Search3
;
}
/*
* OK, now we have 3 ascending matches; let's write at least the first one
* ip & ref are known; Now for ml
*/
if
(
start2
<
ip
+
ml
)
{
if
((
start2
-
ip
)
<
(
int
)
ML_MASK
)
{
int
correction
;
if
(
ml
>
OPTIMAL_ML
)
ml
=
OPTIMAL_ML
;
if
(
ip
+
ml
>
start2
+
ml2
-
MINMATCH
)
ml
=
(
int
)(
start2
-
ip
)
+
ml2
-
MINMATCH
;
correction
=
ml
-
(
int
)(
start2
-
ip
);
if
(
correction
>
0
)
{
start2
+=
correction
;
ref2
+=
correction
;
ml2
-=
correction
;
}
}
else
{
ml
=
(
int
)(
start2
-
ip
);
}
}
if
(
LZ4HC_encodeSequence
(
&
ip
,
&
op
,
&
anchor
,
ml
,
ref
,
limit
,
oend
))
return
0
;
ip
=
start2
;
ref
=
ref2
;
ml
=
ml2
;
start2
=
start3
;
ref2
=
ref3
;
ml2
=
ml3
;
goto
_Search3
;
}
/* Encode Last Literals */
{
int
lastRun
=
(
int
)(
iend
-
anchor
);
if
((
limit
)
&&
(((
char
*
)
op
-
dest
)
+
lastRun
+
1
+
((
lastRun
+
255
-
RUN_MASK
)
/
255
)
>
(
U32
)
maxOutputSize
))
return
0
;
/* Check output limit */
if
(
lastRun
>=
(
int
)
RUN_MASK
)
{
*
op
++=
(
RUN_MASK
<<
ML_BITS
);
lastRun
-=
RUN_MASK
;
for
(;
lastRun
>
254
;
lastRun
-=
255
)
*
op
++
=
255
;
*
op
++
=
(
BYTE
)
lastRun
;
}
else
*
op
++
=
(
BYTE
)(
lastRun
<<
ML_BITS
);
memcpy
(
op
,
anchor
,
iend
-
anchor
);
op
+=
iend
-
anchor
;
}
/* End */
return
(
int
)
(((
char
*
)
op
)
-
dest
);
}
int
LZ4_compressHC2
(
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
compressionLevel
)
{
LZ4HC_Data_Structure
ctx
;
LZ4HC_init
(
&
ctx
,
(
const
BYTE
*
)
source
);
return
LZ4HC_compress_generic
(
&
ctx
,
source
,
dest
,
inputSize
,
0
,
compressionLevel
,
noLimit
);
}
int
LZ4_compressHC
(
const
char
*
source
,
char
*
dest
,
int
inputSize
)
{
return
LZ4_compressHC2
(
source
,
dest
,
inputSize
,
0
);
}
int
LZ4_compressHC2_limitedOutput
(
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
maxOutputSize
,
int
compressionLevel
)
{
LZ4HC_Data_Structure
ctx
;
LZ4HC_init
(
&
ctx
,
(
const
BYTE
*
)
source
);
return
LZ4HC_compress_generic
(
&
ctx
,
source
,
dest
,
inputSize
,
maxOutputSize
,
compressionLevel
,
limitedOutput
);
}
int
LZ4_compressHC_limitedOutput
(
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
maxOutputSize
)
{
return
LZ4_compressHC2_limitedOutput
(
source
,
dest
,
inputSize
,
maxOutputSize
,
0
);
}
/*****************************
* Using external allocation
* ***************************/
int
LZ4_sizeofStateHC
(
void
)
{
return
sizeof
(
LZ4HC_Data_Structure
);
}
int
LZ4_compressHC2_withStateHC
(
void
*
state
,
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
compressionLevel
)
{
if
(((
size_t
)(
state
)
&
(
sizeof
(
void
*
)
-
1
))
!=
0
)
return
0
;
/* Error : state is not aligned for pointers (32 or 64 bits) */
LZ4HC_init
((
LZ4HC_Data_Structure
*
)
state
,
(
const
BYTE
*
)
source
);
return
LZ4HC_compress_generic
(
state
,
source
,
dest
,
inputSize
,
0
,
compressionLevel
,
noLimit
);
}
int
LZ4_compressHC_withStateHC
(
void
*
state
,
const
char
*
source
,
char
*
dest
,
int
inputSize
)
{
return
LZ4_compressHC2_withStateHC
(
state
,
source
,
dest
,
inputSize
,
0
);
}
int
LZ4_compressHC2_limitedOutput_withStateHC
(
void
*
state
,
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
maxOutputSize
,
int
compressionLevel
)
{
if
(((
size_t
)(
state
)
&
(
sizeof
(
void
*
)
-
1
))
!=
0
)
return
0
;
/* Error : state is not aligned for pointers (32 or 64 bits) */
LZ4HC_init
((
LZ4HC_Data_Structure
*
)
state
,
(
const
BYTE
*
)
source
);
return
LZ4HC_compress_generic
(
state
,
source
,
dest
,
inputSize
,
maxOutputSize
,
compressionLevel
,
limitedOutput
);
}
int
LZ4_compressHC_limitedOutput_withStateHC
(
void
*
state
,
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
maxOutputSize
)
{
return
LZ4_compressHC2_limitedOutput_withStateHC
(
state
,
source
,
dest
,
inputSize
,
maxOutputSize
,
0
);
}
/**************************************
* Streaming Functions
* ************************************/
/* allocation */
LZ4_streamHC_t
*
LZ4_createStreamHC
(
void
)
{
return
(
LZ4_streamHC_t
*
)
malloc
(
sizeof
(
LZ4_streamHC_t
));
}
int
LZ4_freeStreamHC
(
LZ4_streamHC_t
*
LZ4_streamHCPtr
)
{
free
(
LZ4_streamHCPtr
);
return
0
;
}
/* initialization */
void
LZ4_resetStreamHC
(
LZ4_streamHC_t
*
LZ4_streamHCPtr
,
int
compressionLevel
)
{
LZ4_STATIC_ASSERT
(
sizeof
(
LZ4HC_Data_Structure
)
<=
LZ4_STREAMHCSIZE
);
/* if compilation fails here, LZ4_STREAMHCSIZE must be increased */
((
LZ4HC_Data_Structure
*
)
LZ4_streamHCPtr
)
->
base
=
NULL
;
((
LZ4HC_Data_Structure
*
)
LZ4_streamHCPtr
)
->
compressionLevel
=
(
unsigned
)
compressionLevel
;
}
int
LZ4_loadDictHC
(
LZ4_streamHC_t
*
LZ4_streamHCPtr
,
const
char
*
dictionary
,
int
dictSize
)
{
LZ4HC_Data_Structure
*
ctxPtr
=
(
LZ4HC_Data_Structure
*
)
LZ4_streamHCPtr
;
if
(
dictSize
>
64
KB
)
{
dictionary
+=
dictSize
-
64
KB
;
dictSize
=
64
KB
;
}
LZ4HC_init
(
ctxPtr
,
(
const
BYTE
*
)
dictionary
);
if
(
dictSize
>=
4
)
LZ4HC_Insert
(
ctxPtr
,
(
const
BYTE
*
)
dictionary
+
(
dictSize
-
3
));
ctxPtr
->
end
=
(
const
BYTE
*
)
dictionary
+
dictSize
;
return
dictSize
;
}
/* compression */
static
void
LZ4HC_setExternalDict
(
LZ4HC_Data_Structure
*
ctxPtr
,
const
BYTE
*
newBlock
)
{
if
(
ctxPtr
->
end
>=
ctxPtr
->
base
+
4
)
LZ4HC_Insert
(
ctxPtr
,
ctxPtr
->
end
-
3
);
/* Referencing remaining dictionary content */
/* Only one memory segment for extDict, so any previous extDict is lost at this stage */
ctxPtr
->
lowLimit
=
ctxPtr
->
dictLimit
;
ctxPtr
->
dictLimit
=
(
U32
)(
ctxPtr
->
end
-
ctxPtr
->
base
);
ctxPtr
->
dictBase
=
ctxPtr
->
base
;
ctxPtr
->
base
=
newBlock
-
ctxPtr
->
dictLimit
;
ctxPtr
->
end
=
newBlock
;
ctxPtr
->
nextToUpdate
=
ctxPtr
->
dictLimit
;
/* match referencing will resume from there */
}
static
int
LZ4_compressHC_continue_generic
(
LZ4HC_Data_Structure
*
ctxPtr
,
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
maxOutputSize
,
limitedOutput_directive
limit
)
{
/* auto-init if forgotten */
if
(
ctxPtr
->
base
==
NULL
)
LZ4HC_init
(
ctxPtr
,
(
const
BYTE
*
)
source
);
/* Check overflow */
if
((
size_t
)(
ctxPtr
->
end
-
ctxPtr
->
base
)
>
2
GB
)
{
size_t
dictSize
=
(
size_t
)(
ctxPtr
->
end
-
ctxPtr
->
base
)
-
ctxPtr
->
dictLimit
;
if
(
dictSize
>
64
KB
)
dictSize
=
64
KB
;
LZ4_loadDictHC
((
LZ4_streamHC_t
*
)
ctxPtr
,
(
const
char
*
)(
ctxPtr
->
end
)
-
dictSize
,
(
int
)
dictSize
);
}
/* Check if blocks follow each other */
if
((
const
BYTE
*
)
source
!=
ctxPtr
->
end
)
LZ4HC_setExternalDict
(
ctxPtr
,
(
const
BYTE
*
)
source
);
/* Check overlapping input/dictionary space */
{
const
BYTE
*
sourceEnd
=
(
const
BYTE
*
)
source
+
inputSize
;
const
BYTE
*
dictBegin
=
ctxPtr
->
dictBase
+
ctxPtr
->
lowLimit
;
const
BYTE
*
dictEnd
=
ctxPtr
->
dictBase
+
ctxPtr
->
dictLimit
;
if
((
sourceEnd
>
dictBegin
)
&&
((
BYTE
*
)
source
<
dictEnd
))
{
if
(
sourceEnd
>
dictEnd
)
sourceEnd
=
dictEnd
;
ctxPtr
->
lowLimit
=
(
U32
)(
sourceEnd
-
ctxPtr
->
dictBase
);
if
(
ctxPtr
->
dictLimit
-
ctxPtr
->
lowLimit
<
4
)
ctxPtr
->
lowLimit
=
ctxPtr
->
dictLimit
;
}
}
return
LZ4HC_compress_generic
(
ctxPtr
,
source
,
dest
,
inputSize
,
maxOutputSize
,
ctxPtr
->
compressionLevel
,
limit
);
}
int
LZ4_compressHC_continue
(
LZ4_streamHC_t
*
LZ4_streamHCPtr
,
const
char
*
source
,
char
*
dest
,
int
inputSize
)
{
return
LZ4_compressHC_continue_generic
((
LZ4HC_Data_Structure
*
)
LZ4_streamHCPtr
,
source
,
dest
,
inputSize
,
0
,
noLimit
);
}
int
LZ4_compressHC_limitedOutput_continue
(
LZ4_streamHC_t
*
LZ4_streamHCPtr
,
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
maxOutputSize
)
{
return
LZ4_compressHC_continue_generic
((
LZ4HC_Data_Structure
*
)
LZ4_streamHCPtr
,
source
,
dest
,
inputSize
,
maxOutputSize
,
limitedOutput
);
}
/* dictionary saving */
int
LZ4_saveDictHC
(
LZ4_streamHC_t
*
LZ4_streamHCPtr
,
char
*
safeBuffer
,
int
dictSize
)
{
LZ4HC_Data_Structure
*
streamPtr
=
(
LZ4HC_Data_Structure
*
)
LZ4_streamHCPtr
;
int
prefixSize
=
(
int
)(
streamPtr
->
end
-
(
streamPtr
->
base
+
streamPtr
->
dictLimit
));
if
(
dictSize
>
64
KB
)
dictSize
=
64
KB
;
if
(
dictSize
<
4
)
dictSize
=
0
;
if
(
dictSize
>
prefixSize
)
dictSize
=
prefixSize
;
memcpy
(
safeBuffer
,
streamPtr
->
end
-
dictSize
,
dictSize
);
{
U32
endIndex
=
(
U32
)(
streamPtr
->
end
-
streamPtr
->
base
);
streamPtr
->
end
=
(
const
BYTE
*
)
safeBuffer
+
dictSize
;
streamPtr
->
base
=
streamPtr
->
end
-
endIndex
;
streamPtr
->
dictLimit
=
endIndex
-
dictSize
;
streamPtr
->
lowLimit
=
endIndex
-
dictSize
;
if
(
streamPtr
->
nextToUpdate
<
streamPtr
->
dictLimit
)
streamPtr
->
nextToUpdate
=
streamPtr
->
dictLimit
;
}
return
dictSize
;
}
/***********************************
* Deprecated Functions
***********************************/
int
LZ4_sizeofStreamStateHC
(
void
)
{
return
LZ4_STREAMHCSIZE
;
}
int
LZ4_resetStreamStateHC
(
void
*
state
,
const
char
*
inputBuffer
)
{
if
((((
size_t
)
state
)
&
(
sizeof
(
void
*
)
-
1
))
!=
0
)
return
1
;
/* Error : pointer is not aligned for pointer (32 or 64 bits) */
LZ4HC_init
((
LZ4HC_Data_Structure
*
)
state
,
(
const
BYTE
*
)
inputBuffer
);
return
0
;
}
void
*
LZ4_createHC
(
const
char
*
inputBuffer
)
{
void
*
hc4
=
ALLOCATOR
(
1
,
sizeof
(
LZ4HC_Data_Structure
));
LZ4HC_init
((
LZ4HC_Data_Structure
*
)
hc4
,
(
const
BYTE
*
)
inputBuffer
);
return
hc4
;
}
int
LZ4_freeHC
(
void
*
LZ4HC_Data
)
{
FREEMEM
(
LZ4HC_Data
);
return
(
0
);
}
/*
int LZ4_compressHC_continue (void* LZ4HC_Data, const char* source, char* dest, int inputSize)
{
return LZ4HC_compress_generic (LZ4HC_Data, source, dest, inputSize, 0, 0, noLimit);
}
int LZ4_compressHC_limitedOutput_continue (void* LZ4HC_Data, const char* source, char* dest, int inputSize, int maxOutputSize)
{
return LZ4HC_compress_generic (LZ4HC_Data, source, dest, inputSize, maxOutputSize, 0, limitedOutput);
}
*/
int
LZ4_compressHC2_continue
(
void
*
LZ4HC_Data
,
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
compressionLevel
)
{
return
LZ4HC_compress_generic
(
LZ4HC_Data
,
source
,
dest
,
inputSize
,
0
,
compressionLevel
,
noLimit
);
}
int
LZ4_compressHC2_limitedOutput_continue
(
void
*
LZ4HC_Data
,
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
maxOutputSize
,
int
compressionLevel
)
{
return
LZ4HC_compress_generic
(
LZ4HC_Data
,
source
,
dest
,
inputSize
,
maxOutputSize
,
compressionLevel
,
limitedOutput
);
}
char
*
LZ4_slideInputBufferHC
(
void
*
LZ4HC_Data
)
{
LZ4HC_Data_Structure
*
hc4
=
(
LZ4HC_Data_Structure
*
)
LZ4HC_Data
;
int
dictSize
=
LZ4_saveDictHC
((
LZ4_streamHC_t
*
)
LZ4HC_Data
,
(
char
*
)(
hc4
->
inputBuffer
),
64
KB
);
return
(
char
*
)(
hc4
->
inputBuffer
+
dictSize
);
}
vendor/github.com/cloudflare/golz4/src/lz4hc.h
0 → 100644
View file @
d0d28566
/*
LZ4 HC - High Compression Mode of LZ4
Header File
Copyright (C) 2011-2014, Yann Collet.
BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following disclaimer
in the documentation and/or other materials provided with the
distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
You can contact the author at :
- LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html
- LZ4 source repository : http://code.google.com/p/lz4/
*/
#pragma once
#if defined (__cplusplus)
extern
"C"
{
#endif
int
LZ4_compressHC
(
const
char
*
source
,
char
*
dest
,
int
inputSize
);
/*
LZ4_compressHC :
return : the number of bytes in compressed buffer dest
or 0 if compression fails.
note : destination buffer must be already allocated.
To avoid any problem, size it to handle worst cases situations (input data not compressible)
Worst case size evaluation is provided by function LZ4_compressBound() (see "lz4.h")
*/
int
LZ4_compressHC_limitedOutput
(
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
maxOutputSize
);
/*
LZ4_compress_limitedOutput() :
Compress 'inputSize' bytes from 'source' into an output buffer 'dest' of maximum size 'maxOutputSize'.
If it cannot achieve it, compression will stop, and result of the function will be zero.
This function never writes outside of provided output buffer.
inputSize : Max supported value is 1 GB
maxOutputSize : is maximum allowed size into the destination buffer (which must be already allocated)
return : the number of output bytes written in buffer 'dest'
or 0 if compression fails.
*/
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
);
/*
Same functions as above, but with programmable 'compressionLevel'.
Recommended values are between 4 and 9, although any value between 0 and 16 will work.
'compressionLevel'==0 means use default 'compressionLevel' value.
Values above 16 behave the same as 16.
Equivalent variants exist for all other compression functions below.
*/
/* Note :
Decompression functions are provided within LZ4 source code (see "lz4.h") (BSD license)
*/
/**************************************
Using an external allocation
**************************************/
int
LZ4_sizeofStateHC
(
void
);
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
);
/*
These functions are provided should you prefer to allocate memory for compression tables with your own allocation methods.
To know how much memory must be allocated for the compression tables, use :
int LZ4_sizeofStateHC();
Note that tables must be aligned for pointer (32 or 64 bits), otherwise compression will fail (return code 0).
The allocated memory can be provided to the compression functions using 'void* state' parameter.
LZ4_compress_withStateHC() and LZ4_compress_limitedOutput_withStateHC() are equivalent to previously described functions.
They just use the externally allocated memory for state instead of allocating their own (on stack, or on heap).
*/
/**************************************
Experimental Streaming Functions
**************************************/
#define LZ4_STREAMHCSIZE_U64 32774
#define LZ4_STREAMHCSIZE (LZ4_STREAMHCSIZE_U64 * sizeof(unsigned long long))
typedef
struct
{
unsigned
long
long
table
[
LZ4_STREAMHCSIZE_U64
];
}
LZ4_streamHC_t
;
/*
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 with statically linked library.
If you want to use LZ4 as a DLL, please use construction functions below, which are more future-proof.
*/
LZ4_streamHC_t
*
LZ4_createStreamHC
(
void
);
int
LZ4_freeStreamHC
(
LZ4_streamHC_t
*
LZ4_streamHCPtr
);
/*
These functions create and release memory for LZ4 HC streaming state.
Newly created states are already initialized.
Existing state space can be re-used anytime using LZ4_resetStreamHC().
If you use LZ4 as a DLL, please use these functions instead of direct struct allocation,
to avoid size mismatch between different versions.
*/
void
LZ4_resetStreamHC
(
LZ4_streamHC_t
*
LZ4_streamHCPtr
,
int
compressionLevel
);
int
LZ4_loadDictHC
(
LZ4_streamHC_t
*
LZ4_streamHCPtr
,
const
char
*
dictionary
,
int
dictSize
);
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
);
int
LZ4_saveDictHC
(
LZ4_streamHC_t
*
LZ4_streamHCPtr
,
char
*
safeBuffer
,
int
maxDictSize
);
/*
These functions compress data in successive blocks of any size, using previous blocks as dictionary.
One key assumption is that each previous block will remain read-accessible while compressing next block.
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).
Then, use LZ4_compressHC_continue() or LZ4_compressHC_limitedOutput_continue() to compress each successive block.
They work like usual LZ4_compressHC() or LZ4_compressHC_limitedOutput(), but use previous memory blocks to improve compression.
Previous memory blocks (including initial dictionary when present) must remain accessible and unmodified during compression.
If, for any reason, previous data block can't be preserved in memory during next compression block,
you must save it to a safer memory space,
using LZ4_saveDictHC().
*/
/**************************************
* Deprecated Streaming Functions
* ************************************/
/* Note : these streaming functions follows the older model, and should no longer be used */
void
*
LZ4_createHC
(
const
char
*
inputBuffer
);
char
*
LZ4_slideInputBufferHC
(
void
*
LZ4HC_Data
);
int
LZ4_freeHC
(
void
*
LZ4HC_Data
);
int
LZ4_compressHC2_continue
(
void
*
LZ4HC_Data
,
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
compressionLevel
);
int
LZ4_compressHC2_limitedOutput_continue
(
void
*
LZ4HC_Data
,
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
maxOutputSize
,
int
compressionLevel
);
int
LZ4_sizeofStreamStateHC
(
void
);
int
LZ4_resetStreamStateHC
(
void
*
state
,
const
char
*
inputBuffer
);
#if defined (__cplusplus)
}
#endif
vendor/github.com/elazarl/go-bindata-assetfs/LICENSE
0 → 100644
View file @
d0d28566
Copyright (c) 2014, Elazar Leibovich
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
vendor/github.com/elazarl/go-bindata-assetfs/README.md
0 → 100644
View file @
d0d28566
# go-bindata-assetfs
Serve embedded files from
[
jteeuwen/go-bindata
](
https://github.com/jteeuwen/go-bindata
)
with
`net/http`
.
[
GoDoc
](
http://godoc.org/github.com/elazarl/go-bindata-assetfs
)
### Installation
Install with
$ go get github.com/jteeuwen/go-bindata/...
$ go get github.com/elazarl/go-bindata-assetfs/...
### Creating embedded data
Usage is identical to
[
jteeuwen/go-bindata
](
https://github.com/jteeuwen/go-bindata
)
usage,
instead of running
`go-bindata`
run
`go-bindata-assetfs`
.
The tool will create a
`bindata_assetfs.go`
file, which contains the embedded data.
A typical use case is
$ go-bindata-assetfs data/...
### Using assetFS in your code
The generated file provides an
`assetFS()`
function that returns a
`http.Filesystem`
wrapping the embedded files. What you usually want to do is:
http.Handle("/", http.FileServer(assetFS()))
This would run an HTTP server serving the embedded files.
## Without running binary tool
You can always just run the
`go-bindata`
tool, and then
use
import "github.com/elazarl/go-bindata-assetfs"
...
http.Handle("/",
http.FileServer(
&assetfs.AssetFS{Asset: Asset, AssetDir: AssetDir, AssetInfo: AssetInfo, Prefix: "data"}))
to serve files embedded from the
`data`
directory.
vendor/github.com/elazarl/go-bindata-assetfs/assetfs.go
0 → 100644
View file @
d0d28566
package
assetfs
import
(
"bytes"
"errors"
"io"
"io/ioutil"
"net/http"
"os"
"path"
"path/filepath"
"strings"
"time"
)
var
(
defaultFileTimestamp
=
time
.
Now
()
)
// FakeFile implements os.FileInfo interface for a given path and size
type
FakeFile
struct
{
// Path is the path of this file
Path
string
// Dir marks of the path is a directory
Dir
bool
// Len is the length of the fake file, zero if it is a directory
Len
int64
// Timestamp is the ModTime of this file
Timestamp
time
.
Time
}
func
(
f
*
FakeFile
)
Name
()
string
{
_
,
name
:=
filepath
.
Split
(
f
.
Path
)
return
name
}
func
(
f
*
FakeFile
)
Mode
()
os
.
FileMode
{
mode
:=
os
.
FileMode
(
0644
)
if
f
.
Dir
{
return
mode
|
os
.
ModeDir
}
return
mode
}
func
(
f
*
FakeFile
)
ModTime
()
time
.
Time
{
return
f
.
Timestamp
}
func
(
f
*
FakeFile
)
Size
()
int64
{
return
f
.
Len
}
func
(
f
*
FakeFile
)
IsDir
()
bool
{
return
f
.
Mode
()
.
IsDir
()
}
func
(
f
*
FakeFile
)
Sys
()
interface
{}
{
return
nil
}
// AssetFile implements http.File interface for a no-directory file with content
type
AssetFile
struct
{
*
bytes
.
Reader
io
.
Closer
FakeFile
}
func
NewAssetFile
(
name
string
,
content
[]
byte
,
timestamp
time
.
Time
)
*
AssetFile
{
if
timestamp
.
IsZero
()
{
timestamp
=
defaultFileTimestamp
}
return
&
AssetFile
{
bytes
.
NewReader
(
content
),
ioutil
.
NopCloser
(
nil
),
FakeFile
{
name
,
false
,
int64
(
len
(
content
)),
timestamp
}}
}
func
(
f
*
AssetFile
)
Readdir
(
count
int
)
([]
os
.
FileInfo
,
error
)
{
return
nil
,
errors
.
New
(
"not a directory"
)
}
func
(
f
*
AssetFile
)
Size
()
int64
{
return
f
.
FakeFile
.
Size
()
}
func
(
f
*
AssetFile
)
Stat
()
(
os
.
FileInfo
,
error
)
{
return
f
,
nil
}
// AssetDirectory implements http.File interface for a directory
type
AssetDirectory
struct
{
AssetFile
ChildrenRead
int
Children
[]
os
.
FileInfo
}
func
NewAssetDirectory
(
name
string
,
children
[]
string
,
fs
*
AssetFS
)
*
AssetDirectory
{
fileinfos
:=
make
([]
os
.
FileInfo
,
0
,
len
(
children
))
for
_
,
child
:=
range
children
{
_
,
err
:=
fs
.
AssetDir
(
filepath
.
Join
(
name
,
child
))
fileinfos
=
append
(
fileinfos
,
&
FakeFile
{
child
,
err
==
nil
,
0
,
time
.
Time
{}})
}
return
&
AssetDirectory
{
AssetFile
{
bytes
.
NewReader
(
nil
),
ioutil
.
NopCloser
(
nil
),
FakeFile
{
name
,
true
,
0
,
time
.
Time
{}},
},
0
,
fileinfos
}
}
func
(
f
*
AssetDirectory
)
Readdir
(
count
int
)
([]
os
.
FileInfo
,
error
)
{
if
count
<=
0
{
return
f
.
Children
,
nil
}
if
f
.
ChildrenRead
+
count
>
len
(
f
.
Children
)
{
count
=
len
(
f
.
Children
)
-
f
.
ChildrenRead
}
rv
:=
f
.
Children
[
f
.
ChildrenRead
:
f
.
ChildrenRead
+
count
]
f
.
ChildrenRead
+=
count
return
rv
,
nil
}
func
(
f
*
AssetDirectory
)
Stat
()
(
os
.
FileInfo
,
error
)
{
return
f
,
nil
}
// AssetFS implements http.FileSystem, allowing
// embedded files to be served from net/http package.
type
AssetFS
struct
{
// Asset should return content of file in path if exists
Asset
func
(
path
string
)
([]
byte
,
error
)
// AssetDir should return list of files in the path
AssetDir
func
(
path
string
)
([]
string
,
error
)
// AssetInfo should return the info of file in path if exists
AssetInfo
func
(
path
string
)
(
os
.
FileInfo
,
error
)
// Prefix would be prepended to http requests
Prefix
string
}
func
(
fs
*
AssetFS
)
Open
(
name
string
)
(
http
.
File
,
error
)
{
name
=
path
.
Join
(
fs
.
Prefix
,
name
)
if
len
(
name
)
>
0
&&
name
[
0
]
==
'/'
{
name
=
name
[
1
:
]
}
if
b
,
err
:=
fs
.
Asset
(
name
);
err
==
nil
{
timestamp
:=
defaultFileTimestamp
if
fs
.
AssetInfo
!=
nil
{
if
info
,
err
:=
fs
.
AssetInfo
(
name
);
err
==
nil
{
timestamp
=
info
.
ModTime
()
}
}
return
NewAssetFile
(
name
,
b
,
timestamp
),
nil
}
if
children
,
err
:=
fs
.
AssetDir
(
name
);
err
==
nil
{
return
NewAssetDirectory
(
name
,
children
,
fs
),
nil
}
else
{
// If the error is not found, return an error that will
// result in a 404 error. Otherwise the server returns
// a 500 error for files not found.
if
strings
.
Contains
(
err
.
Error
(),
"not found"
)
{
return
nil
,
os
.
ErrNotExist
}
return
nil
,
err
}
}
vendor/github.com/elazarl/go-bindata-assetfs/doc.go
0 → 100644
View file @
d0d28566
// assetfs allows packages to serve static content embedded
// with the go-bindata tool with the standard net/http package.
//
// See https://github.com/jteeuwen/go-bindata for more information
// about embedding binary data with go-bindata.
//
// Usage example, after running
// $ go-bindata data/...
// use:
// http.Handle("/",
// http.FileServer(
// &assetfs.AssetFS{Asset: Asset, AssetDir: AssetDir, Prefix: "data"}))
package
assetfs
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment