Gzip-Zopfli
view release on metacpan or search on metacpan
zopfli-one.c view on Meta::CPAN
to this must be made for consecutive bytes.
*/
void ZopfliUpdateHash(const unsigned char* array, size_t pos, size_t end,
ZopfliHash* h);
/*
Prepopulates hash:
Fills in the initial values in the hash, before ZopfliUpdateHash can be used
correctly.
*/
void ZopfliWarmupHash(const unsigned char* array, size_t pos, size_t end,
ZopfliHash* h);
#endif /* ZOPFLI_HASH_H_ */
/* zopfli.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_ZOPFLI_H_
#define ZOPFLI_ZOPFLI_H_
#include <stddef.h>
#include <stdlib.h> /* for size_t */
#ifdef __cplusplus
extern "C" {
#endif
/*
Options used throughout the program.
*/
typedef struct ZopfliOptions {
/* Whether to print output */
int verbose;
/* Whether to print more detailed output */
int verbose_more;
/*
Maximum amount of times to rerun forward and backward pass to optimize LZ77
compression cost. Good values: 10, 15 for small files, 5 for files over
several MB in size or it will be too slow.
*/
int numiterations;
/*
If true, splits the data in multiple deflate blocks with optimal choice
for the block boundaries. Block splitting gives better compression. Default:
true (1).
*/
int blocksplitting;
/*
No longer used, left for compatibility.
*/
int blocksplittinglast;
/*
Maximum amount of blocks to split into (0 for unlimited, but this can give
extreme results that hurt compression on some files). Default value: 15.
*/
int blocksplittingmax;
} ZopfliOptions;
/* Initializes options with default values. */
void ZopfliInitOptions(ZopfliOptions* options);
/* Output format */
typedef enum {
ZOPFLI_FORMAT_GZIP,
ZOPFLI_FORMAT_ZLIB,
ZOPFLI_FORMAT_DEFLATE
} ZopfliFormat;
/*
Compresses according to the given output format and appends the result to the
output.
options: global program options
output_type: the output format to use
out: pointer to the dynamic output array to which the result is appended. Must
be freed after use
outsize: pointer to the dynamic output array size
*/
void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
const unsigned char* in, size_t insize,
unsigned char** out, size_t* outsize);
#ifdef __cplusplus
} // extern "C"
#endif
#endif /* ZOPFLI_ZOPFLI_H_ */
/*
Stores lit/length and dist pairs for LZ77.
Parameter litlens: Contains the literal symbols or length values.
Parameter dists: Contains the distances. A value is 0 to indicate that there is
no dist and the corresponding litlens value is a literal instead of a length.
Parameter size: The size of both the litlens and dists arrays.
The memory can best be managed by using ZopfliInitLZ77Store to initialize it,
ZopfliCleanLZ77Store to destroy it, and ZopfliStoreLitLenDist to append values.
zopfli-one.c view on Meta::CPAN
unsigned short dist, unsigned short length);
/*
Does LZ77 using an algorithm similar to gzip, with lazy matching, rather than
with the slow but better "squeeze" implementation.
The result is placed in the ZopfliLZ77Store.
If instart is larger than 0, it uses values before instart as starting
dictionary.
*/
void ZopfliLZ77Greedy(ZopfliBlockState* s, const unsigned char* in,
size_t instart, size_t inend,
ZopfliLZ77Store* store, ZopfliHash* h);
#endif /* ZOPFLI_LZ77_H_ */
/* zopfli.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_ZOPFLI_H_
#define ZOPFLI_ZOPFLI_H_
#include <stddef.h>
#include <stdlib.h> /* for size_t */
#ifdef __cplusplus
extern "C" {
#endif
/*
Options used throughout the program.
*/
typedef struct ZopfliOptions {
/* Whether to print output */
int verbose;
/* Whether to print more detailed output */
int verbose_more;
/*
Maximum amount of times to rerun forward and backward pass to optimize LZ77
compression cost. Good values: 10, 15 for small files, 5 for files over
several MB in size or it will be too slow.
*/
int numiterations;
/*
If true, splits the data in multiple deflate blocks with optimal choice
for the block boundaries. Block splitting gives better compression. Default:
true (1).
*/
int blocksplitting;
/*
No longer used, left for compatibility.
*/
int blocksplittinglast;
/*
Maximum amount of blocks to split into (0 for unlimited, but this can give
extreme results that hurt compression on some files). Default value: 15.
*/
int blocksplittingmax;
} ZopfliOptions;
/* Initializes options with default values. */
void ZopfliInitOptions(ZopfliOptions* options);
/* Output format */
typedef enum {
ZOPFLI_FORMAT_GZIP,
ZOPFLI_FORMAT_ZLIB,
ZOPFLI_FORMAT_DEFLATE
} ZopfliFormat;
/*
Compresses according to the given output format and appends the result to the
output.
options: global program options
output_type: the output format to use
out: pointer to the dynamic output array to which the result is appended. Must
be freed after use
outsize: pointer to the dynamic output array size
*/
void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
const unsigned char* in, size_t insize,
unsigned char** out, size_t* outsize);
#ifdef __cplusplus
} // extern "C"
#endif
#endif /* ZOPFLI_ZOPFLI_H_ */
/*
Does blocksplitting on LZ77 data.
The output splitpoints are indices in the LZ77 data.
maxblocks: set a limit to the amount of blocks. Set to 0 to mean no limit.
*/
void ZopfliBlockSplitLZ77(const ZopfliOptions* options,
const ZopfliLZ77Store* lz77, size_t maxblocks,
size_t** splitpoints, size_t* npoints);
zopfli-one.c view on Meta::CPAN
to this must be made for consecutive bytes.
*/
void ZopfliUpdateHash(const unsigned char* array, size_t pos, size_t end,
ZopfliHash* h);
/*
Prepopulates hash:
Fills in the initial values in the hash, before ZopfliUpdateHash can be used
correctly.
*/
void ZopfliWarmupHash(const unsigned char* array, size_t pos, size_t end,
ZopfliHash* h);
#endif /* ZOPFLI_HASH_H_ */
/* zopfli.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_ZOPFLI_H_
#define ZOPFLI_ZOPFLI_H_
#include <stddef.h>
#include <stdlib.h> /* for size_t */
#ifdef __cplusplus
extern "C" {
#endif
/*
Options used throughout the program.
*/
typedef struct ZopfliOptions {
/* Whether to print output */
int verbose;
/* Whether to print more detailed output */
int verbose_more;
/*
Maximum amount of times to rerun forward and backward pass to optimize LZ77
compression cost. Good values: 10, 15 for small files, 5 for files over
several MB in size or it will be too slow.
*/
int numiterations;
/*
If true, splits the data in multiple deflate blocks with optimal choice
for the block boundaries. Block splitting gives better compression. Default:
true (1).
*/
int blocksplitting;
/*
No longer used, left for compatibility.
*/
int blocksplittinglast;
/*
Maximum amount of blocks to split into (0 for unlimited, but this can give
extreme results that hurt compression on some files). Default value: 15.
*/
int blocksplittingmax;
} ZopfliOptions;
/* Initializes options with default values. */
void ZopfliInitOptions(ZopfliOptions* options);
/* Output format */
typedef enum {
ZOPFLI_FORMAT_GZIP,
ZOPFLI_FORMAT_ZLIB,
ZOPFLI_FORMAT_DEFLATE
} ZopfliFormat;
/*
Compresses according to the given output format and appends the result to the
output.
options: global program options
output_type: the output format to use
out: pointer to the dynamic output array to which the result is appended. Must
be freed after use
outsize: pointer to the dynamic output array size
*/
void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
const unsigned char* in, size_t insize,
unsigned char** out, size_t* outsize);
#ifdef __cplusplus
} // extern "C"
#endif
#endif /* ZOPFLI_ZOPFLI_H_ */
/*
Stores lit/length and dist pairs for LZ77.
Parameter litlens: Contains the literal symbols or length values.
Parameter dists: Contains the distances. A value is 0 to indicate that there is
no dist and the corresponding litlens value is a literal instead of a length.
Parameter size: The size of both the litlens and dists arrays.
The memory can best be managed by using ZopfliInitLZ77Store to initialize it,
ZopfliCleanLZ77Store to destroy it, and ZopfliStoreLitLenDist to append values.
zopfli-one.c view on Meta::CPAN
unsigned short dist, unsigned short length);
/*
Does LZ77 using an algorithm similar to gzip, with lazy matching, rather than
with the slow but better "squeeze" implementation.
The result is placed in the ZopfliLZ77Store.
If instart is larger than 0, it uses values before instart as starting
dictionary.
*/
void ZopfliLZ77Greedy(ZopfliBlockState* s, const unsigned char* in,
size_t instart, size_t inend,
ZopfliLZ77Store* store, ZopfliHash* h);
#endif /* ZOPFLI_LZ77_H_ */
/* zopfli.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_ZOPFLI_H_
#define ZOPFLI_ZOPFLI_H_
#include <stddef.h>
#include <stdlib.h> /* for size_t */
#ifdef __cplusplus
extern "C" {
#endif
/*
Options used throughout the program.
*/
typedef struct ZopfliOptions {
/* Whether to print output */
int verbose;
/* Whether to print more detailed output */
int verbose_more;
/*
Maximum amount of times to rerun forward and backward pass to optimize LZ77
compression cost. Good values: 10, 15 for small files, 5 for files over
several MB in size or it will be too slow.
*/
int numiterations;
/*
If true, splits the data in multiple deflate blocks with optimal choice
for the block boundaries. Block splitting gives better compression. Default:
true (1).
*/
int blocksplitting;
/*
No longer used, left for compatibility.
*/
int blocksplittinglast;
/*
Maximum amount of blocks to split into (0 for unlimited, but this can give
extreme results that hurt compression on some files). Default value: 15.
*/
int blocksplittingmax;
} ZopfliOptions;
/* Initializes options with default values. */
void ZopfliInitOptions(ZopfliOptions* options);
/* Output format */
typedef enum {
ZOPFLI_FORMAT_GZIP,
ZOPFLI_FORMAT_ZLIB,
ZOPFLI_FORMAT_DEFLATE
} ZopfliFormat;
/*
Compresses according to the given output format and appends the result to the
output.
options: global program options
output_type: the output format to use
out: pointer to the dynamic output array to which the result is appended. Must
be freed after use
outsize: pointer to the dynamic output array size
*/
void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
const unsigned char* in, size_t insize,
unsigned char** out, size_t* outsize);
#ifdef __cplusplus
} // extern "C"
#endif
#endif /* ZOPFLI_ZOPFLI_H_ */
#ifdef __cplusplus
extern "C" {
#endif
/*
Compresses according to the deflate specification and append the compressed
result to the output.
This function will usually output multiple deflate blocks. If final is 1, then
the final bit will be set on the last block.
zopfli-one.c view on Meta::CPAN
to this must be made for consecutive bytes.
*/
void ZopfliUpdateHash(const unsigned char* array, size_t pos, size_t end,
ZopfliHash* h);
/*
Prepopulates hash:
Fills in the initial values in the hash, before ZopfliUpdateHash can be used
correctly.
*/
void ZopfliWarmupHash(const unsigned char* array, size_t pos, size_t end,
ZopfliHash* h);
#endif /* ZOPFLI_HASH_H_ */
/* zopfli.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_ZOPFLI_H_
#define ZOPFLI_ZOPFLI_H_
#include <stddef.h>
#include <stdlib.h> /* for size_t */
#ifdef __cplusplus
extern "C" {
#endif
/*
Options used throughout the program.
*/
typedef struct ZopfliOptions {
/* Whether to print output */
int verbose;
/* Whether to print more detailed output */
int verbose_more;
/*
Maximum amount of times to rerun forward and backward pass to optimize LZ77
compression cost. Good values: 10, 15 for small files, 5 for files over
several MB in size or it will be too slow.
*/
int numiterations;
/*
If true, splits the data in multiple deflate blocks with optimal choice
for the block boundaries. Block splitting gives better compression. Default:
true (1).
*/
int blocksplitting;
/*
No longer used, left for compatibility.
*/
int blocksplittinglast;
/*
Maximum amount of blocks to split into (0 for unlimited, but this can give
extreme results that hurt compression on some files). Default value: 15.
*/
int blocksplittingmax;
} ZopfliOptions;
/* Initializes options with default values. */
void ZopfliInitOptions(ZopfliOptions* options);
/* Output format */
typedef enum {
ZOPFLI_FORMAT_GZIP,
ZOPFLI_FORMAT_ZLIB,
ZOPFLI_FORMAT_DEFLATE
} ZopfliFormat;
/*
Compresses according to the given output format and appends the result to the
output.
options: global program options
output_type: the output format to use
out: pointer to the dynamic output array to which the result is appended. Must
be freed after use
outsize: pointer to the dynamic output array size
*/
void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
const unsigned char* in, size_t insize,
unsigned char** out, size_t* outsize);
#ifdef __cplusplus
} // extern "C"
#endif
#endif /* ZOPFLI_ZOPFLI_H_ */
/*
Stores lit/length and dist pairs for LZ77.
Parameter litlens: Contains the literal symbols or length values.
Parameter dists: Contains the distances. A value is 0 to indicate that there is
no dist and the corresponding litlens value is a literal instead of a length.
Parameter size: The size of both the litlens and dists arrays.
The memory can best be managed by using ZopfliInitLZ77Store to initialize it,
ZopfliCleanLZ77Store to destroy it, and ZopfliStoreLitLenDist to append values.
zopfli-one.c view on Meta::CPAN
#endif
/* The start (inclusive) and end (not inclusive) of the current block. */
size_t blockstart;
size_t blockend;
} ZopfliBlockState;
void ZopfliInitBlockState(const ZopfliOptions* options,
size_t blockstart, size_t blockend, int add_lmc,
ZopfliBlockState* s);
void ZopfliCleanBlockState(ZopfliBlockState* s);
/*
Finds the longest match (length and corresponding distance) for LZ77
compression.
Even when not using "sublen", it can be more efficient to provide an array,
because only then the caching is used.
array: the data
pos: position in the data to find the match for
size: size of the data
limit: limit length to maximum this value (default should be 258). This allows
finding a shorter dist for that length (= less extra bits). Must be
in the range [ZOPFLI_MIN_MATCH, ZOPFLI_MAX_MATCH].
sublen: output array of 259 elements, or null. Has, for each length, the
smallest distance required to reach this length. Only 256 of its 259 values
are used, the first 3 are ignored (the shortest length is 3. It is purely
for convenience that the array is made 3 longer).
*/
void ZopfliFindLongestMatch(
ZopfliBlockState *s, const ZopfliHash* h, const unsigned char* array,
size_t pos, size_t size, size_t limit,
unsigned short* sublen, unsigned short* distance, unsigned short* length);
/*
Verifies if length and dist are indeed valid, only used for assertion.
*/
void ZopfliVerifyLenDist(const unsigned char* data, size_t datasize, size_t pos,
unsigned short dist, unsigned short length);
/*
Does LZ77 using an algorithm similar to gzip, with lazy matching, rather than
with the slow but better "squeeze" implementation.
The result is placed in the ZopfliLZ77Store.
If instart is larger than 0, it uses values before instart as starting
dictionary.
*/
void ZopfliLZ77Greedy(ZopfliBlockState* s, const unsigned char* in,
size_t instart, size_t inend,
ZopfliLZ77Store* store, ZopfliHash* h);
#endif /* ZOPFLI_LZ77_H_ */
/*
Calculates lit/len and dist pairs for given data.
If instart is larger than 0, it uses values before instart as starting
dictionary.
*/
void ZopfliLZ77Optimal(ZopfliBlockState *s,
const unsigned char* in, size_t instart, size_t inend,
int numiterations,
ZopfliLZ77Store* store);
/*
Does the same as ZopfliLZ77Optimal, but optimized for the fixed tree of the
deflate standard.
The fixed tree never gives the best compression. But this gives the best
possible LZ77 encoding possible with the fixed tree.
This does not create or output any fixed tree, only LZ77 data optimized for
using with a fixed tree.
If instart is larger than 0, it uses values before instart as starting
dictionary.
*/
void ZopfliLZ77OptimalFixed(ZopfliBlockState *s,
const unsigned char* in,
size_t instart, size_t inend,
ZopfliLZ77Store* store);
#endif /* ZOPFLI_SQUEEZE_H_ */
/* tree.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
/*
Utilities for creating and using Huffman trees.
*/
#ifndef ZOPFLI_TREE_H_
#define ZOPFLI_TREE_H_
#include <string.h>
/*
Calculates the bitlengths for the Huffman tree, based on the counts of each
symbol.
*/
void ZopfliCalculateBitLengths(const size_t* count, size_t n, int maxbits,
unsigned *bitlengths);
/*
Converts a series of Huffman tree bitlengths, to the bit values of the symbols.
*/
void ZopfliLengthsToSymbols(const unsigned* lengths, size_t n, unsigned maxbits,
unsigned* symbols);
zopfli-one.c view on Meta::CPAN
to this must be made for consecutive bytes.
*/
void ZopfliUpdateHash(const unsigned char* array, size_t pos, size_t end,
ZopfliHash* h);
/*
Prepopulates hash:
Fills in the initial values in the hash, before ZopfliUpdateHash can be used
correctly.
*/
void ZopfliWarmupHash(const unsigned char* array, size_t pos, size_t end,
ZopfliHash* h);
#endif /* ZOPFLI_HASH_H_ */
/* zopfli.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_ZOPFLI_H_
#define ZOPFLI_ZOPFLI_H_
#include <stddef.h>
#include <stdlib.h> /* for size_t */
#ifdef __cplusplus
extern "C" {
#endif
/*
Options used throughout the program.
*/
typedef struct ZopfliOptions {
/* Whether to print output */
int verbose;
/* Whether to print more detailed output */
int verbose_more;
/*
Maximum amount of times to rerun forward and backward pass to optimize LZ77
compression cost. Good values: 10, 15 for small files, 5 for files over
several MB in size or it will be too slow.
*/
int numiterations;
/*
If true, splits the data in multiple deflate blocks with optimal choice
for the block boundaries. Block splitting gives better compression. Default:
true (1).
*/
int blocksplitting;
/*
No longer used, left for compatibility.
*/
int blocksplittinglast;
/*
Maximum amount of blocks to split into (0 for unlimited, but this can give
extreme results that hurt compression on some files). Default value: 15.
*/
int blocksplittingmax;
} ZopfliOptions;
/* Initializes options with default values. */
void ZopfliInitOptions(ZopfliOptions* options);
/* Output format */
typedef enum {
ZOPFLI_FORMAT_GZIP,
ZOPFLI_FORMAT_ZLIB,
ZOPFLI_FORMAT_DEFLATE
} ZopfliFormat;
/*
Compresses according to the given output format and appends the result to the
output.
options: global program options
output_type: the output format to use
out: pointer to the dynamic output array to which the result is appended. Must
be freed after use
outsize: pointer to the dynamic output array size
*/
void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
const unsigned char* in, size_t insize,
unsigned char** out, size_t* outsize);
#ifdef __cplusplus
} // extern "C"
#endif
#endif /* ZOPFLI_ZOPFLI_H_ */
/*
Stores lit/length and dist pairs for LZ77.
Parameter litlens: Contains the literal symbols or length values.
Parameter dists: Contains the distances. A value is 0 to indicate that there is
no dist and the corresponding litlens value is a literal instead of a length.
Parameter size: The size of both the litlens and dists arrays.
The memory can best be managed by using ZopfliInitLZ77Store to initialize it,
ZopfliCleanLZ77Store to destroy it, and ZopfliStoreLitLenDist to append values.
zopfli-one.c view on Meta::CPAN
unsigned short dist, unsigned short length);
/*
Does LZ77 using an algorithm similar to gzip, with lazy matching, rather than
with the slow but better "squeeze" implementation.
The result is placed in the ZopfliLZ77Store.
If instart is larger than 0, it uses values before instart as starting
dictionary.
*/
void ZopfliLZ77Greedy(ZopfliBlockState* s, const unsigned char* in,
size_t instart, size_t inend,
ZopfliLZ77Store* store, ZopfliHash* h);
#endif /* ZOPFLI_LZ77_H_ */
/* zopfli.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_ZOPFLI_H_
#define ZOPFLI_ZOPFLI_H_
#include <stddef.h>
#include <stdlib.h> /* for size_t */
#ifdef __cplusplus
extern "C" {
#endif
/*
Options used throughout the program.
*/
typedef struct ZopfliOptions {
/* Whether to print output */
int verbose;
/* Whether to print more detailed output */
int verbose_more;
/*
Maximum amount of times to rerun forward and backward pass to optimize LZ77
compression cost. Good values: 10, 15 for small files, 5 for files over
several MB in size or it will be too slow.
*/
int numiterations;
/*
If true, splits the data in multiple deflate blocks with optimal choice
for the block boundaries. Block splitting gives better compression. Default:
true (1).
*/
int blocksplitting;
/*
No longer used, left for compatibility.
*/
int blocksplittinglast;
/*
Maximum amount of blocks to split into (0 for unlimited, but this can give
extreme results that hurt compression on some files). Default value: 15.
*/
int blocksplittingmax;
} ZopfliOptions;
/* Initializes options with default values. */
void ZopfliInitOptions(ZopfliOptions* options);
/* Output format */
typedef enum {
ZOPFLI_FORMAT_GZIP,
ZOPFLI_FORMAT_ZLIB,
ZOPFLI_FORMAT_DEFLATE
} ZopfliFormat;
/*
Compresses according to the given output format and appends the result to the
output.
options: global program options
output_type: the output format to use
out: pointer to the dynamic output array to which the result is appended. Must
be freed after use
outsize: pointer to the dynamic output array size
*/
void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
const unsigned char* in, size_t insize,
unsigned char** out, size_t* outsize);
#ifdef __cplusplus
} // extern "C"
#endif
#endif /* ZOPFLI_ZOPFLI_H_ */
#ifdef __cplusplus
extern "C" {
#endif
/*
Compresses according to the deflate specification and append the compressed
result to the output.
This function will usually output multiple deflate blocks. If final is 1, then
the final bit will be set on the last block.
zopfli-one.c view on Meta::CPAN
to this must be made for consecutive bytes.
*/
void ZopfliUpdateHash(const unsigned char* array, size_t pos, size_t end,
ZopfliHash* h);
/*
Prepopulates hash:
Fills in the initial values in the hash, before ZopfliUpdateHash can be used
correctly.
*/
void ZopfliWarmupHash(const unsigned char* array, size_t pos, size_t end,
ZopfliHash* h);
#endif /* ZOPFLI_HASH_H_ */
/* zopfli.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_ZOPFLI_H_
#define ZOPFLI_ZOPFLI_H_
#include <stddef.h>
#include <stdlib.h> /* for size_t */
#ifdef __cplusplus
extern "C" {
#endif
/*
Options used throughout the program.
*/
typedef struct ZopfliOptions {
/* Whether to print output */
int verbose;
/* Whether to print more detailed output */
int verbose_more;
/*
Maximum amount of times to rerun forward and backward pass to optimize LZ77
compression cost. Good values: 10, 15 for small files, 5 for files over
several MB in size or it will be too slow.
*/
int numiterations;
/*
If true, splits the data in multiple deflate blocks with optimal choice
for the block boundaries. Block splitting gives better compression. Default:
true (1).
*/
int blocksplitting;
/*
No longer used, left for compatibility.
*/
int blocksplittinglast;
/*
Maximum amount of blocks to split into (0 for unlimited, but this can give
extreme results that hurt compression on some files). Default value: 15.
*/
int blocksplittingmax;
} ZopfliOptions;
/* Initializes options with default values. */
void ZopfliInitOptions(ZopfliOptions* options);
/* Output format */
typedef enum {
ZOPFLI_FORMAT_GZIP,
ZOPFLI_FORMAT_ZLIB,
ZOPFLI_FORMAT_DEFLATE
} ZopfliFormat;
/*
Compresses according to the given output format and appends the result to the
output.
options: global program options
output_type: the output format to use
out: pointer to the dynamic output array to which the result is appended. Must
be freed after use
outsize: pointer to the dynamic output array size
*/
void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
const unsigned char* in, size_t insize,
unsigned char** out, size_t* outsize);
#ifdef __cplusplus
} // extern "C"
#endif
#endif /* ZOPFLI_ZOPFLI_H_ */
/*
Stores lit/length and dist pairs for LZ77.
Parameter litlens: Contains the literal symbols or length values.
Parameter dists: Contains the distances. A value is 0 to indicate that there is
no dist and the corresponding litlens value is a literal instead of a length.
Parameter size: The size of both the litlens and dists arrays.
The memory can best be managed by using ZopfliInitLZ77Store to initialize it,
ZopfliCleanLZ77Store to destroy it, and ZopfliStoreLitLenDist to append values.
zopfli-one.c view on Meta::CPAN
unsigned short dist, unsigned short length);
/*
Does LZ77 using an algorithm similar to gzip, with lazy matching, rather than
with the slow but better "squeeze" implementation.
The result is placed in the ZopfliLZ77Store.
If instart is larger than 0, it uses values before instart as starting
dictionary.
*/
void ZopfliLZ77Greedy(ZopfliBlockState* s, const unsigned char* in,
size_t instart, size_t inend,
ZopfliLZ77Store* store, ZopfliHash* h);
#endif /* ZOPFLI_LZ77_H_ */
/* zopfli.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_ZOPFLI_H_
#define ZOPFLI_ZOPFLI_H_
#include <stddef.h>
#include <stdlib.h> /* for size_t */
#ifdef __cplusplus
extern "C" {
#endif
/*
Options used throughout the program.
*/
typedef struct ZopfliOptions {
/* Whether to print output */
int verbose;
/* Whether to print more detailed output */
int verbose_more;
/*
Maximum amount of times to rerun forward and backward pass to optimize LZ77
compression cost. Good values: 10, 15 for small files, 5 for files over
several MB in size or it will be too slow.
*/
int numiterations;
/*
If true, splits the data in multiple deflate blocks with optimal choice
for the block boundaries. Block splitting gives better compression. Default:
true (1).
*/
int blocksplitting;
/*
No longer used, left for compatibility.
*/
int blocksplittinglast;
/*
Maximum amount of blocks to split into (0 for unlimited, but this can give
extreme results that hurt compression on some files). Default value: 15.
*/
int blocksplittingmax;
} ZopfliOptions;
/* Initializes options with default values. */
void ZopfliInitOptions(ZopfliOptions* options);
/* Output format */
typedef enum {
ZOPFLI_FORMAT_GZIP,
ZOPFLI_FORMAT_ZLIB,
ZOPFLI_FORMAT_DEFLATE
} ZopfliFormat;
/*
Compresses according to the given output format and appends the result to the
output.
options: global program options
output_type: the output format to use
out: pointer to the dynamic output array to which the result is appended. Must
be freed after use
outsize: pointer to the dynamic output array size
*/
void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
const unsigned char* in, size_t insize,
unsigned char** out, size_t* outsize);
#ifdef __cplusplus
} // extern "C"
#endif
#endif /* ZOPFLI_ZOPFLI_H_ */
/*
Does blocksplitting on LZ77 data.
The output splitpoints are indices in the LZ77 data.
maxblocks: set a limit to the amount of blocks. Set to 0 to mean no limit.
*/
void ZopfliBlockSplitLZ77(const ZopfliOptions* options,
const ZopfliLZ77Store* lz77, size_t maxblocks,
size_t** splitpoints, size_t* npoints);
zopfli-one.c view on Meta::CPAN
to this must be made for consecutive bytes.
*/
void ZopfliUpdateHash(const unsigned char* array, size_t pos, size_t end,
ZopfliHash* h);
/*
Prepopulates hash:
Fills in the initial values in the hash, before ZopfliUpdateHash can be used
correctly.
*/
void ZopfliWarmupHash(const unsigned char* array, size_t pos, size_t end,
ZopfliHash* h);
#endif /* ZOPFLI_HASH_H_ */
/* zopfli.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_ZOPFLI_H_
#define ZOPFLI_ZOPFLI_H_
#include <stddef.h>
#include <stdlib.h> /* for size_t */
#ifdef __cplusplus
extern "C" {
#endif
/*
Options used throughout the program.
*/
typedef struct ZopfliOptions {
/* Whether to print output */
int verbose;
/* Whether to print more detailed output */
int verbose_more;
/*
Maximum amount of times to rerun forward and backward pass to optimize LZ77
compression cost. Good values: 10, 15 for small files, 5 for files over
several MB in size or it will be too slow.
*/
int numiterations;
/*
If true, splits the data in multiple deflate blocks with optimal choice
for the block boundaries. Block splitting gives better compression. Default:
true (1).
*/
int blocksplitting;
/*
No longer used, left for compatibility.
*/
int blocksplittinglast;
/*
Maximum amount of blocks to split into (0 for unlimited, but this can give
extreme results that hurt compression on some files). Default value: 15.
*/
int blocksplittingmax;
} ZopfliOptions;
/* Initializes options with default values. */
void ZopfliInitOptions(ZopfliOptions* options);
/* Output format */
typedef enum {
ZOPFLI_FORMAT_GZIP,
ZOPFLI_FORMAT_ZLIB,
ZOPFLI_FORMAT_DEFLATE
} ZopfliFormat;
/*
Compresses according to the given output format and appends the result to the
output.
options: global program options
output_type: the output format to use
out: pointer to the dynamic output array to which the result is appended. Must
be freed after use
outsize: pointer to the dynamic output array size
*/
void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
const unsigned char* in, size_t insize,
unsigned char** out, size_t* outsize);
#ifdef __cplusplus
} // extern "C"
#endif
#endif /* ZOPFLI_ZOPFLI_H_ */
/*
Stores lit/length and dist pairs for LZ77.
Parameter litlens: Contains the literal symbols or length values.
Parameter dists: Contains the distances. A value is 0 to indicate that there is
no dist and the corresponding litlens value is a literal instead of a length.
Parameter size: The size of both the litlens and dists arrays.
The memory can best be managed by using ZopfliInitLZ77Store to initialize it,
ZopfliCleanLZ77Store to destroy it, and ZopfliStoreLitLenDist to append values.
zopfli-one.c view on Meta::CPAN
#endif
/* The start (inclusive) and end (not inclusive) of the current block. */
size_t blockstart;
size_t blockend;
} ZopfliBlockState;
void ZopfliInitBlockState(const ZopfliOptions* options,
size_t blockstart, size_t blockend, int add_lmc,
ZopfliBlockState* s);
void ZopfliCleanBlockState(ZopfliBlockState* s);
/*
Finds the longest match (length and corresponding distance) for LZ77
compression.
Even when not using "sublen", it can be more efficient to provide an array,
because only then the caching is used.
array: the data
pos: position in the data to find the match for
size: size of the data
limit: limit length to maximum this value (default should be 258). This allows
finding a shorter dist for that length (= less extra bits). Must be
in the range [ZOPFLI_MIN_MATCH, ZOPFLI_MAX_MATCH].
sublen: output array of 259 elements, or null. Has, for each length, the
smallest distance required to reach this length. Only 256 of its 259 values
are used, the first 3 are ignored (the shortest length is 3. It is purely
for convenience that the array is made 3 longer).
*/
void ZopfliFindLongestMatch(
ZopfliBlockState *s, const ZopfliHash* h, const unsigned char* array,
size_t pos, size_t size, size_t limit,
unsigned short* sublen, unsigned short* distance, unsigned short* length);
/*
Verifies if length and dist are indeed valid, only used for assertion.
*/
void ZopfliVerifyLenDist(const unsigned char* data, size_t datasize, size_t pos,
unsigned short dist, unsigned short length);
/*
Does LZ77 using an algorithm similar to gzip, with lazy matching, rather than
with the slow but better "squeeze" implementation.
The result is placed in the ZopfliLZ77Store.
If instart is larger than 0, it uses values before instart as starting
dictionary.
*/
void ZopfliLZ77Greedy(ZopfliBlockState* s, const unsigned char* in,
size_t instart, size_t inend,
ZopfliLZ77Store* store, ZopfliHash* h);
#endif /* ZOPFLI_LZ77_H_ */
/*
Calculates lit/len and dist pairs for given data.
If instart is larger than 0, it uses values before instart as starting
dictionary.
*/
void ZopfliLZ77Optimal(ZopfliBlockState *s,
const unsigned char* in, size_t instart, size_t inend,
int numiterations,
ZopfliLZ77Store* store);
/*
Does the same as ZopfliLZ77Optimal, but optimized for the fixed tree of the
deflate standard.
The fixed tree never gives the best compression. But this gives the best
possible LZ77 encoding possible with the fixed tree.
This does not create or output any fixed tree, only LZ77 data optimized for
using with a fixed tree.
If instart is larger than 0, it uses values before instart as starting
dictionary.
*/
void ZopfliLZ77OptimalFixed(ZopfliBlockState *s,
const unsigned char* in,
size_t instart, size_t inend,
ZopfliLZ77Store* store);
#endif /* ZOPFLI_SQUEEZE_H_ */
/* symbols.h */
/*
Copyright 2016 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
/*
Utilities for using the lz77 symbols of the deflate spec.
*/
#ifndef ZOPFLI_SYMBOLS_H_
#define ZOPFLI_SYMBOLS_H_
/* __has_builtin available in clang */
#ifdef __has_builtin
# if __has_builtin(__builtin_clz)
# define ZOPFLI_HAS_BUILTIN_CLZ
# endif
/* __builtin_clz available beginning with GCC 3.4 */
#elif __GNUC__ * 100 + __GNUC_MINOR__ >= 304
# define ZOPFLI_HAS_BUILTIN_CLZ
#endif
/* Gets the amount of extra bits for the given dist, cfr. the DEFLATE spec. */
static int ZopfliGetDistExtraBits(int dist) {
#ifdef ZOPFLI_HAS_BUILTIN_CLZ
if (dist < 5) return 0;
zopfli-one.c view on Meta::CPAN
/*
Deflate a part, to allow ZopfliDeflate() to use multiple master blocks if
needed.
It is possible to call this function multiple times in a row, shifting
instart and inend to next bytes of the data. If instart is larger than 0, then
previous bytes are used as the initial dictionary for LZ77.
This function will usually output multiple deflate blocks. If final is 1, then
the final bit will be set on the last block.
*/
void ZopfliDeflatePart(const ZopfliOptions* options, int btype, int final,
const unsigned char* in, size_t instart, size_t inend,
unsigned char* bp, unsigned char** out,
size_t* outsize) {
size_t i;
/* byte coordinates rather than lz77 index */
size_t* splitpoints_uncompressed = 0;
size_t npoints = 0;
size_t* splitpoints = 0;
double totalcost = 0;
ZopfliLZ77Store lz77;
/* If btype=2 is specified, it tries all block types. If a lesser btype is
given, then however it forces that one. Neither of the lesser types needs
block splitting as they have no dynamic huffman trees. */
if (btype == 0) {
AddNonCompressedBlock(options, final, in, instart, inend, bp, out, outsize);
return;
} else if (btype == 1) {
ZopfliLZ77Store store;
ZopfliBlockState s;
ZopfliInitLZ77Store(in, &store);
ZopfliInitBlockState(options, instart, inend, 1, &s);
ZopfliLZ77OptimalFixed(&s, in, instart, inend, &store);
AddLZ77Block(options, btype, final, &store, 0, store.size, 0,
bp, out, outsize);
ZopfliCleanBlockState(&s);
ZopfliCleanLZ77Store(&store);
return;
}
if (options->blocksplitting) {
ZopfliBlockSplit(options, in, instart, inend,
options->blocksplittingmax,
&splitpoints_uncompressed, &npoints);
splitpoints = (size_t*)malloc(sizeof(*splitpoints) * npoints);
}
ZopfliInitLZ77Store(in, &lz77);
for (i = 0; i <= npoints; i++) {
size_t start = i == 0 ? instart : splitpoints_uncompressed[i - 1];
size_t end = i == npoints ? inend : splitpoints_uncompressed[i];
ZopfliBlockState s;
ZopfliLZ77Store store;
ZopfliInitLZ77Store(in, &store);
ZopfliInitBlockState(options, start, end, 1, &s);
ZopfliLZ77Optimal(&s, in, start, end, options->numiterations, &store);
totalcost += ZopfliCalculateBlockSizeAutoType(&store, 0, store.size);
ZopfliAppendLZ77Store(&store, &lz77);
if (i < npoints) splitpoints[i] = lz77.size;
ZopfliCleanBlockState(&s);
ZopfliCleanLZ77Store(&store);
}
/* Second block splitting attempt */
if (options->blocksplitting && npoints > 1) {
size_t* splitpoints2 = 0;
size_t npoints2 = 0;
double totalcost2 = 0;
ZopfliBlockSplitLZ77(options, &lz77,
options->blocksplittingmax, &splitpoints2, &npoints2);
for (i = 0; i <= npoints2; i++) {
size_t start = i == 0 ? 0 : splitpoints2[i - 1];
size_t end = i == npoints2 ? lz77.size : splitpoints2[i];
totalcost2 += ZopfliCalculateBlockSizeAutoType(&lz77, start, end);
}
if (totalcost2 < totalcost) {
free(splitpoints);
splitpoints = splitpoints2;
npoints = npoints2;
} else {
free(splitpoints2);
}
}
for (i = 0; i <= npoints; i++) {
size_t start = i == 0 ? 0 : splitpoints[i - 1];
size_t end = i == npoints ? lz77.size : splitpoints[i];
AddLZ77BlockAutoType(options, i == npoints && final,
&lz77, start, end, 0,
bp, out, outsize);
}
ZopfliCleanLZ77Store(&lz77);
free(splitpoints);
free(splitpoints_uncompressed);
}
void ZopfliDeflate(const ZopfliOptions* options, int btype, int final,
const unsigned char* in, size_t insize,
unsigned char* bp, unsigned char** out, size_t* outsize) {
size_t offset = *outsize;
#if ZOPFLI_MASTER_BLOCK_SIZE == 0
ZopfliDeflatePart(options, btype, final, in, 0, insize, bp, out, outsize);
#else
size_t i = 0;
do {
int masterfinal = (i + ZOPFLI_MASTER_BLOCK_SIZE >= insize);
int final2 = final && masterfinal;
size_t size = masterfinal ? insize - i : ZOPFLI_MASTER_BLOCK_SIZE;
ZopfliDeflatePart(options, btype, final2,
in, i, i + size, bp, out, outsize);
zopfli-one.c view on Meta::CPAN
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_GZIP_H_
#define ZOPFLI_GZIP_H_
/*
Functions to compress according to the Gzip specification.
*/
/* zopfli.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_ZOPFLI_H_
#define ZOPFLI_ZOPFLI_H_
#include <stddef.h>
#include <stdlib.h> /* for size_t */
#ifdef __cplusplus
extern "C" {
#endif
/*
Options used throughout the program.
*/
typedef struct ZopfliOptions {
/* Whether to print output */
int verbose;
/* Whether to print more detailed output */
int verbose_more;
/*
Maximum amount of times to rerun forward and backward pass to optimize LZ77
compression cost. Good values: 10, 15 for small files, 5 for files over
several MB in size or it will be too slow.
*/
int numiterations;
/*
If true, splits the data in multiple deflate blocks with optimal choice
for the block boundaries. Block splitting gives better compression. Default:
true (1).
*/
int blocksplitting;
/*
No longer used, left for compatibility.
*/
int blocksplittinglast;
/*
Maximum amount of blocks to split into (0 for unlimited, but this can give
extreme results that hurt compression on some files). Default value: 15.
*/
int blocksplittingmax;
} ZopfliOptions;
/* Initializes options with default values. */
void ZopfliInitOptions(ZopfliOptions* options);
/* Output format */
typedef enum {
ZOPFLI_FORMAT_GZIP,
ZOPFLI_FORMAT_ZLIB,
ZOPFLI_FORMAT_DEFLATE
} ZopfliFormat;
/*
Compresses according to the given output format and appends the result to the
output.
options: global program options
output_type: the output format to use
out: pointer to the dynamic output array to which the result is appended. Must
be freed after use
outsize: pointer to the dynamic output array size
*/
void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
const unsigned char* in, size_t insize,
unsigned char** out, size_t* outsize);
#ifdef __cplusplus
} // extern "C"
#endif
#endif /* ZOPFLI_ZOPFLI_H_ */
#ifdef __cplusplus
extern "C" {
#endif
/*
Compresses according to the gzip specification and append the compressed
result to the output.
options: global program options
zopfli-one.c view on Meta::CPAN
to this must be made for consecutive bytes.
*/
void ZopfliUpdateHash(const unsigned char* array, size_t pos, size_t end,
ZopfliHash* h);
/*
Prepopulates hash:
Fills in the initial values in the hash, before ZopfliUpdateHash can be used
correctly.
*/
void ZopfliWarmupHash(const unsigned char* array, size_t pos, size_t end,
ZopfliHash* h);
#endif /* ZOPFLI_HASH_H_ */
/* zopfli.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_ZOPFLI_H_
#define ZOPFLI_ZOPFLI_H_
#include <stddef.h>
#include <stdlib.h> /* for size_t */
#ifdef __cplusplus
extern "C" {
#endif
/*
Options used throughout the program.
*/
typedef struct ZopfliOptions {
/* Whether to print output */
int verbose;
/* Whether to print more detailed output */
int verbose_more;
/*
Maximum amount of times to rerun forward and backward pass to optimize LZ77
compression cost. Good values: 10, 15 for small files, 5 for files over
several MB in size or it will be too slow.
*/
int numiterations;
/*
If true, splits the data in multiple deflate blocks with optimal choice
for the block boundaries. Block splitting gives better compression. Default:
true (1).
*/
int blocksplitting;
/*
No longer used, left for compatibility.
*/
int blocksplittinglast;
/*
Maximum amount of blocks to split into (0 for unlimited, but this can give
extreme results that hurt compression on some files). Default value: 15.
*/
int blocksplittingmax;
} ZopfliOptions;
/* Initializes options with default values. */
void ZopfliInitOptions(ZopfliOptions* options);
/* Output format */
typedef enum {
ZOPFLI_FORMAT_GZIP,
ZOPFLI_FORMAT_ZLIB,
ZOPFLI_FORMAT_DEFLATE
} ZopfliFormat;
/*
Compresses according to the given output format and appends the result to the
output.
options: global program options
output_type: the output format to use
out: pointer to the dynamic output array to which the result is appended. Must
be freed after use
outsize: pointer to the dynamic output array size
*/
void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
const unsigned char* in, size_t insize,
unsigned char** out, size_t* outsize);
#ifdef __cplusplus
} // extern "C"
#endif
#endif /* ZOPFLI_ZOPFLI_H_ */
/*
Stores lit/length and dist pairs for LZ77.
Parameter litlens: Contains the literal symbols or length values.
Parameter dists: Contains the distances. A value is 0 to indicate that there is
no dist and the corresponding litlens value is a literal instead of a length.
Parameter size: The size of both the litlens and dists arrays.
The memory can best be managed by using ZopfliInitLZ77Store to initialize it,
ZopfliCleanLZ77Store to destroy it, and ZopfliStoreLitLenDist to append values.
zopfli-one.c view on Meta::CPAN
unsigned short dist, unsigned short length);
/*
Does LZ77 using an algorithm similar to gzip, with lazy matching, rather than
with the slow but better "squeeze" implementation.
The result is placed in the ZopfliLZ77Store.
If instart is larger than 0, it uses values before instart as starting
dictionary.
*/
void ZopfliLZ77Greedy(ZopfliBlockState* s, const unsigned char* in,
size_t instart, size_t inend,
ZopfliLZ77Store* store, ZopfliHash* h);
#endif /* ZOPFLI_LZ77_H_ */
/* zopfli.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_ZOPFLI_H_
#define ZOPFLI_ZOPFLI_H_
#include <stddef.h>
#include <stdlib.h> /* for size_t */
#ifdef __cplusplus
extern "C" {
#endif
/*
Options used throughout the program.
*/
typedef struct ZopfliOptions {
/* Whether to print output */
int verbose;
/* Whether to print more detailed output */
int verbose_more;
/*
Maximum amount of times to rerun forward and backward pass to optimize LZ77
compression cost. Good values: 10, 15 for small files, 5 for files over
several MB in size or it will be too slow.
*/
int numiterations;
/*
If true, splits the data in multiple deflate blocks with optimal choice
for the block boundaries. Block splitting gives better compression. Default:
true (1).
*/
int blocksplitting;
/*
No longer used, left for compatibility.
*/
int blocksplittinglast;
/*
Maximum amount of blocks to split into (0 for unlimited, but this can give
extreme results that hurt compression on some files). Default value: 15.
*/
int blocksplittingmax;
} ZopfliOptions;
/* Initializes options with default values. */
void ZopfliInitOptions(ZopfliOptions* options);
/* Output format */
typedef enum {
ZOPFLI_FORMAT_GZIP,
ZOPFLI_FORMAT_ZLIB,
ZOPFLI_FORMAT_DEFLATE
} ZopfliFormat;
/*
Compresses according to the given output format and appends the result to the
output.
options: global program options
output_type: the output format to use
out: pointer to the dynamic output array to which the result is appended. Must
be freed after use
outsize: pointer to the dynamic output array size
*/
void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
const unsigned char* in, size_t insize,
unsigned char** out, size_t* outsize);
#ifdef __cplusplus
} // extern "C"
#endif
#endif /* ZOPFLI_ZOPFLI_H_ */
#ifdef __cplusplus
extern "C" {
#endif
/*
Compresses according to the deflate specification and append the compressed
result to the output.
This function will usually output multiple deflate blocks. If final is 1, then
the final bit will be set on the last block.
zopfli-one.c view on Meta::CPAN
to this must be made for consecutive bytes.
*/
void ZopfliUpdateHash(const unsigned char* array, size_t pos, size_t end,
ZopfliHash* h);
/*
Prepopulates hash:
Fills in the initial values in the hash, before ZopfliUpdateHash can be used
correctly.
*/
void ZopfliWarmupHash(const unsigned char* array, size_t pos, size_t end,
ZopfliHash* h);
#endif /* ZOPFLI_HASH_H_ */
/* zopfli.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_ZOPFLI_H_
#define ZOPFLI_ZOPFLI_H_
#include <stddef.h>
#include <stdlib.h> /* for size_t */
#ifdef __cplusplus
extern "C" {
#endif
/*
Options used throughout the program.
*/
typedef struct ZopfliOptions {
/* Whether to print output */
int verbose;
/* Whether to print more detailed output */
int verbose_more;
/*
Maximum amount of times to rerun forward and backward pass to optimize LZ77
compression cost. Good values: 10, 15 for small files, 5 for files over
several MB in size or it will be too slow.
*/
int numiterations;
/*
If true, splits the data in multiple deflate blocks with optimal choice
for the block boundaries. Block splitting gives better compression. Default:
true (1).
*/
int blocksplitting;
/*
No longer used, left for compatibility.
*/
int blocksplittinglast;
/*
Maximum amount of blocks to split into (0 for unlimited, but this can give
extreme results that hurt compression on some files). Default value: 15.
*/
int blocksplittingmax;
} ZopfliOptions;
/* Initializes options with default values. */
void ZopfliInitOptions(ZopfliOptions* options);
/* Output format */
typedef enum {
ZOPFLI_FORMAT_GZIP,
ZOPFLI_FORMAT_ZLIB,
ZOPFLI_FORMAT_DEFLATE
} ZopfliFormat;
/*
Compresses according to the given output format and appends the result to the
output.
options: global program options
output_type: the output format to use
out: pointer to the dynamic output array to which the result is appended. Must
be freed after use
outsize: pointer to the dynamic output array size
*/
void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
const unsigned char* in, size_t insize,
unsigned char** out, size_t* outsize);
#ifdef __cplusplus
} // extern "C"
#endif
#endif /* ZOPFLI_ZOPFLI_H_ */
/*
Stores lit/length and dist pairs for LZ77.
Parameter litlens: Contains the literal symbols or length values.
Parameter dists: Contains the distances. A value is 0 to indicate that there is
no dist and the corresponding litlens value is a literal instead of a length.
Parameter size: The size of both the litlens and dists arrays.
The memory can best be managed by using ZopfliInitLZ77Store to initialize it,
ZopfliCleanLZ77Store to destroy it, and ZopfliStoreLitLenDist to append values.
zopfli-one.c view on Meta::CPAN
to this must be made for consecutive bytes.
*/
void ZopfliUpdateHash(const unsigned char* array, size_t pos, size_t end,
ZopfliHash* h);
/*
Prepopulates hash:
Fills in the initial values in the hash, before ZopfliUpdateHash can be used
correctly.
*/
void ZopfliWarmupHash(const unsigned char* array, size_t pos, size_t end,
ZopfliHash* h);
#endif /* ZOPFLI_HASH_H_ */
/* zopfli.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_ZOPFLI_H_
#define ZOPFLI_ZOPFLI_H_
#include <stddef.h>
#include <stdlib.h> /* for size_t */
#ifdef __cplusplus
extern "C" {
#endif
/*
Options used throughout the program.
*/
typedef struct ZopfliOptions {
/* Whether to print output */
int verbose;
/* Whether to print more detailed output */
int verbose_more;
/*
Maximum amount of times to rerun forward and backward pass to optimize LZ77
compression cost. Good values: 10, 15 for small files, 5 for files over
several MB in size or it will be too slow.
*/
int numiterations;
/*
If true, splits the data in multiple deflate blocks with optimal choice
for the block boundaries. Block splitting gives better compression. Default:
true (1).
*/
int blocksplitting;
/*
No longer used, left for compatibility.
*/
int blocksplittinglast;
/*
Maximum amount of blocks to split into (0 for unlimited, but this can give
extreme results that hurt compression on some files). Default value: 15.
*/
int blocksplittingmax;
} ZopfliOptions;
/* Initializes options with default values. */
void ZopfliInitOptions(ZopfliOptions* options);
/* Output format */
typedef enum {
ZOPFLI_FORMAT_GZIP,
ZOPFLI_FORMAT_ZLIB,
ZOPFLI_FORMAT_DEFLATE
} ZopfliFormat;
/*
Compresses according to the given output format and appends the result to the
output.
options: global program options
output_type: the output format to use
out: pointer to the dynamic output array to which the result is appended. Must
be freed after use
outsize: pointer to the dynamic output array size
*/
void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
const unsigned char* in, size_t insize,
unsigned char** out, size_t* outsize);
#ifdef __cplusplus
} // extern "C"
#endif
#endif /* ZOPFLI_ZOPFLI_H_ */
/*
Stores lit/length and dist pairs for LZ77.
Parameter litlens: Contains the literal symbols or length values.
Parameter dists: Contains the distances. A value is 0 to indicate that there is
no dist and the corresponding litlens value is a literal instead of a length.
Parameter size: The size of both the litlens and dists arrays.
The memory can best be managed by using ZopfliInitLZ77Store to initialize it,
ZopfliCleanLZ77Store to destroy it, and ZopfliStoreLitLenDist to append values.
zopfli-one.c view on Meta::CPAN
#endif
/* The start (inclusive) and end (not inclusive) of the current block. */
size_t blockstart;
size_t blockend;
} ZopfliBlockState;
void ZopfliInitBlockState(const ZopfliOptions* options,
size_t blockstart, size_t blockend, int add_lmc,
ZopfliBlockState* s);
void ZopfliCleanBlockState(ZopfliBlockState* s);
/*
Finds the longest match (length and corresponding distance) for LZ77
compression.
Even when not using "sublen", it can be more efficient to provide an array,
because only then the caching is used.
array: the data
pos: position in the data to find the match for
size: size of the data
limit: limit length to maximum this value (default should be 258). This allows
finding a shorter dist for that length (= less extra bits). Must be
in the range [ZOPFLI_MIN_MATCH, ZOPFLI_MAX_MATCH].
sublen: output array of 259 elements, or null. Has, for each length, the
smallest distance required to reach this length. Only 256 of its 259 values
are used, the first 3 are ignored (the shortest length is 3. It is purely
for convenience that the array is made 3 longer).
*/
void ZopfliFindLongestMatch(
ZopfliBlockState *s, const ZopfliHash* h, const unsigned char* array,
size_t pos, size_t size, size_t limit,
unsigned short* sublen, unsigned short* distance, unsigned short* length);
/*
Verifies if length and dist are indeed valid, only used for assertion.
*/
void ZopfliVerifyLenDist(const unsigned char* data, size_t datasize, size_t pos,
unsigned short dist, unsigned short length);
/*
Does LZ77 using an algorithm similar to gzip, with lazy matching, rather than
with the slow but better "squeeze" implementation.
The result is placed in the ZopfliLZ77Store.
If instart is larger than 0, it uses values before instart as starting
dictionary.
*/
void ZopfliLZ77Greedy(ZopfliBlockState* s, const unsigned char* in,
size_t instart, size_t inend,
ZopfliLZ77Store* store, ZopfliHash* h);
#endif /* ZOPFLI_LZ77_H_ */
/*
Calculates lit/len and dist pairs for given data.
If instart is larger than 0, it uses values before instart as starting
dictionary.
*/
void ZopfliLZ77Optimal(ZopfliBlockState *s,
const unsigned char* in, size_t instart, size_t inend,
int numiterations,
ZopfliLZ77Store* store);
/*
Does the same as ZopfliLZ77Optimal, but optimized for the fixed tree of the
deflate standard.
The fixed tree never gives the best compression. But this gives the best
possible LZ77 encoding possible with the fixed tree.
This does not create or output any fixed tree, only LZ77 data optimized for
using with a fixed tree.
If instart is larger than 0, it uses values before instart as starting
dictionary.
*/
void ZopfliLZ77OptimalFixed(ZopfliBlockState *s,
const unsigned char* in,
size_t instart, size_t inend,
ZopfliLZ77Store* store);
#endif /* ZOPFLI_SQUEEZE_H_ */
#include <assert.h>
#include <math.h>
#include <stdio.h>
/* blocksplitter.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
/*
Functions to choose good boundaries for block splitting. Deflate allows encoding
the data in multiple blocks, with a separate Huffman tree for each block. The
Huffman tree itself requires some bytes to encode, so by choosing certain
blocks, you can either hurt, or enhance compression. These functions choose good
ones that enhance it.
*/
#ifndef ZOPFLI_BLOCKSPLITTER_H_
#define ZOPFLI_BLOCKSPLITTER_H_
#include <stdlib.h>
/* lz77.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
zopfli-one.c view on Meta::CPAN
to this must be made for consecutive bytes.
*/
void ZopfliUpdateHash(const unsigned char* array, size_t pos, size_t end,
ZopfliHash* h);
/*
Prepopulates hash:
Fills in the initial values in the hash, before ZopfliUpdateHash can be used
correctly.
*/
void ZopfliWarmupHash(const unsigned char* array, size_t pos, size_t end,
ZopfliHash* h);
#endif /* ZOPFLI_HASH_H_ */
/* zopfli.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_ZOPFLI_H_
#define ZOPFLI_ZOPFLI_H_
#include <stddef.h>
#include <stdlib.h> /* for size_t */
#ifdef __cplusplus
extern "C" {
#endif
/*
Options used throughout the program.
*/
typedef struct ZopfliOptions {
/* Whether to print output */
int verbose;
/* Whether to print more detailed output */
int verbose_more;
/*
Maximum amount of times to rerun forward and backward pass to optimize LZ77
compression cost. Good values: 10, 15 for small files, 5 for files over
several MB in size or it will be too slow.
*/
int numiterations;
/*
If true, splits the data in multiple deflate blocks with optimal choice
for the block boundaries. Block splitting gives better compression. Default:
true (1).
*/
int blocksplitting;
/*
No longer used, left for compatibility.
*/
int blocksplittinglast;
/*
Maximum amount of blocks to split into (0 for unlimited, but this can give
extreme results that hurt compression on some files). Default value: 15.
*/
int blocksplittingmax;
} ZopfliOptions;
/* Initializes options with default values. */
void ZopfliInitOptions(ZopfliOptions* options);
/* Output format */
typedef enum {
ZOPFLI_FORMAT_GZIP,
ZOPFLI_FORMAT_ZLIB,
ZOPFLI_FORMAT_DEFLATE
} ZopfliFormat;
/*
Compresses according to the given output format and appends the result to the
output.
options: global program options
output_type: the output format to use
out: pointer to the dynamic output array to which the result is appended. Must
be freed after use
outsize: pointer to the dynamic output array size
*/
void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
const unsigned char* in, size_t insize,
unsigned char** out, size_t* outsize);
#ifdef __cplusplus
} // extern "C"
#endif
#endif /* ZOPFLI_ZOPFLI_H_ */
/*
Stores lit/length and dist pairs for LZ77.
Parameter litlens: Contains the literal symbols or length values.
Parameter dists: Contains the distances. A value is 0 to indicate that there is
no dist and the corresponding litlens value is a literal instead of a length.
Parameter size: The size of both the litlens and dists arrays.
The memory can best be managed by using ZopfliInitLZ77Store to initialize it,
ZopfliCleanLZ77Store to destroy it, and ZopfliStoreLitLenDist to append values.
zopfli-one.c view on Meta::CPAN
unsigned short dist, unsigned short length);
/*
Does LZ77 using an algorithm similar to gzip, with lazy matching, rather than
with the slow but better "squeeze" implementation.
The result is placed in the ZopfliLZ77Store.
If instart is larger than 0, it uses values before instart as starting
dictionary.
*/
void ZopfliLZ77Greedy(ZopfliBlockState* s, const unsigned char* in,
size_t instart, size_t inend,
ZopfliLZ77Store* store, ZopfliHash* h);
#endif /* ZOPFLI_LZ77_H_ */
/* zopfli.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_ZOPFLI_H_
#define ZOPFLI_ZOPFLI_H_
#include <stddef.h>
#include <stdlib.h> /* for size_t */
#ifdef __cplusplus
extern "C" {
#endif
/*
Options used throughout the program.
*/
typedef struct ZopfliOptions {
/* Whether to print output */
int verbose;
/* Whether to print more detailed output */
int verbose_more;
/*
Maximum amount of times to rerun forward and backward pass to optimize LZ77
compression cost. Good values: 10, 15 for small files, 5 for files over
several MB in size or it will be too slow.
*/
int numiterations;
/*
If true, splits the data in multiple deflate blocks with optimal choice
for the block boundaries. Block splitting gives better compression. Default:
true (1).
*/
int blocksplitting;
/*
No longer used, left for compatibility.
*/
int blocksplittinglast;
/*
Maximum amount of blocks to split into (0 for unlimited, but this can give
extreme results that hurt compression on some files). Default value: 15.
*/
int blocksplittingmax;
} ZopfliOptions;
/* Initializes options with default values. */
void ZopfliInitOptions(ZopfliOptions* options);
/* Output format */
typedef enum {
ZOPFLI_FORMAT_GZIP,
ZOPFLI_FORMAT_ZLIB,
ZOPFLI_FORMAT_DEFLATE
} ZopfliFormat;
/*
Compresses according to the given output format and appends the result to the
output.
options: global program options
output_type: the output format to use
out: pointer to the dynamic output array to which the result is appended. Must
be freed after use
outsize: pointer to the dynamic output array size
*/
void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
const unsigned char* in, size_t insize,
unsigned char** out, size_t* outsize);
#ifdef __cplusplus
} // extern "C"
#endif
#endif /* ZOPFLI_ZOPFLI_H_ */
/*
Does blocksplitting on LZ77 data.
The output splitpoints are indices in the LZ77 data.
maxblocks: set a limit to the amount of blocks. Set to 0 to mean no limit.
*/
void ZopfliBlockSplitLZ77(const ZopfliOptions* options,
const ZopfliLZ77Store* lz77, size_t maxblocks,
size_t** splitpoints, size_t* npoints);
zopfli-one.c view on Meta::CPAN
to this must be made for consecutive bytes.
*/
void ZopfliUpdateHash(const unsigned char* array, size_t pos, size_t end,
ZopfliHash* h);
/*
Prepopulates hash:
Fills in the initial values in the hash, before ZopfliUpdateHash can be used
correctly.
*/
void ZopfliWarmupHash(const unsigned char* array, size_t pos, size_t end,
ZopfliHash* h);
#endif /* ZOPFLI_HASH_H_ */
/* zopfli.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_ZOPFLI_H_
#define ZOPFLI_ZOPFLI_H_
#include <stddef.h>
#include <stdlib.h> /* for size_t */
#ifdef __cplusplus
extern "C" {
#endif
/*
Options used throughout the program.
*/
typedef struct ZopfliOptions {
/* Whether to print output */
int verbose;
/* Whether to print more detailed output */
int verbose_more;
/*
Maximum amount of times to rerun forward and backward pass to optimize LZ77
compression cost. Good values: 10, 15 for small files, 5 for files over
several MB in size or it will be too slow.
*/
int numiterations;
/*
If true, splits the data in multiple deflate blocks with optimal choice
for the block boundaries. Block splitting gives better compression. Default:
true (1).
*/
int blocksplitting;
/*
No longer used, left for compatibility.
*/
int blocksplittinglast;
/*
Maximum amount of blocks to split into (0 for unlimited, but this can give
extreme results that hurt compression on some files). Default value: 15.
*/
int blocksplittingmax;
} ZopfliOptions;
/* Initializes options with default values. */
void ZopfliInitOptions(ZopfliOptions* options);
/* Output format */
typedef enum {
ZOPFLI_FORMAT_GZIP,
ZOPFLI_FORMAT_ZLIB,
ZOPFLI_FORMAT_DEFLATE
} ZopfliFormat;
/*
Compresses according to the given output format and appends the result to the
output.
options: global program options
output_type: the output format to use
out: pointer to the dynamic output array to which the result is appended. Must
be freed after use
outsize: pointer to the dynamic output array size
*/
void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
const unsigned char* in, size_t insize,
unsigned char** out, size_t* outsize);
#ifdef __cplusplus
} // extern "C"
#endif
#endif /* ZOPFLI_ZOPFLI_H_ */
/*
Stores lit/length and dist pairs for LZ77.
Parameter litlens: Contains the literal symbols or length values.
Parameter dists: Contains the distances. A value is 0 to indicate that there is
no dist and the corresponding litlens value is a literal instead of a length.
Parameter size: The size of both the litlens and dists arrays.
The memory can best be managed by using ZopfliInitLZ77Store to initialize it,
ZopfliCleanLZ77Store to destroy it, and ZopfliStoreLitLenDist to append values.
zopfli-one.c view on Meta::CPAN
unsigned short dist, unsigned short length);
/*
Does LZ77 using an algorithm similar to gzip, with lazy matching, rather than
with the slow but better "squeeze" implementation.
The result is placed in the ZopfliLZ77Store.
If instart is larger than 0, it uses values before instart as starting
dictionary.
*/
void ZopfliLZ77Greedy(ZopfliBlockState* s, const unsigned char* in,
size_t instart, size_t inend,
ZopfliLZ77Store* store, ZopfliHash* h);
#endif /* ZOPFLI_LZ77_H_ */
/* zopfli.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_ZOPFLI_H_
#define ZOPFLI_ZOPFLI_H_
#include <stddef.h>
#include <stdlib.h> /* for size_t */
#ifdef __cplusplus
extern "C" {
#endif
/*
Options used throughout the program.
*/
typedef struct ZopfliOptions {
/* Whether to print output */
int verbose;
/* Whether to print more detailed output */
int verbose_more;
/*
Maximum amount of times to rerun forward and backward pass to optimize LZ77
compression cost. Good values: 10, 15 for small files, 5 for files over
several MB in size or it will be too slow.
*/
int numiterations;
/*
If true, splits the data in multiple deflate blocks with optimal choice
for the block boundaries. Block splitting gives better compression. Default:
true (1).
*/
int blocksplitting;
/*
No longer used, left for compatibility.
*/
int blocksplittinglast;
/*
Maximum amount of blocks to split into (0 for unlimited, but this can give
extreme results that hurt compression on some files). Default value: 15.
*/
int blocksplittingmax;
} ZopfliOptions;
/* Initializes options with default values. */
void ZopfliInitOptions(ZopfliOptions* options);
/* Output format */
typedef enum {
ZOPFLI_FORMAT_GZIP,
ZOPFLI_FORMAT_ZLIB,
ZOPFLI_FORMAT_DEFLATE
} ZopfliFormat;
/*
Compresses according to the given output format and appends the result to the
output.
options: global program options
output_type: the output format to use
out: pointer to the dynamic output array to which the result is appended. Must
be freed after use
outsize: pointer to the dynamic output array size
*/
void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
const unsigned char* in, size_t insize,
unsigned char** out, size_t* outsize);
#ifdef __cplusplus
} // extern "C"
#endif
#endif /* ZOPFLI_ZOPFLI_H_ */
#ifdef __cplusplus
extern "C" {
#endif
/*
Compresses according to the deflate specification and append the compressed
result to the output.
This function will usually output multiple deflate blocks. If final is 1, then
the final bit will be set on the last block.
zopfli-one.c view on Meta::CPAN
}
}
/* Calculates the entropy of the statistics */
static void CalculateStatistics(SymbolStats* stats) {
ZopfliCalculateEntropy(stats->litlens, ZOPFLI_NUM_LL, stats->ll_symbols);
ZopfliCalculateEntropy(stats->dists, ZOPFLI_NUM_D, stats->d_symbols);
}
/* Appends the symbol statistics from the store. */
static void GetStatistics(const ZopfliLZ77Store* store, SymbolStats* stats) {
size_t i;
for (i = 0; i < store->size; i++) {
if (store->dists[i] == 0) {
stats->litlens[store->litlens[i]]++;
} else {
stats->litlens[ZopfliGetLengthSymbol(store->litlens[i])]++;
stats->dists[ZopfliGetDistSymbol(store->dists[i])]++;
}
}
stats->litlens[256] = 1; /* End symbol. */
CalculateStatistics(stats);
}
/*
Does a single run for ZopfliLZ77Optimal. For good compression, repeated runs
with updated statistics should be performed.
s: the block state
in: the input data array
instart: where to start
inend: where to stop (not inclusive)
path: pointer to dynamically allocated memory to store the path
pathsize: pointer to the size of the dynamic path array
length_array: array of size (inend - instart) used to store lengths
costmodel: function to use as the cost model for this squeeze run
costcontext: abstract context for the costmodel function
store: place to output the LZ77 data
returns the cost that was, according to the costmodel, needed to get to the end.
This is not the actual cost.
*/
static double LZ77OptimalRun(ZopfliBlockState* s,
const unsigned char* in, size_t instart, size_t inend,
unsigned short** path, size_t* pathsize,
unsigned short* length_array, CostModelFun* costmodel,
void* costcontext, ZopfliLZ77Store* store,
ZopfliHash* h, float* costs) {
double cost = GetBestLengths(s, in, instart, inend, costmodel,
costcontext, length_array, h, costs);
free(*path);
*path = 0;
*pathsize = 0;
TraceBackwards(inend - instart, length_array, path, pathsize);
FollowPath(s, in, instart, inend, *path, *pathsize, store, h);
assert(cost < ZOPFLI_LARGE_FLOAT);
return cost;
}
void ZopfliLZ77Optimal(ZopfliBlockState *s,
const unsigned char* in, size_t instart, size_t inend,
int numiterations,
ZopfliLZ77Store* store) {
/* Dist to get to here with smallest cost. */
size_t blocksize = inend - instart;
unsigned short* length_array =
(unsigned short*)malloc(sizeof(unsigned short) * (blocksize + 1));
unsigned short* path = 0;
size_t pathsize = 0;
ZopfliLZ77Store currentstore;
ZopfliHash hash;
ZopfliHash* h = &hash;
SymbolStats stats, beststats, laststats;
int i;
float* costs = (float*)malloc(sizeof(float) * (blocksize + 1));
double cost;
double bestcost = ZOPFLI_LARGE_FLOAT;
double lastcost = 0;
/* Try randomizing the costs a bit once the size stabilizes. */
RanState ran_state;
int lastrandomstep = -1;
if (!costs) exit(-1); /* Allocation failed. */
if (!length_array) exit(-1); /* Allocation failed. */
InitRanState(&ran_state);
InitStats(&stats);
ZopfliInitLZ77Store(in, ¤tstore);
ZopfliAllocHash(ZOPFLI_WINDOW_SIZE, h);
/* Do regular deflate, then loop multiple shortest path runs, each time using
the statistics of the previous run. */
/* Initial run. */
ZopfliLZ77Greedy(s, in, instart, inend, ¤tstore, h);
GetStatistics(¤tstore, &stats);
/* Repeat statistics with each time the cost model from the previous stat
run. */
for (i = 0; i < numiterations; i++) {
ZopfliCleanLZ77Store(¤tstore);
ZopfliInitLZ77Store(in, ¤tstore);
LZ77OptimalRun(s, in, instart, inend, &path, &pathsize,
length_array, GetCostStat, (void*)&stats,
¤tstore, h, costs);
cost = ZopfliCalculateBlockSize(¤tstore, 0, currentstore.size, 2);
if (s->options->verbose_more || (s->options->verbose && cost < bestcost)) {
fprintf(stderr, "Iteration %d: %d bit\n", i, (int) cost);
}
if (cost < bestcost) {
/* Copy to the output store. */
ZopfliCopyLZ77Store(¤tstore, store);
CopyStats(&stats, &beststats);
bestcost = cost;
}
CopyStats(&stats, &laststats);
ClearStatFreqs(&stats);
GetStatistics(¤tstore, &stats);
if (lastrandomstep != -1) {
/* This makes it converge slower but better. Do it only once the
randomness kicks in so that if the user does few iterations, it gives a
better result sooner. */
AddWeighedStatFreqs(&stats, 1.0, &laststats, 0.5, &stats);
CalculateStatistics(&stats);
}
if (i > 5 && cost == lastcost) {
CopyStats(&beststats, &stats);
RandomizeStatFreqs(&ran_state, &stats);
CalculateStatistics(&stats);
lastrandomstep = i;
}
lastcost = cost;
}
free(length_array);
free(path);
free(costs);
ZopfliCleanLZ77Store(¤tstore);
ZopfliCleanHash(h);
}
void ZopfliLZ77OptimalFixed(ZopfliBlockState *s,
const unsigned char* in,
size_t instart, size_t inend,
ZopfliLZ77Store* store)
{
/* Dist to get to here with smallest cost. */
size_t blocksize = inend - instart;
unsigned short* length_array =
(unsigned short*)malloc(sizeof(unsigned short) * (blocksize + 1));
unsigned short* path = 0;
size_t pathsize = 0;
ZopfliHash hash;
ZopfliHash* h = &hash;
float* costs = (float*)malloc(sizeof(float) * (blocksize + 1));
if (!costs) exit(-1); /* Allocation failed. */
if (!length_array) exit(-1); /* Allocation failed. */
ZopfliAllocHash(ZOPFLI_WINDOW_SIZE, h);
s->blockstart = instart;
s->blockend = inend;
/* Shortest path for fixed tree This one should give the shortest possible
result for fixed tree, no repeated runs are needed since the tree is known. */
LZ77OptimalRun(s, in, instart, inend, &path, &pathsize,
length_array, GetCostFixed, 0, store, h, costs);
free(length_array);
free(path);
free(costs);
ZopfliCleanHash(h);
}
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
zopfli-one.c view on Meta::CPAN
#define ZOPFLI_APPEND_DATA(/* T */ value, /* T** */ data, /* size_t* */ size) {\
if (!((*size) & ((*size) - 1))) {\
/*double alloc size if it's a power of two*/\
(*data) = (*size) == 0 ? malloc(sizeof(**data))\
: realloc((*data), (*size) * 2 * sizeof(**data));\
}\
(*data)[(*size)] = (value);\
(*size)++;\
}
#endif
#endif /* ZOPFLI_UTIL_H_ */
/* zopfli.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_ZOPFLI_H_
#define ZOPFLI_ZOPFLI_H_
#include <stddef.h>
#include <stdlib.h> /* for size_t */
#ifdef __cplusplus
extern "C" {
#endif
/*
Options used throughout the program.
*/
typedef struct ZopfliOptions {
/* Whether to print output */
int verbose;
/* Whether to print more detailed output */
int verbose_more;
/*
Maximum amount of times to rerun forward and backward pass to optimize LZ77
compression cost. Good values: 10, 15 for small files, 5 for files over
several MB in size or it will be too slow.
*/
int numiterations;
/*
If true, splits the data in multiple deflate blocks with optimal choice
for the block boundaries. Block splitting gives better compression. Default:
true (1).
*/
int blocksplitting;
/*
No longer used, left for compatibility.
*/
int blocksplittinglast;
/*
Maximum amount of blocks to split into (0 for unlimited, but this can give
extreme results that hurt compression on some files). Default value: 15.
*/
int blocksplittingmax;
} ZopfliOptions;
/* Initializes options with default values. */
void ZopfliInitOptions(ZopfliOptions* options);
/* Output format */
typedef enum {
ZOPFLI_FORMAT_GZIP,
ZOPFLI_FORMAT_ZLIB,
ZOPFLI_FORMAT_DEFLATE
} ZopfliFormat;
/*
Compresses according to the given output format and appends the result to the
output.
options: global program options
output_type: the output format to use
out: pointer to the dynamic output array to which the result is appended. Must
be freed after use
outsize: pointer to the dynamic output array size
*/
void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
const unsigned char* in, size_t insize,
unsigned char** out, size_t* outsize);
#ifdef __cplusplus
} // extern "C"
#endif
#endif /* ZOPFLI_ZOPFLI_H_ */
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
void ZopfliInitOptions(ZopfliOptions* options) {
options->verbose = 0;
options->verbose_more = 0;
options->numiterations = 15;
options->blocksplitting = 1;
options->blocksplittinglast = 0;
options->blocksplittingmax = 15;
}
/*
Copyright 2013 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
/* zlib_container.h */
/*
Copyright 2013 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_ZLIB_H_
#define ZOPFLI_ZLIB_H_
/*
Functions to compress according to the Zlib specification.
*/
/* zopfli.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_ZOPFLI_H_
#define ZOPFLI_ZOPFLI_H_
#include <stddef.h>
#include <stdlib.h> /* for size_t */
#ifdef __cplusplus
extern "C" {
#endif
/*
Options used throughout the program.
*/
typedef struct ZopfliOptions {
/* Whether to print output */
int verbose;
/* Whether to print more detailed output */
int verbose_more;
/*
Maximum amount of times to rerun forward and backward pass to optimize LZ77
compression cost. Good values: 10, 15 for small files, 5 for files over
several MB in size or it will be too slow.
*/
int numiterations;
/*
If true, splits the data in multiple deflate blocks with optimal choice
for the block boundaries. Block splitting gives better compression. Default:
true (1).
*/
int blocksplitting;
/*
No longer used, left for compatibility.
*/
int blocksplittinglast;
/*
Maximum amount of blocks to split into (0 for unlimited, but this can give
extreme results that hurt compression on some files). Default value: 15.
*/
int blocksplittingmax;
} ZopfliOptions;
/* Initializes options with default values. */
void ZopfliInitOptions(ZopfliOptions* options);
/* Output format */
typedef enum {
ZOPFLI_FORMAT_GZIP,
ZOPFLI_FORMAT_ZLIB,
ZOPFLI_FORMAT_DEFLATE
} ZopfliFormat;
/*
Compresses according to the given output format and appends the result to the
output.
options: global program options
output_type: the output format to use
out: pointer to the dynamic output array to which the result is appended. Must
be freed after use
outsize: pointer to the dynamic output array size
*/
void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
const unsigned char* in, size_t insize,
unsigned char** out, size_t* outsize);
#ifdef __cplusplus
} // extern "C"
#endif
#endif /* ZOPFLI_ZOPFLI_H_ */
#ifdef __cplusplus
extern "C" {
#endif
/*
Compresses according to the zlib specification and append the compressed
result to the output.
options: global program options
zopfli-one.c view on Meta::CPAN
to this must be made for consecutive bytes.
*/
void ZopfliUpdateHash(const unsigned char* array, size_t pos, size_t end,
ZopfliHash* h);
/*
Prepopulates hash:
Fills in the initial values in the hash, before ZopfliUpdateHash can be used
correctly.
*/
void ZopfliWarmupHash(const unsigned char* array, size_t pos, size_t end,
ZopfliHash* h);
#endif /* ZOPFLI_HASH_H_ */
/* zopfli.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_ZOPFLI_H_
#define ZOPFLI_ZOPFLI_H_
#include <stddef.h>
#include <stdlib.h> /* for size_t */
#ifdef __cplusplus
extern "C" {
#endif
/*
Options used throughout the program.
*/
typedef struct ZopfliOptions {
/* Whether to print output */
int verbose;
/* Whether to print more detailed output */
int verbose_more;
/*
Maximum amount of times to rerun forward and backward pass to optimize LZ77
compression cost. Good values: 10, 15 for small files, 5 for files over
several MB in size or it will be too slow.
*/
int numiterations;
/*
If true, splits the data in multiple deflate blocks with optimal choice
for the block boundaries. Block splitting gives better compression. Default:
true (1).
*/
int blocksplitting;
/*
No longer used, left for compatibility.
*/
int blocksplittinglast;
/*
Maximum amount of blocks to split into (0 for unlimited, but this can give
extreme results that hurt compression on some files). Default value: 15.
*/
int blocksplittingmax;
} ZopfliOptions;
/* Initializes options with default values. */
void ZopfliInitOptions(ZopfliOptions* options);
/* Output format */
typedef enum {
ZOPFLI_FORMAT_GZIP,
ZOPFLI_FORMAT_ZLIB,
ZOPFLI_FORMAT_DEFLATE
} ZopfliFormat;
/*
Compresses according to the given output format and appends the result to the
output.
options: global program options
output_type: the output format to use
out: pointer to the dynamic output array to which the result is appended. Must
be freed after use
outsize: pointer to the dynamic output array size
*/
void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
const unsigned char* in, size_t insize,
unsigned char** out, size_t* outsize);
#ifdef __cplusplus
} // extern "C"
#endif
#endif /* ZOPFLI_ZOPFLI_H_ */
/*
Stores lit/length and dist pairs for LZ77.
Parameter litlens: Contains the literal symbols or length values.
Parameter dists: Contains the distances. A value is 0 to indicate that there is
no dist and the corresponding litlens value is a literal instead of a length.
Parameter size: The size of both the litlens and dists arrays.
The memory can best be managed by using ZopfliInitLZ77Store to initialize it,
ZopfliCleanLZ77Store to destroy it, and ZopfliStoreLitLenDist to append values.
zopfli-one.c view on Meta::CPAN
unsigned short dist, unsigned short length);
/*
Does LZ77 using an algorithm similar to gzip, with lazy matching, rather than
with the slow but better "squeeze" implementation.
The result is placed in the ZopfliLZ77Store.
If instart is larger than 0, it uses values before instart as starting
dictionary.
*/
void ZopfliLZ77Greedy(ZopfliBlockState* s, const unsigned char* in,
size_t instart, size_t inend,
ZopfliLZ77Store* store, ZopfliHash* h);
#endif /* ZOPFLI_LZ77_H_ */
/* zopfli.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_ZOPFLI_H_
#define ZOPFLI_ZOPFLI_H_
#include <stddef.h>
#include <stdlib.h> /* for size_t */
#ifdef __cplusplus
extern "C" {
#endif
/*
Options used throughout the program.
*/
typedef struct ZopfliOptions {
/* Whether to print output */
int verbose;
/* Whether to print more detailed output */
int verbose_more;
/*
Maximum amount of times to rerun forward and backward pass to optimize LZ77
compression cost. Good values: 10, 15 for small files, 5 for files over
several MB in size or it will be too slow.
*/
int numiterations;
/*
If true, splits the data in multiple deflate blocks with optimal choice
for the block boundaries. Block splitting gives better compression. Default:
true (1).
*/
int blocksplitting;
/*
No longer used, left for compatibility.
*/
int blocksplittinglast;
/*
Maximum amount of blocks to split into (0 for unlimited, but this can give
extreme results that hurt compression on some files). Default value: 15.
*/
int blocksplittingmax;
} ZopfliOptions;
/* Initializes options with default values. */
void ZopfliInitOptions(ZopfliOptions* options);
/* Output format */
typedef enum {
ZOPFLI_FORMAT_GZIP,
ZOPFLI_FORMAT_ZLIB,
ZOPFLI_FORMAT_DEFLATE
} ZopfliFormat;
/*
Compresses according to the given output format and appends the result to the
output.
options: global program options
output_type: the output format to use
out: pointer to the dynamic output array to which the result is appended. Must
be freed after use
outsize: pointer to the dynamic output array size
*/
void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
const unsigned char* in, size_t insize,
unsigned char** out, size_t* outsize);
#ifdef __cplusplus
} // extern "C"
#endif
#endif /* ZOPFLI_ZOPFLI_H_ */
#ifdef __cplusplus
extern "C" {
#endif
/*
Compresses according to the deflate specification and append the compressed
result to the output.
This function will usually output multiple deflate blocks. If final is 1, then
the final bit will be set on the last block.
zopfli-one.c view on Meta::CPAN
to this must be made for consecutive bytes.
*/
void ZopfliUpdateHash(const unsigned char* array, size_t pos, size_t end,
ZopfliHash* h);
/*
Prepopulates hash:
Fills in the initial values in the hash, before ZopfliUpdateHash can be used
correctly.
*/
void ZopfliWarmupHash(const unsigned char* array, size_t pos, size_t end,
ZopfliHash* h);
#endif /* ZOPFLI_HASH_H_ */
/* zopfli.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_ZOPFLI_H_
#define ZOPFLI_ZOPFLI_H_
#include <stddef.h>
#include <stdlib.h> /* for size_t */
#ifdef __cplusplus
extern "C" {
#endif
/*
Options used throughout the program.
*/
typedef struct ZopfliOptions {
/* Whether to print output */
int verbose;
/* Whether to print more detailed output */
int verbose_more;
/*
Maximum amount of times to rerun forward and backward pass to optimize LZ77
compression cost. Good values: 10, 15 for small files, 5 for files over
several MB in size or it will be too slow.
*/
int numiterations;
/*
If true, splits the data in multiple deflate blocks with optimal choice
for the block boundaries. Block splitting gives better compression. Default:
true (1).
*/
int blocksplitting;
/*
No longer used, left for compatibility.
*/
int blocksplittinglast;
/*
Maximum amount of blocks to split into (0 for unlimited, but this can give
extreme results that hurt compression on some files). Default value: 15.
*/
int blocksplittingmax;
} ZopfliOptions;
/* Initializes options with default values. */
void ZopfliInitOptions(ZopfliOptions* options);
/* Output format */
typedef enum {
ZOPFLI_FORMAT_GZIP,
ZOPFLI_FORMAT_ZLIB,
ZOPFLI_FORMAT_DEFLATE
} ZopfliFormat;
/*
Compresses according to the given output format and appends the result to the
output.
options: global program options
output_type: the output format to use
out: pointer to the dynamic output array to which the result is appended. Must
be freed after use
outsize: pointer to the dynamic output array size
*/
void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
const unsigned char* in, size_t insize,
unsigned char** out, size_t* outsize);
#ifdef __cplusplus
} // extern "C"
#endif
#endif /* ZOPFLI_ZOPFLI_H_ */
/*
Stores lit/length and dist pairs for LZ77.
Parameter litlens: Contains the literal symbols or length values.
Parameter dists: Contains the distances. A value is 0 to indicate that there is
no dist and the corresponding litlens value is a literal instead of a length.
Parameter size: The size of both the litlens and dists arrays.
The memory can best be managed by using ZopfliInitLZ77Store to initialize it,
ZopfliCleanLZ77Store to destroy it, and ZopfliStoreLitLenDist to append values.
zopfli-one.c view on Meta::CPAN
unsigned short dist, unsigned short length);
/*
Does LZ77 using an algorithm similar to gzip, with lazy matching, rather than
with the slow but better "squeeze" implementation.
The result is placed in the ZopfliLZ77Store.
If instart is larger than 0, it uses values before instart as starting
dictionary.
*/
void ZopfliLZ77Greedy(ZopfliBlockState* s, const unsigned char* in,
size_t instart, size_t inend,
ZopfliLZ77Store* store, ZopfliHash* h);
#endif /* ZOPFLI_LZ77_H_ */
/* zopfli.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_ZOPFLI_H_
#define ZOPFLI_ZOPFLI_H_
#include <stddef.h>
#include <stdlib.h> /* for size_t */
#ifdef __cplusplus
extern "C" {
#endif
/*
Options used throughout the program.
*/
typedef struct ZopfliOptions {
/* Whether to print output */
int verbose;
/* Whether to print more detailed output */
int verbose_more;
/*
Maximum amount of times to rerun forward and backward pass to optimize LZ77
compression cost. Good values: 10, 15 for small files, 5 for files over
several MB in size or it will be too slow.
*/
int numiterations;
/*
If true, splits the data in multiple deflate blocks with optimal choice
for the block boundaries. Block splitting gives better compression. Default:
true (1).
*/
int blocksplitting;
/*
No longer used, left for compatibility.
*/
int blocksplittinglast;
/*
Maximum amount of blocks to split into (0 for unlimited, but this can give
extreme results that hurt compression on some files). Default value: 15.
*/
int blocksplittingmax;
} ZopfliOptions;
/* Initializes options with default values. */
void ZopfliInitOptions(ZopfliOptions* options);
/* Output format */
typedef enum {
ZOPFLI_FORMAT_GZIP,
ZOPFLI_FORMAT_ZLIB,
ZOPFLI_FORMAT_DEFLATE
} ZopfliFormat;
/*
Compresses according to the given output format and appends the result to the
output.
options: global program options
output_type: the output format to use
out: pointer to the dynamic output array to which the result is appended. Must
be freed after use
outsize: pointer to the dynamic output array size
*/
void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
const unsigned char* in, size_t insize,
unsigned char** out, size_t* outsize);
#ifdef __cplusplus
} // extern "C"
#endif
#endif /* ZOPFLI_ZOPFLI_H_ */
#ifdef __cplusplus
extern "C" {
#endif
/*
Compresses according to the deflate specification and append the compressed
result to the output.
This function will usually output multiple deflate blocks. If final is 1, then
the final bit will be set on the last block.
zopfli-one.c view on Meta::CPAN
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_GZIP_H_
#define ZOPFLI_GZIP_H_
/*
Functions to compress according to the Gzip specification.
*/
/* zopfli.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_ZOPFLI_H_
#define ZOPFLI_ZOPFLI_H_
#include <stddef.h>
#include <stdlib.h> /* for size_t */
#ifdef __cplusplus
extern "C" {
#endif
/*
Options used throughout the program.
*/
typedef struct ZopfliOptions {
/* Whether to print output */
int verbose;
/* Whether to print more detailed output */
int verbose_more;
/*
Maximum amount of times to rerun forward and backward pass to optimize LZ77
compression cost. Good values: 10, 15 for small files, 5 for files over
several MB in size or it will be too slow.
*/
int numiterations;
/*
If true, splits the data in multiple deflate blocks with optimal choice
for the block boundaries. Block splitting gives better compression. Default:
true (1).
*/
int blocksplitting;
/*
No longer used, left for compatibility.
*/
int blocksplittinglast;
/*
Maximum amount of blocks to split into (0 for unlimited, but this can give
extreme results that hurt compression on some files). Default value: 15.
*/
int blocksplittingmax;
} ZopfliOptions;
/* Initializes options with default values. */
void ZopfliInitOptions(ZopfliOptions* options);
/* Output format */
typedef enum {
ZOPFLI_FORMAT_GZIP,
ZOPFLI_FORMAT_ZLIB,
ZOPFLI_FORMAT_DEFLATE
} ZopfliFormat;
/*
Compresses according to the given output format and appends the result to the
output.
options: global program options
output_type: the output format to use
out: pointer to the dynamic output array to which the result is appended. Must
be freed after use
outsize: pointer to the dynamic output array size
*/
void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
const unsigned char* in, size_t insize,
unsigned char** out, size_t* outsize);
#ifdef __cplusplus
} // extern "C"
#endif
#endif /* ZOPFLI_ZOPFLI_H_ */
#ifdef __cplusplus
extern "C" {
#endif
/*
Compresses according to the gzip specification and append the compressed
result to the output.
options: global program options
zopfli-one.c view on Meta::CPAN
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_ZLIB_H_
#define ZOPFLI_ZLIB_H_
/*
Functions to compress according to the Zlib specification.
*/
/* zopfli.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_ZOPFLI_H_
#define ZOPFLI_ZOPFLI_H_
#include <stddef.h>
#include <stdlib.h> /* for size_t */
#ifdef __cplusplus
extern "C" {
#endif
/*
Options used throughout the program.
*/
typedef struct ZopfliOptions {
/* Whether to print output */
int verbose;
/* Whether to print more detailed output */
int verbose_more;
/*
Maximum amount of times to rerun forward and backward pass to optimize LZ77
compression cost. Good values: 10, 15 for small files, 5 for files over
several MB in size or it will be too slow.
*/
int numiterations;
/*
If true, splits the data in multiple deflate blocks with optimal choice
for the block boundaries. Block splitting gives better compression. Default:
true (1).
*/
int blocksplitting;
/*
No longer used, left for compatibility.
*/
int blocksplittinglast;
/*
Maximum amount of blocks to split into (0 for unlimited, but this can give
extreme results that hurt compression on some files). Default value: 15.
*/
int blocksplittingmax;
} ZopfliOptions;
/* Initializes options with default values. */
void ZopfliInitOptions(ZopfliOptions* options);
/* Output format */
typedef enum {
ZOPFLI_FORMAT_GZIP,
ZOPFLI_FORMAT_ZLIB,
ZOPFLI_FORMAT_DEFLATE
} ZopfliFormat;
/*
Compresses according to the given output format and appends the result to the
output.
options: global program options
output_type: the output format to use
out: pointer to the dynamic output array to which the result is appended. Must
be freed after use
outsize: pointer to the dynamic output array size
*/
void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
const unsigned char* in, size_t insize,
unsigned char** out, size_t* outsize);
#ifdef __cplusplus
} // extern "C"
#endif
#endif /* ZOPFLI_ZOPFLI_H_ */
#ifdef __cplusplus
extern "C" {
#endif
/*
Compresses according to the zlib specification and append the compressed
result to the output.
options: global program options
zopfli-one.c view on Meta::CPAN
unsigned char* out = 0;
size_t outsize = 0;
if (!LoadFile(infilename, &in, &insize)) {
fprintf(stderr, "Invalid filename: %s\n", infilename);
return;
}
ZopfliCompress(options, output_type, in, insize, &out, &outsize);
if (outfilename) {
SaveFile(outfilename, out, outsize);
} else {
#if _WIN32
/* Windows workaround for stdout output. */
_setmode(_fileno(stdout), _O_BINARY);
#endif
fwrite(out, 1, outsize, stdout);
}
free(out);
free(in);
}
/*
Add two strings together. Size does not matter. Result must be freed.
*/
static char* AddStrings(const char* str1, const char* str2) {
size_t len = strlen(str1) + strlen(str2);
char* result = (char*)malloc(len + 1);
if (!result) exit(-1); /* Allocation failed. */
strcpy(result, str1);
strcat(result, str2);
return result;
}
static char StringsEqual(const char* str1, const char* str2) {
return strcmp(str1, str2) == 0;
}
int main(int argc, char* argv[]) {
ZopfliOptions options;
ZopfliFormat output_type = ZOPFLI_FORMAT_GZIP;
const char* filename = 0;
int output_to_stdout = 0;
int i;
ZopfliInitOptions(&options);
for (i = 1; i < argc; i++) {
const char* arg = argv[i];
if (StringsEqual(arg, "-v")) options.verbose = 1;
else if (StringsEqual(arg, "-c")) output_to_stdout = 1;
else if (StringsEqual(arg, "--deflate")) {
output_type = ZOPFLI_FORMAT_DEFLATE;
}
else if (StringsEqual(arg, "--zlib")) output_type = ZOPFLI_FORMAT_ZLIB;
else if (StringsEqual(arg, "--gzip")) output_type = ZOPFLI_FORMAT_GZIP;
else if (StringsEqual(arg, "--splitlast")) /* Ignore */;
else if (arg[0] == '-' && arg[1] == '-' && arg[2] == 'i'
&& arg[3] >= '0' && arg[3] <= '9') {
options.numiterations = atoi(arg + 3);
}
else if (StringsEqual(arg, "-h")) {
fprintf(stderr,
"Usage: zopfli [OPTION]... FILE...\n"
" -h gives this help\n"
" -c write the result on standard output, instead of disk"
" filename + '.gz'\n"
" -v verbose mode\n"
" --i# perform # iterations (default 15). More gives"
" more compression but is slower."
" Examples: --i10, --i50, --i1000\n");
fprintf(stderr,
" --gzip output to gzip format (default)\n"
" --zlib output to zlib format instead of gzip\n"
" --deflate output to deflate format instead of gzip\n"
" --splitlast ignored, left for backwards compatibility\n");
return 0;
}
}
if (options.numiterations < 1) {
fprintf(stderr, "Error: must have 1 or more iterations\n");
return 0;
}
for (i = 1; i < argc; i++) {
if (argv[i][0] != '-') {
char* outfilename;
filename = argv[i];
if (output_to_stdout) {
outfilename = 0;
} else if (output_type == ZOPFLI_FORMAT_GZIP) {
outfilename = AddStrings(filename, ".gz");
} else if (output_type == ZOPFLI_FORMAT_ZLIB) {
outfilename = AddStrings(filename, ".zlib");
} else {
assert(output_type == ZOPFLI_FORMAT_DEFLATE);
outfilename = AddStrings(filename, ".deflate");
}
if (options.verbose && outfilename) {
fprintf(stderr, "Saving to: %s\n", outfilename);
}
CompressFile(&options, output_type, filename, outfilename);
free(outfilename);
}
}
if (!filename) {
fprintf(stderr,
"Please provide filename\nFor help, type: %s -h\n", argv[0]);
}
return 0;
}
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
/* zopfli.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_ZOPFLI_H_
#define ZOPFLI_ZOPFLI_H_
#include <stddef.h>
#include <stdlib.h> /* for size_t */
#ifdef __cplusplus
extern "C" {
#endif
/*
Options used throughout the program.
*/
typedef struct ZopfliOptions {
/* Whether to print output */
int verbose;
/* Whether to print more detailed output */
int verbose_more;
/*
Maximum amount of times to rerun forward and backward pass to optimize LZ77
compression cost. Good values: 10, 15 for small files, 5 for files over
several MB in size or it will be too slow.
*/
int numiterations;
/*
If true, splits the data in multiple deflate blocks with optimal choice
for the block boundaries. Block splitting gives better compression. Default:
true (1).
*/
int blocksplitting;
/*
No longer used, left for compatibility.
*/
int blocksplittinglast;
/*
Maximum amount of blocks to split into (0 for unlimited, but this can give
extreme results that hurt compression on some files). Default value: 15.
*/
int blocksplittingmax;
} ZopfliOptions;
/* Initializes options with default values. */
void ZopfliInitOptions(ZopfliOptions* options);
/* Output format */
typedef enum {
ZOPFLI_FORMAT_GZIP,
ZOPFLI_FORMAT_ZLIB,
ZOPFLI_FORMAT_DEFLATE
} ZopfliFormat;
/*
Compresses according to the given output format and appends the result to the
output.
options: global program options
output_type: the output format to use
out: pointer to the dynamic output array to which the result is appended. Must
be freed after use
outsize: pointer to the dynamic output array size
*/
void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
const unsigned char* in, size_t insize,
unsigned char** out, size_t* outsize);
#ifdef __cplusplus
} // extern "C"
#endif
#endif /* ZOPFLI_ZOPFLI_H_ */
/* deflate.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
zopfli-one.c view on Meta::CPAN
to this must be made for consecutive bytes.
*/
void ZopfliUpdateHash(const unsigned char* array, size_t pos, size_t end,
ZopfliHash* h);
/*
Prepopulates hash:
Fills in the initial values in the hash, before ZopfliUpdateHash can be used
correctly.
*/
void ZopfliWarmupHash(const unsigned char* array, size_t pos, size_t end,
ZopfliHash* h);
#endif /* ZOPFLI_HASH_H_ */
/* zopfli.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_ZOPFLI_H_
#define ZOPFLI_ZOPFLI_H_
#include <stddef.h>
#include <stdlib.h> /* for size_t */
#ifdef __cplusplus
extern "C" {
#endif
/*
Options used throughout the program.
*/
typedef struct ZopfliOptions {
/* Whether to print output */
int verbose;
/* Whether to print more detailed output */
int verbose_more;
/*
Maximum amount of times to rerun forward and backward pass to optimize LZ77
compression cost. Good values: 10, 15 for small files, 5 for files over
several MB in size or it will be too slow.
*/
int numiterations;
/*
If true, splits the data in multiple deflate blocks with optimal choice
for the block boundaries. Block splitting gives better compression. Default:
true (1).
*/
int blocksplitting;
/*
No longer used, left for compatibility.
*/
int blocksplittinglast;
/*
Maximum amount of blocks to split into (0 for unlimited, but this can give
extreme results that hurt compression on some files). Default value: 15.
*/
int blocksplittingmax;
} ZopfliOptions;
/* Initializes options with default values. */
void ZopfliInitOptions(ZopfliOptions* options);
/* Output format */
typedef enum {
ZOPFLI_FORMAT_GZIP,
ZOPFLI_FORMAT_ZLIB,
ZOPFLI_FORMAT_DEFLATE
} ZopfliFormat;
/*
Compresses according to the given output format and appends the result to the
output.
options: global program options
output_type: the output format to use
out: pointer to the dynamic output array to which the result is appended. Must
be freed after use
outsize: pointer to the dynamic output array size
*/
void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
const unsigned char* in, size_t insize,
unsigned char** out, size_t* outsize);
#ifdef __cplusplus
} // extern "C"
#endif
#endif /* ZOPFLI_ZOPFLI_H_ */
/*
Stores lit/length and dist pairs for LZ77.
Parameter litlens: Contains the literal symbols or length values.
Parameter dists: Contains the distances. A value is 0 to indicate that there is
no dist and the corresponding litlens value is a literal instead of a length.
Parameter size: The size of both the litlens and dists arrays.
The memory can best be managed by using ZopfliInitLZ77Store to initialize it,
ZopfliCleanLZ77Store to destroy it, and ZopfliStoreLitLenDist to append values.
zopfli-one.c view on Meta::CPAN
unsigned short dist, unsigned short length);
/*
Does LZ77 using an algorithm similar to gzip, with lazy matching, rather than
with the slow but better "squeeze" implementation.
The result is placed in the ZopfliLZ77Store.
If instart is larger than 0, it uses values before instart as starting
dictionary.
*/
void ZopfliLZ77Greedy(ZopfliBlockState* s, const unsigned char* in,
size_t instart, size_t inend,
ZopfliLZ77Store* store, ZopfliHash* h);
#endif /* ZOPFLI_LZ77_H_ */
/* zopfli.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_ZOPFLI_H_
#define ZOPFLI_ZOPFLI_H_
#include <stddef.h>
#include <stdlib.h> /* for size_t */
#ifdef __cplusplus
extern "C" {
#endif
/*
Options used throughout the program.
*/
typedef struct ZopfliOptions {
/* Whether to print output */
int verbose;
/* Whether to print more detailed output */
int verbose_more;
/*
Maximum amount of times to rerun forward and backward pass to optimize LZ77
compression cost. Good values: 10, 15 for small files, 5 for files over
several MB in size or it will be too slow.
*/
int numiterations;
/*
If true, splits the data in multiple deflate blocks with optimal choice
for the block boundaries. Block splitting gives better compression. Default:
true (1).
*/
int blocksplitting;
/*
No longer used, left for compatibility.
*/
int blocksplittinglast;
/*
Maximum amount of blocks to split into (0 for unlimited, but this can give
extreme results that hurt compression on some files). Default value: 15.
*/
int blocksplittingmax;
} ZopfliOptions;
/* Initializes options with default values. */
void ZopfliInitOptions(ZopfliOptions* options);
/* Output format */
typedef enum {
ZOPFLI_FORMAT_GZIP,
ZOPFLI_FORMAT_ZLIB,
ZOPFLI_FORMAT_DEFLATE
} ZopfliFormat;
/*
Compresses according to the given output format and appends the result to the
output.
options: global program options
output_type: the output format to use
out: pointer to the dynamic output array to which the result is appended. Must
be freed after use
outsize: pointer to the dynamic output array size
*/
void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
const unsigned char* in, size_t insize,
unsigned char** out, size_t* outsize);
#ifdef __cplusplus
} // extern "C"
#endif
#endif /* ZOPFLI_ZOPFLI_H_ */
#ifdef __cplusplus
extern "C" {
#endif
/*
Compresses according to the deflate specification and append the compressed
result to the output.
This function will usually output multiple deflate blocks. If final is 1, then
the final bit will be set on the last block.
zopfli-one.c view on Meta::CPAN
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_GZIP_H_
#define ZOPFLI_GZIP_H_
/*
Functions to compress according to the Gzip specification.
*/
/* zopfli.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_ZOPFLI_H_
#define ZOPFLI_ZOPFLI_H_
#include <stddef.h>
#include <stdlib.h> /* for size_t */
#ifdef __cplusplus
extern "C" {
#endif
/*
Options used throughout the program.
*/
typedef struct ZopfliOptions {
/* Whether to print output */
int verbose;
/* Whether to print more detailed output */
int verbose_more;
/*
Maximum amount of times to rerun forward and backward pass to optimize LZ77
compression cost. Good values: 10, 15 for small files, 5 for files over
several MB in size or it will be too slow.
*/
int numiterations;
/*
If true, splits the data in multiple deflate blocks with optimal choice
for the block boundaries. Block splitting gives better compression. Default:
true (1).
*/
int blocksplitting;
/*
No longer used, left for compatibility.
*/
int blocksplittinglast;
/*
Maximum amount of blocks to split into (0 for unlimited, but this can give
extreme results that hurt compression on some files). Default value: 15.
*/
int blocksplittingmax;
} ZopfliOptions;
/* Initializes options with default values. */
void ZopfliInitOptions(ZopfliOptions* options);
/* Output format */
typedef enum {
ZOPFLI_FORMAT_GZIP,
ZOPFLI_FORMAT_ZLIB,
ZOPFLI_FORMAT_DEFLATE
} ZopfliFormat;
/*
Compresses according to the given output format and appends the result to the
output.
options: global program options
output_type: the output format to use
out: pointer to the dynamic output array to which the result is appended. Must
be freed after use
outsize: pointer to the dynamic output array size
*/
void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
const unsigned char* in, size_t insize,
unsigned char** out, size_t* outsize);
#ifdef __cplusplus
} // extern "C"
#endif
#endif /* ZOPFLI_ZOPFLI_H_ */
#ifdef __cplusplus
extern "C" {
#endif
/*
Compresses according to the gzip specification and append the compressed
result to the output.
options: global program options
zopfli-one.c view on Meta::CPAN
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_ZLIB_H_
#define ZOPFLI_ZLIB_H_
/*
Functions to compress according to the Zlib specification.
*/
/* zopfli.h */
/*
Copyright 2011 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#ifndef ZOPFLI_ZOPFLI_H_
#define ZOPFLI_ZOPFLI_H_
#include <stddef.h>
#include <stdlib.h> /* for size_t */
#ifdef __cplusplus
extern "C" {
#endif
/*
Options used throughout the program.
*/
typedef struct ZopfliOptions {
/* Whether to print output */
int verbose;
/* Whether to print more detailed output */
int verbose_more;
/*
Maximum amount of times to rerun forward and backward pass to optimize LZ77
compression cost. Good values: 10, 15 for small files, 5 for files over
several MB in size or it will be too slow.
*/
int numiterations;
/*
If true, splits the data in multiple deflate blocks with optimal choice
for the block boundaries. Block splitting gives better compression. Default:
true (1).
*/
int blocksplitting;
/*
No longer used, left for compatibility.
*/
int blocksplittinglast;
/*
Maximum amount of blocks to split into (0 for unlimited, but this can give
extreme results that hurt compression on some files). Default value: 15.
*/
int blocksplittingmax;
} ZopfliOptions;
/* Initializes options with default values. */
void ZopfliInitOptions(ZopfliOptions* options);
/* Output format */
typedef enum {
ZOPFLI_FORMAT_GZIP,
ZOPFLI_FORMAT_ZLIB,
ZOPFLI_FORMAT_DEFLATE
} ZopfliFormat;
/*
Compresses according to the given output format and appends the result to the
output.
options: global program options
output_type: the output format to use
out: pointer to the dynamic output array to which the result is appended. Must
be freed after use
outsize: pointer to the dynamic output array size
*/
void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
const unsigned char* in, size_t insize,
unsigned char** out, size_t* outsize);
#ifdef __cplusplus
} // extern "C"
#endif
#endif /* ZOPFLI_ZOPFLI_H_ */
#ifdef __cplusplus
extern "C" {
#endif
/*
Compresses according to the zlib specification and append the compressed
result to the output.
options: global program options
( run in 2.203 seconds using v1.01-cache-2.11-cpan-5c0b1e786e0 )