Spaces:
Running
Running
| # -*- coding: utf-8 -*- | |
| import sys | |
| from cffi import FFI | |
| ffi = FFI() | |
| libraries = ['libbrotli'] | |
| if 'win32' not in str(sys.platform).lower(): | |
| libraries.append('stdc++') | |
| ffi.set_source( | |
| "_brotli", | |
| """#include <brotli/decode.h> | |
| #include <brotli/encode.h> | |
| """, | |
| libraries=libraries, | |
| include_dirs=["libbrotli", "libbrotli/include"] | |
| ) | |
| ffi.cdef(""" | |
| /* common/types.h */ | |
| typedef bool BROTLI_BOOL; | |
| #define BROTLI_TRUE ... | |
| #define BROTLI_FALSE ... | |
| /* dec/state.h */ | |
| /* Allocating function pointer. Function MUST return 0 in the case of | |
| failure. Otherwise it MUST return a valid pointer to a memory region of | |
| at least size length. Neither items nor size are allowed to be 0. | |
| opaque argument is a pointer provided by client and could be used to | |
| bind function to specific object (memory pool). */ | |
| typedef void* (*brotli_alloc_func)(void* opaque, size_t size); | |
| /* Deallocating function pointer. Function SHOULD be no-op in the case the | |
| address is 0. */ | |
| typedef void (*brotli_free_func)(void* opaque, void* address); | |
| /* dec/decode.h */ | |
| typedef enum { | |
| /* Decoding error, e.g. corrupt input or memory allocation problem */ | |
| BROTLI_DECODER_RESULT_ERROR = 0, | |
| /* Decoding successfully completed */ | |
| BROTLI_DECODER_RESULT_SUCCESS = 1, | |
| /* Partially done; should be called again with more input */ | |
| BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT = 2, | |
| /* Partially done; should be called again with more output */ | |
| BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT = 3 | |
| } BrotliDecoderResult; | |
| typedef enum {...} BrotliDecoderErrorCode; | |
| typedef ... BrotliDecoderState; | |
| /* Creates the instance of BrotliDecoderState and initializes it. | |
| |alloc_func| and |free_func| MUST be both zero or both non-zero. In the | |
| case they are both zero, default memory allocators are used. |opaque| is | |
| passed to |alloc_func| and |free_func| when they are called. */ | |
| BrotliDecoderState* BrotliDecoderCreateInstance(brotli_alloc_func, | |
| brotli_free_func, | |
| void *); | |
| /* Deinitializes and frees BrotliDecoderState instance. */ | |
| void BrotliDecoderDestroyInstance(BrotliDecoderState* state); | |
| /* Decompresses the data. Supports partial input and output. | |
| Must be called with an allocated input buffer in |*next_in| and an | |
| allocated output buffer in |*next_out|. The values |*available_in| and | |
| |*available_out| must specify the allocated size in |*next_in| and | |
| |*next_out| respectively. | |
| After each call, |*available_in| will be decremented by the amount of | |
| input bytes consumed, and the |*next_in| pointer will be incremented by | |
| that amount. Similarly, |*available_out| will be decremented by the | |
| amount of output bytes written, and the |*next_out| pointer will be | |
| incremented by that amount. |total_out|, if it is not a null-pointer, | |
| will be set to the number of bytes decompressed since the last state | |
| initialization. | |
| Input is never overconsumed, so |next_in| and |available_in| could be | |
| passed to the next consumer after decoding is complete. */ | |
| BrotliDecoderResult BrotliDecoderDecompressStream(BrotliDecoderState* s, | |
| size_t* available_in, | |
| const uint8_t** next_in, | |
| size_t* available_out, | |
| uint8_t** next_out, | |
| size_t* total_out); | |
| /* Fills the new state with a dictionary for LZ77, warming up the | |
| ringbuffer, e.g. for custom static dictionaries for data formats. | |
| Not to be confused with the built-in transformable dictionary of Brotli. | |
| |size| should be less or equal to 2^24 (16MiB), otherwise the dictionary | |
| will be ignored. The dictionary must exist in memory until decoding is | |
| done and is owned by the caller. To use: | |
| 1) Allocate and initialize state with BrotliCreateInstance | |
| 2) Use BrotliSetCustomDictionary | |
| 3) Use BrotliDecompressStream | |
| 4) Clean up and free state with BrotliDestroyState | |
| */ | |
| void BrotliDecoderSetCustomDictionary( | |
| BrotliDecoderState* s, size_t size, const uint8_t* dict); | |
| /* Returns true, if decoder has some unconsumed output. | |
| Otherwise returns false. */ | |
| BROTLI_BOOL BrotliDecoderHasMoreOutput(const BrotliDecoderState* s); | |
| /* Returns true, if decoder has already received some input bytes. | |
| Otherwise returns false. */ | |
| BROTLI_BOOL BrotliDecoderIsUsed(const BrotliDecoderState* s); | |
| /* Returns true, if decoder is in a state where we reached the end of the | |
| input and produced all of the output; returns false otherwise. */ | |
| BROTLI_BOOL BrotliDecoderIsFinished(const BrotliDecoderState* s); | |
| /* Returns detailed error code after BrotliDecompressStream returns | |
| BROTLI_DECODER_RESULT_ERROR. */ | |
| BrotliDecoderErrorCode BrotliDecoderGetErrorCode( | |
| const BrotliDecoderState* s); | |
| const char* BrotliDecoderErrorString(BrotliDecoderErrorCode c); | |
| /* enc/encode.h */ | |
| typedef ... BrotliEncoderState; | |
| typedef enum BrotliEncoderParameter { | |
| BROTLI_PARAM_MODE = 0, | |
| /* Controls the compression-speed vs compression-density tradeoffs. The | |
| higher the quality, the slower the compression. Range is 0 to 11. */ | |
| BROTLI_PARAM_QUALITY = 1, | |
| /* Base 2 logarithm of the sliding window size. Range is 10 to 24. */ | |
| BROTLI_PARAM_LGWIN = 2, | |
| /* Base 2 logarithm of the maximum input block size. Range is 16 to 24. | |
| If set to 0, the value will be set based on the quality. */ | |
| BROTLI_PARAM_LGBLOCK = 3 | |
| } BrotliEncoderParameter; | |
| typedef enum BrotliEncoderMode { | |
| /* Default compression mode. The compressor does not know anything in | |
| advance about the properties of the input. */ | |
| BROTLI_MODE_GENERIC = 0, | |
| /* Compression mode for UTF-8 format text input. */ | |
| BROTLI_MODE_TEXT = 1, | |
| /* Compression mode used in WOFF 2.0. */ | |
| BROTLI_MODE_FONT = 2 | |
| } BrotliEncoderMode; | |
| int BROTLI_DEFAULT_QUALITY = 11; | |
| int BROTLI_DEFAULT_WINDOW = 22; | |
| #define BROTLI_DEFAULT_MODE ... | |
| typedef enum BrotliEncoderOperation { | |
| BROTLI_OPERATION_PROCESS = 0, | |
| /* Request output stream to flush. Performed when input stream is | |
| depleted and there is enough space in output stream. */ | |
| BROTLI_OPERATION_FLUSH = 1, | |
| /* Request output stream to finish. Performed when input stream is | |
| depleted and there is enough space in output stream. */ | |
| BROTLI_OPERATION_FINISH = 2 | |
| } BrotliEncoderOperation; | |
| /* Creates the instance of BrotliEncoderState and initializes it. | |
| |alloc_func| and |free_func| MUST be both zero or both non-zero. In the | |
| case they are both zero, default memory allocators are used. |opaque| is | |
| passed to |alloc_func| and |free_func| when they are called. */ | |
| BrotliEncoderState* BrotliEncoderCreateInstance(brotli_alloc_func, | |
| brotli_free_func, | |
| void *); | |
| /* Deinitializes and frees BrotliEncoderState instance. */ | |
| void BrotliEncoderDestroyInstance(BrotliEncoderState* state); | |
| /* Compresses the data in |input_buffer| into |encoded_buffer|, and sets | |
| |*encoded_size| to the compressed length. | |
| BROTLI_DEFAULT_QUALITY, BROTLI_DEFAULT_WINDOW and BROTLI_DEFAULT_MODE | |
| should be used as |quality|, |lgwin| and |mode| if there are no specific | |
| requirements to encoder speed and compression ratio. | |
| If compression fails, |*encoded_size| is set to 0. | |
| If BrotliEncoderMaxCompressedSize(|input_size|) is not zero, then | |
| |*encoded_size| is never set to the bigger value. | |
| Returns false if there was an error and true otherwise. */ | |
| BROTLI_BOOL BrotliEncoderCompress(int quality, | |
| int lgwin, | |
| BrotliEncoderMode mode, | |
| size_t input_size, | |
| const uint8_t* input_buffer, | |
| size_t* encoded_size, | |
| uint8_t* encoded_buffer); | |
| BROTLI_BOOL BrotliEncoderCompressStream(BrotliEncoderState* s, | |
| BrotliEncoderOperation op, | |
| size_t* available_in, | |
| const uint8_t** next_in, | |
| size_t* available_out, | |
| uint8_t** next_out, | |
| size_t* total_out); | |
| BROTLI_BOOL BrotliEncoderSetParameter(BrotliEncoderState* state, | |
| BrotliEncoderParameter p, | |
| uint32_t value); | |
| /* Fills the new state with a dictionary for LZ77, warming up the | |
| ringbuffer, e.g. for custom static dictionaries for data formats. | |
| Not to be confused with the built-in transformable dictionary of Brotli. | |
| To decode, use BrotliSetCustomDictionary() of the decoder with the same | |
| dictionary. */ | |
| void BrotliEncoderSetCustomDictionary(BrotliEncoderState* state, | |
| size_t size, | |
| const uint8_t* dict); | |
| /* Check if encoder is in "finished" state, i.e. no more input is | |
| acceptable and no more output will be produced. | |
| Works only with BrotliEncoderCompressStream workflow. | |
| Returns 1 if stream is finished and 0 otherwise. */ | |
| BROTLI_BOOL BrotliEncoderIsFinished(BrotliEncoderState* s); | |
| /* Check if encoder has more output bytes in internal buffer. | |
| Works only with BrotliEncoderCompressStream workflow. | |
| Returns 1 if has more output (in internal buffer) and 0 otherwise. */ | |
| BROTLI_BOOL BrotliEncoderHasMoreOutput(BrotliEncoderState* s); | |
| """) | |
| if __name__ == '__main__': | |
| ffi.compile() | |