Gzip-Zopfli
view release on metacpan or search on metacpan
gzip-zopfli-perl.c view on Meta::CPAN
if (CMP(key, no_warn)) {
if (SvTRUE (value)) {
gz->no_warn = 1;
}
else {
gz->no_warn = 0;
}
return;
}
if (CMP(key, numiterations)) {
int n;
if (! SvIOK (value)) {
warn ("numiterations requires a number");
}
n = SvIV (value);
// Check values
gz->options.numiterations = n;
return;
}
if (CMP (key, blocksplitting)) {
gz->options.blocksplitting = SvTRUE (value);
return;
}
if (CMP (key, blocksplittingmax)) {
if (! SvIOK (value)) {
warn ("blocksplittingmax requires a number");
}
lib/Gzip/Zopfli.pod view on Meta::CPAN
Boolean. Apply blocksplitting or not? Default value is true.
=item blocksplittingmax
my $out = zopfli_compress ($in, blocksplittingmax => 0);
Maximum number of blocks to split into. Default is 15. Set to 0 for
unlimited.
=item numiterations
my $out = zopfli_compress ($in, numiterations => 1);
Number of iterations. Default value is 15.
=item type
my $out = zopfli_compress ($in, type => 'zlib');
Type of compression. Either C<gzip> (the default), C<zlib>, or C<deflate>.
=back
=head2 zopfli_compress_file
zopfli-one.c view on Meta::CPAN
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.
zopfli-one.c view on Meta::CPAN
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.
zopfli-one.c view on Meta::CPAN
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.
zopfli-one.c view on Meta::CPAN
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.
zopfli-one.c view on Meta::CPAN
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.
zopfli-one.c view on Meta::CPAN
#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
zopfli-one.c view on Meta::CPAN
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.
zopfli-one.c view on Meta::CPAN
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.
zopfli-one.c view on Meta::CPAN
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.
zopfli-one.c view on Meta::CPAN
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.
zopfli-one.c view on Meta::CPAN
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.
zopfli-one.c view on Meta::CPAN
#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
zopfli-one.c view on Meta::CPAN
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 */
zopfli-one.c view on Meta::CPAN
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.
zopfli-one.c view on Meta::CPAN
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.
zopfli-one.c view on Meta::CPAN
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.
zopfli-one.c view on Meta::CPAN
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.
zopfli-one.c view on Meta::CPAN
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.
zopfli-one.c view on Meta::CPAN
#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
zopfli-one.c view on Meta::CPAN
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.
zopfli-one.c view on Meta::CPAN
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.
zopfli-one.c view on Meta::CPAN
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.
zopfli-one.c view on Meta::CPAN
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.
zopfli-one.c view on Meta::CPAN
*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;
zopfli-one.c view on Meta::CPAN
/* 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;
}
zopfli-one.c view on Meta::CPAN
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.
zopfli-one.c view on Meta::CPAN
#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
zopfli-one.c view on Meta::CPAN
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.
zopfli-one.c view on Meta::CPAN
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.
zopfli-one.c view on Meta::CPAN
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.
zopfli-one.c view on Meta::CPAN
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.
zopfli-one.c view on Meta::CPAN
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.
zopfli-one.c view on Meta::CPAN
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.
zopfli-one.c view on Meta::CPAN
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.
zopfli-one.c view on Meta::CPAN
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) {
zopfli-one.c view on Meta::CPAN
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.
zopfli-one.c view on Meta::CPAN
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.
zopfli-one.c view on Meta::CPAN
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.
zopfli-one.c view on Meta::CPAN
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.
zopfli-one.c view on Meta::CPAN
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.
( run in 0.882 second using v1.01-cache-2.11-cpan-71847e10f99 )