| |
| import os |
| import sys |
|
|
| from cffi import FFI |
| ffi = FFI() |
|
|
| USE_SHARED_BROTLI = os.environ.get("USE_SHARED_BROTLI") |
| if USE_SHARED_BROTLI != "1": |
| libraries = ['libbrotli'] |
| else: |
| libraries = ['brotlienc', 'brotlidec'] |
|
|
| if 'win32' not in str(sys.platform).lower(): |
| libraries.append('stdc++') |
|
|
|
|
| ffi.set_source( |
| "_brotlicffi", |
| """#include <brotli/decode.h> |
| #include <brotli/encode.h> |
| """, |
| libraries=libraries, |
| include_dirs=["libbrotli/c", "libbrotli/c/include", "libbrotli/c/common"] |
| ) |
|
|
| 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); |
| |
| /* 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); |
| |
| /* 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() |
|
|
