mirror of
https://github.com/google/brotli.git
synced 2024-12-27 10:20:17 +00:00
302 lines
8.7 KiB
C++
302 lines
8.7 KiB
C++
#define PY_SSIZE_T_CLEAN 1
|
|
#include <Python.h>
|
|
#include <bytesobject.h>
|
|
#include "../enc/encode.h"
|
|
#include "../dec/decode.h"
|
|
#include "../tools/version.h"
|
|
|
|
#if PY_MAJOR_VERSION >= 3
|
|
#define PyInt_Check PyLong_Check
|
|
#define PyInt_AsLong PyLong_AsLong
|
|
#endif
|
|
|
|
using namespace brotli;
|
|
|
|
static PyObject *BrotliError;
|
|
|
|
static int as_bounded_int(PyObject *o, int* result, int lower_bound, int upper_bound) {
|
|
long value = PyInt_AsLong(o);
|
|
if ((value < (long) lower_bound) || (value > (long) upper_bound)) {
|
|
return 0;
|
|
}
|
|
*result = (int) value;
|
|
return 1;
|
|
}
|
|
|
|
static int mode_convertor(PyObject *o, BrotliParams::Mode *mode) {
|
|
if (!PyInt_Check(o)) {
|
|
PyErr_SetString(BrotliError, "Invalid mode");
|
|
return 0;
|
|
}
|
|
|
|
int mode_value = -1;
|
|
if (!as_bounded_int(o, &mode_value, 0, 255)) {
|
|
PyErr_SetString(BrotliError, "Invalid mode");
|
|
return 0;
|
|
}
|
|
*mode = (BrotliParams::Mode) mode_value;
|
|
if (*mode != BrotliParams::MODE_GENERIC &&
|
|
*mode != BrotliParams::MODE_TEXT &&
|
|
*mode != BrotliParams::MODE_FONT) {
|
|
PyErr_SetString(BrotliError, "Invalid mode");
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int quality_convertor(PyObject *o, int *quality) {
|
|
if (!PyInt_Check(o)) {
|
|
PyErr_SetString(BrotliError, "Invalid quality");
|
|
return 0;
|
|
}
|
|
|
|
if (!as_bounded_int(o, quality, 0, 11)) {
|
|
PyErr_SetString(BrotliError, "Invalid quality. Range is 0 to 11.");
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int lgwin_convertor(PyObject *o, int *lgwin) {
|
|
if (!PyInt_Check(o)) {
|
|
PyErr_SetString(BrotliError, "Invalid lgwin");
|
|
return 0;
|
|
}
|
|
|
|
if (!as_bounded_int(o, lgwin, 10, 24)) {
|
|
PyErr_SetString(BrotliError, "Invalid lgwin. Range is 10 to 24.");
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int lgblock_convertor(PyObject *o, int *lgblock) {
|
|
if (!PyInt_Check(o)) {
|
|
PyErr_SetString(BrotliError, "Invalid lgblock");
|
|
return 0;
|
|
}
|
|
|
|
if (!as_bounded_int(o, lgblock, 0, 24) || (*lgblock != 0 && *lgblock < 16)) {
|
|
PyErr_SetString(BrotliError, "Invalid lgblock. Can be 0 or in range 16 to 24.");
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
PyDoc_STRVAR(compress__doc__,
|
|
"Compress a byte string.\n"
|
|
"\n"
|
|
"Signature:\n"
|
|
" compress(string, mode=MODE_GENERIC, quality=11, lgwin=22, lgblock=0, dictionary='')\n"
|
|
"\n"
|
|
"Args:\n"
|
|
" string (bytes): The input data.\n"
|
|
" mode (int, optional): The compression mode can be MODE_GENERIC (default),\n"
|
|
" MODE_TEXT (for UTF-8 format text input) or MODE_FONT (for WOFF 2.0). \n"
|
|
" quality (int, optional): Controls the compression-speed vs compression-\n"
|
|
" density tradeoff. The higher the quality, the slower the compression.\n"
|
|
" Range is 0 to 11. Defaults to 11.\n"
|
|
" lgwin (int, optional): Base 2 logarithm of the sliding window size. Range\n"
|
|
" is 10 to 24. Defaults to 22.\n"
|
|
" lgblock (int, optional): Base 2 logarithm of the maximum input block size.\n"
|
|
" Range is 16 to 24. If set to 0, the value will be set based on the\n"
|
|
" quality. Defaults to 0.\n"
|
|
" dictionary (bytes, optional): Custom dictionary. Only last sliding window\n"
|
|
" size bytes will be used.\n"
|
|
"\n"
|
|
"Returns:\n"
|
|
" The compressed byte string.\n"
|
|
"\n"
|
|
"Raises:\n"
|
|
" brotli.error: If arguments are invalid, or compressor fails.\n");
|
|
|
|
static PyObject* brotli_compress(PyObject *self, PyObject *args, PyObject *keywds) {
|
|
PyObject *ret = NULL;
|
|
uint8_t *input, *output, *custom_dictionary;
|
|
size_t length, output_length, custom_dictionary_length;
|
|
BrotliParams::Mode mode = (BrotliParams::Mode) -1;
|
|
int quality = -1;
|
|
int lgwin = -1;
|
|
int lgblock = -1;
|
|
int ok;
|
|
|
|
static const char *kwlist[] = {
|
|
"string", "mode", "quality", "lgwin", "lgblock", "dictionary", NULL};
|
|
|
|
custom_dictionary = NULL;
|
|
custom_dictionary_length = 0;
|
|
|
|
ok = PyArg_ParseTupleAndKeywords(args, keywds, "s#|O&O&O&O&s#:compress",
|
|
const_cast<char **>(kwlist),
|
|
&input, &length,
|
|
&mode_convertor, &mode,
|
|
&quality_convertor, &quality,
|
|
&lgwin_convertor, &lgwin,
|
|
&lgblock_convertor, &lgblock,
|
|
&custom_dictionary, &custom_dictionary_length);
|
|
if (!ok)
|
|
return NULL;
|
|
|
|
output_length = length + (length >> 2) + 10240;
|
|
output = new uint8_t[output_length];
|
|
|
|
BrotliParams params;
|
|
if ((int) mode != -1)
|
|
params.mode = mode;
|
|
if (quality != -1)
|
|
params.quality = quality;
|
|
if (lgwin != -1)
|
|
params.lgwin = lgwin;
|
|
if (lgblock != -1)
|
|
params.lgblock = lgblock;
|
|
|
|
if (custom_dictionary_length == 0) {
|
|
ok = BrotliCompressBuffer(params, length, input,
|
|
&output_length, output);
|
|
} else {
|
|
uint8_t *custom_dictionary_start = custom_dictionary;
|
|
BrotliMemIn in(input, length);
|
|
BrotliMemOut out(output, output_length);
|
|
size_t sliding_window_size = ((size_t)1) << params.lgwin;
|
|
if (custom_dictionary_length > sliding_window_size) {
|
|
custom_dictionary_start += custom_dictionary_length - sliding_window_size;
|
|
custom_dictionary_length = sliding_window_size;
|
|
}
|
|
ok = BrotliCompressWithCustomDictionary(custom_dictionary_length,
|
|
custom_dictionary_start, params, &in, &out);
|
|
output_length = out.position();
|
|
}
|
|
|
|
if (ok) {
|
|
ret = PyBytes_FromStringAndSize((char*)output, output_length);
|
|
} else {
|
|
PyErr_SetString(BrotliError, "BrotliCompressBuffer failed");
|
|
}
|
|
|
|
delete[] output;
|
|
|
|
return ret;
|
|
}
|
|
|
|
PyDoc_STRVAR(decompress__doc__,
|
|
"Decompress a compressed byte string.\n"
|
|
"\n"
|
|
"Signature:\n"
|
|
" decompress(string)\n"
|
|
"\n"
|
|
"Args:\n"
|
|
" string (bytes): The compressed input data.\n"
|
|
" dictionary (bytes, optional): Custom dictionary. MUST be the same data\n"
|
|
" as passed to compress method.\n"
|
|
"\n"
|
|
"Returns:\n"
|
|
" The decompressed byte string.\n"
|
|
"\n"
|
|
"Raises:\n"
|
|
" brotli.error: If decompressor fails.\n");
|
|
|
|
static PyObject* brotli_decompress(PyObject *self, PyObject *args, PyObject *keywds) {
|
|
PyObject *ret = NULL;
|
|
const uint8_t *input, *custom_dictionary;
|
|
size_t length, custom_dictionary_length;
|
|
int ok;
|
|
|
|
static const char *kwlist[] = {"string", "dictionary", NULL};
|
|
|
|
custom_dictionary = NULL;
|
|
custom_dictionary_length = 0;
|
|
|
|
ok = PyArg_ParseTupleAndKeywords(args, keywds, "s#|s#:decompress",
|
|
const_cast<char **>(kwlist),
|
|
&input, &length,
|
|
&custom_dictionary, &custom_dictionary_length);
|
|
if (!ok)
|
|
return NULL;
|
|
|
|
std::vector<uint8_t> output;
|
|
const size_t kBufferSize = 65536;
|
|
uint8_t* buffer = new uint8_t[kBufferSize];
|
|
BrotliState* state = BrotliCreateState(0, 0, 0);
|
|
if (custom_dictionary_length != 0) {
|
|
BrotliSetCustomDictionary(custom_dictionary_length, custom_dictionary, state);
|
|
}
|
|
|
|
BrotliResult result = BROTLI_RESULT_NEEDS_MORE_OUTPUT;
|
|
while (result == BROTLI_RESULT_NEEDS_MORE_OUTPUT) {
|
|
size_t available_out = kBufferSize;
|
|
uint8_t* next_out = buffer;
|
|
size_t total_out = 0;
|
|
result = BrotliDecompressStream(&length, &input,
|
|
&available_out, &next_out,
|
|
&total_out, state);
|
|
size_t used_out = kBufferSize - available_out;
|
|
if (used_out != 0)
|
|
output.insert(output.end(), buffer, buffer + used_out);
|
|
}
|
|
ok = result == BROTLI_RESULT_SUCCESS;
|
|
if (ok) {
|
|
ret = PyBytes_FromStringAndSize((char*)(output.size() ? &output[0] : NULL), output.size());
|
|
} else {
|
|
PyErr_SetString(BrotliError, "BrotliDecompress failed");
|
|
}
|
|
|
|
BrotliDestroyState(state);
|
|
delete[] buffer;
|
|
|
|
return ret;
|
|
}
|
|
|
|
static PyMethodDef brotli_methods[] = {
|
|
{"compress", (PyCFunction)brotli_compress, METH_VARARGS | METH_KEYWORDS, compress__doc__},
|
|
{"decompress", (PyCFunction)brotli_decompress, METH_VARARGS | METH_KEYWORDS, decompress__doc__},
|
|
{NULL, NULL, 0, NULL}
|
|
};
|
|
|
|
PyDoc_STRVAR(brotli__doc__,
|
|
"The functions in this module allow compression and decompression using the\n"
|
|
"Brotli library.\n\n");
|
|
|
|
#if PY_MAJOR_VERSION >= 3
|
|
#define INIT_BROTLI PyInit_brotli
|
|
#define CREATE_BROTLI PyModule_Create(&brotli_module)
|
|
#define RETURN_BROTLI return m
|
|
|
|
static struct PyModuleDef brotli_module = {
|
|
PyModuleDef_HEAD_INIT,
|
|
"brotli",
|
|
brotli__doc__,
|
|
0,
|
|
brotli_methods,
|
|
NULL,
|
|
NULL,
|
|
NULL
|
|
};
|
|
#else
|
|
#define INIT_BROTLI initbrotli
|
|
#define CREATE_BROTLI Py_InitModule3("brotli", brotli_methods, brotli__doc__)
|
|
#define RETURN_BROTLI return
|
|
#endif
|
|
|
|
PyMODINIT_FUNC INIT_BROTLI(void) {
|
|
PyObject *m = CREATE_BROTLI;
|
|
|
|
BrotliError = PyErr_NewException((char*) "brotli.error", NULL, NULL);
|
|
|
|
if (BrotliError != NULL) {
|
|
Py_INCREF(BrotliError);
|
|
PyModule_AddObject(m, "error", BrotliError);
|
|
}
|
|
|
|
PyModule_AddIntConstant(m, "MODE_GENERIC", (int) BrotliParams::MODE_GENERIC);
|
|
PyModule_AddIntConstant(m, "MODE_TEXT", (int) BrotliParams::MODE_TEXT);
|
|
PyModule_AddIntConstant(m, "MODE_FONT", (int) BrotliParams::MODE_FONT);
|
|
|
|
PyModule_AddStringConstant(m, "__version__", BROTLI_VERSION);
|
|
|
|
RETURN_BROTLI;
|
|
}
|