add boost on mac
This commit is contained in:
Bassem Girgis
404
macx64/include/boost/beast/zlib/deflate_stream.hpp
Normal file
404
macx64/include/boost/beast/zlib/deflate_stream.hpp
Normal file
@@ -0,0 +1,404 @@
|
||||
//
|
||||
// Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com)
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
// Official repository: https://github.com/boostorg/beast
|
||||
//
|
||||
|
||||
#ifndef BOOST_BEAST_ZLIB_DEFLATE_STREAM_HPP
|
||||
#define BOOST_BEAST_ZLIB_DEFLATE_STREAM_HPP
|
||||
|
||||
#include <boost/beast/core/detail/config.hpp>
|
||||
#include <boost/beast/zlib/error.hpp>
|
||||
#include <boost/beast/zlib/zlib.hpp>
|
||||
#include <boost/beast/zlib/detail/deflate_stream.hpp>
|
||||
#include <algorithm>
|
||||
#include <cstdlib>
|
||||
#include <cstdint>
|
||||
#include <cstring>
|
||||
#include <memory>
|
||||
|
||||
namespace boost {
|
||||
namespace beast {
|
||||
namespace zlib {
|
||||
|
||||
// This is a derivative work based on Zlib, copyright below:
|
||||
/*
|
||||
Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
|
||||
Jean-loup Gailly Mark Adler
|
||||
jloup@gzip.org madler@alumni.caltech.edu
|
||||
|
||||
The data format used by the zlib library is described by RFCs (Request for
|
||||
Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950
|
||||
(zlib format), rfc1951 (deflate format) and rfc1952 (gzip format).
|
||||
*/
|
||||
|
||||
/** Raw deflate compressor.
|
||||
|
||||
This is a port of zlib's "deflate" functionality to C++.
|
||||
*/
|
||||
class deflate_stream
|
||||
: private detail::deflate_stream
|
||||
{
|
||||
public:
|
||||
/** Construct a default deflate stream.
|
||||
|
||||
Upon construction, the stream settings will be set
|
||||
to these default values:
|
||||
|
||||
@li `level = 6`
|
||||
|
||||
@li `windowBits = 15`
|
||||
|
||||
@li `memLevel = 8`
|
||||
|
||||
@li `strategy = Strategy::normal`
|
||||
|
||||
Although the stream is ready to be used immediately
|
||||
after construction, any required internal buffers are
|
||||
not dynamically allocated until needed.
|
||||
*/
|
||||
deflate_stream()
|
||||
{
|
||||
reset(6, 15, DEF_MEM_LEVEL, Strategy::normal);
|
||||
}
|
||||
|
||||
/** Reset the stream and compression settings.
|
||||
|
||||
This function initializes the stream to the specified
|
||||
compression settings.
|
||||
|
||||
Although the stream is ready to be used immediately
|
||||
after a reset, any required internal buffers are not
|
||||
dynamically allocated until needed.
|
||||
|
||||
@note Any unprocessed input or pending output from
|
||||
previous calls are discarded.
|
||||
*/
|
||||
void
|
||||
reset(
|
||||
int level,
|
||||
int windowBits,
|
||||
int memLevel,
|
||||
Strategy strategy)
|
||||
{
|
||||
doReset(level, windowBits, memLevel, strategy);
|
||||
}
|
||||
|
||||
/** Reset the stream without deallocating memory.
|
||||
|
||||
This function performs the equivalent of calling `clear`
|
||||
followed by `reset` with the same compression settings,
|
||||
without deallocating the internal buffers.
|
||||
|
||||
@note Any unprocessed input or pending output from
|
||||
previous calls are discarded.
|
||||
*/
|
||||
void
|
||||
reset()
|
||||
{
|
||||
doReset();
|
||||
}
|
||||
|
||||
/** Clear the stream.
|
||||
|
||||
This function resets the stream and frees all dynamically
|
||||
allocated internal buffers. The compression settings are
|
||||
left unchanged.
|
||||
|
||||
@note Any unprocessed input or pending output from
|
||||
previous calls are discarded.
|
||||
*/
|
||||
void
|
||||
clear()
|
||||
{
|
||||
doClear();
|
||||
}
|
||||
|
||||
/** Returns the upper limit on the size of a compressed block.
|
||||
|
||||
This function makes a conservative estimate of the maximum number
|
||||
of bytes needed to store the result of compressing a block of
|
||||
data based on the current compression level and strategy.
|
||||
|
||||
@param sourceLen The size of the uncompressed data.
|
||||
|
||||
@return The maximum number of resulting compressed bytes.
|
||||
*/
|
||||
std::size_t
|
||||
upper_bound(std::size_t sourceLen) const
|
||||
{
|
||||
return doUpperBound(sourceLen);
|
||||
}
|
||||
|
||||
/** Fine tune internal compression parameters.
|
||||
|
||||
Compression parameters should only be tuned by someone who
|
||||
understands the algorithm used by zlib's deflate for searching
|
||||
for the best matching string, and even then only by the most
|
||||
fanatic optimizer trying to squeeze out the last compressed bit
|
||||
for their specific input data. Read the deflate.c source code
|
||||
(ZLib) for the meaning of the max_lazy, good_length, nice_length,
|
||||
and max_chain parameters.
|
||||
*/
|
||||
void
|
||||
tune(
|
||||
int good_length,
|
||||
int max_lazy,
|
||||
int nice_length,
|
||||
int max_chain)
|
||||
{
|
||||
doTune(good_length, max_lazy, nice_length, max_chain);
|
||||
}
|
||||
|
||||
/** Compress input and write output.
|
||||
|
||||
This function compresses as much data as possible, and stops when
|
||||
the input buffer becomes empty or the output buffer becomes full.
|
||||
It may introduce some output latency (reading input without
|
||||
producing any output) except when forced to flush.
|
||||
|
||||
In each call, one or both of these actions are performed:
|
||||
|
||||
@li Compress more input starting at `zs.next_in` and update
|
||||
`zs.next_in` and `zs.avail_in` accordingly. If not all
|
||||
input can be processed (because there is not enough room in
|
||||
the output buffer), `zs.next_in` and `zs.avail_in` are updated
|
||||
and processing will resume at this point for the next call.
|
||||
|
||||
@li Provide more output starting at `zs.next_out` and update
|
||||
`zs.next_out` and `zs.avail_out` accordingly. This action is
|
||||
forced if the parameter flush is not `Flush::none`. Forcing
|
||||
flush frequently degrades the compression ratio, so this parameter
|
||||
should be set only when necessary (in interactive applications).
|
||||
Some output may be provided even if flush is not set.
|
||||
|
||||
Before the call, the application must ensure that at least one
|
||||
of the actions is possible, by providing more input and/or
|
||||
consuming more output, and updating `zs.avail_in` or `zs.avail_out`
|
||||
accordingly; `zs.avail_out` should never be zero before the call.
|
||||
The application can consume the compressed output when it wants,
|
||||
for example when the output buffer is full (`zs.avail_out == 0`),
|
||||
or after each call of `write`. If `write` returns no error
|
||||
with zero `zs.avail_out`, it must be called again after making
|
||||
room in the output buffer because there might be more output
|
||||
pending.
|
||||
|
||||
Normally the parameter flush is set to `Flush::none`, which allows
|
||||
deflate to decide how much data to accumulate before producing
|
||||
output, in order to maximize compression.
|
||||
|
||||
If the parameter flush is set to `Flush::sync`, all pending output
|
||||
is flushed to the output buffer and the output is aligned on a
|
||||
byte boundary, so that the decompressor can get all input data
|
||||
available so far. In particular `zs.avail_in` is zero after the
|
||||
call if enough output space has been provided before the call.
|
||||
Flushing may degrade compression for some compression algorithms
|
||||
and so it should be used only when necessary. This completes the
|
||||
current deflate block and follows it with an empty stored block
|
||||
that is three bits plus filler bits to the next byte, followed
|
||||
by the four bytes `{ 0x00, 0x00 0xff 0xff }`.
|
||||
|
||||
If flush is set to `Flush::partial`, all pending output is flushed
|
||||
to the output buffer, but the output is not aligned to a byte
|
||||
boundary. All of the input data so far will be available to the
|
||||
decompressor, as for Z_SYNC_FLUSH. This completes the current
|
||||
deflate block and follows it with an empty fixed codes block that
|
||||
is 10 bits long. This assures that enough bytes are output in order
|
||||
for the decompressor to finish the block before the empty fixed
|
||||
code block.
|
||||
|
||||
If flush is set to `Flush::block`, a deflate block is completed
|
||||
and emitted, as for `Flush::sync`, but the output is not aligned
|
||||
on a byte boundary, and up to seven bits of the current block are
|
||||
held to be written as the next byte after the next deflate block
|
||||
is completed. In this case, the decompressor may not be provided
|
||||
enough bits at this point in order to complete decompression of
|
||||
the data provided so far to the compressor. It may need to wait
|
||||
for the next block to be emitted. This is for advanced applications
|
||||
that need to control the emission of deflate blocks.
|
||||
|
||||
If flush is set to `Flush::full`, all output is flushed as with
|
||||
`Flush::sync`, and the compression state is reset so that
|
||||
decompression can restart from this point if previous compressed
|
||||
data has been damaged or if random access is desired. Using
|
||||
`Flush::full` too often can seriously degrade compression.
|
||||
|
||||
If `write` returns with `zs.avail_out == 0`, this function must
|
||||
be called again with the same value of the flush parameter and
|
||||
more output space (updated `zs.avail_out`), until the flush is
|
||||
complete (`write` returns with non-zero `zs.avail_out`). In the
|
||||
case of a `Flush::full`or `Flush::sync`, make sure that
|
||||
`zs.avail_out` is greater than six to avoid repeated flush markers
|
||||
due to `zs.avail_out == 0` on return.
|
||||
|
||||
If the parameter flush is set to `Flush::finish`, pending input
|
||||
is processed, pending output is flushed and deflate returns the
|
||||
error `error::end_of_stream` if there was enough output space;
|
||||
if deflate returns with no error, this function must be called
|
||||
again with `Flush::finish` and more output space (updated
|
||||
`zs.avail_out`) but no more input data, until it returns the
|
||||
error `error::end_of_stream` or another error. After `write` has
|
||||
returned the `error::end_of_stream` error, the only possible
|
||||
operations on the stream are to reset or destroy.
|
||||
|
||||
`Flush::finish` can be used immediately after initialization
|
||||
if all the compression is to be done in a single step. In this
|
||||
case, `zs.avail_out` must be at least value returned by
|
||||
`upper_bound` (see below). Then `write` is guaranteed to return
|
||||
the `error::end_of_stream` error. If not enough output space
|
||||
is provided, deflate will not return `error::end_of_stream`,
|
||||
and it must be called again as described above.
|
||||
|
||||
`write` returns no error if some progress has been made (more
|
||||
input processed or more output produced), `error::end_of_stream`
|
||||
if all input has been consumed and all output has been produced
|
||||
(only when flush is set to `Flush::finish`), `error::stream_error`
|
||||
if the stream state was inconsistent (for example if `zs.next_in`
|
||||
or `zs.next_out` was `nullptr`), `error::need_buffers` if no
|
||||
progress is possible (for example `zs.avail_in` or `zs.avail_out`
|
||||
was zero). Note that `error::need_buffers` is not fatal, and
|
||||
`write` can be called again with more input and more output space
|
||||
to continue compressing.
|
||||
*/
|
||||
void
|
||||
write(
|
||||
z_params& zs,
|
||||
Flush flush,
|
||||
error_code& ec)
|
||||
{
|
||||
doWrite(zs, flush, ec);
|
||||
}
|
||||
|
||||
/** Update the compression level and strategy.
|
||||
|
||||
This function dynamically updates the compression level and
|
||||
compression strategy. The interpretation of level and strategy
|
||||
is as in @ref reset. This can be used to switch between compression
|
||||
and straight copy of the input data, or to switch to a different kind
|
||||
of input data requiring a different strategy. If the compression level
|
||||
is changed, the input available so far is compressed with the old level
|
||||
(and may be flushed); the new level will take effect only at the next
|
||||
call of @ref write.
|
||||
|
||||
Before the call of `params`, the stream state must be set as for a
|
||||
call of @ref write, since the currently available input may have to be
|
||||
compressed and flushed. In particular, `zs.avail_out` must be non-zero.
|
||||
|
||||
@return `Z_OK` if success, `Z_STREAM_ERROR` if the source stream state
|
||||
was inconsistent or if a parameter was invalid, `error::need_buffers`
|
||||
if `zs.avail_out` was zero.
|
||||
*/
|
||||
void
|
||||
params(
|
||||
z_params& zs,
|
||||
int level,
|
||||
Strategy strategy,
|
||||
error_code& ec)
|
||||
{
|
||||
doParams(zs, level, strategy, ec);
|
||||
}
|
||||
|
||||
/** Return bits pending in the output.
|
||||
|
||||
This function returns the number of bytes and bits of output
|
||||
that have been generated, but not yet provided in the available
|
||||
output. The bytes not provided would be due to the available
|
||||
output space having being consumed. The number of bits of output
|
||||
not provided are between 0 and 7, where they await more bits to
|
||||
join them in order to fill out a full byte. If pending or bits
|
||||
are `nullptr`, then those values are not set.
|
||||
|
||||
@return `Z_OK` if success, or `Z_STREAM_ERROR` if the source
|
||||
stream state was inconsistent.
|
||||
*/
|
||||
void
|
||||
pending(unsigned *value, int *bits)
|
||||
{
|
||||
doPending(value, bits);
|
||||
}
|
||||
|
||||
/** Insert bits into the compressed output stream.
|
||||
|
||||
This function inserts bits in the deflate output stream. The
|
||||
intent is that this function is used to start off the deflate
|
||||
output with the bits leftover from a previous deflate stream when
|
||||
appending to it. As such, this function can only be used for raw
|
||||
deflate, and must be used before the first `write` call after an
|
||||
initialization. `bits` must be less than or equal to 16, and that
|
||||
many of the least significant bits of `value` will be inserted in
|
||||
the output.
|
||||
|
||||
@return `error::need_buffers` if there was not enough room in
|
||||
the internal buffer to insert the bits.
|
||||
*/
|
||||
void
|
||||
prime(int bits, int value, error_code& ec)
|
||||
{
|
||||
return doPrime(bits, value, ec);
|
||||
}
|
||||
};
|
||||
|
||||
/** Returns the upper limit on the size of a compressed block.
|
||||
|
||||
This function makes a conservative estimate of the maximum number
|
||||
of bytes needed to store the result of compressing a block of
|
||||
data.
|
||||
|
||||
@param bytes The size of the uncompressed data.
|
||||
|
||||
@return The maximum number of resulting compressed bytes.
|
||||
*/
|
||||
std::size_t
|
||||
deflate_upper_bound(std::size_t bytes);
|
||||
|
||||
/* For the default windowBits of 15 and memLevel of 8, this function returns
|
||||
a close to exact, as well as small, upper bound on the compressed size.
|
||||
They are coded as constants here for a reason--if the #define's are
|
||||
changed, then this function needs to be changed as well. The return
|
||||
value for 15 and 8 only works for those exact settings.
|
||||
|
||||
For any setting other than those defaults for windowBits and memLevel,
|
||||
the value returned is a conservative worst case for the maximum expansion
|
||||
resulting from using fixed blocks instead of stored blocks, which deflate
|
||||
can emit on compressed data for some combinations of the parameters.
|
||||
|
||||
This function could be more sophisticated to provide closer upper bounds for
|
||||
every combination of windowBits and memLevel. But even the conservative
|
||||
upper bound of about 14% expansion does not seem onerous for output buffer
|
||||
allocation.
|
||||
*/
|
||||
inline
|
||||
std::size_t
|
||||
deflate_upper_bound(std::size_t bytes)
|
||||
{
|
||||
return bytes +
|
||||
((bytes + 7) >> 3) +
|
||||
((bytes + 63) >> 6) + 5 +
|
||||
6;
|
||||
}
|
||||
|
||||
} // zlib
|
||||
} // beast
|
||||
} // boost
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user